Get Gentoo!
gentoo.org sites
gentoo.org Wiki Bugs Forums Packages
Planet Archives Sources
Infra Status
aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMagnus Granberg <zorry@gentoo.org>2016-12-28 21:18:58 +0000
committerMagnus Granberg <zorry@gentoo.org>2016-12-28 21:18:58 +0000
commitbf4bee3bf91539a3c9db53af677bae61f95494d6 (patch)
tree5499f1c27b2add785e42b96ad48c8d07a4d31603
parentadd gcc-6.3 patchset (diff)
downloadgcc-patches-bf4bee3bf91539a3c9db53af677bae61f95494d6.tar.gz
gcc-patches-bf4bee3bf91539a3c9db53af677bae61f95494d6.tar.bz2
gcc-patches-bf4bee3bf91539a3c9db53af677bae61f95494d6.zip
bump gcc 5.4 gentoo patchset to 1.2
Diffstat
-rw-r--r--4.8.4/pie/40_all_gcc48_config_esp.patch14
-rw-r--r--4.8.4/pie/README.Changelog7
-rw-r--r--4.8.4/pie/README.history4
-rw-r--r--5.4.0/gentoo/71_all_gcc-5-march-native-pr67310.patch137
-rw-r--r--5.4.0/gentoo/95_all_gcc5-head-snapshot-diff-20161227.patch219502
-rw-r--r--5.4.0/gentoo/README.history6
6 files changed, 219526 insertions, 144 deletions
diff --git a/4.8.4/pie/40_all_gcc48_config_esp.patch b/4.8.4/pie/40_all_gcc48_config_esp.patch
index 535b638..e90f65c 100644
--- a/4.8.4/pie/40_all_gcc48_config_esp.patch
+++ b/4.8.4/pie/40_all_gcc48_config_esp.patch
@@ -1,13 +1,13 @@
-2014-01-04 Magnus Granberg <zorry@gentoo.org>
+2015-05-12 Magnus Granberg <zorry@gentoo.org>
* gcc/esp.h New file to support --enable-esp
- Version 20140104.1
+ Version 20150512.1
--- gcc/config/esp.h 2010-04-09 16:14:00.000000000 +0200
+++ gcc/config/esp.h 2012-06-23 01:00:31.248348491 +0200
-@@ -0,0 +1,128 @@
+@@ -0,0 +1,132 @@
+/* License terms see GNU GENERAL PUBLIC LICENSE Version 3.
-+ * Version 20140104.1
++ * Version 201500512.1
+ * Magnus Granberg (Zorry) <zorry@gentoo.org> */
+#ifndef GCC_ESP_H
+#define GCC_ESP_H
@@ -51,11 +51,15 @@
+
+ /* This will add -fstack-protector-all if we don't have -nostdlib -nodefaultlibs -fno-stack-protector -fstack-protector
+ -fstack-protector-all and we have EFAULT_SSP or EFAULT_PIE_SSP defined. */
-+ #if defined ( EFAULT_SSP ) || defined ( EFAULT_PIE_SSP )
++ #if defined (( EFAULT_SSP ) || defined ( EFAULT_PIE_SSP )) && !defined (__arm__)
+ #define ESP_OPTIONS_SSP_SPEC \
+ "%{nostdlib|nodefaultlibs|ffreestanding|fno-stack-protector| \
+ fstack-protector|fstack-protector-all:;:-fstack-protector-all} \
+ %{fstack-check|fstack-check=*:;: -fstack-check}"
++ #elif defined (( EFAULT_SSP ) || defined ( EFAULT_PIE_SSP )) && defined (__arm__)
++ #define ESP_OPTIONS_SSP_SPEC \
++ "%{nostdlib|nodefaultlibs|ffreestanding|fno-stack-protector| \
++ fstack-protector|fstack-protector-all:;:-fstack-protector-all}"
+ #else
+ #define ESP_OPTIONS_SSP_SPEC ""
+ #endif
diff --git a/4.8.4/pie/README.Changelog b/4.8.4/pie/README.Changelog
index 7a55349..4c1b30e 100644
--- a/4.8.4/pie/README.Changelog
+++ b/4.8.4/pie/README.Changelog
@@ -1,5 +1,10 @@
+0.6.2 Magnus Granberg <zorry@gentoo.org>
+
+ #518598
+ * gcc/config/esp.h don't use -fstack-check for arm
+
0.6.1 Magnus Granberg <zorry@gentoo.org>
-
+
#528690
* libgcc/Makefile Disable -fstack-check
diff --git a/4.8.4/pie/README.history b/4.8.4/pie/README.history
index ca6a77a..eaedefc 100644
--- a/4.8.4/pie/README.history
+++ b/4.8.4/pie/README.history
@@ -1,3 +1,5 @@
+0.6.2 12 May 2015
+ U 40_all_gcc48_config_esp.h.patch
0.6.1 3 Dec 2014
U 03_all_gcc48_Makefile.in.patch
0.6.0 7 jun 2014
@@ -34,7 +36,7 @@
+ 36_all_gcc48_config_mips.patch
+ 37_all_gcc48_config_ia64.patch
- 35_all_gcc47_config_esp.h.patch
- - 35_all_gcc48_config_esp.h.patch
+ + 40_all_gcc48_config_esp.h.patch
U README
0.5.4 02 Oct 2012
U 01_all_gcc47_configure.patch
diff --git a/5.4.0/gentoo/71_all_gcc-5-march-native-pr67310.patch b/5.4.0/gentoo/71_all_gcc-5-march-native-pr67310.patch
deleted file mode 100644
index 5226d88..0000000
--- a/5.4.0/gentoo/71_all_gcc-5-march-native-pr67310.patch
+++ /dev/null
@@ -1,137 +0,0 @@
-https://bugs.gentoo.org/558466
-https://gcc.gnu.org/PR67310
-
-From 2a7c98f6327a25a352fd338e8e12ee66ca7a6f63 Mon Sep 17 00:00:00 2001
-From: uros <uros@138bc75d-0d04-0410-961f-82ee72b054a4>
-Date: Sun, 5 Jun 2016 15:47:50 +0000
-Subject: [PATCH]
-
-2016-06-05 Uros Bizjak <ubizjak@gmail.com>
-
- Backport from mainline
- 2016-06-01 Uros Bizjak <ubizjak@gmail.com>
- Jocelyn Mayer <l_indien@magic.fr>
-
- PR target/67310
- * config/i386/driver-i386.c (host_detect_local_cpu): Correctly
- detect processor family for signature_CENTAUR_ebx.
- <case PROCESSOR_I486>: Pass c3, winchip2 or winchip-c6 for
- signature_CENTAUR_ebx.
- <case PROCESSOR _PENTIUMPRO>: Pass c3-2 for signature_CENTAUR_ebx.
- <default>: Pass x86-64 for has_longmode.
-
-git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/gcc-5-branch@237100 138bc75d-0d04-0410-961f-82ee72b054a4
----
- gcc/ChangeLog | 14 +++++++++
- gcc/config/i386/driver-i386.c | 73 ++++++++++++++++++++++++++-----------------
- 2 files changed, 58 insertions(+), 29 deletions(-)
-
-diff --git a/gcc/config/i386/driver-i386.c b/gcc/config/i386/driver-i386.c
-index 1c6c22172d49..c2cdb49ff686 100644
---- a/gcc/config/i386/driver-i386.c
-+++ b/gcc/config/i386/driver-i386.c
-@@ -630,33 +630,27 @@ const char *host_detect_local_cpu (int argc, const char **argv)
- }
- else if (vendor == signature_CENTAUR_ebx)
- {
-- if (arch)
-+ processor = PROCESSOR_GENERIC;
-+
-+ switch (family)
- {
-- switch (family)
-- {
-- case 6:
-- if (model > 9)
-- /* Use the default detection procedure. */
-- processor = PROCESSOR_GENERIC;
-- else if (model == 9)
-- cpu = "c3-2";
-- else if (model >= 6)
-- cpu = "c3";
-- else
-- processor = PROCESSOR_GENERIC;
-- break;
-- case 5:
-- if (has_3dnow)
-- cpu = "winchip2";
-- else if (has_mmx)
-- cpu = "winchip2-c6";
-- else
-- processor = PROCESSOR_GENERIC;
-- break;
-- default:
-- /* We have no idea. */
-- processor = PROCESSOR_GENERIC;
-- }
-+ default:
-+ /* We have no idea. */
-+ break;
-+
-+ case 5:
-+ if (has_3dnow || has_mmx)
-+ processor = PROCESSOR_I486;
-+ break;
-+
-+ case 6:
-+ if (model > 9 || has_longmode)
-+ /* Use the default detection procedure. */
-+ ;
-+ else if (model == 9)
-+ processor = PROCESSOR_PENTIUMPRO;
-+ else if (model >= 6)
-+ processor = PROCESSOR_I486;
- }
- }
- else
-@@ -687,7 +681,18 @@ const char *host_detect_local_cpu (int argc, const char **argv)
- /* Default. */
- break;
- case PROCESSOR_I486:
-- cpu = "i486";
-+ if (arch && vendor == signature_CENTAUR_ebx)
-+ {
-+ if (model >= 6)
-+ cpu = "c3";
-+ else if (has_3dnow)
-+ cpu = "winchip2";
-+ else
-+ /* Assume WinChip C6. */
-+ cpu = "winchip-c6";
-+ }
-+ else
-+ cpu = "i486";
- break;
- case PROCESSOR_PENTIUM:
- if (arch && has_mmx)
-@@ -804,8 +809,13 @@ const char *host_detect_local_cpu (int argc, const char **argv)
- /* It is Pentium M. */
- cpu = "pentium-m";
- else if (has_sse)
-- /* It is Pentium III. */
-- cpu = "pentium3";
-+ {
-+ if (vendor == signature_CENTAUR_ebx)
-+ cpu = "c3-2";
-+ else
-+ /* It is Pentium III. */
-+ cpu = "pentium3";
-+ }
- else if (has_mmx)
- /* It is Pentium II. */
- cpu = "pentium2";
-@@ -886,6 +896,11 @@ const char *host_detect_local_cpu (int argc, const char **argv)
- else
- cpu = "prescott";
- }
-+ else if (has_longmode)
-+ /* Perhaps some emulator? Assume x86-64, otherwise gcc
-+ -march=native would be unusable for 64-bit compilations,
-+ as all the CPUs below are 32-bit only. */
-+ cpu = "x86-64";
- else if (has_sse2)
- cpu = "pentium4";
- else if (has_cmov)
---
-2.8.2
-
diff --git a/5.4.0/gentoo/95_all_gcc5-head-snapshot-diff-20161227.patch b/5.4.0/gentoo/95_all_gcc5-head-snapshot-diff-20161227.patch
new file mode 100644
index 0000000..d3b5569
--- /dev/null
+++ b/5.4.0/gentoo/95_all_gcc5-head-snapshot-diff-20161227.patch
@@ -0,0 +1,219502 @@
+This patch include alot of patches and fixes.
+The patch snapshot is taken with
+git diff 32c3b88e8ced4b6d022484a73c40f3d663e20fd4 > file
+on the gcc 5 branch. I meens that it include all fixes that is
+commited from the relese date and to current day. 20161227
+https://gcc.gnu.org/bugzilla/buglist.cgi?bug_status=RESOLVED&resolution=FIXED&target_milestone=5.5
+
+diff --git a/ChangeLog b/ChangeLog
+index d060aff..e715661 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,7 @@
++2016-08-31 Jakub Sejdak <jakub.sejdak@phoesys.com>
++
++ * config.sub: Add support for Phoenix-RTOS targets.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/config.sub b/config.sub
+index 6d2e94c..9fa3867 100755
+--- a/config.sub
++++ b/config.sub
+@@ -1393,7 +1393,7 @@ case $os in
+ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+- | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*)
++ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos* | -phoenix*)
+ # Remember, each alternative MUST END IN *, to match a version number.
+ ;;
+ -qnx*)
+diff --git a/fixincludes/ChangeLog b/fixincludes/ChangeLog
+index c9be771..0d372d4 100644
+--- a/fixincludes/ChangeLog
++++ b/fixincludes/ChangeLog
+@@ -1,3 +1,28 @@
++2016-12-01 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ Backport from mainline
++ 2016-11-21 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ * inclhack.def (solaris_math_12): New fix.
++ (hpux11_fabsf): Replace bypass by *-hp-hpux11* mach selector.
++ * fixincl.x: Regenerate.
++ * tests/base/math.h [SOLARIS_MATH_12_CHECK]: New test.
++
++2016-06-15 David Edelsohn <dje.gcc@gmail.com>
++
++ Backport from mainline
++ 2016-06-13 David Edelsohn <dje.gcc@gmail.com>
++
++ * inclhack.def (aix_stdlib_malloc): New fix.
++ (aix_stdlib_realloc): New fix.
++ (aix_stdlib_calloc): New fix.
++ (aix_stdlib_valloc): New fix.
++ * fixincl.x: Regenerate.
++ * tests/base/stdlib.h [AIX_STDLIB_MALLOC]: New test.
++ [AIX_STDLIB_REALLOC]: New test.
++ [AIX_STDLIB_CALLOC]: New test.
++ [AIX_STDLIB_VALLOC]: New test.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/fixincludes/fixincl.x b/fixincludes/fixincl.x
+index a7d8edc..ca30937 100644
+--- a/fixincludes/fixincl.x
++++ b/fixincludes/fixincl.x
+@@ -2,11 +2,11 @@
+ *
+ * DO NOT EDIT THIS FILE (fixincl.x)
+ *
+- * It has been AutoGen-ed Monday February 1, 2016 at 03:24:02 PM EST
++ * It has been AutoGen-ed November 18, 2016 at 02:12:59 PM by AutoGen 5.16.2
+ * From the definitions inclhack.def
+ * and the template file fixincl
+ */
+-/* DO NOT SVN-MERGE THIS FILE, EITHER Mon 1 Feb 2016 15:24:02 EST
++/* DO NOT SVN-MERGE THIS FILE, EITHER Fri Nov 18 14:12:59 2016
+ *
+ * You must regenerate it. Use the ./genfixes script.
+ *
+@@ -15,7 +15,7 @@
+ * certain ANSI-incompatible system header files which are fixed to work
+ * correctly with ANSI C and placed in a directory that GNU C will search.
+ *
+- * This file contains 231 fixup descriptions.
++ * This file contains 236 fixup descriptions.
+ *
+ * See README for more information.
+ *
+@@ -1547,6 +1547,154 @@ static const char* apzAix_Stdio_InlinePatch[] = {
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * *
+ *
++ * Description of Aix_Stdlib_Malloc fix
++ */
++tSCC zAix_Stdlib_MallocName[] =
++ "aix_stdlib_malloc";
++
++/*
++ * File name selection pattern
++ */
++tSCC zAix_Stdlib_MallocList[] =
++ "stdlib.h\0";
++/*
++ * Machine/OS name selection pattern
++ */
++tSCC* apzAix_Stdlib_MallocMachs[] = {
++ "*-*-aix*",
++ (const char*)NULL };
++
++/*
++ * content selection pattern - do fix if pattern found
++ */
++tSCC zAix_Stdlib_MallocSelect0[] =
++ "#define[ \t]+malloc[ \t]+__linux_malloc";
++
++#define AIX_STDLIB_MALLOC_TEST_CT 1
++static tTestDesc aAix_Stdlib_MallocTests[] = {
++ { TT_EGREP, zAix_Stdlib_MallocSelect0, (regex_t*)NULL }, };
++
++/*
++ * Fix Command Arguments for Aix_Stdlib_Malloc
++ */
++static const char* apzAix_Stdlib_MallocPatch[] = {
++ "format",
++ "extern void *malloc(size_t) __asm__(\"__linux_malloc\");",
++ (char*)NULL };
++
++/* * * * * * * * * * * * * * * * * * * * * * * * * *
++ *
++ * Description of Aix_Stdlib_Realloc fix
++ */
++tSCC zAix_Stdlib_ReallocName[] =
++ "aix_stdlib_realloc";
++
++/*
++ * File name selection pattern
++ */
++tSCC zAix_Stdlib_ReallocList[] =
++ "stdlib.h\0";
++/*
++ * Machine/OS name selection pattern
++ */
++tSCC* apzAix_Stdlib_ReallocMachs[] = {
++ "*-*-aix*",
++ (const char*)NULL };
++
++/*
++ * content selection pattern - do fix if pattern found
++ */
++tSCC zAix_Stdlib_ReallocSelect0[] =
++ "#define[ \t]+realloc[ \t]+__linux_realloc";
++
++#define AIX_STDLIB_REALLOC_TEST_CT 1
++static tTestDesc aAix_Stdlib_ReallocTests[] = {
++ { TT_EGREP, zAix_Stdlib_ReallocSelect0, (regex_t*)NULL }, };
++
++/*
++ * Fix Command Arguments for Aix_Stdlib_Realloc
++ */
++static const char* apzAix_Stdlib_ReallocPatch[] = {
++ "format",
++ "extern void *realloc(void *, size_t) __asm__(\"__linux_realloc\");",
++ (char*)NULL };
++
++/* * * * * * * * * * * * * * * * * * * * * * * * * *
++ *
++ * Description of Aix_Stdlib_Calloc fix
++ */
++tSCC zAix_Stdlib_CallocName[] =
++ "aix_stdlib_calloc";
++
++/*
++ * File name selection pattern
++ */
++tSCC zAix_Stdlib_CallocList[] =
++ "stdlib.h\0";
++/*
++ * Machine/OS name selection pattern
++ */
++tSCC* apzAix_Stdlib_CallocMachs[] = {
++ "*-*-aix*",
++ (const char*)NULL };
++
++/*
++ * content selection pattern - do fix if pattern found
++ */
++tSCC zAix_Stdlib_CallocSelect0[] =
++ "#define[ \t]+calloc[ \t]+__linux_calloc";
++
++#define AIX_STDLIB_CALLOC_TEST_CT 1
++static tTestDesc aAix_Stdlib_CallocTests[] = {
++ { TT_EGREP, zAix_Stdlib_CallocSelect0, (regex_t*)NULL }, };
++
++/*
++ * Fix Command Arguments for Aix_Stdlib_Calloc
++ */
++static const char* apzAix_Stdlib_CallocPatch[] = {
++ "format",
++ "extern void *calloc(size_t, size_t) __asm__(\"__linux_calloc\");",
++ (char*)NULL };
++
++/* * * * * * * * * * * * * * * * * * * * * * * * * *
++ *
++ * Description of Aix_Stdlib_Valloc fix
++ */
++tSCC zAix_Stdlib_VallocName[] =
++ "aix_stdlib_valloc";
++
++/*
++ * File name selection pattern
++ */
++tSCC zAix_Stdlib_VallocList[] =
++ "stdlib.h\0";
++/*
++ * Machine/OS name selection pattern
++ */
++tSCC* apzAix_Stdlib_VallocMachs[] = {
++ "*-*-aix*",
++ (const char*)NULL };
++
++/*
++ * content selection pattern - do fix if pattern found
++ */
++tSCC zAix_Stdlib_VallocSelect0[] =
++ "#define[ \t]+valloc[ \t]+__linux_valloc";
++
++#define AIX_STDLIB_VALLOC_TEST_CT 1
++static tTestDesc aAix_Stdlib_VallocTests[] = {
++ { TT_EGREP, zAix_Stdlib_VallocSelect0, (regex_t*)NULL }, };
++
++/*
++ * Fix Command Arguments for Aix_Stdlib_Valloc
++ */
++static const char* apzAix_Stdlib_VallocPatch[] = {
++ "format",
++ "extern void *valloc(size_t) __asm__(\"__linux_valloc\");",
++ (char*)NULL };
++
++/* * * * * * * * * * * * * * * * * * * * * * * * * *
++ *
+ * Description of Aix_Strtof_Const fix
+ */
+ tSCC zAix_Strtof_ConstName[] =
+@@ -4152,7 +4300,9 @@ tSCC zHpux11_FabsfList[] =
+ /*
+ * Machine/OS name selection pattern
+ */
+-#define apzHpux11_FabsfMachs (const char**)NULL
++tSCC* apzHpux11_FabsfMachs[] = {
++ "*-hp-hpux11*",
++ (const char*)NULL };
+
+ /*
+ * content selection pattern - do fix if pattern found
+@@ -4160,15 +4310,8 @@ tSCC zHpux11_FabsfList[] =
+ tSCC zHpux11_FabsfSelect0[] =
+ "^[ \t]*#[ \t]*define[ \t]+fabsf\\(.*";
+
+-/*
+- * content bypass pattern - skip fix if pattern found
+- */
+-tSCC zHpux11_FabsfBypass0[] =
+- "__cplusplus";
+-
+-#define HPUX11_FABSF_TEST_CT 2
++#define HPUX11_FABSF_TEST_CT 1
+ static tTestDesc aHpux11_FabsfTests[] = {
+- { TT_NEGREP, zHpux11_FabsfBypass0, (regex_t*)NULL },
+ { TT_EGREP, zHpux11_FabsfSelect0, (regex_t*)NULL }, };
+
+ /*
+@@ -7191,6 +7334,42 @@ static const char* apzSolaris_Math_11Patch[] = {
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * *
+ *
++ * Description of Solaris_Math_12 fix
++ */
++tSCC zSolaris_Math_12Name[] =
++ "solaris_math_12";
++
++/*
++ * File name selection pattern
++ */
++tSCC zSolaris_Math_12List[] =
++ "math.h\0";
++/*
++ * Machine/OS name selection pattern
++ */
++tSCC* apzSolaris_Math_12Machs[] = {
++ "*-*-solaris2*",
++ (const char*)NULL };
++
++/*
++ * content selection pattern - do fix if pattern found
++ */
++tSCC zSolaris_Math_12Select0[] =
++ "#undef.*_GLIBCXX_USE_C99_MATH";
++
++#define SOLARIS_MATH_12_TEST_CT 1
++static tTestDesc aSolaris_Math_12Tests[] = {
++ { TT_EGREP, zSolaris_Math_12Select0, (regex_t*)NULL }, };
++
++/*
++ * Fix Command Arguments for Solaris_Math_12
++ */
++static const char* apzSolaris_Math_12Patch[] = { sed_cmd_z,
++ "-e", "/#undef[ \t]*_GLIBCXX_USE_C99_MATH/d",
++ (char*)NULL };
++
++/* * * * * * * * * * * * * * * * * * * * * * * * * *
++ *
+ * Description of Solaris_Once_Init_1 fix
+ */
+ tSCC zSolaris_Once_Init_1Name[] =
+@@ -9485,9 +9664,9 @@ static const char* apzX11_SprintfPatch[] = {
+ *
+ * List of all fixes
+ */
+-#define REGEX_COUNT 268
++#define REGEX_COUNT 272
+ #define MACH_LIST_SIZE_LIMIT 187
+-#define FIX_COUNT 231
++#define FIX_COUNT 236
+
+ /*
+ * Enumerate the fixes
+@@ -9525,6 +9704,10 @@ typedef enum {
+ AIX_STDINT_4_FIXIDX,
+ AIX_STDINT_5_FIXIDX,
+ AIX_STDIO_INLINE_FIXIDX,
++ AIX_STDLIB_MALLOC_FIXIDX,
++ AIX_STDLIB_REALLOC_FIXIDX,
++ AIX_STDLIB_CALLOC_FIXIDX,
++ AIX_STDLIB_VALLOC_FIXIDX,
+ AIX_STRTOF_CONST_FIXIDX,
+ AIX_SYSMACHINE_FIXIDX,
+ AIX_SYSWAIT_2_FIXIDX,
+@@ -9666,6 +9849,7 @@ typedef enum {
+ SOLARIS_MATH_8_FIXIDX,
+ SOLARIS_MATH_9_FIXIDX,
+ SOLARIS_MATH_11_FIXIDX,
++ SOLARIS_MATH_12_FIXIDX,
+ SOLARIS_ONCE_INIT_1_FIXIDX,
+ SOLARIS_POSIX_SPAWN_RESTRICT_FIXIDX,
+ SOLARIS_POW_INT_OVERLOAD_FIXIDX,
+@@ -9887,6 +10071,26 @@ tFixDesc fixDescList[ FIX_COUNT ] = {
+ AIX_STDIO_INLINE_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
+ aAix_Stdio_InlineTests, apzAix_Stdio_InlinePatch, 0 },
+
++ { zAix_Stdlib_MallocName, zAix_Stdlib_MallocList,
++ apzAix_Stdlib_MallocMachs,
++ AIX_STDLIB_MALLOC_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
++ aAix_Stdlib_MallocTests, apzAix_Stdlib_MallocPatch, 0 },
++
++ { zAix_Stdlib_ReallocName, zAix_Stdlib_ReallocList,
++ apzAix_Stdlib_ReallocMachs,
++ AIX_STDLIB_REALLOC_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
++ aAix_Stdlib_ReallocTests, apzAix_Stdlib_ReallocPatch, 0 },
++
++ { zAix_Stdlib_CallocName, zAix_Stdlib_CallocList,
++ apzAix_Stdlib_CallocMachs,
++ AIX_STDLIB_CALLOC_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
++ aAix_Stdlib_CallocTests, apzAix_Stdlib_CallocPatch, 0 },
++
++ { zAix_Stdlib_VallocName, zAix_Stdlib_VallocList,
++ apzAix_Stdlib_VallocMachs,
++ AIX_STDLIB_VALLOC_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
++ aAix_Stdlib_VallocTests, apzAix_Stdlib_VallocPatch, 0 },
++
+ { zAix_Strtof_ConstName, zAix_Strtof_ConstList,
+ apzAix_Strtof_ConstMachs,
+ AIX_STRTOF_CONST_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
+@@ -10592,6 +10796,11 @@ tFixDesc fixDescList[ FIX_COUNT ] = {
+ SOLARIS_MATH_11_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
+ aSolaris_Math_11Tests, apzSolaris_Math_11Patch, 0 },
+
++ { zSolaris_Math_12Name, zSolaris_Math_12List,
++ apzSolaris_Math_12Machs,
++ SOLARIS_MATH_12_TEST_CT, FD_MACH_ONLY,
++ aSolaris_Math_12Tests, apzSolaris_Math_12Patch, 0 },
++
+ { zSolaris_Once_Init_1Name, zSolaris_Once_Init_1List,
+ apzSolaris_Once_Init_1Machs,
+ SOLARIS_ONCE_INIT_1_TEST_CT, FD_MACH_ONLY | FD_SUBROUTINE,
+diff --git a/fixincludes/inclhack.def b/fixincludes/inclhack.def
+index 8b6d1fe..2ba12f0 100644
+--- a/fixincludes/inclhack.def
++++ b/fixincludes/inclhack.def
+@@ -911,6 +911,48 @@ fix = {
+ test_text = "#ifdef __cplusplus\n}\n\n#ifdef ferror";
+ };
+
++/*
++ * stdlib.h on AIX uses #define on malloc and friends.
++ */
++fix = {
++ hackname = aix_stdlib_malloc;
++ mach = "*-*-aix*";
++ files = stdlib.h;
++ select = "#define[ \t]+malloc[ \t]+__linux_malloc";
++ c_fix = format;
++ c_fix_arg = "extern void *malloc(size_t) __asm__(\"__linux_malloc\");";
++ test_text = "#define malloc __linux_malloc";
++};
++
++fix = {
++ hackname = aix_stdlib_realloc;
++ mach = "*-*-aix*";
++ files = stdlib.h;
++ select = "#define[ \t]+realloc[ \t]+__linux_realloc";
++ c_fix = format;
++ c_fix_arg = "extern void *realloc(void *, size_t) __asm__(\"__linux_realloc\");";
++ test_text = "#define realloc __linux_realloc";
++};
++
++fix = {
++ hackname = aix_stdlib_calloc;
++ mach = "*-*-aix*";
++ files = stdlib.h;
++ select = "#define[ \t]+calloc[ \t]+__linux_calloc";
++ c_fix = format;
++ c_fix_arg = "extern void *calloc(size_t, size_t) __asm__(\"__linux_calloc\");";
++ test_text = "#define calloc __linux_calloc";
++};
++
++fix = {
++ hackname = aix_stdlib_valloc;
++ mach = "*-*-aix*";
++ files = stdlib.h;
++ select = "#define[ \t]+valloc[ \t]+__linux_valloc";
++ c_fix = format;
++ c_fix_arg = "extern void *valloc(size_t) __asm__(\"__linux_valloc\");";
++ test_text = "#define valloc __linux_valloc";
++};
+
+ /*
+ * stdlib.h on AIX 4.3 declares strtof() with a non-const first argument.
+@@ -2195,9 +2237,9 @@ fix = {
+ */
+ fix = {
+ hackname = hpux11_fabsf;
++ mach = "*-hp-hpux11*";
+ files = math.h;
+ select = "^[ \t]*#[ \t]*define[ \t]+fabsf\\(.*";
+- bypass = "__cplusplus";
+
+ c_fix = format;
+ c_fix_arg = "#ifndef __cplusplus\n%0\n#endif";
+@@ -3715,6 +3757,23 @@ _EOText_;
+ };
+
+ /*
++ * Some versions of Solaris 10+ <math.h> #undef libstdc++-internal macros.
++ */
++fix = {
++ hackname = solaris_math_12;
++ files = math.h;
++ mach = '*-*-solaris2*';
++ select = '#undef.*_GLIBCXX_USE_C99_MATH';
++ sed = "/#undef[ \t]*_GLIBCXX_USE_C99_MATH/d";
++ test_text = << _EOText_
++#if __cplusplus >= 201103L
++#undef _GLIBCXX_USE_C99_MATH
++#undef _GLIBCXX_USE_C99_MATH_TR1
++#endif
++_EOText_;
++};
++
++/*
+ * Sun Solaris defines PTHREAD_ONCE_INIT as an array containing a
+ * structure. As such, it need two levels of brackets, but only
+ * contains one. Wrap the macro definition in an extra layer.
+diff --git a/fixincludes/tests/base/math.h b/fixincludes/tests/base/math.h
+index 7660172..c7da15a 100644
+--- a/fixincludes/tests/base/math.h
++++ b/fixincludes/tests/base/math.h
+@@ -85,6 +85,12 @@ extern int class();
+ #endif /* RS6000_DOUBLE_CHECK */
+
+
++#if defined( SOLARIS_MATH_12_CHECK )
++#if __cplusplus >= 201103L
++#endif
++#endif /* SOLARIS_MATH_12_CHECK */
++
++
+ #if defined( STRICT_ANSI_NOT_CTD_CHECK )
+ #if 1 && \
+ && defined(mumbling) |& ( !defined(__STRICT_ANSI__)) \
+diff --git a/fixincludes/tests/base/stdlib.h b/fixincludes/tests/base/stdlib.h
+index 2f91e07..cee7e5d 100644
+--- a/fixincludes/tests/base/stdlib.h
++++ b/fixincludes/tests/base/stdlib.h
+@@ -9,6 +9,26 @@
+
+
+
++#if defined( AIX_STDLIB_MALLOC_CHECK )
++extern void *malloc(size_t) __asm__("__linux_malloc");
++#endif /* AIX_STDLIB_MALLOC_CHECK */
++
++
++#if defined( AIX_STDLIB_REALLOC_CHECK )
++extern void *realloc(void *, size_t) __asm__("__linux_realloc");
++#endif /* AIX_STDLIB_REALLOC_CHECK */
++
++
++#if defined( AIX_STDLIB_CALLOC_CHECK )
++extern void *calloc(size_t, size_t) __asm__("__linux_calloc");
++#endif /* AIX_STDLIB_CALLOC_CHECK */
++
++
++#if defined( AIX_STDLIB_VALLOC_CHECK )
++extern void *valloc(size_t) __asm__("__linux_valloc");
++#endif /* AIX_STDLIB_VALLOC_CHECK */
++
++
+ #if defined( AIX_STRTOF_CONST_CHECK )
+ extern float strtof(const char *, char **);
+ #endif /* AIX_STRTOF_CONST_CHECK */
+diff --git a/gcc/ChangeLog b/gcc/ChangeLog
+index 242d9e1..fa387f8 100644
+--- a/gcc/ChangeLog
++++ b/gcc/ChangeLog
+@@ -1,3 +1,802 @@
++2016-12-27 Jakub Jelinek <jakub@redhat.com>
++
++ PR translation/78922
++ * config/i386/stringop.opt: Remove.
++
++2016-12-14 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/78731
++ * tree-ssa-threadedge.c (simplify_control_stmt_condition):
++ If we've seen a backedge to not walk the SSA value chain.
++ (thread_around_empty_blocks): Pass down whether we've seen
++ a backedge to simplify_control_stmt_condition.
++ (thread_through_normal_block): Likewise.
++
++2016-12-14 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-25 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ * tree-ssa-math-opts.c (struct symbolic_number): Improve comment.
++
++2016-12-14 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-25 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ PR tree-optimization/77673
++ * tree-ssa-math-opts.c (struct symbolic_number): Add new src field.
++ (init_symbolic_number): Initialize src field from src parameter.
++ (perform_symbolic_merge): Select most dominated statement as the
++ source statement. Set src field of resulting n structure from the
++ input src with the lowest address.
++ (find_bswap_or_nop): Rename source_stmt into ins_stmt.
++ (bswap_replace): Rename src_stmt into ins_stmt. Initially get source
++ of load from src field rather than insertion statement. Cancel
++ optimization if statement analyzed is not dominated by the insertion
++ statement.
++ (pass_optimize_bswap::execute): Rename src_stmt to ins_stmt. Compute
++ dominance information.
++
++2016-12-13 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-17 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ PR target/77933
++ * config/arm/arm.c (thumb1_expand_prologue): Distinguish between lr
++ being live in the function and lr needing to be saved. Distinguish
++ between already saved pushable registers and registers to push.
++ Check for LR being an available pushable register.
++
++2016-12-12 Bernd Schmidt <bschmidt@redhat.com>
++
++ Backport from mainline
++ 2016-11-07 Bernd Schmidt <bschmidt@redhat.com>
++
++ PR rtl-optimization/77309
++ * combine.c (make_compound_operation): Allow EQ for IN_CODE, and
++ don't assume an equality comparison for plain COMPARE.
++ (simplify_comparison): Pass a more accurate code to
++ make_compound_operation.
++
++2016-12-07 Segher Boessenkool <segher@kernel.crashing.org>
++
++ Backport from mainline
++ 2016-11-12 Segher Boessenkool <segher@kernel.crashing.org>
++
++ PR target/77957
++ * config/rs6000/rs6000.c (rs6000_output_function_epilogue): Don't
++ return early if !optional_tbtab.
++
++2016-12-07 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-16 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ * config/arm/arm.md (arm_addsi3): Add alternative for addition of
++ general register with general register or ARM constant into SP
++ register.
++
++2016-12-06 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-12-05 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++ Stefan Freudenberger <stefan@reservoir.com>
++
++ PR tree-optimization/78646
++ * gimple-ssa-strength-reduction.c (replace_ref): The pointer
++ addition used for the memory base expression should have the type
++ of the candidate.
++
++2016-12-02 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-10-21 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR rtl-optimization/78038
++ * ree.c (get_defs): Return NULL if a defining insn for REG cannot
++ be deduced to set REG through the RTL structure.
++ (make_defs_and_copies_lists): Return false on a failing get_defs call.
++
++2016-12-02 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-12-02 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ * config/s390/s390-modes.def (CCVEQANY, CCVH, CCVHANY, CCVHU)
++ (CCVHUANY): Remove modes.
++ (CCVIH, CCVIHU, CCVIALL, CCVIANY, CCVFALL, CCVFANY): Add modes and
++ documentation.
++ * config/s390/s390.c (s390_match_ccmode_set): Rename cc modes.
++ (s390_expand_vec_compare_scalar): Pick one of the cc consumer
++ modes.
++ (s390_branch_condition_mask): Adjust to use the new cc consumer
++ modes. The new modes allow for proper reversal in the middle-end.
++ (s390_expand_vec_compare_cc): Determine the proper cc producer and
++ consumer modes for a comparison.
++ * config/s390/s390.md: Rename CCVH to CCVIH and CCVHU to CCVIHU
++ throughout the file.
++ * config/s390/vx-builtins.md: Likewise.
++
++2016-12-01 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-12-01 Alan Modra <amodra@gmail.com>
++
++ * gcc/config/rs6000/rs6000.c (insn_is_swappable_p): Properly
++ look inside UNSPEC_VSX_XXSPLTW vec.
++
++2016-11-29 Kaz Kojima <kkojima@gcc.gnu.org>
++
++ Backported from mainline
++ 2016-11-19 Kaz Kojima <kkojima@gcc.gnu.org>
++
++ PR target/78426
++ * config/sh/sh-mem.cc (sh_expand_cmpnstr): Use copy_to_mode_reg
++ instead of force_reg.
++ (sh_expand_setmem): Likewise.
++
++2016-11-24 Martin Liska <mliska@suse.cz>
++ Backported from mainline
++ 2016-11-22 Martin Liska <mliska@suse.cz>
++
++ PR ipa/78309
++ * ipa-icf.c (void sem_item::set_hash): Update m_hash_set.
++ (sem_function::get_hash): Use the new field.
++ (sem_function::parse): Remove an argument from ctor.
++ (sem_variable::parse): Likewise.
++ (sem_variable::get_hash): Use the new field.
++ (sem_item_optimizer::read_section): Use new ctor and set hash.
++ * ipa-icf.h: _hash is removed from sem_item::sem_item,
++ sem_variable::sem_variable, sem_function::sem_function.
++
++2016-11-23 Uros Bizjak <ubizjak@gmail.com>
++
++ * config/i386/i386.md (*<any_or:code>hi_1): Fix operand 2 constraints.
++ (kxnor<mode>): Return "#" for alternative 0.
++
++2016-11-22 Uros Bizjak <ubizjak@gmail.com>
++
++ * Makefile.in ($(lang_checks_parallelized)): Fix detection
++ of -j argument.
++
++2016-11-15 Matthias Klose <doko@ubuntu.com>
++
++ * doc/install.texi: Move the 'Overriding configure test results'
++ subsub section to the 'Cross-Compiler-Specific Options' sub section.
++
++2016-11-11 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/78310
++ * config/i386/i386.md (rotate to rotatex splitter): Avoid overflow
++ when calculating operand 2.
++ (rotate to rotatex zext splitter): Ditto.
++
++2016-11-09 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/78262
++ * config/i386/i386.md (*<shift_insn><mode>3_doubleword): Mark
++ operand 0 as earlyclobber.
++ (*ashl<mode>3_doubleword): Ditto for all operand 0 alternatives.
++
++2016-11-06 Jack Howarth <howarth.at.gcc@gmail.com>
++
++ PR driver/78206
++ * incpath.c: (remove_dup(): Also silently ignore EPERM.
++
++2016-11-03 Martin Liska <mliska@suse.cz>
++
++ Backport from mainline
++ 2016-08-12 Martin Liska <mliska@suse.cz>
++ Adam Fineman <afineman@afineman.com>
++
++ * gcov.c (process_file): Create .gcov file when .gcda
++ file is missing.
++
++2016-11-03 Eric Botcazou <ebotcazou@adacore.com>
++
++ Backport from mainline
++ 2016-10-17 Eric Botcazou <ebotcazou@adacore.com>
++
++ * explow.c (validize_mem): Do not modify the argument in-place.
++
++2016-11-02 Will Schmidt <will_schmidt@vnet.ibm.com>
++
++ Backport from trunk
++ 2016-10-26 Will Schmidt <will_schmidt@vnet.ibm.com>
++
++ PR middle-end/72747
++ * gimplify.c (gimplify_init_constructor): Move emit of constructor
++ assignment to earlier in the if/else logic.
++
++2016-10-29 John David Anglin <danglin@gcc.gnu.org>
++
++ * config/pa/pa.h (BIGGEST_ALIGNMENT): Adjust comment.
++ (MALLOC_ABI_ALIGNMENT): Define.
++
++2016-10-23 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-10-17 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR tree-optimization/77916
++ * gimple-ssa-strength-reduction.c (create_add_on_incoming_edge):
++ Don't allow a MINUS_EXPR for pointer arithmetic for either known
++ or unknown strides.
++ (record_increment): Increments of -1 for unknown strides just use
++ a multiply initializer like other negative values.
++ (analyze_increments): Remove stopgap solution for -1 increment
++ applied to pointer arithmetic.
++ (insert_initializers): Requirement of initializer for -1 should be
++ based on pointer-typedness of the candidate basis.
++
++2016-10-19 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/77991
++ * config/i386/i386.c (legitimize_tls_address)
++ <case TLS_MODEL_INITIAL_EXEC>: For TARGET_64BIT || TARGET_ANY_GNU_TLS
++ convert dest to Pmode if different than Pmode.
++
++2016-10-18 Kugan Vivekanandarajah <kuganv@linaro.org>
++
++ Backport from mainline
++ 2016-10-11 Kugan Vivekanandarajah <kuganv@linaro.org>
++
++ * tree-vrp.c (vrp_intersect_ranges_1): Allocate bitmap before
++ copying.
++
++2016-10-17 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-10-12 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR tree-optimization/77937
++ * gimple-ssa-strength-reduction.c (analyze_increments): Use
++ POINTER_TYPE_P on the candidate type to determine whether
++ candidates in this chain require pointer arithmetic.
++
++ 2016-10-13 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR tree-optimization/77937
++ * gimple-ssa-strength-reduction.c (analyze_increments): Set cost
++ to infinite when we have a pointer with an increment of -1.
++
++2016-10-17 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-10-13 Martin Liska <mliska@suse.cz>
++
++ PR tree-optimization/77943
++ * tree-ssa-tail-merge.c (merge_stmts_p): Do not merge BBs with
++ a different EH landing pads.
++
++2016-10-16 Eric Botcazou <ebotcazou@adacore.com>
++
++ * config/sparc/sparc.c (sparc_expand_vector_init): Only accept literal
++ constants in CONST_VECTORs.
++
++2016-10-15 Eric Botcazou <ebotcazou@adacore.com>
++
++ * config/sparc/sparc.c (sparc_expand_vec_perm_bmask): Use a scratch
++ register as destination of bmask.
++ (vector_init_bshuffle): Likewise.
++ * config/sparc/sparc.md (vec_perm_constv8qi): Likewise.
++ (bmaskdi_vis): Enable only in 64-bit mode.
++
++2016-10-13 Andrew Senkevich <andrew.senkevich@intel.com>
++
++ Backport from trunk
++ * common/config/i386/i386-common.c (OPTION_MASK_ISA_PCOMMIT_UNSET,
++ OPTION_MASK_ISA_PCOMMIT_SET): Deleted definitions.
++ (ix86_handle_option): Deleted handle of OPT_mpcommit.
++ * config.gcc: Deleted pcommitintrin.h
++ * config/i386/pcommitintrin.h: Deleted file.
++ * config/i386/cpuid.h (bit_PCOMMIT): Deleted.
++ * config/i386/driver-i386.c (host_detect_local_cpu): Deleted pcommit
++ detection.
++ * config/i386/i386-c.c (ix86_target_macros_internal): Deleted define
++ __PCOMMIT__.
++ * config/i386/i386.c (ix86_target_string): Deleted -mpcommit.
++ (PTA_PCOMMIT, IX86_BUILTIN_PCOMMIT, __builtin_ia32_pcommit): Deleted.
++ (ix86_option_override_internal): Deleted handle of option.
++ (ix86_valid_target_attribute_inner_p): Deleted pcommit.
++ * config/i386/i386.h (TARGET_PCOMMIT, TARGET_PCOMMIT_P): Deleted.
++ * config/i386/i386.md (unspecv): Deleted UNSPECV_PCOMMIT.
++ (pcommit): Deleted instruction.
++ * config/i386/i386.opt: Mention -mpcommit deprecation.
++ * config/i386/x86intrin.h: Deleted inclusion of pcommitintrin.h.
++
++2016-10-10 Georg-Johann Lay <avr@gjlay.de>
++
++ * config/avr/gen-avr-mmcu-texi.c (string.h): Include.
++
++2016-10-06 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/77874
++ * config/i386/sse.md (<mask_codefor><code><mode>3<mask_name>):
++ Remove wrong assert.
++ (<floatsuffix>float<sseintvecmodelower><mode>2<mask_name><round_name>:
++ Use <round_constraint> as operand 1 constraint.
++
++2016-09-28 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++ Alan Modra <amodra@gmail.com>
++
++ Backport from mainline
++ 2016-07-01 Alan Modra <amodra@gmail.com>
++
++ PR rtl-optimization/71709
++ * ira-lives.c (find_call_crossed_cheap_reg): Exit loop on arg reg
++ being set, not referenced.
++
++2016-09-27 David Edelsohn <dje.gcc@gmail.com>
++
++ Backport from mainline
++ 2016-09-27 David Edelsohn <dje.gcc@gmail.com>
++
++ * config/rs6000/rs6000.c (rs6000_output_symbol): Don't modify
++ VAR_DECL string.
++
++2016-09-27 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/77478
++ * tree-vect-loop-manip.c (vect_gen_niters_for_prolog_loop):
++ Fix alignment of SSA var used before the alignment prologue.
++
++2016-09-27 Senthil Kumar Selvaraj <senthil_kumar.selvaraj@atmel.com>
++
++ Backport from trunk r227496
++
++ PR target/65210
++ * config/avr/avr.c (avr_eval_addr_attrib): Look for io_low
++ attribute as well.
++
++2016-09-22 Senthil Kumar Selvaraj <senthil_kumar.selvaraj@atmel.com>
++
++ Backport from 2016-09-22 trunk r240388.
++
++ * config/avr/avr.c (avr_rtx_costs_1): Handle DImode MULT.
++ (avr_address_cost): Replace 61 with MAX_LD_OFFSET(mode).
++
++2016-09-21 Segher Boessenkool <segher@kernel.crashing.org>
++
++ * doc/rtl.texi (JUMP_LABEL): Document RETURN and SIMPLE_RETURN values.
++
++2016-09-21 Georg-Johann Lay <avr@gjlay.de>
++
++ Backport from 2016-09-21 trunk r240306.
++
++ PR target/77326
++ * config/avr/avr.c (hard-reg-set.h): Move #include up in front
++ of rtl.h to that HARD_CONST is defined in rtl.h.
++ (avr_notice_update_cc) [CC_NONE]: If insn touches some regs
++ mentioned in cc_status, do CC_STATUS_INIT.
++
++2016-09-16 Jonathan Wakely <jwakely@redhat.com>
++
++ * doc/extend.texi (Integer Overflow Builtins): Fix type of out
++ parameters for functions taking long long arguments.
++
++2016-08-31 Jakub Sejdak <jakub.sejdak@phoesys.com>
++
++ * config.gcc: Add support for arm*-*-phoenix* targets.
++ * config/arm/t-phoenix: New.
++ * config/phoenix.h: New.
++
++2016-08-29 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/77403
++ * config/i386/sse.md (vec_set_lo_<mode><mask_name>): Fix assembler
++ template for intel asm dialect.
++ (vec_set_hi_<mode><mask_name>): Ditto.
++
++2016-08-29 Eric Botcazou <ebotcazou@adacore.com>
++
++ * Makefile.in (gcov-iov.h): Add dummy recipe.
++
++2016-08-26 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-04-20 Andrew Pinski <apinski@cavium.com>
++ Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR target/64971
++ * config/aarch64/aarch64.md (sibcall): Force call
++ address to be DImode for ILP32.
++ (sibcall_value): Likewise.
++
++2016-08-25 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline (minus test for POWER9 support)
++ 2016-08-11 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR target/72863
++ * vsx.md (vsx_load_<mode>): For P8LE, emit swaps at expand time.
++ (vsx_store_<mode>): Likewise.
++
++2016-08-25 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-07-12 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR middle-end/71700
++ * expr.c (store_constructor): Mask sign-extended bits when widening
++ sub-word constructor element at the start of a word.
++
++2016-08-22 Uros Bizjak <ubizjak@gmail.com>
++
++ Backport from mainline
++ 2016-08-14 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/76342
++ * config/i386/avx512fintrin.h (_mm512_undefined_epi32):
++ Renamed from _mm512_undefined_si512.
++ (_mm_undefined_si512): New definition.
++
++ Backport from mainline:
++ 2016-08-09 David Wohlferd <dw@LimeGreenSocks.com>
++
++ * config/i3836/avx512fintrin.h (_mm512_cvtsepi64_epi32): Remove
++ unused variable __O.
++
++ Backport from mainline:
++ 2016-08-09 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/72843
++ * config/i386/i386.md (*movtf_internal): Use
++ lra_in_progress || reload_completed instead of !can_create_pseudo_p
++ in the insn constraint.
++ (*movxf_internal): Ditto.
++ (*movdf_internal): Ditto.
++ (*movsf_internal): Ditto.
++
++2016-08-18 Oleg Endo <olegendo@gcc.gnu.org>
++
++ Backport from mainline
++ 2016-06-17 DJ Delorie <dj@redhat.com>
++
++ PR target/71338
++ * config/rl78/rl78-expand.c (umulqihi3): Enable for G10.
++ * config/rl78/rl78-virtual.c (umulhi3_shift_virt): Likewise.
++ (umulqihi3_virt): Likewise.
++ * config/rl78/rl78-real.c (umulhi3_shift_real): Likewise.
++ (umulqihi3_real): Likewise.
++
++2016-08-16 Eric Botcazou <ebotcazou@adacore.com>
++
++ * doc/install.texi (*-*-solaris2*): Adjust latest change.
++
++2016-08-15 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-08-15 Martin Liska <mliska@suse.cz>
++
++ PR driver/72765
++ * gcc.c (do_spec_1): Call save_string with the right size.
++ (save_string): Do an assert about string we copy.
++
++2016-08-15 Eric Botcazou <ebotcazou@adacore.com>
++
++ * doc/install.texi (*-*-solaris2*): Fix version number and document
++ requirement on GNU make for building libjava with the Solaris linker.
++
++2016-08-12 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ Backport from mainline
++ 2016-08-11 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ PR tree-optimization/71083
++ * tree-predcom.c (ref_at_iteration): Correctly align the
++ reference type.
++
++2016-08-08 Georg-Johann Lay <avr@gjlay.de>
++
++ Backport from 2016-07-29 trunk r238863.
++
++ PR rtl-optimization/71976
++ * combine.c (get_last_value): Return 0 if the argument for which
++ the function is called has a wider mode than the recorded value.
++
++2016-08-04 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/72805
++ * config/i386/avx512fintrin.h (_mm512_cmp_epi32_mask) [!__OPTIMIZE__]:
++ Cast builtin function result to __mmask16 instead of __mmask8.
++ (_mm512_cmp_epu32_mask) [!__OPTIMIZE__]: Ditto.
++ (_mm512_mask_cmp_epi32_mask) [!__OPTIMIZE__]: Ditto.
++ (_mm512_mask_cmp_epu32_mask) [!__OPTIMIZE__]: Ditto.
++
++2016-08-01 Georg-Johann Lay <avr@gjlay.de>
++
++ Backport from 2016-08-01 trunk r238948.
++
++ PR target/72767
++ * config/avr/avr.md (length) [branch]: Correct insn length
++ attribute for forward branches.
++
++2016-07-29 Marek Polacek <polacek@redhat.com>
++
++ Backport from mainline
++ 2016-07-29 Marek Polacek <polacek@redhat.com>
++
++ PR c/7652
++ * config/rs6000/rs6000.c (altivec_expand_ld_builtin): Add break.
++ (altivec_expand_st_builtin): Likewise.
++ * config/i386/i386.c (ix86_expand_args_builtin): Likewise.
++ (ix86_expand_round_builtin): Likewise.
++
++2016-07-27 Segher Boessenkool <segher@kernel.crashing.org>
++
++ PR target/71216
++ * config/rs6000/rs6000.c (rs6000_file_start): Fix condition for
++ when to emit a ".machine" pseudo-op.
++
++2016-07-26 Alan Modra <amodra@gmail.com>
++
++ PR target/72103
++ * config/rs6000/rs6000.c (rs6000_secondary_reload): Initialize
++ sri->t_icode.
++
++2016-07-20 Martin Jambor <mjambor@suse.cz>
++
++ PR fortran/71688
++ * trans-decl.c (gfc_generate_function_code): Use get_create rather
++ than create to get a call graph node.
++
++2016-07-19 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71874
++ * gimple-fold.c (fold_builtin_memory_op): Use
++ get_addr_base_and_unit_offset instead of get_ref_base_and_extent.
++
++2016-07-19 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-03-15 Richard Henderson <rth@redhat.com>
++
++ * line-map.c (new_linemap): Make alloc_size a size_t.
++
++2016-07-19 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-07-11 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71758
++ * omp-low.c (expand_omp_target): Gimplify device.
++
++2016-07-18 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-07-12 Martin Liska <mliska@suse.cz>
++
++ PR rtl-optimization/71634
++ * ira-build.c (mark_loops_for_removal): Properly iterate
++ loops.
++
++2016-07-12 Segher Boessenkool <segher@kernel.crashing.org>
++
++ Backport from mainline
++ 2016-07-06 Segher Boessenkool <segher@kernel.crashing.org>
++
++ PR target/70098
++ PR target/71763
++ * config/rs6000/rs6000.md (*ctr<mode>_internal1, *ctr<mode>_internal2,
++ *ctr<mode>_internal5, *ctr<mode>_internal6): Add *wi to the output
++ constraint.
++
++2016-07-08 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-07-08 Martin Liska <mliska@suse.cz>
++
++ PR middle-end/71606
++ * fold-const.c (fold_convertible_p): As COMPLEX_TYPE
++ folding produces SAVE_EXPRs, thus return false for the type.
++
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-06-28 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71626
++ * config/i386/i386.c (ix86_expand_vector_move): For SUBREG of
++ a constant, force its SUBREG_REG into memory or register instead
++ of whole op1.
++
++ 2016-06-21 Jakub Jelinek <jakub@redhat.com>
++
++ PR tree-optimization/71588
++ * tree-ssa-strlen.c (valid_builtin_call): New function.
++ (adjust_last_stmt, handle_builtin_memset, strlen_optimize_stmt): Use
++ it.
++
++ 2016-06-20 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71581
++ * tree-ssa-uninit.c (warn_uninit): If EXPR and VAR are NULL,
++ see if T isn't anonymous SSA_NAME with COMPLEX_EXPR created
++ for conversion of scalar user var to complex type and use the
++ underlying SSA_NAME_VAR in that case. If EXPR is still NULL,
++ punt.
++
++ 2016-06-10 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71494
++ * tree-nested.c (convert_nonlocal_reference_stmt): For GIMPLE_GOTO
++ without LABEL_DECL, set *handled_ops_p to false instead of true.
++
++ 2016-04-13 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/70641
++ * ipa-pure-const.c (pass_nothrow::execute): Call maybe_clean_eh_stmt
++ on all recursive call stmts. Return TODO_cleanup_cfg if any dead
++ eh edges have been purged.
++
++ PR middle-end/70633
++ * gimplify.c (gimplify_init_constructor): Clear TREE_STATIC if
++ gimplification turns some element into non-constant.
++
++ 2016-04-13 Jakub Jelinek <jakub@redhat.com>
++
++ PR debug/70628
++ * explow.c (convert_memory_address_addr_space_1): Formatting fix.
++
++ PR debug/70628
++ * rtl.h (convert_memory_address_addr_space_1): New prototype.
++ * explow.c (convert_memory_address_addr_space_1): No longer static,
++ add NO_EMIT argument and don't call convert_modes if true, pass
++ it down recursively, remove break after return.
++ (convert_memory_address_addr_space): Adjust caller.
++ * simplify-rtx.c (simplify_unary_operation_1): Call
++ convert_memory_address_addr_space_1 instead of convert_memory_address,
++ if it returns NULL, don't simplify.
++
++ 2016-04-08 Jakub Jelinek <jakub@redhat.com>
++
++ PR rtl-optimization/70574
++ * fwprop.c (forward_propagate_and_simplify): Don't add
++ REG_EQUAL note if DF_REF_REG (use) is a paradoxical subreg.
++ (try_fwprop_subst): Don't add REG_EQUAL note if there are any
++ paradoxical subregs within *loc.
++
++ 2016-04-05 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/70336
++ * match.pd (nested int casts): Limit to GIMPLE.
++
++2016-07-07 Richard Biener <rguenther@suse.de>
++
++ Backport from mainline
++ 2016-06-07 Richard Biener <rguenther@suse.de>
++
++ PR middle-end/71423
++ * match.pd ((X | ~Y) -> Y <= X): Properly invert the comparison
++ for signed ops.
++
++ 2016-06-08 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/71452
++ * tree-ssa.c (non_rewritable_lvalue_p): Make sure that the
++ type used for the SSA rewrite has enough precision to cover
++ the dynamic type of the location.
++
++ 2016-06-14 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/71522
++ * tree-ssa.c (non_rewritable_lvalue_p): Do not rewrite non-float
++ copying into float copying.
++
++2016-07-01 Eric Botcazou <ebotcazou@adacore.com>
++
++ * config/arm/arm.c (arm_function_ok_for_sibcall): Add another check
++ for NULL decl.
++
++2016-06-30 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71693
++ * fold-const.c (fold_binary_loc) <case RROTATE_EXPR>: Cast
++ TREE_OPERAND (arg0, 0) and TREE_OPERAND (arg0, 1) to type
++ first when permuting bitwise operation with rotate. Cast
++ TREE_OPERAND (arg0, 0) to type when cancelling two rotations.
++
++2016-06-21 Georg-Johann Lay <avr@gjlay.de>
++
++ Backport from 2016-06-21 trunk r237639.
++
++ PR target/30417
++ * config/avr/gen-avr-mmcu-specs.c (print_mcu):
++ [*link_data_start]: Wrap -Tdata into %{!Tdata:...}.
++ [*link_text_start]: Wrap -Ttext into %{!Ttext:...}.
++
++2016-06-21 Georg-Johann Lay <avr@gjlay.de>
++
++ PR target/71103
++ * config/avr/avr.md (movqi): Only handle loading subreg:qi of
++ constant addresses if can_create_pseudo_p.
++
++2016-06-20 Georg-Johann Lay <avr@gjlay.de>
++ Pitchumani Sivanupandi <pitchumani.s@atmel.com>
++
++ Backport from 2016-06-20 trunk r237589, r236558.
++
++ PR target/71103
++ * config/avr/avr.md (movqi): Handle loading subreg:qi (const,
++ symbol_ref,label_ref).
++
++2016-06-16 Jakub Jelinek <jakub@redhat.com>
++
++ PR target/71554
++ * config/i386/i386.md (setcc + movzbl peephole2): Use reg_set_p.
++ (setcc + and peephole2): Likewise.
++
++ Backported from mainline
++ 2015-04-29 Uros Bizjak <ubizjak@gmail.com>
++
++ * config/i386/i386.md (setcc+movzbl peephole2): Check also clobbered
++ reg.
++ (setcc+andl peephole2): Ditto.
++
++2016-06-15 Andreas Tobler <andreast@gcc.gnu.org>
++
++ Backported from mainline
++ 2016-06-14 Andreas Tobler <andreast@gcc.gnu.org>
++
++ * config/arm/freebsd.h: Only enable unaligned access for armv6 on
++ FreeBSD 11 and above.
++
++2016-06-13 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/71505
++ * tree-vect-data-refs.c (vect_analyze_data_ref_accesses): Make
++ assert match comment.
++
++2016-06-13 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-06-13 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ PR target/71379
++ * config/s390/s390.c (s390_expand_builtin): Increase MAX_ARGS by
++ one.
++
++2016-06-07 Peter Bergner <bergner@vnet.ibm.com>
++
++ Backport from mainline
++ 2016-06-07 Peter Bergner <bergner@vnet.ibm.com>
++
++ * doc/invoke.texi (RS/6000 and PowerPC Options): Document -mhtm and
++ -mno-htm.
++
++2016-06-07 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/71389
++ * config/i386/i386.c (ix86_avx256_split_vector_move_misalign):
++ Copy op1 RTX to avoid invalid sharing.
++ (ix86_expand_vector_move_misalign): Ditto.
++
++2016-06-05 Uros Bizjak <ubizjak@gmail.com>
++
++ Backport from mainline
++ 2016-06-01 Uros Bizjak <ubizjak@gmail.com>
++ Jocelyn Mayer <l_indien@magic.fr>
++
++ PR target/67310
++ * config/i386/driver-i386.c (host_detect_local_cpu): Correctly
++ detect processor family for signature_CENTAUR_ebx.
++ <case PROCESSOR_I486>: Pass c3, winchip2 or winchip-c6 for
++ signature_CENTAUR_ebx.
++ <case PROCESSOR _PENTIUMPRO>: Pass c3-2 for signature_CENTAUR_ebx.
++ <default>: Pass x86-64 for has_longmode.
++
++2016-06-03 Andreas Tobler <andreast@gcc.gnu.org>
++
++ Backport from mainline
++ 2016-05-30 Andreas Tobler <andreast@gcc.gnu.org>
++
++ * config.gcc: Move hard float support for arm*hf*-*-freebsd* into
++ armv6*-*-freebsd* for FreeBSD 11. Eliminate the arm*hf*-*-freebsd*
++ target.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+@@ -38,7 +837,7 @@
+
+ 2016-03-24 Richard Henderson <rth@redhat.com>
+
+- PR middle-end/69845
++ PR middle-end/69845
+ * fold-const.c (extract_muldiv_1): Correct test for multiplication
+ overflow.
+
+@@ -2196,7 +2995,7 @@
+
+ Backport from mainline
+ 2015-11-26 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
+- Bernd Schmidt <bschmidt@redhat.com>
++ Bernd Schmidt <bschmidt@redhat.com>
+
+ PR rtl-optimization/67226
+ * calls.c (store_one_arg): Take into account
+@@ -2256,7 +3055,7 @@
+
+ Backport from mainline
+ 2015-11-24 Bernd Schmidt <bschmidt@redhat.com>
+- Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++ Kyrylo Tkachov <kyrylo.tkachov@arm.com>
+
+ PR rtl-optimization/68194
+ PR rtl-optimization/68328
+@@ -2529,7 +3328,7 @@
+
+ Backport from mainline
+ 2015-11-16 Oleg Endo <olegendo@gcc.gnu.org>
+- Kaz Kojima <kkojima@gcc.gnu.org>
++ Kaz Kojima <kkojima@gcc.gnu.org>
+
+ PR target/68277
+ * config/sh/sh.md (addsi3_scr): Handle reg overlap of operands[0] and
+@@ -2603,7 +3402,7 @@
+
+ Backport from mainline
+ 2015-10-23 Steve Ellcey <sellcey@imgtec.com>
+- Andrew Pinski <apinski@cavium.com>
++ Andrew Pinski <apinski@cavium.com>
+
+ PR rtl-optimization/67736
+ * combine.c (simplify_comparison): Use gen_lowpart_or_truncate instead
+diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
+index 4b57e77..cd07604 100644
+--- a/gcc/DATESTAMP
++++ b/gcc/DATESTAMP
+@@ -1 +1 @@
+-20160603
++20161227
+diff --git a/gcc/Makefile.in b/gcc/Makefile.in
+index 07c6f0a..89bef14 100644
+--- a/gcc/Makefile.in
++++ b/gcc/Makefile.in
+@@ -2639,7 +2639,7 @@ build/gcov-iov$(build_exeext): build/gcov-iov.o
+ +$(LINKER_FOR_BUILD) $(BUILD_LINKERFLAGS) $(BUILD_LDFLAGS) \
+ build/gcov-iov.o -o $@
+
+-gcov-iov.h: s-iov
++gcov-iov.h: s-iov; @true
+ s-iov: build/gcov-iov$(build_exeext) $(BASEVER) $(DEVPHASE)
+ build/gcov-iov$(build_exeext) '$(BASEVER_c)' '$(DEVPHASE_c)' \
+ > tmp-gcov-iov.h
+@@ -3739,7 +3739,7 @@ check_p_subdirs=$(wordlist 1,$(check_p_count),$(wordlist 1, \
+ # variable (see above check_gcc_parallelize description).
+ $(lang_checks_parallelized): check-% : site.exp
+ -rm -rf $(TESTSUITEDIR)/$*-parallel
+- @if [ "$(filter -j, $(MFLAGS))" = "-j" ]; then \
++ @if [ -n "$(filter -j%, $(MFLAGS))" ]; then \
+ test -d $(TESTSUITEDIR) || mkdir $(TESTSUITEDIR) || true; \
+ test -d $(TESTSUITEDIR)/$*-parallel || mkdir $(TESTSUITEDIR)/$*-parallel || true; \
+ GCC_RUNTEST_PARALLELIZE_DIR=`${PWD_COMMAND}`/$(TESTSUITEDIR)/$(check_p_tool)-parallel ; \
+diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
+index 9b0a98b..8f904d3 100644
+--- a/gcc/ada/ChangeLog
++++ b/gcc/ada/ChangeLog
+@@ -1,3 +1,74 @@
++2016-11-22 Uros Bizjak <ubizjak@gmail.com>
++
++ * gcc-interface/Make-lang.in (check-acats): Fix detection
++ of -j argument.
++
++2016-11-13 Bob Duff <duff@adacore.com>
++
++ * gcc-interface/decl.c (gnat_to_gnu_entity): In assertion about known
++ Esize, protect with !is_type and change !Unknown_Esize to Known_Esize.
++
++2016-11-02 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ Backport from mainline
++ 2016-10-24 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ * gcc-interface/Make-lang.in (lang_checks_parallelized): New target.
++ (check_gnat_parallelize): Likewise.
++
++2016-10-17 Eric Botcazou <ebotcazou@adacore.com>
++
++ * system-darwin-ppc64.ads (Support_64_Bit_Divides): Delete.
++ * system-linux-armeb.ads (Support_64_Bit_Divides): Likewise.
++ * system-linux-mips.ads (Support_64_Bit_Divides): Likewise.
++ * system-linux-mips64el.ads (Support_64_Bit_Divides): Likewise.
++ * system-linux-mipsel.ads (Support_64_Bit_Divides): Likewise.
++ * system-linux-sparcv9.ads (Support_64_Bit_Divides): Likewise.
++ * system-rtems.ads (Support_64_Bit_Divides): Likewise.
++
++2016-10-16 Eric Botcazou <ebotcazou@adacore.com>
++
++ * system-aix.ads (Always_Compatible_Rep): Change to False.
++ * system-aix64.ads (Always_Compatible_Rep): Likewise.
++ * system-hpux-ia64.ads (Always_Compatible_Rep): Likewise.
++ * system-hpux.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-alpha.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-hppa.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-ia64.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-mips.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-mips64el.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-mipsel.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-s390.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-s390x.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-sh4.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-sparc.ads (Always_Compatible_Rep): Likewise.
++ * system-linux-sparcv9.ads (Always_Compatible_Rep): Likewise.
++ * system-rtems.ads (Always_Compatible_Rep): Likewise.
++
++2016-10-11 Eric Botcazou <ebotcazou@adacore.com>
++
++ Backport from mainline
++ 2016-10-11 Eric Botcazou <ebotcazou@adacore.com>
++
++ * system-linux-armeb.ads (Backend_Overflow_Checks): Change to True.
++ * system-linux-mips.ads (Backend_Overflow_Checks): Likewise.
++ * system-linux-mips64el.ads (Backend_Overflow_Checks): Likewise.
++ * system-linux-mipsel.ads (Backend_Overflow_Checks): Likewise.
++ * system-linux-sparcv9.ads (Backend_Overflow_Checks): Likewise.
++ * system-rtems.ads (Always_Compatible_Rep): Likewise.
++
++ 2016-10-11 Eric Botcazou <ebotcazou@adacore.com>
++ Tristan Gingold <gingold@adacore.com>
++
++ * system-linux-ppc64.ads: Delete.
++ * system-linux-ppc.ads: Make 32-bit/64-bit neutral.
++ * gcc-interface/Makefile.in (PowerPC/Linux): Simplify.
++
++2016-10-10 Eric Botcazou <ebotcazou@adacore.com>
++
++ * gcc-interface/utils.c (convert): For a biased input type, convert
++ the bias itself to the base type before adding it.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/gcc/ada/gcc-interface/Make-lang.in b/gcc/ada/gcc-interface/Make-lang.in
+index 45e463d..72ccae5 100644
+--- a/gcc/ada/gcc-interface/Make-lang.in
++++ b/gcc/ada/gcc-interface/Make-lang.in
+@@ -861,6 +861,9 @@ ada.stagefeedback: stagefeedback-start
+ -$(MV) ada/stamp-* stagefeedback/ada
+
+ lang_checks += check-gnat
++lang_checks_parallelized += check-gnat
++# For description see the check_$lang_parallelize comment in gcc/Makefile.in.
++check_gnat_parallelize = 1000
+
+ check-ada: check-acats check-gnat
+ check-ada-subtargets: check-acats-subtargets check-gnat-subtargets
+@@ -884,7 +887,7 @@ check-acats:
+ @test -d $(ACATSDIR) || mkdir -p $(ACATSDIR); \
+ rootme=`${PWD_COMMAND}`; export rootme; \
+ EXPECT=$(EXPECT); export EXPECT; \
+- if [ -z "$(CHAPTERS)" ] && [ "$(filter -j, $(MFLAGS))" = "-j" ]; \
++ if [ -z "$(CHAPTERS)" ] && [ -n "$(filter -j%, $(MFLAGS))" ]; \
+ then \
+ rm -rf $(ACATSDIR)-parallel; \
+ mkdir $(ACATSDIR)-parallel; \
+diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in
+index c9ee7b5..3aaa64f 100644
+--- a/gcc/ada/gcc-interface/Makefile.in
++++ b/gcc/ada/gcc-interface/Makefile.in
+@@ -1813,41 +1813,26 @@ ifeq ($(strip $(filter-out powerpc% linux%,$(target_cpu) $(target_os))),)
+ s-tpopsp.adb<s-tpopsp-tls.adb \
+ g-sercom.adb<g-sercom-linux.adb \
+ $(ATOMICS_TARGET_PAIRS) \
+- $(ATOMICS_BUILTINS_TARGET_PAIRS)
++ $(ATOMICS_BUILTINS_TARGET_PAIRS) \
++ system.ads<system-linux-ppc.ads
+
+ ifeq ($(strip $(filter-out xenomai,$(THREAD_KIND))),)
+ LIBGNAT_TARGET_PAIRS = \
+- $(LIBGNAT_TARGET_PAIRS_COMMON)
+-
+- LIBGNAT_TARGET_PAIRS += \
+- s-osinte.ads<s-osinte-linux-xenomai.ads \
+- s-osprim.adb<s-osprim-linux-xenomai.adb \
+- s-taprop.adb<s-taprop-linux-xenomai.adb \
+- s-taspri.ads<s-taspri-linux-xenomai.ads \
+- system.ads<system-linux-ppc.ads
++ $(LIBGNAT_TARGET_PAIRS_COMMON) \
++ s-osinte.ads<s-osinte-linux-xenomai.ads \
++ s-osprim.adb<s-osprim-linux-xenomai.adb \
++ s-taprop.adb<s-taprop-linux-xenomai.adb \
++ s-taspri.ads<s-taspri-linux-xenomai.ads
+ else
+- LIBGNAT_TARGET_PAIRS_32 = \
+- system.ads<system-linux-ppc.ads
+-
+- LIBGNAT_TARGET_PAIRS_64 = \
+- system.ads<system-linux-ppc64.ads
+-
+- ifneq (,$(or $(filter powerpc64%, $(shell $(GCC_FOR_TARGET) $(GNATLIBCFLAGS) -print-multiarch)), $(filter ../lib64, $(shell $(GCC_FOR_TARGET) $(GNATLIBCFLAGS) -print-multi-os-directory))))
+- LIBGNAT_TARGET_PAIRS = \
+- $(LIBGNAT_TARGET_PAIRS_COMMON) $(LIBGNAT_TARGET_PAIRS_64)
+- else
+- LIBGNAT_TARGET_PAIRS = \
+- $(LIBGNAT_TARGET_PAIRS_COMMON) $(LIBGNAT_TARGET_PAIRS_32)
+- endif
+-
+- LIBGNAT_TARGET_PAIRS += \
+- s-mudido.adb<s-mudido-affinity.adb \
+- s-osinte.ads<s-osinte-linux.ads \
+- s-osprim.adb<s-osprim-posix.adb \
+- s-taprop.adb<s-taprop-linux.adb \
+- s-tasinf.ads<s-tasinf-linux.ads \
+- s-tasinf.adb<s-tasinf-linux.adb \
+- s-taspri.ads<s-taspri-posix-noaltstack.ads
++ LIBGNAT_TARGET_PAIRS = \
++ $(LIBGNAT_TARGET_PAIRS_COMMON) \
++ s-mudido.adb<s-mudido-affinity.adb \
++ s-osinte.ads<s-osinte-linux.ads \
++ s-osprim.adb<s-osprim-posix.adb \
++ s-taprop.adb<s-taprop-linux.adb \
++ s-tasinf.ads<s-tasinf-linux.ads \
++ s-tasinf.adb<s-tasinf-linux.adb \
++ s-taspri.ads<s-taspri-posix-noaltstack.ads
+ endif
+
+ TOOLS_TARGET_PAIRS = \
+diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
+index d3f3089..243758b 100644
+--- a/gcc/ada/gcc-interface/decl.c
++++ b/gcc/ada/gcc-interface/decl.c
+@@ -361,7 +361,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
+ must be specified unless it was specified by the programmer. Exceptions
+ are for access-to-protected-subprogram types and all access subtypes, as
+ another GNAT type is used to lay out the GCC type for them. */
+- gcc_assert (!Unknown_Esize (gnat_entity)
++ gcc_assert (!is_type
++ || Known_Esize (gnat_entity)
+ || Has_Size_Clause (gnat_entity)
+ || (!IN (kind, Numeric_Kind)
+ && !IN (kind, Enumeration_Kind)
+diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
+index 6834012..ce53e93 100644
+--- a/gcc/ada/gcc-interface/utils.c
++++ b/gcc/ada/gcc-interface/utils.c
+@@ -4086,12 +4086,15 @@ convert (tree type, tree expr)
+ return convert (type, unpadded);
+ }
+
+- /* If the input is a biased type, adjust first. */
++ /* If the input is a biased type, convert first to the base type and add
++ the bias. Note that the bias must go through a full conversion to the
++ base type, lest it is itself a biased value; this happens for subtypes
++ of biased types. */
+ if (ecode == INTEGER_TYPE && TYPE_BIASED_REPRESENTATION_P (etype))
+ return convert (type, fold_build2 (PLUS_EXPR, TREE_TYPE (etype),
+ fold_convert (TREE_TYPE (etype), expr),
+- fold_convert (TREE_TYPE (etype),
+- TYPE_MIN_VALUE (etype))));
++ convert (TREE_TYPE (etype),
++ TYPE_MIN_VALUE (etype))));
+
+ /* If the input is a justified modular type, we need to extract the actual
+ object before converting it to any other type with the exceptions of an
+@@ -4393,7 +4396,12 @@ convert (tree type, tree expr)
+ && (ecode == ARRAY_TYPE || ecode == UNCONSTRAINED_ARRAY_TYPE
+ || (ecode == RECORD_TYPE && TYPE_CONTAINS_TEMPLATE_P (etype))))
+ return unchecked_convert (type, expr, false);
+- else if (TYPE_BIASED_REPRESENTATION_P (type))
++
++ /* If the output is a biased type, convert first to the base type and
++ subtract the bias. Note that the bias itself must go through a full
++ conversion to the base type, lest it is a biased value; this happens
++ for subtypes of biased types. */
++ if (TYPE_BIASED_REPRESENTATION_P (type))
+ return fold_convert (type,
+ fold_build2 (MINUS_EXPR, TREE_TYPE (type),
+ convert (TREE_TYPE (type), expr),
+diff --git a/gcc/ada/system-aix.ads b/gcc/ada/system-aix.ads
+index 4a14f64..06190b7 100644
+--- a/gcc/ada/system-aix.ads
++++ b/gcc/ada/system-aix.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (AIX/PPC Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -148,7 +148,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-aix64.ads b/gcc/ada/system-aix64.ads
+index fd881bc..55df8de 100644
+--- a/gcc/ada/system-aix64.ads
++++ b/gcc/ada/system-aix64.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (PPC/AIX64 Version) --
+ -- --
+--- Copyright (C) 2009-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 2009-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -148,7 +148,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-darwin-ppc64.ads b/gcc/ada/system-darwin-ppc64.ads
+index ebd5ada..6c6fc9d 100644
+--- a/gcc/ada/system-darwin-ppc64.ads
++++ b/gcc/ada/system-darwin-ppc64.ads
+@@ -138,7 +138,6 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := False;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Atomic_Primitives : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+diff --git a/gcc/ada/system-hpux-ia64.ads b/gcc/ada/system-hpux-ia64.ads
+index 2fb0f78..a1223ff 100644
+--- a/gcc/ada/system-hpux-ia64.ads
++++ b/gcc/ada/system-hpux-ia64.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (HP-UX/ia64 Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -139,7 +139,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-hpux.ads b/gcc/ada/system-hpux.ads
+index bc3052b..1a3e599 100644
+--- a/gcc/ada/system-hpux.ads
++++ b/gcc/ada/system-hpux.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (HP-UX Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-alpha.ads b/gcc/ada/system-linux-alpha.ads
+index c364496..c511a87 100644
+--- a/gcc/ada/system-linux-alpha.ads
++++ b/gcc/ada/system-linux-alpha.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/alpha Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-armeb.ads b/gcc/ada/system-linux-armeb.ads
+index 2d8f344..4fe426a 100644
+--- a/gcc/ada/system-linux-armeb.ads
++++ b/gcc/ada/system-linux-armeb.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/ARMEB Version) --
+ -- --
+--- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -127,7 +127,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -142,7 +142,6 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := True;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+@@ -150,6 +149,6 @@ private
+ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+- ZCX_By_Default : constant Boolean := False;
++ ZCX_By_Default : constant Boolean := True;
+
+ end System;
+diff --git a/gcc/ada/system-linux-hppa.ads b/gcc/ada/system-linux-hppa.ads
+index 4d3b2af..4d0bbca 100644
+--- a/gcc/ada/system-linux-hppa.ads
++++ b/gcc/ada/system-linux-hppa.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU/Linux-HPPA Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-ia64.ads b/gcc/ada/system-linux-ia64.ads
+index c1a8ca1..1683534 100644
+--- a/gcc/ada/system-linux-ia64.ads
++++ b/gcc/ada/system-linux-ia64.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/ia64 Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -147,7 +147,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-mips.ads b/gcc/ada/system-linux-mips.ads
+index f34f665..69e92d0 100644
+--- a/gcc/ada/system-linux-mips.ads
++++ b/gcc/ada/system-linux-mips.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/MIPS Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -119,7 +119,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -134,12 +134,11 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := True;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-mips64el.ads b/gcc/ada/system-linux-mips64el.ads
+index e4093cd..9c16790 100644
+--- a/gcc/ada/system-linux-mips64el.ads
++++ b/gcc/ada/system-linux-mips64el.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/MIPS64EL Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -119,7 +119,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -134,12 +134,11 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := True;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-mipsel.ads b/gcc/ada/system-linux-mipsel.ads
+index 53415c8..b8aa474 100644
+--- a/gcc/ada/system-linux-mipsel.ads
++++ b/gcc/ada/system-linux-mipsel.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/MIPSEL Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -119,7 +119,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -134,12 +134,11 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := True;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-ppc.ads b/gcc/ada/system-linux-ppc.ads
+index 927bd85..d47c35c 100644
+--- a/gcc/ada/system-linux-ppc.ads
++++ b/gcc/ada/system-linux-ppc.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/PPC Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -69,8 +69,8 @@ package System is
+ Null_Address : constant Address;
+
+ Storage_Unit : constant := 8;
+- Word_Size : constant := 32;
+- Memory_Size : constant := 2 ** 32;
++ Word_Size : constant := Standard'Word_Size;
++ Memory_Size : constant := 2 ** Word_Size;
+
+ -- Address comparison
+
+diff --git a/gcc/ada/system-linux-ppc64.ads b/gcc/ada/system-linux-ppc64.ads
+deleted file mode 100644
+index a9862f4..0000000
+--- a/gcc/ada/system-linux-ppc64.ads
++++ /dev/null
+@@ -1,155 +0,0 @@
+-------------------------------------------------------------------------------
+--- --
+--- GNAT RUN-TIME COMPONENTS --
+--- --
+--- S Y S T E M --
+--- --
+--- S p e c --
+--- (GNU-Linux/PPC64 Version) --
+--- --
+--- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
+--- --
+--- This specification is derived from the Ada Reference Manual for use with --
+--- GNAT. The copyright notice above, and the license provisions that follow --
+--- apply solely to the contents of the part following the private keyword. --
+--- --
+--- GNAT is free software; you can redistribute it and/or modify it under --
+--- terms of the GNU General Public License as published by the Free Soft- --
+--- ware Foundation; either version 3, or (at your option) any later ver- --
+--- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
+--- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
+--- or FITNESS FOR A PARTICULAR PURPOSE. --
+--- --
+--- As a special exception under Section 7 of GPL version 3, you are granted --
+--- additional permissions described in the GCC Runtime Library Exception, --
+--- version 3.1, as published by the Free Software Foundation. --
+--- --
+--- You should have received a copy of the GNU General Public License and --
+--- a copy of the GCC Runtime Library Exception along with this program; --
+--- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
+--- <http://www.gnu.org/licenses/>. --
+--- --
+--- GNAT was originally developed by the GNAT team at New York University. --
+--- Extensive contributions were provided by Ada Core Technologies Inc. --
+--- --
+-------------------------------------------------------------------------------
+-
+-package System is
+- pragma Pure;
+- -- Note that we take advantage of the implementation permission to make
+- -- this unit Pure instead of Preelaborable; see RM 13.7.1(15). In Ada
+- -- 2005, this is Pure in any case (AI-362).
+-
+- pragma No_Elaboration_Code_All;
+- -- Allow the use of that restriction in units that WITH this unit
+-
+- type Name is (SYSTEM_NAME_GNAT);
+- System_Name : constant Name := SYSTEM_NAME_GNAT;
+-
+- -- System-Dependent Named Numbers
+-
+- Min_Int : constant := Long_Long_Integer'First;
+- Max_Int : constant := Long_Long_Integer'Last;
+-
+- Max_Binary_Modulus : constant := 2 ** Long_Long_Integer'Size;
+- Max_Nonbinary_Modulus : constant := 2 ** Integer'Size - 1;
+-
+- Max_Base_Digits : constant := Long_Long_Float'Digits;
+- Max_Digits : constant := Long_Long_Float'Digits;
+-
+- Max_Mantissa : constant := 63;
+- Fine_Delta : constant := 2.0 ** (-Max_Mantissa);
+-
+- Tick : constant := 0.000_001;
+-
+- -- Storage-related Declarations
+-
+- type Address is private;
+- pragma Preelaborable_Initialization (Address);
+- Null_Address : constant Address;
+-
+- Storage_Unit : constant := 8;
+- Word_Size : constant := 64;
+- Memory_Size : constant := 2 ** 64;
+-
+- -- Address comparison
+-
+- function "<" (Left, Right : Address) return Boolean;
+- function "<=" (Left, Right : Address) return Boolean;
+- function ">" (Left, Right : Address) return Boolean;
+- function ">=" (Left, Right : Address) return Boolean;
+- function "=" (Left, Right : Address) return Boolean;
+-
+- pragma Import (Intrinsic, "<");
+- pragma Import (Intrinsic, "<=");
+- pragma Import (Intrinsic, ">");
+- pragma Import (Intrinsic, ">=");
+- pragma Import (Intrinsic, "=");
+-
+- -- Other System-Dependent Declarations
+-
+- type Bit_Order is (High_Order_First, Low_Order_First);
+- Default_Bit_Order : constant Bit_Order := High_Order_First;
+- pragma Warnings (Off, Default_Bit_Order); -- kill constant condition warning
+-
+- -- Priority-related Declarations (RM D.1)
+-
+- -- 0 .. 98 corresponds to the system priority range 1 .. 99.
+- --
+- -- If the scheduling policy is SCHED_FIFO or SCHED_RR the runtime makes use
+- -- of the entire range provided by the system.
+- --
+- -- If the scheduling policy is SCHED_OTHER the only valid system priority
+- -- is 1 and other values are simply ignored.
+-
+- Max_Priority : constant Positive := 97;
+- Max_Interrupt_Priority : constant Positive := 98;
+-
+- subtype Any_Priority is Integer range 0 .. 98;
+- subtype Priority is Any_Priority range 0 .. 97;
+- subtype Interrupt_Priority is Any_Priority range 98 .. 98;
+-
+- Default_Priority : constant Priority := 48;
+-
+-private
+-
+- type Address is mod Memory_Size;
+- Null_Address : constant Address := 0;
+-
+- --------------------------------------
+- -- System Implementation Parameters --
+- --------------------------------------
+-
+- -- These parameters provide information about the target that is used
+- -- by the compiler. They are in the private part of System, where they
+- -- can be accessed using the special circuitry in the Targparm unit
+- -- whose source should be consulted for more detailed descriptions
+- -- of the individual switch values.
+-
+- Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
+- Command_Line_Args : constant Boolean := True;
+- Configurable_Run_Time : constant Boolean := False;
+- Denorm : constant Boolean := True;
+- Duration_32_Bits : constant Boolean := False;
+- Exit_Status_Supported : constant Boolean := True;
+- Fractional_Fixed_Ops : constant Boolean := False;
+- Frontend_Layout : constant Boolean := False;
+- Machine_Overflows : constant Boolean := False;
+- Machine_Rounds : constant Boolean := True;
+- Preallocated_Stacks : constant Boolean := False;
+- Signed_Zeros : constant Boolean := True;
+- Stack_Check_Default : constant Boolean := False;
+- Stack_Check_Probes : constant Boolean := True;
+- Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+- Support_Aggregates : constant Boolean := True;
+- Support_Composite_Assign : constant Boolean := True;
+- Support_Composite_Compare : constant Boolean := True;
+- Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := False;
+- Suppress_Standard_Library : constant Boolean := False;
+- Use_Ada_Main_Program_Name : constant Boolean := False;
+- ZCX_By_Default : constant Boolean := True;
+-
+-end System;
+diff --git a/gcc/ada/system-linux-s390.ads b/gcc/ada/system-linux-s390.ads
+index 1765a22..cd99ddf 100644
+--- a/gcc/ada/system-linux-s390.ads
++++ b/gcc/ada/system-linux-s390.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/s390 Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-s390x.ads b/gcc/ada/system-linux-s390x.ads
+index 0e41be3..a07ec39 100644
+--- a/gcc/ada/system-linux-s390x.ads
++++ b/gcc/ada/system-linux-s390x.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/s390x Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-sh4.ads b/gcc/ada/system-linux-sh4.ads
+index d3590a1..be2a7af 100644
+--- a/gcc/ada/system-linux-sh4.ads
++++ b/gcc/ada/system-linux-sh4.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU-Linux/sh4 Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -146,7 +146,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-sparc.ads b/gcc/ada/system-linux-sparc.ads
+index 1ad20e2..a6f74c0 100644
+--- a/gcc/ada/system-linux-sparc.ads
++++ b/gcc/ada/system-linux-sparc.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU/Linux-SPARC Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-linux-sparcv9.ads b/gcc/ada/system-linux-sparcv9.ads
+index 8adf4f3..2b976f5 100644
+--- a/gcc/ada/system-linux-sparcv9.ads
++++ b/gcc/ada/system-linux-sparcv9.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (GNU/Linux-SPARCV9 Version) --
+ -- --
+--- Copyright (C) 1992-2014, Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -119,7 +119,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -134,12 +134,11 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := True;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := True;
+diff --git a/gcc/ada/system-rtems.ads b/gcc/ada/system-rtems.ads
+index 1ab644c..7665ca8 100644
+--- a/gcc/ada/system-rtems.ads
++++ b/gcc/ada/system-rtems.ads
+@@ -7,7 +7,7 @@
+ -- S p e c --
+ -- (Compiler Version) --
+ -- --
+--- Copyright (C) 1992-2014 Free Software Foundation, Inc. --
++-- Copyright (C) 1992-2016 Free Software Foundation, Inc. --
+ -- --
+ -- This specification is derived from the Ada Reference Manual for use with --
+ -- GNAT. The copyright notice above, and the license provisions that follow --
+@@ -138,7 +138,7 @@ private
+ -- of the individual switch values.
+
+ Backend_Divide_Checks : constant Boolean := False;
+- Backend_Overflow_Checks : constant Boolean := False;
++ Backend_Overflow_Checks : constant Boolean := True;
+ Command_Line_Args : constant Boolean := True;
+ Configurable_Run_Time : constant Boolean := False;
+ Denorm : constant Boolean := True;
+@@ -153,12 +153,11 @@ private
+ Stack_Check_Default : constant Boolean := False;
+ Stack_Check_Probes : constant Boolean := False;
+ Stack_Check_Limits : constant Boolean := False;
+- Support_64_Bit_Divides : constant Boolean := True;
+ Support_Aggregates : constant Boolean := True;
+ Support_Composite_Assign : constant Boolean := True;
+ Support_Composite_Compare : constant Boolean := True;
+ Support_Long_Shifts : constant Boolean := True;
+- Always_Compatible_Rep : constant Boolean := True;
++ Always_Compatible_Rep : constant Boolean := False;
+ Suppress_Standard_Library : constant Boolean := False;
+ Use_Ada_Main_Program_Name : constant Boolean := False;
+ ZCX_By_Default : constant Boolean := False;
+diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog
+index 9f5c0e9..8d5304a 100644
+--- a/gcc/c-family/ChangeLog
++++ b/gcc/c-family/ChangeLog
+@@ -1,3 +1,17 @@
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-06-13 Jakub Jelinek <jakub@redhat.com>
++
++ PR sanitizer/71498
++ * c-gimplify.c (ubsan_walk_array_refs_r): Set *walk_subtrees = 0 on
++ all BIND_EXPRs, and on all BIND_EXPRs recurse also on BIND_EXPR_BODY.
++
++2016-07-05 Markus Trippelsdorf <markus@trippelsdorf.de>
++
++ PR c++/71214
++ * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_rvalue_references.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/gcc/c-family/c-cppbuiltin.c b/gcc/c-family/c-cppbuiltin.c
+index 60c2d7f..2ab7727 100644
+--- a/gcc/c-family/c-cppbuiltin.c
++++ b/gcc/c-family/c-cppbuiltin.c
+@@ -856,6 +856,7 @@ c_cpp_builtins (cpp_reader *pfile)
+ cpp_define (pfile, "__cpp_decltype=200707");
+ cpp_define (pfile, "__cpp_attributes=200809");
+ cpp_define (pfile, "__cpp_rvalue_reference=200610");
++ cpp_define (pfile, "__cpp_rvalue_references=200610");
+ cpp_define (pfile, "__cpp_variadic_templates=200704");
+ cpp_define (pfile, "__cpp_initializer_lists=200806");
+ cpp_define (pfile, "__cpp_delegating_constructors=200604");
+diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c
+index 4e7a96f..c6a67a1 100644
+--- a/gcc/c-family/c-gimplify.c
++++ b/gcc/c-family/c-gimplify.c
+@@ -96,23 +96,23 @@ ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data)
+ {
+ hash_set<tree> *pset = (hash_set<tree> *) data;
+
+- /* Since walk_tree doesn't call the callback function on the decls
+- in BIND_EXPR_VARS, we have to walk them manually. */
+ if (TREE_CODE (*tp) == BIND_EXPR)
+ {
++ /* Since walk_tree doesn't call the callback function on the decls
++ in BIND_EXPR_VARS, we have to walk them manually, so we can avoid
++ instrumenting DECL_INITIAL of TREE_STATIC vars. */
++ *walk_subtrees = 0;
+ for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
+ {
+ if (TREE_STATIC (decl))
+- {
+- *walk_subtrees = 0;
+- continue;
+- }
++ continue;
+ walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset,
+ pset);
+ walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset);
+ walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset,
+ pset);
+ }
++ walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset);
+ }
+ else if (TREE_CODE (*tp) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF)
+diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
+index d9a8b4e..85f9e9a 100644
+--- a/gcc/c/ChangeLog
++++ b/gcc/c/ChangeLog
+@@ -1,3 +1,11 @@
++2016-11-05 Martin Sebor <msebor@redhat.com>
++
++ Backport from trunk.
++ PR c/71115
++ * c-typeck.c (error_init): Use
++ expansion_point_location_if_in_system_header.
++ (warning_init): Same.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
+index be4967f..15a1fc9 100644
+--- a/gcc/c/c-typeck.c
++++ b/gcc/c/c-typeck.c
+@@ -5632,16 +5632,21 @@ error_init (location_t loc, const char *gmsgid)
+ component name is taken from the spelling stack. */
+
+ static void
+-pedwarn_init (location_t location, int opt, const char *gmsgid)
++pedwarn_init (location_t loc, int opt, const char *gmsgid)
+ {
+ char *ofwhat;
+ bool warned;
+
++ /* Use the location where a macro was expanded rather than where
++ it was defined to make sure macros defined in system headers
++ but used incorrectly elsewhere are diagnosed. */
++ source_location exploc = expansion_point_location_if_in_system_header (loc);
++
+ /* The gmsgid may be a format string with %< and %>. */
+- warned = pedwarn (location, opt, gmsgid);
++ warned = pedwarn (exploc, opt, gmsgid);
+ ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
+ if (*ofwhat && warned)
+- inform (location, "(near initialization for %qs)", ofwhat);
++ inform (exploc, "(near initialization for %qs)", ofwhat);
+ }
+
+ /* Issue a warning for a bad initializer component.
+@@ -5656,11 +5661,16 @@ warning_init (location_t loc, int opt, const char *gmsgid)
+ char *ofwhat;
+ bool warned;
+
++ /* Use the location where a macro was expanded rather than where
++ it was defined to make sure macros defined in system headers
++ but used incorrectly elsewhere are diagnosed. */
++ source_location exploc = expansion_point_location_if_in_system_header (loc);
++
+ /* The gmsgid may be a format string with %< and %>. */
+- warned = warning_at (loc, opt, gmsgid);
++ warned = warning_at (exploc, opt, gmsgid);
+ ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
+ if (*ofwhat && warned)
+- inform (loc, "(near initialization for %qs)", ofwhat);
++ inform (exploc, "(near initialization for %qs)", ofwhat);
+ }
+
+ /* If TYPE is an array type and EXPR is a parenthesized string
+diff --git a/gcc/combine.c b/gcc/combine.c
+index 16048bf..a6c1344 100644
+--- a/gcc/combine.c
++++ b/gcc/combine.c
+@@ -7726,10 +7726,12 @@ extract_left_shift (rtx x, int count)
+
+ We try, as much as possible, to re-use rtl expressions to save memory.
+
+- IN_CODE says what kind of expression we are processing. Normally, it is
+- SET. In a memory address (inside a MEM, PLUS or minus, the latter two
+- being kludges), it is MEM. When processing the arguments of a comparison
+- or a COMPARE against zero, it is COMPARE. */
++ IN_CODE says what kind of expression we are processing. Normally,
++ it is SET. In a memory address (inside a MEM, PLUS or minus, the
++ latter two being kludges), it is MEM. When processing the
++ arguments of a comparison or a COMPARE against zero, it is COMPARE,
++ or EQ if more + precisely it is an equality comparison against
++ zero.. */
+
+ rtx
+ make_compound_operation (rtx x, enum rtx_code in_code)
+@@ -7743,11 +7745,17 @@ make_compound_operation (rtx x, enum rtx_code in_code)
+ rtx new_rtx = 0;
+ rtx tem;
+ const char *fmt;
++ bool equality_comparison = false;
+
+ /* Select the code to be used in recursive calls. Once we are inside an
+ address, we stay there. If we have a comparison, set to COMPARE,
+ but once inside, go back to our default of SET. */
+
++ if (in_code == EQ)
++ {
++ equality_comparison = true;
++ in_code = COMPARE;
++ }
+ next_code = (code == MEM ? MEM
+ : ((code == PLUS || code == MINUS)
+ && SCALAR_INT_MODE_P (mode)) ? MEM
+@@ -7935,11 +7943,12 @@ make_compound_operation (rtx x, enum rtx_code in_code)
+ /* If we are in a comparison and this is an AND with a power of two,
+ convert this into the appropriate bit extract. */
+ else if (in_code == COMPARE
+- && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0)
++ && (i = exact_log2 (UINTVAL (XEXP (x, 1)))) >= 0
++ && (equality_comparison || i < GET_MODE_PRECISION (mode) - 1))
+ new_rtx = make_extraction (mode,
+- make_compound_operation (XEXP (x, 0),
+- next_code),
+- i, NULL_RTX, 1, 1, 0, 1);
++ make_compound_operation (XEXP (x, 0),
++ next_code),
++ i, NULL_RTX, 1, 1, 0, 1);
+
+ break;
+
+@@ -12253,7 +12262,11 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
+ We can never remove a SUBREG for a non-equality comparison because
+ the sign bit is in a different place in the underlying object. */
+
+- op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
++ rtx_code op0_mco_code = SET;
++ if (op1 == const0_rtx)
++ op0_mco_code = code == NE || code == EQ ? EQ : COMPARE;
++
++ op0 = make_compound_operation (op0, op0_mco_code);
+ op1 = make_compound_operation (op1, SET);
+
+ if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
+@@ -13041,6 +13054,12 @@ get_last_value (const_rtx x)
+ && DF_INSN_LUID (rsp->last_set) >= subst_low_luid)
+ return 0;
+
++ /* If fewer bits were set than what we are asked for now, we cannot use
++ the value. */
++ if (GET_MODE_PRECISION (rsp->last_set_mode)
++ < GET_MODE_PRECISION (GET_MODE (x)))
++ return 0;
++
+ /* If the value has all its registers valid, return it. */
+ if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 0))
+ return value;
+diff --git a/gcc/common/config/i386/i386-common.c b/gcc/common/config/i386/i386-common.c
+index 0f8c3e1..0a6b4a2 100644
+--- a/gcc/common/config/i386/i386-common.c
++++ b/gcc/common/config/i386/i386-common.c
+@@ -86,7 +86,6 @@ along with GCC; see the file COPYING3. If not see
+ #define OPTION_MASK_ISA_XSAVEC_SET \
+ (OPTION_MASK_ISA_XSAVEC | OPTION_MASK_ISA_XSAVE)
+ #define OPTION_MASK_ISA_CLWB_SET OPTION_MASK_ISA_CLWB
+-#define OPTION_MASK_ISA_PCOMMIT_SET OPTION_MASK_ISA_PCOMMIT
+
+ /* SSE4 includes both SSE4.1 and SSE4.2. -msse4 should be the same
+ as -msse4.2. */
+@@ -185,7 +184,6 @@ along with GCC; see the file COPYING3. If not see
+ #define OPTION_MASK_ISA_CLFLUSHOPT_UNSET OPTION_MASK_ISA_CLFLUSHOPT
+ #define OPTION_MASK_ISA_XSAVEC_UNSET OPTION_MASK_ISA_XSAVEC
+ #define OPTION_MASK_ISA_XSAVES_UNSET OPTION_MASK_ISA_XSAVES
+-#define OPTION_MASK_ISA_PCOMMIT_UNSET OPTION_MASK_ISA_PCOMMIT
+ #define OPTION_MASK_ISA_CLWB_UNSET OPTION_MASK_ISA_CLWB
+ #define OPTION_MASK_ISA_MWAITX_UNSET OPTION_MASK_ISA_MWAITX
+
+@@ -908,19 +906,6 @@ ix86_handle_option (struct gcc_options *opts,
+ }
+ return true;
+
+- case OPT_mpcommit:
+- if (value)
+- {
+- opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PCOMMIT_SET;
+- opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCOMMIT_SET;
+- }
+- else
+- {
+- opts->x_ix86_isa_flags &= ~OPTION_MASK_ISA_PCOMMIT_UNSET;
+- opts->x_ix86_isa_flags_explicit |= OPTION_MASK_ISA_PCOMMIT_UNSET;
+- }
+- return true;
+-
+ case OPT_mclwb:
+ if (value)
+ {
+diff --git a/gcc/config.gcc b/gcc/config.gcc
+index c835734..313af3f 100644
+--- a/gcc/config.gcc
++++ b/gcc/config.gcc
+@@ -367,7 +367,7 @@ i[34567]86-*-*)
+ xsavesintrin.h avx512dqintrin.h avx512bwintrin.h
+ avx512vlintrin.h avx512vlbwintrin.h avx512vldqintrin.h
+ avx512ifmaintrin.h avx512ifmavlintrin.h avx512vbmiintrin.h
+- avx512vbmivlintrin.h clwbintrin.h pcommitintrin.h mwaitxintrin.h"
++ avx512vbmivlintrin.h clwbintrin.h mwaitxintrin.h"
+ ;;
+ x86_64-*-*)
+ cpu_type=i386
+@@ -388,7 +388,7 @@ x86_64-*-*)
+ xsavesintrin.h avx512dqintrin.h avx512bwintrin.h
+ avx512vlintrin.h avx512vlbwintrin.h avx512vldqintrin.h
+ avx512ifmaintrin.h avx512ifmavlintrin.h avx512vbmiintrin.h
+- avx512vbmivlintrin.h clwbintrin.h pcommitintrin.h mwaitxintrin.h"
++ avx512vbmivlintrin.h clwbintrin.h mwaitxintrin.h"
+ ;;
+ ia64-*-*)
+ extra_headers=ia64intrin.h
+@@ -790,6 +790,11 @@ case ${target} in
+ ;;
+ esac
+ ;;
++*-*-phoenix*)
++ gas=yes
++ gnu_ld=yes
++ default_use_cxa_atexit=yes
++ ;;
+ *-*-rtems*)
+ case ${enable_threads} in
+ "" | yes | rtems) thread_file='rtems' ;;
+@@ -1026,11 +1031,9 @@ arm*-*-freebsd*) # ARM FreeBSD EABI
+ case $target in
+ armv6*-*-freebsd*)
+ tm_defines="${tm_defines} TARGET_FREEBSD_ARMv6=1"
+- ;;
+- esac
+- case $target in
+- arm*hf-*-freebsd*)
+- tm_defines="${tm_defines} TARGET_FREEBSD_ARM_HARD_FLOAT=1"
++ if test $fbsd_major -ge 11; then
++ tm_defines="${tm_defines} TARGET_FREEBSD_ARM_HARD_FLOAT=1"
++ fi
+ ;;
+ esac
+ with_tls=${with_tls:-gnu}
+@@ -1067,6 +1070,12 @@ arm*-*-uclinux*eabi*) # ARM ucLinux
+ # The EABI requires the use of __cxa_atexit.
+ default_use_cxa_atexit=yes
+ ;;
++arm*-*-phoenix*)
++ tm_file="elfos.h arm/unknown-elf.h arm/elf.h arm/bpabi.h"
++ tm_file="${tm_file} newlib-stdint.h phoenix.h"
++ tm_file="${tm_file} arm/aout.h arm/arm.h"
++ tmake_file="${tmake_file} arm/t-arm arm/t-bpabi arm/t-phoenix"
++ ;;
+ arm*-*-eabi* | arm*-*-symbianelf* | arm*-*-rtems*)
+ case ${target} in
+ arm*eb-*-eabi*)
+diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md
+index 116fd89..501ae44 100644
+--- a/gcc/config/aarch64/aarch64.md
++++ b/gcc/config/aarch64/aarch64.md
+@@ -687,6 +687,13 @@
+ && (GET_CODE (XEXP (operands[0], 0)) != SYMBOL_REF))
+ XEXP (operands[0], 0) = force_reg (Pmode, XEXP (operands[0], 0));
+
++ /* This is a band-aid. An SImode symbol reference is sometimes generated
++ by expand_expr_addr_expr. See PR 64971. */
++ if (TARGET_ILP32
++ && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF
++ && GET_MODE (XEXP (operands[0], 0)) == SImode)
++ XEXP (operands[0], 0) = convert_memory_address (Pmode,
++ XEXP (operands[0], 0));
+ if (operands[2] == NULL_RTX)
+ operands[2] = const0_rtx;
+
+@@ -717,6 +724,14 @@
+ && (GET_CODE (XEXP (operands[1], 0)) != SYMBOL_REF))
+ XEXP (operands[1], 0) = force_reg (Pmode, XEXP (operands[1], 0));
+
++ /* This is a band-aid. An SImode symbol reference is sometimes generated
++ by expand_expr_addr_expr. See PR 64971. */
++ if (TARGET_ILP32
++ && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
++ && GET_MODE (XEXP (operands[1], 0)) == SImode)
++ XEXP (operands[1], 0) = convert_memory_address (Pmode,
++ XEXP (operands[1], 0));
++
+ if (operands[3] == NULL_RTX)
+ operands[3] = const0_rtx;
+
+diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
+index 8c95c78..5c97562 100644
+--- a/gcc/config/arm/arm.c
++++ b/gcc/config/arm/arm.c
+@@ -6481,7 +6481,7 @@ arm_function_ok_for_sibcall (tree decl, tree exp)
+
+ /* The PIC register is live on entry to VxWorks PLT entries, so we
+ must make the call before restoring the PIC register. */
+- if (TARGET_VXWORKS_RTP && flag_pic && !targetm.binds_local_p (decl))
++ if (TARGET_VXWORKS_RTP && flag_pic && decl && !targetm.binds_local_p (decl))
+ return false;
+
+ /* If we are interworking and the function is not declared static
+@@ -24457,6 +24457,7 @@ thumb1_expand_prologue (void)
+ unsigned long live_regs_mask;
+ unsigned long l_mask;
+ unsigned high_regs_pushed = 0;
++ bool lr_needs_saving;
+
+ func_type = arm_current_func_type ();
+
+@@ -24479,6 +24480,7 @@ thumb1_expand_prologue (void)
+
+ offsets = arm_get_frame_offsets ();
+ live_regs_mask = offsets->saved_regs_mask;
++ lr_needs_saving = live_regs_mask & (1 << LR_REGNUM);
+
+ /* Extract a mask of the ones we can give to the Thumb's push instruction. */
+ l_mask = live_regs_mask & 0x40ff;
+@@ -24545,6 +24547,7 @@ thumb1_expand_prologue (void)
+ {
+ insn = thumb1_emit_multi_reg_push (l_mask, l_mask);
+ RTX_FRAME_RELATED_P (insn) = 1;
++ lr_needs_saving = false;
+
+ offset = bit_count (l_mask) * UNITS_PER_WORD;
+ }
+@@ -24609,12 +24612,13 @@ thumb1_expand_prologue (void)
+ be a push of LR and we can combine it with the push of the first high
+ register. */
+ else if ((l_mask & 0xff) != 0
+- || (high_regs_pushed == 0 && l_mask))
++ || (high_regs_pushed == 0 && lr_needs_saving))
+ {
+ unsigned long mask = l_mask;
+ mask |= (1 << thumb1_extra_regs_pushed (offsets, true)) - 1;
+ insn = thumb1_emit_multi_reg_push (mask, mask);
+ RTX_FRAME_RELATED_P (insn) = 1;
++ lr_needs_saving = false;
+ }
+
+ if (high_regs_pushed)
+@@ -24632,7 +24636,9 @@ thumb1_expand_prologue (void)
+ /* Here we need to mask out registers used for passing arguments
+ even if they can be pushed. This is to avoid using them to stash the high
+ registers. Such kind of stash may clobber the use of arguments. */
+- pushable_regs = l_mask & (~arg_regs_mask) & 0xff;
++ pushable_regs = l_mask & (~arg_regs_mask);
++ if (lr_needs_saving)
++ pushable_regs &= ~(1 << LR_REGNUM);
+
+ if (pushable_regs == 0)
+ pushable_regs = 1 << thumb_find_work_register (live_regs_mask);
+@@ -24640,8 +24646,9 @@ thumb1_expand_prologue (void)
+ while (high_regs_pushed > 0)
+ {
+ unsigned long real_regs_mask = 0;
++ unsigned long push_mask = 0;
+
+- for (regno = LAST_LO_REGNUM; regno >= 0; regno --)
++ for (regno = LR_REGNUM; regno >= 0; regno --)
+ {
+ if (pushable_regs & (1 << regno))
+ {
+@@ -24650,6 +24657,7 @@ thumb1_expand_prologue (void)
+
+ high_regs_pushed --;
+ real_regs_mask |= (1 << next_hi_reg);
++ push_mask |= (1 << regno);
+
+ if (high_regs_pushed)
+ {
+@@ -24659,23 +24667,20 @@ thumb1_expand_prologue (void)
+ break;
+ }
+ else
+- {
+- pushable_regs &= ~((1 << regno) - 1);
+- break;
+- }
++ break;
+ }
+ }
+
+ /* If we had to find a work register and we have not yet
+ saved the LR then add it to the list of regs to push. */
+- if (l_mask == (1 << LR_REGNUM))
++ if (lr_needs_saving)
+ {
+- pushable_regs |= l_mask;
+- real_regs_mask |= l_mask;
+- l_mask = 0;
++ push_mask |= 1 << LR_REGNUM;
++ real_regs_mask |= 1 << LR_REGNUM;
++ lr_needs_saving = false;
+ }
+
+- insn = thumb1_emit_multi_reg_push (pushable_regs, real_regs_mask);
++ insn = thumb1_emit_multi_reg_push (push_mask, real_regs_mask);
+ RTX_FRAME_RELATED_P (insn) = 1;
+ }
+ }
+diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
+index 32e015d..faa08e47 100644
+--- a/gcc/config/arm/arm.md
++++ b/gcc/config/arm/arm.md
+@@ -567,9 +567,9 @@
+ ;; (plus (reg rN) (reg sp)) into (reg rN). In this case reload will
+ ;; put the duplicated register first, and not try the commutative version.
+ (define_insn_and_split "*arm_addsi3"
+- [(set (match_operand:SI 0 "s_register_operand" "=rk,l,l ,l ,r ,k ,r,r ,k ,r ,k,k,r ,k ,r")
+- (plus:SI (match_operand:SI 1 "s_register_operand" "%0 ,l,0 ,l ,rk,k ,r,rk,k ,rk,k,r,rk,k ,rk")
+- (match_operand:SI 2 "reg_or_int_operand" "rk ,l,Py,Pd,rI,rI,k,Pj,Pj,L ,L,L,PJ,PJ,?n")))]
++ [(set (match_operand:SI 0 "s_register_operand" "=rk,l,l ,l ,r ,k ,r,k ,r ,k ,r ,k,k,r ,k ,r")
++ (plus:SI (match_operand:SI 1 "s_register_operand" "%0 ,l,0 ,l ,rk,k ,r,r ,rk,k ,rk,k,r,rk,k ,rk")
++ (match_operand:SI 2 "reg_or_int_operand" "rk ,l,Py,Pd,rI,rI,k,rI,Pj,Pj,L ,L,L,PJ,PJ,?n")))]
+ "TARGET_32BIT"
+ "@
+ add%?\\t%0, %0, %2
+@@ -579,6 +579,7 @@
+ add%?\\t%0, %1, %2
+ add%?\\t%0, %1, %2
+ add%?\\t%0, %2, %1
++ add%?\\t%0, %1, %2
+ addw%?\\t%0, %1, %2
+ addw%?\\t%0, %1, %2
+ sub%?\\t%0, %1, #%n2
+@@ -598,10 +599,10 @@
+ operands[1], 0);
+ DONE;
+ "
+- [(set_attr "length" "2,4,4,4,4,4,4,4,4,4,4,4,4,4,16")
++ [(set_attr "length" "2,4,4,4,4,4,4,4,4,4,4,4,4,4,4,16")
+ (set_attr "predicable" "yes")
+- (set_attr "predicable_short_it" "yes,yes,yes,yes,no,no,no,no,no,no,no,no,no,no,no")
+- (set_attr "arch" "t2,t2,t2,t2,*,*,*,t2,t2,*,*,a,t2,t2,*")
++ (set_attr "predicable_short_it" "yes,yes,yes,yes,no,no,no,no,no,no,no,no,no,no,no,no")
++ (set_attr "arch" "t2,t2,t2,t2,*,*,*,a,t2,t2,*,*,a,t2,t2,*")
+ (set (attr "type") (if_then_else (match_operand 2 "const_int_operand" "")
+ (const_string "alu_imm")
+ (const_string "alu_sreg")))
+diff --git a/gcc/config/arm/freebsd.h b/gcc/config/arm/freebsd.h
+index 040d7c1..807027a 100644
+--- a/gcc/config/arm/freebsd.h
++++ b/gcc/config/arm/freebsd.h
+@@ -120,11 +120,15 @@
+ #define SUBTARGET_CPU_DEFAULT TARGET_CPU_arm9
+ #endif
+
++/* FreeBSD 10 does not support unaligned access for armv6 and up.
++ Unaligned access support was added in FreeBSD 11. */
++#if FBSD_MAJOR < 11
+ #define SUBTARGET_OVERRIDE_OPTIONS \
+ do { \
+ if (unaligned_access) \
+ unaligned_access = 0; \
+ } while (0)
++#endif
+
+ #undef MAX_SYNC_LIBFUNC_SIZE
+ #define MAX_SYNC_LIBFUNC_SIZE 4 /* UNITS_PER_WORD not defined yet. */
+diff --git a/gcc/config/arm/t-phoenix b/gcc/config/arm/t-phoenix
+new file mode 100644
+index 0000000..d881884
+--- /dev/null
++++ b/gcc/config/arm/t-phoenix
+@@ -0,0 +1,29 @@
++# Copyright (C) 2016 Free Software Foundation, Inc.
++#
++# This file is part of GCC.
++#
++# GCC is free software; you can redistribute it and/or modify
++# it under the terms of the GNU General Public License as published by
++# the Free Software Foundation; either version 3, or (at your option)
++# any later version.
++#
++# GCC 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 General Public License for more details.
++#
++# You should have received a copy of the GNU General Public License
++# along with GCC; see the file COPYING3. If not see
++# <http://www.gnu.org/licenses/>.
++
++MULTILIB_OPTIONS = marm/mthumb
++MULTILIB_DIRNAMES = arm thumb
++MULTILIB_EXCEPTIONS =
++MULTILIB_MATCHES =
++
++MULTILIB_OPTIONS += mfloat-abi=hard
++MULTILIB_DIRNAMES += fpu
++MULTILIB_MATCHES += mfloat-abi?hard=mhard-float
++
++MULTILIB_OPTIONS += mno-thumb-interwork/mthumb-interwork
++MULTILIB_DIRNAMES += normal interwork
+diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c
+index 75cdd3b..4ffb38c 100644
+--- a/gcc/config/avr/avr.c
++++ b/gcc/config/avr/avr.c
+@@ -22,9 +22,9 @@
+ #include "system.h"
+ #include "coretypes.h"
+ #include "tm.h"
++#include "hard-reg-set.h"
+ #include "rtl.h"
+ #include "regs.h"
+-#include "hard-reg-set.h"
+ #include "insn-config.h"
+ #include "conditions.h"
+ #include "insn-attr.h"
+@@ -2526,8 +2526,44 @@ avr_notice_update_cc (rtx body ATTRIBUTE_UNUSED, rtx_insn *insn)
+ break;
+
+ case CC_NONE:
+- /* Insn does not affect CC at all. */
+- break;
++ /* Insn does not affect CC at all, but it might set some registers
++ that are stored in cc_status. If such a register is affected by
++ the current insn, for example by means of a SET or a CLOBBER,
++ then we must reset cc_status; cf. PR77326.
++
++ Unfortunately, set_of cannot be used as reg_overlap_mentioned_p
++ will abort on COMPARE (which might be found in cc_status.value1/2).
++ Thus work out the registers set by the insn and regs mentioned
++ in cc_status.value1/2. */
++
++ if (cc_status.value1
++ || cc_status.value2)
++ {
++ HARD_REG_SET regs_used;
++ HARD_REG_SET regs_set;
++ CLEAR_HARD_REG_SET (regs_used);
++
++ if (cc_status.value1
++ && !CONSTANT_P (cc_status.value1))
++ {
++ find_all_hard_regs (cc_status.value1, &regs_used);
++ }
++
++ if (cc_status.value2
++ && !CONSTANT_P (cc_status.value2))
++ {
++ find_all_hard_regs (cc_status.value2, &regs_used);
++ }
++
++ find_all_hard_reg_sets (insn, &regs_set, false);
++
++ if (hard_reg_set_intersect_p (regs_used, regs_set))
++ {
++ CC_STATUS_INIT;
++ }
++ }
++
++ break; // CC_NONE
+
+ case CC_SET_N:
+ CC_STATUS_INIT;
+@@ -9086,6 +9122,8 @@ avr_eval_addr_attrib (rtx x)
+ if (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_IO)
+ {
+ attr = lookup_attribute ("io", DECL_ATTRIBUTES (decl));
++ if (!attr || !TREE_VALUE (attr))
++ attr = lookup_attribute ("io_low", DECL_ATTRIBUTES (decl));
+ gcc_assert (attr);
+ }
+ if (!attr || !TREE_VALUE (attr))
+@@ -10199,6 +10237,7 @@ avr_rtx_costs_1 (rtx x, int codearg, int outer_code ATTRIBUTE_UNUSED,
+ break;
+
+ case SImode:
++ case DImode:
+ if (AVR_HAVE_MUL)
+ {
+ if (!speed)
+@@ -10224,7 +10263,10 @@ avr_rtx_costs_1 (rtx x, int codearg, int outer_code ATTRIBUTE_UNUSED,
+ *total = COSTS_N_INSNS (AVR_HAVE_JMP_CALL ? 5 : 4);
+ }
+
+- return true;
++ if (mode == DImode)
++ *total *= 2;
++
++ return true;
+
+ default:
+ return false;
+@@ -10801,7 +10843,7 @@ avr_address_cost (rtx x, machine_mode mode ATTRIBUTE_UNUSED,
+ && (REG_P (XEXP (x, 0))
+ || GET_CODE (XEXP (x, 0)) == SUBREG))
+ {
+- if (INTVAL (XEXP (x, 1)) >= 61)
++ if (INTVAL (XEXP (x, 1)) > MAX_LD_OFFSET(mode))
+ cost = 18;
+ }
+ else if (CONSTANT_ADDRESS_P (x))
+diff --git a/gcc/config/avr/avr.md b/gcc/config/avr/avr.md
+index 1b39ddb..881f374 100644
+--- a/gcc/config/avr/avr.md
++++ b/gcc/config/avr/avr.md
+@@ -112,12 +112,12 @@
+ (define_attr "length" ""
+ (cond [(eq_attr "type" "branch")
+ (if_then_else (and (ge (minus (pc) (match_dup 0))
+- (const_int -63))
++ (const_int -62))
+ (le (minus (pc) (match_dup 0))
+ (const_int 62)))
+ (const_int 1)
+ (if_then_else (and (ge (minus (pc) (match_dup 0))
+- (const_int -2045))
++ (const_int -2044))
+ (le (minus (pc) (match_dup 0))
+ (const_int 2045)))
+ (const_int 2)
+@@ -641,6 +641,22 @@
+ if (avr_mem_flash_p (dest))
+ DONE;
+
++ if (QImode == <MODE>mode
++ && SUBREG_P (src)
++ && CONSTANT_ADDRESS_P (SUBREG_REG (src))
++ && can_create_pseudo_p())
++ {
++ // store_bitfield may want to store a SYMBOL_REF or CONST in a
++ // structure that's represented as PSImode. As the upper 16 bits
++ // of PSImode cannot be expressed as an HImode subreg, the rhs is
++ // decomposed into QImode (word_mode) subregs of SYMBOL_REF,
++ // CONST or LABEL_REF; cf. PR71103.
++
++ rtx const_addr = SUBREG_REG (src);
++ operands[1] = src = copy_rtx (src);
++ SUBREG_REG (src) = copy_to_mode_reg (GET_MODE (const_addr), const_addr);
++ }
++
+ /* One of the operands has to be in a register. */
+ if (!register_operand (dest, <MODE>mode)
+ && !reg_or_0_operand (src, <MODE>mode))
+diff --git a/gcc/config/avr/gen-avr-mmcu-specs.c b/gcc/config/avr/gen-avr-mmcu-specs.c
+index d21125b..b78bb62 100644
+--- a/gcc/config/avr/gen-avr-mmcu-specs.c
++++ b/gcc/config/avr/gen-avr-mmcu-specs.c
+@@ -27,7 +27,7 @@
+
+ #include "avr-devices.c"
+
+-// Get rid of "defaults.h". We just need tm.h for `WITH_AVRLIBS' and
++// Get rid of "defaults.h". We just need tm.h for `WITH_AVRLIBC' and
+ // and `WITH_RTEMS'. */
+ #define GCC_DEFAULTS_H
+
+@@ -242,12 +242,13 @@ print_mcu (const avr_mcu_t *mcu)
+ fprintf (f, "*link_data_start:\n");
+ if (mcu->data_section_start
+ != arch->default_data_section_start)
+- fprintf (f, "\t-Tdata 0x%lX", 0x800000UL + mcu->data_section_start);
++ fprintf (f, "\t%%{!Tdata:-Tdata 0x%lX}",
++ 0x800000UL + mcu->data_section_start);
+ fprintf (f, "\n\n");
+
+ fprintf (f, "*link_text_start:\n");
+ if (mcu->text_section_start != 0x0)
+- fprintf (f, "\t-Ttext 0x%lX", 0UL + mcu->text_section_start);
++ fprintf (f, "\t%%{!Ttext:-Ttext 0x%lX}", 0UL + mcu->text_section_start);
+ fprintf (f, "\n\n");
+ }
+
+diff --git a/gcc/config/avr/gen-avr-mmcu-texi.c b/gcc/config/avr/gen-avr-mmcu-texi.c
+index ea0de49..6d9517b 100644
+--- a/gcc/config/avr/gen-avr-mmcu-texi.c
++++ b/gcc/config/avr/gen-avr-mmcu-texi.c
+@@ -19,6 +19,7 @@
+
+ #include <stdlib.h>
+ #include <stdio.h>
++#include <string.h>
+
+ #define IN_GEN_AVR_MMCU_TEXI
+
+diff --git a/gcc/config/i386/avx512bwintrin.h b/gcc/config/i386/avx512bwintrin.h
+index 3114849..7a7ed68 100644
+--- a/gcc/config/i386/avx512bwintrin.h
++++ b/gcc/config/i386/avx512bwintrin.h
+@@ -270,9 +270,8 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_broadcastb_epi8 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastb512_mask ((__v16qi) __A,
+- (__v64qi)_mm512_undefined_si512(),
+- (__mmask64) -
+- 1);
++ (__v64qi)_mm512_undefined_epi32(),
++ (__mmask64) -1);
+ }
+
+ extern __inline __m512i
+@@ -318,8 +317,8 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_broadcastw_epi16 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastw512_mask ((__v8hi) __A,
+- (__v32hi)_mm512_undefined_si512(),
+- (__mmask32)-1);
++ (__v32hi)_mm512_undefined_epi32(),
++ (__mmask32) -1);
+ }
+
+ extern __inline __m512i
+@@ -588,8 +587,7 @@ _mm512_permutex2var_epi16 (__m512i __A, __m512i __I, __m512i __B)
+ /* idx */ ,
+ (__v32hi) __A,
+ (__v32hi) __B,
+- (__mmask32) -
+- 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __m512i
+@@ -2284,7 +2282,7 @@ _mm512_cmpneq_epu8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_ucmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 4,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2293,7 +2291,7 @@ _mm512_cmplt_epu8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_ucmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 1,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2302,7 +2300,7 @@ _mm512_cmpge_epu8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_ucmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 5,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2311,7 +2309,7 @@ _mm512_cmple_epu8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_ucmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 2,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2320,7 +2318,7 @@ _mm512_cmpneq_epu16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 4,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2329,7 +2327,7 @@ _mm512_cmplt_epu16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 1,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2338,7 +2336,7 @@ _mm512_cmpge_epu16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 5,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2347,7 +2345,7 @@ _mm512_cmple_epu16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 2,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2356,7 +2354,7 @@ _mm512_cmpneq_epi8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_cmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 4,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2365,7 +2363,7 @@ _mm512_cmplt_epi8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_cmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 1,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2374,7 +2372,7 @@ _mm512_cmpge_epi8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_cmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 5,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask64
+@@ -2383,7 +2381,7 @@ _mm512_cmple_epi8_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask64) __builtin_ia32_cmpb512_mask ((__v64qi) __X,
+ (__v64qi) __Y, 2,
+- (__mmask64) - 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2392,7 +2390,7 @@ _mm512_cmpneq_epi16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 4,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2401,7 +2399,7 @@ _mm512_cmplt_epi16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 1,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2410,7 +2408,7 @@ _mm512_cmpge_epi16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 5,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2419,7 +2417,7 @@ _mm512_cmple_epi16_mask (__m512i __X, __m512i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpw512_mask ((__v32hi) __X,
+ (__v32hi) __Y, 2,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ #ifdef __OPTIMIZE__
+diff --git a/gcc/config/i386/avx512dqintrin.h b/gcc/config/i386/avx512dqintrin.h
+index b36ef48..dd46f72 100644
+--- a/gcc/config/i386/avx512dqintrin.h
++++ b/gcc/config/i386/avx512dqintrin.h
+@@ -41,8 +41,7 @@ _mm512_broadcast_f64x2 (__m128d __A)
+ return (__m512d) __builtin_ia32_broadcastf64x2_512_mask ((__v2df)
+ __A,
+ _mm512_undefined_pd(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512d
+@@ -72,9 +71,8 @@ _mm512_broadcast_i64x2 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_broadcasti64x2_512_mask ((__v2di)
+ __A,
+- _mm512_undefined_si512(),
+- (__mmask8) -
+- 1);
++ _mm512_undefined_epi32(),
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512i
+@@ -104,8 +102,7 @@ _mm512_broadcast_f32x2 (__m128 __A)
+ {
+ return (__m512) __builtin_ia32_broadcastf32x2_512_mask ((__v4sf) __A,
+ (__v16sf)_mm512_undefined_ps(),
+- (__mmask16) -
+- 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __m512
+@@ -133,9 +130,8 @@ _mm512_broadcast_i32x2 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_broadcasti32x2_512_mask ((__v4si)
+ __A,
+- (__v16si)_mm512_undefined_si512(),
+- (__mmask16)
+- -1);
++ (__v16si)_mm512_undefined_epi32(),
++ (__mmask16) -1);
+ }
+
+ extern __inline __m512i
+@@ -165,8 +161,7 @@ _mm512_broadcast_f32x8 (__m256 __A)
+ {
+ return (__m512) __builtin_ia32_broadcastf32x8_512_mask ((__v8sf) __A,
+ _mm512_undefined_ps(),
+- (__mmask16) -
+- 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __m512
+@@ -194,9 +189,8 @@ _mm512_broadcast_i32x8 (__m256i __A)
+ {
+ return (__m512i) __builtin_ia32_broadcasti32x8_512_mask ((__v8si)
+ __A,
+- (__v16si)_mm512_undefined_si512(),
+- (__mmask16)
+- -1);
++ (__v16si)_mm512_undefined_epi32(),
++ (__mmask16) -1);
+ }
+
+ extern __inline __m512i
+@@ -1569,8 +1563,7 @@ _mm512_extractf64x2_pd (__m512d __A, const int __imm)
+ __imm,
+ (__v2df)
+ _mm_setzero_pd (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128d
+@@ -1640,8 +1633,7 @@ _mm512_extracti64x2_epi64 (__m512i __A, const int __imm)
+ __imm,
+ (__v2di)
+ _mm_setzero_di (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -1829,8 +1821,7 @@ _mm512_inserti64x2 (__m512i __A, __m128i __B, const int __imm)
+ __imm,
+ (__v8di)
+ _mm512_setzero_si512 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512i
+@@ -1869,8 +1860,7 @@ _mm512_insertf64x2 (__m512d __A, __m128d __B, const int __imm)
+ __imm,
+ (__v8df)
+ _mm512_setzero_pd (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512d
+@@ -1933,8 +1923,7 @@ _mm512_fpclass_ps_mask (__m512 __A, const int __imm)
+ {
+ return (__mmask16) __builtin_ia32_fpclassps512_mask ((__v16sf) __A,
+ __imm,
+- (__mmask16) -
+- 1);
++ (__mmask16) -1);
+ }
+
+ #else
+diff --git a/gcc/config/i386/avx512fintrin.h b/gcc/config/i386/avx512fintrin.h
+index d7e7020..184e9e8 100644
+--- a/gcc/config/i386/avx512fintrin.h
++++ b/gcc/config/i386/avx512fintrin.h
+@@ -130,12 +130,14 @@ _mm512_undefined_pd (void)
+
+ extern __inline __m512i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+-_mm512_undefined_si512 (void)
++_mm512_undefined_epi32 (void)
+ {
+ __m512i __Y = __Y;
+ return __Y;
+ }
+
++#define _mm512_undefined_si512 _mm512_undefined_epi32
++
+ extern __inline __m512i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_set1_epi8 (char __A)
+@@ -549,7 +551,7 @@ _mm512_sllv_epi32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_psllv16si_mask ((__v16si) __X,
+ (__v16si) __Y,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -581,7 +583,7 @@ _mm512_srav_epi32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_psrav16si_mask ((__v16si) __X,
+ (__v16si) __Y,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -613,7 +615,7 @@ _mm512_srlv_epi32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_psrlv16si_mask ((__v16si) __X,
+ (__v16si) __Y,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -733,7 +735,7 @@ _mm512_srav_epi64 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_psrav8di_mask ((__v8di) __X,
+ (__v8di) __Y,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -765,7 +767,7 @@ _mm512_srlv_epi64 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_psrlv8di_mask ((__v8di) __X,
+ (__v8di) __Y,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -825,7 +827,7 @@ _mm512_mul_epi32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_pmuldq512_mask ((__v16si) __X,
+ (__v16si) __Y,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -884,7 +886,7 @@ _mm512_mul_epu32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_pmuludq512_mask ((__v16si) __X,
+ (__v16si) __Y,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -915,7 +917,7 @@ _mm512_slli_epi64 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_psllqi512_mask ((__v8di) __A, __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -941,7 +943,7 @@ _mm512_maskz_slli_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_slli_epi64(X, C) \
+ ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C),\
+- (__v8di)(__m512i)_mm512_undefined_si512 (),\
++ (__v8di)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask8)-1))
+
+ #define _mm512_mask_slli_epi64(W, U, X, C) \
+@@ -962,7 +964,7 @@ _mm512_sll_epi64 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_psllq512_mask ((__v8di) __A,
+ (__v2di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -994,7 +996,7 @@ _mm512_srli_epi64 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_psrlqi512_mask ((__v8di) __A, __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1020,7 +1022,7 @@ _mm512_maskz_srli_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_srli_epi64(X, C) \
+ ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C),\
+- (__v8di)(__m512i)_mm512_undefined_si512 (),\
++ (__v8di)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask8)-1))
+
+ #define _mm512_mask_srli_epi64(W, U, X, C) \
+@@ -1041,7 +1043,7 @@ _mm512_srl_epi64 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_psrlq512_mask ((__v8di) __A,
+ (__v2di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1073,7 +1075,7 @@ _mm512_srai_epi64 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_psraqi512_mask ((__v8di) __A, __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1099,7 +1101,7 @@ _mm512_maskz_srai_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_srai_epi64(X, C) \
+ ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C),\
+- (__v8di)(__m512i)_mm512_undefined_si512 (),\
++ (__v8di)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask8)-1))
+
+ #define _mm512_mask_srai_epi64(W, U, X, C) \
+@@ -1120,7 +1122,7 @@ _mm512_sra_epi64 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_psraq512_mask ((__v8di) __A,
+ (__v2di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1152,7 +1154,7 @@ _mm512_slli_epi32 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_pslldi512_mask ((__v16si) __A, __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1178,7 +1180,7 @@ _mm512_maskz_slli_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_slli_epi32(X, C) \
+ ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C),\
+- (__v16si)(__m512i)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_slli_epi32(W, U, X, C) \
+@@ -1199,7 +1201,7 @@ _mm512_sll_epi32 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_pslld512_mask ((__v16si) __A,
+ (__v4si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1231,7 +1233,7 @@ _mm512_srli_epi32 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_psrldi512_mask ((__v16si) __A, __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1257,7 +1259,7 @@ _mm512_maskz_srli_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_srli_epi32(X, C) \
+ ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C),\
+- (__v16si)(__m512i)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_srli_epi32(W, U, X, C) \
+@@ -1278,7 +1280,7 @@ _mm512_srl_epi32 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_psrld512_mask ((__v16si) __A,
+ (__v4si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1310,7 +1312,7 @@ _mm512_srai_epi32 (__m512i __A, unsigned int __B)
+ {
+ return (__m512i) __builtin_ia32_psradi512_mask ((__v16si) __A, __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1336,7 +1338,7 @@ _mm512_maskz_srai_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
+ #else
+ #define _mm512_srai_epi32(X, C) \
+ ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C),\
+- (__v16si)(__m512i)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_srai_epi32(W, U, X, C) \
+@@ -1357,7 +1359,7 @@ _mm512_sra_epi32 (__m512i __A, __m128i __B)
+ return (__m512i) __builtin_ia32_psrad512_mask ((__v16si) __A,
+ (__v4si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1778,7 +1780,7 @@ _mm512_cvtepi8_epi32 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovsxbd512_mask ((__v16qi) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1807,7 +1809,7 @@ _mm512_cvtepi8_epi64 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovsxbq512_mask ((__v16qi) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1836,7 +1838,7 @@ _mm512_cvtepi16_epi32 (__m256i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovsxwd512_mask ((__v16hi) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1865,7 +1867,7 @@ _mm512_cvtepi16_epi64 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovsxwq512_mask ((__v8hi) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1894,7 +1896,7 @@ _mm512_cvtepi32_epi64 (__m256i __X)
+ {
+ return (__m512i) __builtin_ia32_pmovsxdq512_mask ((__v8si) __X,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1923,7 +1925,7 @@ _mm512_cvtepu8_epi32 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovzxbd512_mask ((__v16qi) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -1952,7 +1954,7 @@ _mm512_cvtepu8_epi64 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovzxbq512_mask ((__v16qi) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -1981,7 +1983,7 @@ _mm512_cvtepu16_epi32 (__m256i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovzxwd512_mask ((__v16hi) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -2010,7 +2012,7 @@ _mm512_cvtepu16_epi64 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pmovzxwq512_mask ((__v8hi) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -2039,7 +2041,7 @@ _mm512_cvtepu32_epi64 (__m256i __X)
+ {
+ return (__m512i) __builtin_ia32_pmovzxdq512_mask ((__v8si) __X,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -3407,7 +3409,7 @@ _mm512_abs_epi64 (__m512i __A)
+ {
+ return (__m512i) __builtin_ia32_pabsq512_mask ((__v8di) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -3436,7 +3438,7 @@ _mm512_abs_epi32 (__m512i __A)
+ {
+ return (__m512i) __builtin_ia32_pabsd512_mask ((__v16si) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -3521,7 +3523,7 @@ _mm512_broadcastd_epi32 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastd512 ((__v4si) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -3549,7 +3551,7 @@ _mm512_set1_epi32 (int __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastd512_gpr_mask (__A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16)(-1));
+ }
+
+@@ -3577,7 +3579,7 @@ _mm512_broadcastq_epi64 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastq512 ((__v2di) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -3605,7 +3607,7 @@ _mm512_set1_epi64 (long long __A)
+ {
+ return (__m512i) __builtin_ia32_pbroadcastq512_gpr_mask (__A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8)(-1));
+ }
+
+@@ -3662,7 +3664,7 @@ _mm512_broadcast_i32x4 (__m128i __A)
+ {
+ return (__m512i) __builtin_ia32_broadcasti32x4_512 ((__v4si) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -3720,7 +3722,7 @@ _mm512_broadcast_i64x4 (__m256i __A)
+ {
+ return (__m512i) __builtin_ia32_broadcasti64x4_512 ((__v4di) __A,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -3841,7 +3843,7 @@ _mm512_shuffle_epi32 (__m512i __A, _MM_PERM_ENUM __mask)
+ return (__m512i) __builtin_ia32_pshufd512_mask ((__v16si) __A,
+ __mask,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -3874,7 +3876,7 @@ _mm512_shuffle_i64x2 (__m512i __A, __m512i __B, const int __imm)
+ return (__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di) __A,
+ (__v8di) __B, __imm,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -3909,7 +3911,7 @@ _mm512_shuffle_i32x4 (__m512i __A, __m512i __B, const int __imm)
+ (__v16si) __B,
+ __imm,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -4009,7 +4011,7 @@ _mm512_maskz_shuffle_f32x4 (__mmask16 __U, __m512 __A, __m512 __B,
+ #else
+ #define _mm512_shuffle_epi32(X, C) \
+ ((__m512i) __builtin_ia32_pshufd512_mask ((__v16si)(__m512i)(X), (int)(C),\
+- (__v16si)(__m512i)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_shuffle_epi32(W, U, X, C) \
+@@ -4025,7 +4027,7 @@ _mm512_maskz_shuffle_f32x4 (__mmask16 __U, __m512 __A, __m512 __B,
+ #define _mm512_shuffle_i64x2(X, Y, C) \
+ ((__m512i) __builtin_ia32_shuf_i64x2_mask ((__v8di)(__m512i)(X), \
+ (__v8di)(__m512i)(Y), (int)(C),\
+- (__v8di)(__m512i)_mm512_undefined_si512 (),\
++ (__v8di)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask8)-1))
+
+ #define _mm512_mask_shuffle_i64x2(W, U, X, Y, C) \
+@@ -4043,7 +4045,7 @@ _mm512_maskz_shuffle_f32x4 (__mmask16 __U, __m512 __A, __m512 __B,
+ #define _mm512_shuffle_i32x4(X, Y, C) \
+ ((__m512i) __builtin_ia32_shuf_i32x4_mask ((__v16si)(__m512i)(X), \
+ (__v16si)(__m512i)(Y), (int)(C),\
+- (__v16si)(__m512i)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_shuffle_i32x4(W, U, X, Y, C) \
+@@ -4102,7 +4104,7 @@ _mm512_rolv_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_prolvd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -4134,7 +4136,7 @@ _mm512_rorv_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_prorvd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -4166,7 +4168,7 @@ _mm512_rolv_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_prolvq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -4198,7 +4200,7 @@ _mm512_rorv_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_prorvq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -4390,7 +4392,7 @@ _mm512_cvtt_roundps_epi32 (__m512 __A, const int __R)
+ {
+ return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1, __R);
+ }
+
+@@ -4420,7 +4422,7 @@ _mm512_cvtt_roundps_epu32 (__m512 __A, const int __R)
+ {
+ return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1, __R);
+ }
+
+@@ -4445,7 +4447,7 @@ _mm512_maskz_cvtt_roundps_epu32 (__mmask16 __U, __m512 __A, const int __R)
+ }
+ #else
+ #define _mm512_cvtt_roundps_epi32(A, B) \
+- ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
++ ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_undefined_epi32 (), -1, B))
+
+ #define _mm512_mask_cvtt_roundps_epi32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)(W), U, B))
+@@ -4454,7 +4456,7 @@ _mm512_maskz_cvtt_roundps_epu32 (__mmask16 __U, __m512 __A, const int __R)
+ ((__m512i)__builtin_ia32_cvttps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
+
+ #define _mm512_cvtt_roundps_epu32(A, B) \
+- ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
++ ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)_mm512_undefined_epi32 (), -1, B))
+
+ #define _mm512_mask_cvtt_roundps_epu32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_cvttps2udq512_mask(A, (__v16si)(W), U, B))
+@@ -4470,7 +4472,7 @@ _mm512_cvt_roundps_epi32 (__m512 __A, const int __R)
+ {
+ return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1, __R);
+ }
+
+@@ -4500,7 +4502,7 @@ _mm512_cvt_roundps_epu32 (__m512 __A, const int __R)
+ {
+ return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1, __R);
+ }
+
+@@ -4525,7 +4527,7 @@ _mm512_maskz_cvt_roundps_epu32 (__mmask16 __U, __m512 __A, const int __R)
+ }
+ #else
+ #define _mm512_cvt_roundps_epi32(A, B) \
+- ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
++ ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_undefined_epi32 (), -1, B))
+
+ #define _mm512_mask_cvt_roundps_epi32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)(W), U, B))
+@@ -4534,7 +4536,7 @@ _mm512_maskz_cvt_roundps_epu32 (__mmask16 __U, __m512 __A, const int __R)
+ ((__m512i)__builtin_ia32_cvtps2dq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
+
+ #define _mm512_cvt_roundps_epu32(A, B) \
+- ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_undefined_si512 (), -1, B))
++ ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_undefined_epi32 (), -1, B))
+
+ #define _mm512_mask_cvt_roundps_epu32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)(W), U, B))
+@@ -4903,7 +4905,6 @@ extern __inline __m256i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_cvtsepi64_epi32 (__m512i __A)
+ {
+- __v8si __O;
+ return (__m256i) __builtin_ia32_pmovsqd512_mask ((__v8di) __A,
+ (__v8si)
+ _mm256_undefined_si256 (),
+@@ -5556,7 +5557,7 @@ _mm512_inserti64x4 (__m512i __A, __m256i __B, const int __imm)
+ (__v4di) __B,
+ __imm,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -5651,7 +5652,7 @@ _mm512_maskz_insertf64x4 (__mmask8 __U, __m512d __A, __m256d __B,
+ #define _mm512_inserti64x4(X, Y, C) \
+ ((__m512i) __builtin_ia32_inserti64x4_mask ((__v8di)(__m512i) (X), \
+ (__v4di)(__m256i) (Y), (int) (C), \
+- (__v8di)(__m512i)_mm512_undefined_si512 (), \
++ (__v8di)(__m512i)_mm512_undefined_epi32 (), \
+ (__mmask8)-1))
+
+ #define _mm512_mask_inserti64x4(W, U, X, Y, C) \
+@@ -6177,7 +6178,7 @@ _mm512_permutex_epi64 (__m512i __X, const int __I)
+ {
+ return (__m512i) __builtin_ia32_permdi512_mask ((__v8di) __X, __I,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) (-1));
+ }
+
+@@ -6248,7 +6249,7 @@ _mm512_maskz_permutex_pd (__mmask8 __U, __m512d __X, const int __M)
+ ((__m512i) __builtin_ia32_permdi512_mask ((__v8di)(__m512i)(X), \
+ (int)(I), \
+ (__v8di)(__m512i) \
+- (_mm512_undefined_si512 ()),\
++ (_mm512_undefined_epi32 ()),\
+ (__mmask8)(-1)))
+
+ #define _mm512_maskz_permutex_epi64(M, X, I) \
+@@ -6283,7 +6284,7 @@ _mm512_permutexvar_epi64 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_permvardi512_mask ((__v8di) __Y,
+ (__v8di) __X,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -6316,7 +6317,7 @@ _mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_permvarsi512_mask ((__v16si) __Y,
+ (__v16si) __X,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -6891,7 +6892,7 @@ _mm512_rol_epi32 (__m512i __A, const int __B)
+ {
+ return (__m512i) __builtin_ia32_prold512_mask ((__v16si) __A, __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -6920,7 +6921,7 @@ _mm512_ror_epi32 (__m512i __A, int __B)
+ {
+ return (__m512i) __builtin_ia32_prord512_mask ((__v16si) __A, __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -6949,7 +6950,7 @@ _mm512_rol_epi64 (__m512i __A, const int __B)
+ {
+ return (__m512i) __builtin_ia32_prolq512_mask ((__v8di) __A, __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -6978,7 +6979,7 @@ _mm512_ror_epi64 (__m512i __A, int __B)
+ {
+ return (__m512i) __builtin_ia32_prorq512_mask ((__v8di) __A, __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -7005,7 +7006,7 @@ _mm512_maskz_ror_epi64 (__mmask8 __U, __m512i __A, int __B)
+ #define _mm512_rol_epi32(A, B) \
+ ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), \
+ (int)(B), \
+- (__v16si)_mm512_undefined_si512 (), \
++ (__v16si)_mm512_undefined_epi32 (), \
+ (__mmask16)(-1)))
+ #define _mm512_mask_rol_epi32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_prold512_mask ((__v16si)(__m512i)(A), \
+@@ -7020,7 +7021,7 @@ _mm512_maskz_ror_epi64 (__mmask8 __U, __m512i __A, int __B)
+ #define _mm512_ror_epi32(A, B) \
+ ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), \
+ (int)(B), \
+- (__v16si)_mm512_undefined_si512 (), \
++ (__v16si)_mm512_undefined_epi32 (), \
+ (__mmask16)(-1)))
+ #define _mm512_mask_ror_epi32(W, U, A, B) \
+ ((__m512i)__builtin_ia32_prord512_mask ((__v16si)(__m512i)(A), \
+@@ -7035,7 +7036,7 @@ _mm512_maskz_ror_epi64 (__mmask8 __U, __m512i __A, int __B)
+ #define _mm512_rol_epi64(A, B) \
+ ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), \
+ (int)(B), \
+- (__v8di)_mm512_undefined_si512 (), \
++ (__v8di)_mm512_undefined_epi32 (), \
+ (__mmask8)(-1)))
+ #define _mm512_mask_rol_epi64(W, U, A, B) \
+ ((__m512i)__builtin_ia32_prolq512_mask ((__v8di)(__m512i)(A), \
+@@ -7051,7 +7052,7 @@ _mm512_maskz_ror_epi64 (__mmask8 __U, __m512i __A, int __B)
+ #define _mm512_ror_epi64(A, B) \
+ ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), \
+ (int)(B), \
+- (__v8di)_mm512_undefined_si512 (), \
++ (__v8di)_mm512_undefined_epi32 (), \
+ (__mmask8)(-1)))
+ #define _mm512_mask_ror_epi64(W, U, A, B) \
+ ((__m512i)__builtin_ia32_prorq512_mask ((__v8di)(__m512i)(A), \
+@@ -7134,7 +7135,7 @@ _mm512_andnot_si512 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -7145,7 +7146,7 @@ _mm512_andnot_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pandnd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -7177,7 +7178,7 @@ _mm512_andnot_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pandnq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -7275,7 +7276,7 @@ _mm512_unpackhi_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_punpckhdq512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -7308,7 +7309,7 @@ _mm512_unpackhi_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_punpckhqdq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -7340,7 +7341,7 @@ _mm512_unpacklo_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_punpckldq512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -7373,7 +7374,7 @@ _mm512_unpacklo_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_punpcklqdq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -8512,7 +8513,7 @@ _mm512_alignr_epi32 (__m512i __A, __m512i __B, const int __imm)
+ return (__m512i) __builtin_ia32_alignd512_mask ((__v16si) __A,
+ (__v16si) __B, __imm,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -8546,7 +8547,7 @@ _mm512_alignr_epi64 (__m512i __A, __m512i __B, const int __imm)
+ return (__m512i) __builtin_ia32_alignq512_mask ((__v8di) __A,
+ (__v8di) __B, __imm,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -8575,7 +8576,7 @@ _mm512_maskz_alignr_epi64 (__mmask8 __U, __m512i __A, __m512i __B,
+ #else
+ #define _mm512_alignr_epi32(X, Y, C) \
+ ((__m512i)__builtin_ia32_alignd512_mask ((__v16si)(__m512i)(X), \
+- (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_undefined_si512 (),\
++ (__v16si)(__m512i)(Y), (int)(C), (__v16si)_mm512_undefined_epi32 (),\
+ (__mmask16)-1))
+
+ #define _mm512_mask_alignr_epi32(W, U, X, Y, C) \
+@@ -8590,7 +8591,7 @@ _mm512_maskz_alignr_epi64 (__mmask8 __U, __m512i __A, __m512i __B,
+
+ #define _mm512_alignr_epi64(X, Y, C) \
+ ((__m512i)__builtin_ia32_alignq512_mask ((__v8di)(__m512i)(X), \
+- (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_undefined_si512 (), \
++ (__v8di)(__m512i)(Y), (int)(C), (__v8di)_mm512_undefined_epi32 (), \
+ (__mmask8)-1))
+
+ #define _mm512_mask_alignr_epi64(W, U, X, Y, C) \
+@@ -9130,9 +9131,9 @@ _mm_mask_cmp_round_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y,
+ (__mmask8)-1))
+
+ #define _mm512_cmp_epi32_mask(X, Y, P) \
+- ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), \
+- (__v16si)(__m512i)(Y), (int)(P),\
+- (__mmask16)-1))
++ ((__mmask16) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), \
++ (__v16si)(__m512i)(Y), (int)(P), \
++ (__mmask16)-1))
+
+ #define _mm512_cmp_epu64_mask(X, Y, P) \
+ ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), \
+@@ -9140,66 +9141,66 @@ _mm_mask_cmp_round_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y,
+ (__mmask8)-1))
+
+ #define _mm512_cmp_epu32_mask(X, Y, P) \
+- ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), \
+- (__v16si)(__m512i)(Y), (int)(P),\
+- (__mmask16)-1))
++ ((__mmask16) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), \
++ (__v16si)(__m512i)(Y), (int)(P), \
++ (__mmask16)-1))
+
+-#define _mm512_cmp_round_pd_mask(X, Y, P, R) \
++#define _mm512_cmp_round_pd_mask(X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), \
+ (__v8df)(__m512d)(Y), (int)(P),\
+ (__mmask8)-1, R))
+
+-#define _mm512_cmp_round_ps_mask(X, Y, P, R) \
++#define _mm512_cmp_round_ps_mask(X, Y, P, R) \
+ ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), \
+ (__v16sf)(__m512)(Y), (int)(P),\
+ (__mmask16)-1, R))
+
+-#define _mm512_mask_cmp_epi64_mask(M, X, Y, P) \
++#define _mm512_mask_cmp_epi64_mask(M, X, Y, P) \
+ ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), \
+ (__v8di)(__m512i)(Y), (int)(P),\
+ (__mmask8)M))
+
+-#define _mm512_mask_cmp_epi32_mask(M, X, Y, P) \
+- ((__mmask8) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), \
+- (__v16si)(__m512i)(Y), (int)(P),\
+- (__mmask16)M))
++#define _mm512_mask_cmp_epi32_mask(M, X, Y, P) \
++ ((__mmask16) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), \
++ (__v16si)(__m512i)(Y), (int)(P), \
++ (__mmask16)M))
+
+-#define _mm512_mask_cmp_epu64_mask(M, X, Y, P) \
++#define _mm512_mask_cmp_epu64_mask(M, X, Y, P) \
+ ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), \
+ (__v8di)(__m512i)(Y), (int)(P),\
+ (__mmask8)M))
+
+-#define _mm512_mask_cmp_epu32_mask(M, X, Y, P) \
+- ((__mmask8) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), \
+- (__v16si)(__m512i)(Y), (int)(P),\
+- (__mmask16)M))
++#define _mm512_mask_cmp_epu32_mask(M, X, Y, P) \
++ ((__mmask16) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), \
++ (__v16si)(__m512i)(Y), (int)(P), \
++ (__mmask16)M))
+
+-#define _mm512_mask_cmp_round_pd_mask(M, X, Y, P, R) \
++#define _mm512_mask_cmp_round_pd_mask(M, X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), \
+ (__v8df)(__m512d)(Y), (int)(P),\
+ (__mmask8)M, R))
+
+-#define _mm512_mask_cmp_round_ps_mask(M, X, Y, P, R) \
++#define _mm512_mask_cmp_round_ps_mask(M, X, Y, P, R) \
+ ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), \
+ (__v16sf)(__m512)(Y), (int)(P),\
+ (__mmask16)M, R))
+
+-#define _mm_cmp_round_sd_mask(X, Y, P, R) \
++#define _mm_cmp_round_sd_mask(X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), \
+ (__v2df)(__m128d)(Y), (int)(P),\
+ (__mmask8)-1, R))
+
+-#define _mm_mask_cmp_round_sd_mask(M, X, Y, P, R) \
++#define _mm_mask_cmp_round_sd_mask(M, X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), \
+ (__v2df)(__m128d)(Y), (int)(P),\
+ (M), R))
+
+-#define _mm_cmp_round_ss_mask(X, Y, P, R) \
++#define _mm_cmp_round_ss_mask(X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), \
+ (__v4sf)(__m128)(Y), (int)(P), \
+ (__mmask8)-1, R))
+
+-#define _mm_mask_cmp_round_ss_mask(M, X, Y, P, R) \
++#define _mm_mask_cmp_round_ss_mask(M, X, Y, P, R) \
+ ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), \
+ (__v4sf)(__m128)(Y), (int)(P), \
+ (M), R))
+@@ -9306,7 +9307,7 @@ extern __inline __m512i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_i32gather_epi32 (__m512i __index, int const *__addr, int __scale)
+ {
+- __m512i v1_old = _mm512_undefined_si512 ();
++ __m512i v1_old = _mm512_undefined_epi32 ();
+ __mmask16 mask = 0xFFFF;
+
+ return (__m512i) __builtin_ia32_gathersiv16si ((__v16si) v1_old,
+@@ -9330,7 +9331,7 @@ extern __inline __m512i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_i32gather_epi64 (__m256i __index, long long const *__addr, int __scale)
+ {
+- __m512i v1_old = _mm512_undefined_si512 ();
++ __m512i v1_old = _mm512_undefined_epi32 ();
+ __mmask8 mask = 0xFF;
+
+ return (__m512i) __builtin_ia32_gathersiv8di ((__v8di) v1_old,
+@@ -9379,7 +9380,7 @@ extern __inline __m512i
+ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+ _mm512_i64gather_epi64 (__m512i __index, long long const *__addr, int __scale)
+ {
+- __m512i v1_old = _mm512_undefined_si512 ();
++ __m512i v1_old = _mm512_undefined_epi32 ();
+ __mmask8 mask = 0xFF;
+
+ return (__m512i) __builtin_ia32_gatherdiv8di ((__v8di) v1_old,
+@@ -9591,7 +9592,7 @@ _mm512_mask_i64scatter_epi64 (long long *__addr, __mmask8 __mask,
+ (__mmask8)MASK, (int)SCALE)
+
+ #define _mm512_i32gather_epi32(INDEX, ADDR, SCALE) \
+- (__m512i) __builtin_ia32_gathersiv16si ((__v16si)_mm512_undefined_si512 (), \
++ (__m512i) __builtin_ia32_gathersiv16si ((__v16si)_mm512_undefined_epi32 (), \
+ (int const *)ADDR, \
+ (__v16si)(__m512i)INDEX, \
+ (__mmask16)0xFFFF, (int)SCALE)
+@@ -9603,7 +9604,7 @@ _mm512_mask_i64scatter_epi64 (long long *__addr, __mmask8 __mask,
+ (__mmask16)MASK, (int)SCALE)
+
+ #define _mm512_i32gather_epi64(INDEX, ADDR, SCALE) \
+- (__m512i) __builtin_ia32_gathersiv8di ((__v8di)_mm512_undefined_si512 (), \
++ (__m512i) __builtin_ia32_gathersiv8di ((__v8di)_mm512_undefined_epi32 (), \
+ (long long const *)ADDR, \
+ (__v8si)(__m256i)INDEX, \
+ (__mmask8)0xFF, (int)SCALE)
+@@ -9627,7 +9628,7 @@ _mm512_mask_i64scatter_epi64 (long long *__addr, __mmask8 __mask,
+ (__mmask8)MASK, (int)SCALE)
+
+ #define _mm512_i64gather_epi64(INDEX, ADDR, SCALE) \
+- (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)_mm512_undefined_si512 (), \
++ (__m512i) __builtin_ia32_gatherdiv8di ((__v8di)_mm512_undefined_epi32 (), \
+ (long long const *)ADDR, \
+ (__v8di)(__m512i)INDEX, \
+ (__mmask8)0xFF, (int)SCALE)
+@@ -10123,7 +10124,7 @@ _mm512_max_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pmaxsq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -10154,7 +10155,7 @@ _mm512_min_epi64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pminsq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -10185,7 +10186,7 @@ _mm512_max_epu64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pmaxuq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -10216,7 +10217,7 @@ _mm512_min_epu64 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pminuq512_mask ((__v8di) __A,
+ (__v8di) __B,
+ (__v8di)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask8) -1);
+ }
+
+@@ -10247,7 +10248,7 @@ _mm512_max_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pmaxsd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -10278,7 +10279,7 @@ _mm512_min_epi32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pminsd512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -10309,7 +10310,7 @@ _mm512_max_epu32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pmaxud512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -10340,7 +10341,7 @@ _mm512_min_epu32 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_pminud512_mask ((__v16si) __A,
+ (__v16si) __B,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1);
+ }
+
+@@ -11804,7 +11805,7 @@ _mm512_cvttps_epi32 (__m512 __A)
+ {
+ return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1,
+ _MM_FROUND_CUR_DIRECTION);
+ }
+@@ -11836,7 +11837,7 @@ _mm512_cvttps_epu32 (__m512 __A)
+ {
+ return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1,
+ _MM_FROUND_CUR_DIRECTION);
+ }
+@@ -11868,7 +11869,7 @@ _mm512_cvtps_epi32 (__m512 __A)
+ {
+ return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1,
+ _MM_FROUND_CUR_DIRECTION);
+ }
+@@ -11900,7 +11901,7 @@ _mm512_cvtps_epu32 (__m512 __A)
+ {
+ return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,
+ (__v16si)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask16) -1,
+ _MM_FROUND_CUR_DIRECTION);
+ }
+diff --git a/gcc/config/i386/avx512ifmaintrin.h b/gcc/config/i386/avx512ifmaintrin.h
+index b558981..281aa64 100644
+--- a/gcc/config/i386/avx512ifmaintrin.h
++++ b/gcc/config/i386/avx512ifmaintrin.h
+@@ -41,7 +41,7 @@ _mm512_madd52lo_epu64 (__m512i __X, __m512i __Y, __m512i __Z)
+ return (__m512i) __builtin_ia32_vpmadd52luq512_mask ((__v8di) __X,
+ (__v8di) __Y,
+ (__v8di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512i
+@@ -51,7 +51,7 @@ _mm512_madd52hi_epu64 (__m512i __X, __m512i __Y, __m512i __Z)
+ return (__m512i) __builtin_ia32_vpmadd52huq512_mask ((__v8di) __X,
+ (__v8di) __Y,
+ (__v8di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m512i
+diff --git a/gcc/config/i386/avx512ifmavlintrin.h b/gcc/config/i386/avx512ifmavlintrin.h
+index 750eaff..ac37646 100644
+--- a/gcc/config/i386/avx512ifmavlintrin.h
++++ b/gcc/config/i386/avx512ifmavlintrin.h
+@@ -41,7 +41,7 @@ _mm_madd52lo_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+ return (__m128i) __builtin_ia32_vpmadd52luq128_mask ((__v2di) __X,
+ (__v2di) __Y,
+ (__v2di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -51,7 +51,7 @@ _mm_madd52hi_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+ return (__m128i) __builtin_ia32_vpmadd52huq128_mask ((__v2di) __X,
+ (__v2di) __Y,
+ (__v2di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -61,7 +61,7 @@ _mm256_madd52lo_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+ return (__m256i) __builtin_ia32_vpmadd52luq256_mask ((__v4di) __X,
+ (__v4di) __Y,
+ (__v4di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -71,7 +71,7 @@ _mm256_madd52hi_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+ return (__m256i) __builtin_ia32_vpmadd52huq256_mask ((__v4di) __X,
+ (__v4di) __Y,
+ (__v4di) __Z,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+diff --git a/gcc/config/i386/avx512vbmiintrin.h b/gcc/config/i386/avx512vbmiintrin.h
+index f93b13b..7a14865 100644
+--- a/gcc/config/i386/avx512vbmiintrin.h
++++ b/gcc/config/i386/avx512vbmiintrin.h
+@@ -62,7 +62,7 @@ _mm512_multishift_epi64_epi8 (__m512i __X, __m512i __Y)
+ return (__m512i) __builtin_ia32_vpmultishiftqb512_mask ((__v64qi) __X,
+ (__v64qi) __Y,
+ (__v64qi)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask64) -1);
+ }
+
+@@ -73,7 +73,7 @@ _mm512_permutexvar_epi8 (__m512i __A, __m512i __B)
+ return (__m512i) __builtin_ia32_permvarqi512_mask ((__v64qi) __B,
+ (__v64qi) __A,
+ (__v64qi)
+- _mm512_undefined_si512 (),
++ _mm512_undefined_epi32 (),
+ (__mmask64) -1);
+ }
+
+@@ -108,8 +108,7 @@ _mm512_permutex2var_epi8 (__m512i __A, __m512i __I, __m512i __B)
+ /* idx */ ,
+ (__v64qi) __A,
+ (__v64qi) __B,
+- (__mmask64) -
+- 1);
++ (__mmask64) -1);
+ }
+
+ extern __inline __m512i
+diff --git a/gcc/config/i386/avx512vbmivlintrin.h b/gcc/config/i386/avx512vbmivlintrin.h
+index cab4e5c..f7af20e 100644
+--- a/gcc/config/i386/avx512vbmivlintrin.h
++++ b/gcc/config/i386/avx512vbmivlintrin.h
+@@ -173,8 +173,7 @@ _mm256_permutex2var_epi8 (__m256i __A, __m256i __I, __m256i __B)
+ /* idx */ ,
+ (__v32qi) __A,
+ (__v32qi) __B,
+- (__mmask32) -
+- 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __m256i
+@@ -224,8 +223,7 @@ _mm_permutex2var_epi8 (__m128i __A, __m128i __I, __m128i __B)
+ /* idx */ ,
+ (__v16qi) __A,
+ (__v16qi) __B,
+- (__mmask16) -
+- 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __m128i
+diff --git a/gcc/config/i386/avx512vlbwintrin.h b/gcc/config/i386/avx512vlbwintrin.h
+index 601dcdd..9423101 100644
+--- a/gcc/config/i386/avx512vlbwintrin.h
++++ b/gcc/config/i386/avx512vlbwintrin.h
+@@ -575,8 +575,7 @@ _mm256_permutex2var_epi16 (__m256i __A, __m256i __I, __m256i __B)
+ /* idx */ ,
+ (__v16hi) __A,
+ (__v16hi) __B,
+- (__mmask16) -
+- 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __m256i
+@@ -626,8 +625,7 @@ _mm_permutex2var_epi16 (__m128i __A, __m128i __I, __m128i __B)
+ /* idx */ ,
+ (__v8hi) __A,
+ (__v8hi) __B,
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -2009,7 +2007,7 @@ _mm256_cmpneq_epi8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 4,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2018,7 +2016,7 @@ _mm256_cmplt_epi8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 1,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2027,7 +2025,7 @@ _mm256_cmpge_epi8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 5,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -2036,7 +2034,7 @@ _mm256_cmple_epi8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_cmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 2,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2045,7 +2043,7 @@ _mm256_cmpneq_epi16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 4,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2054,7 +2052,7 @@ _mm256_cmplt_epi16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 1,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2063,7 +2061,7 @@ _mm256_cmpge_epi16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 5,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2072,7 +2070,7 @@ _mm256_cmple_epi16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 2,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2081,7 +2079,7 @@ _mm_cmpneq_epu8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 4,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2090,7 +2088,7 @@ _mm_cmplt_epu8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 1,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2099,7 +2097,7 @@ _mm_cmpge_epu8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 5,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2108,7 +2106,7 @@ _mm_cmple_epu8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 2,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2117,7 +2115,7 @@ _mm_cmpneq_epu16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2126,7 +2124,7 @@ _mm_cmplt_epu16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2135,7 +2133,7 @@ _mm_cmpge_epu16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2144,7 +2142,7 @@ _mm_cmple_epu16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2153,7 +2151,7 @@ _mm_cmpneq_epi8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 4,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2162,7 +2160,7 @@ _mm_cmplt_epi8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 1,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2171,7 +2169,7 @@ _mm_cmpge_epi8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 5,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -2180,7 +2178,7 @@ _mm_cmple_epi8_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask16) __builtin_ia32_cmpb128_mask ((__v16qi) __X,
+ (__v16qi) __Y, 2,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2189,7 +2187,7 @@ _mm_cmpneq_epi16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2198,7 +2196,7 @@ _mm_cmplt_epi16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2207,7 +2205,7 @@ _mm_cmpge_epi16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -2216,7 +2214,7 @@ _mm_cmple_epi16_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpw128_mask ((__v8hi) __X,
+ (__v8hi) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -3609,7 +3607,7 @@ _mm256_cmpneq_epu8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 4,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -3618,7 +3616,7 @@ _mm256_cmplt_epu8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 1,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -3627,7 +3625,7 @@ _mm256_cmpge_epu8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 5,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask32
+@@ -3636,7 +3634,7 @@ _mm256_cmple_epu8_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask32) __builtin_ia32_ucmpb256_mask ((__v32qi) __X,
+ (__v32qi) __Y, 2,
+- (__mmask32) - 1);
++ (__mmask32) -1);
+ }
+
+ extern __inline __mmask16
+@@ -3645,7 +3643,7 @@ _mm256_cmpneq_epu16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 4,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -3654,7 +3652,7 @@ _mm256_cmplt_epu16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 1,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -3663,7 +3661,7 @@ _mm256_cmpge_epu16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 5,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline __mmask16
+@@ -3672,7 +3670,7 @@ _mm256_cmple_epu16_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask16) __builtin_ia32_ucmpw256_mask ((__v16hi) __X,
+ (__v16hi) __Y, 2,
+- (__mmask16) - 1);
++ (__mmask16) -1);
+ }
+
+ extern __inline void
+diff --git a/gcc/config/i386/avx512vldqintrin.h b/gcc/config/i386/avx512vldqintrin.h
+index 7ccb62b..56e8513 100644
+--- a/gcc/config/i386/avx512vldqintrin.h
++++ b/gcc/config/i386/avx512vldqintrin.h
+@@ -389,8 +389,7 @@ _mm256_broadcast_f64x2 (__m128d __A)
+ return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df)
+ __A,
+ (__v4df)_mm256_undefined_pd(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256d
+@@ -421,8 +420,7 @@ _mm256_broadcast_i64x2 (__m128i __A)
+ return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di)
+ __A,
+ (__v4di)_mm256_undefined_si256(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -452,8 +450,7 @@ _mm256_broadcast_f32x2 (__m128 __A)
+ {
+ return (__m256) __builtin_ia32_broadcastf32x2_256_mask ((__v4sf) __A,
+ (__v8sf)_mm256_undefined_ps(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256
+@@ -482,8 +479,7 @@ _mm256_broadcast_i32x2 (__m128i __A)
+ return (__m256i) __builtin_ia32_broadcasti32x2_256_mask ((__v4si)
+ __A,
+ (__v8si)_mm256_undefined_si256(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -514,8 +510,7 @@ _mm_broadcast_i32x2 (__m128i __A)
+ return (__m128i) __builtin_ia32_broadcasti32x2_128_mask ((__v4si)
+ __A,
+ (__v4si)_mm_undefined_si128(),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -1351,8 +1346,7 @@ _mm256_extractf64x2_pd (__m256d __A, const int __imm)
+ __imm,
+ (__v2df)
+ _mm_setzero_pd (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128d
+@@ -1388,8 +1382,7 @@ _mm256_extracti64x2_epi64 (__m256i __A, const int __imm)
+ __imm,
+ (__v2di)
+ _mm_setzero_di (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -1743,8 +1736,7 @@ _mm256_inserti64x2 (__m256i __A, __m128i __B, const int __imm)
+ __imm,
+ (__v4di)
+ _mm256_setzero_si256 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -1783,8 +1775,7 @@ _mm256_insertf64x2 (__m256d __A, __m128d __B, const int __imm)
+ __imm,
+ (__v4df)
+ _mm256_setzero_pd (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256d
+diff --git a/gcc/config/i386/avx512vlintrin.h b/gcc/config/i386/avx512vlintrin.h
+index b995cec..36771f6 100644
+--- a/gcc/config/i386/avx512vlintrin.h
++++ b/gcc/config/i386/avx512vlintrin.h
+@@ -2698,8 +2698,7 @@ _mm256_broadcast_f32x4 (__m128 __A)
+ {
+ return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,
+ (__v8sf)_mm256_undefined_pd (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256
+@@ -2728,8 +2727,7 @@ _mm256_broadcast_i32x4 (__m128i __A)
+ return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si)
+ __A,
+ (__v8si)_mm256_undefined_si256 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -6293,8 +6291,7 @@ _mm256_permutex2var_pd (__m256d __A, __m256i __I, __m256d __B)
+ /* idx */ ,
+ (__v4df) __A,
+ (__v4df) __B,
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256d
+@@ -6584,8 +6581,7 @@ _mm_permutex2var_pd (__m128d __A, __m128i __I, __m128d __B)
+ /* idx */ ,
+ (__v2df) __A,
+ (__v2df) __B,
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128d
+@@ -8259,8 +8255,7 @@ _mm256_conflict_epi64 (__m256i __A)
+ return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
+ (__v4di)
+ _mm256_setzero_si256 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -8291,8 +8286,7 @@ _mm256_conflict_epi32 (__m256i __A)
+ return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
+ (__v8si)
+ _mm256_setzero_si256 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -8381,8 +8375,7 @@ _mm_conflict_epi64 (__m128i __A)
+ return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
+ (__v2di)
+ _mm_setzero_di (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -8413,8 +8406,7 @@ _mm_conflict_epi32 (__m128i __A)
+ return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
+ (__v4si)
+ _mm_setzero_si128 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -9291,8 +9283,7 @@ _mm256_inserti32x4 (__m256i __A, __m128i __B, const int __imm)
+ __imm,
+ (__v8si)
+ _mm256_setzero_si256 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m256i
+@@ -9367,8 +9358,7 @@ _mm256_extracti32x4_epi32 (__m256i __A, const int __imm)
+ __imm,
+ (__v4si)
+ _mm_setzero_si128 (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128i
+@@ -9404,8 +9394,7 @@ _mm256_extractf32x4_ps (__m256 __A, const int __imm)
+ __imm,
+ (__v4sf)
+ _mm_setzero_ps (),
+- (__mmask8) -
+- 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __m128
+@@ -11797,7 +11786,7 @@ _mm256_cmpneq_epu32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11815,7 +11804,7 @@ _mm256_cmplt_epu32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11833,7 +11822,7 @@ _mm256_cmpge_epu32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11851,7 +11840,7 @@ _mm256_cmple_epu32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11869,7 +11858,7 @@ _mm256_cmpneq_epu64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11887,7 +11876,7 @@ _mm256_cmplt_epu64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11905,7 +11894,7 @@ _mm256_cmpge_epu64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11923,7 +11912,7 @@ _mm256_cmple_epu64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11941,7 +11930,7 @@ _mm256_cmpneq_epi32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11959,7 +11948,7 @@ _mm256_cmplt_epi32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11977,7 +11966,7 @@ _mm256_cmpge_epi32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -11995,7 +11984,7 @@ _mm256_cmple_epi32_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd256_mask ((__v8si) __X,
+ (__v8si) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12013,7 +12002,7 @@ _mm256_cmpneq_epi64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12031,7 +12020,7 @@ _mm256_cmplt_epi64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12049,7 +12038,7 @@ _mm256_cmpge_epi64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12067,7 +12056,7 @@ _mm256_cmple_epi64_mask (__m256i __X, __m256i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq256_mask ((__v4di) __X,
+ (__v4di) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12085,7 +12074,7 @@ _mm_cmpneq_epu32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12103,7 +12092,7 @@ _mm_cmplt_epu32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12121,7 +12110,7 @@ _mm_cmpge_epu32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12139,7 +12128,7 @@ _mm_cmple_epu32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12157,7 +12146,7 @@ _mm_cmpneq_epu64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12175,7 +12164,7 @@ _mm_cmplt_epu64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12193,7 +12182,7 @@ _mm_cmpge_epu64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12211,7 +12200,7 @@ _mm_cmple_epu64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_ucmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12229,7 +12218,7 @@ _mm_cmpneq_epi32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12247,7 +12236,7 @@ _mm_cmplt_epi32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12265,7 +12254,7 @@ _mm_cmpge_epi32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12283,7 +12272,7 @@ _mm_cmple_epi32_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpd128_mask ((__v4si) __X,
+ (__v4si) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12301,7 +12290,7 @@ _mm_cmpneq_epi64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 4,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12319,7 +12308,7 @@ _mm_cmplt_epi64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 1,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12337,7 +12326,7 @@ _mm_cmpge_epi64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 5,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ extern __inline __mmask8
+@@ -12355,7 +12344,7 @@ _mm_cmple_epi64_mask (__m128i __X, __m128i __Y)
+ {
+ return (__mmask8) __builtin_ia32_cmpq128_mask ((__v2di) __X,
+ (__v2di) __Y, 2,
+- (__mmask8) - 1);
++ (__mmask8) -1);
+ }
+
+ #else
+diff --git a/gcc/config/i386/cpuid.h b/gcc/config/i386/cpuid.h
+index f3ad4db..8e4bbdc 100644
+--- a/gcc/config/i386/cpuid.h
++++ b/gcc/config/i386/cpuid.h
+@@ -79,7 +79,6 @@
+ #define bit_RDSEED (1 << 18)
+ #define bit_ADX (1 << 19)
+ #define bit_AVX512IFMA (1 << 21)
+-#define bit_PCOMMIT (1 << 22)
+ #define bit_CLFLUSHOPT (1 << 23)
+ #define bit_CLWB (1 << 24)
+ #define bit_AVX512PF (1 << 26)
+diff --git a/gcc/config/i386/driver-i386.c b/gcc/config/i386/driver-i386.c
+index 1c6c221..42e0fb0 100644
+--- a/gcc/config/i386/driver-i386.c
++++ b/gcc/config/i386/driver-i386.c
+@@ -413,7 +413,7 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ unsigned int has_clflushopt = 0, has_xsavec = 0, has_xsaves = 0;
+ unsigned int has_avx512dq = 0, has_avx512bw = 0, has_avx512vl = 0;
+ unsigned int has_avx512vbmi = 0, has_avx512ifma = 0, has_clwb = 0;
+- unsigned int has_pcommit = 0, has_mwaitx = 0;
++ unsigned int has_mwaitx = 0;
+
+ bool arch;
+
+@@ -491,7 +491,6 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ has_avx512pf = ebx & bit_AVX512PF;
+ has_avx512cd = ebx & bit_AVX512CD;
+ has_sha = ebx & bit_SHA;
+- has_pcommit = ebx & bit_PCOMMIT;
+ has_clflushopt = ebx & bit_CLFLUSHOPT;
+ has_clwb = ebx & bit_CLWB;
+ has_avx512dq = ebx & bit_AVX512DQ;
+@@ -630,33 +629,27 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ }
+ else if (vendor == signature_CENTAUR_ebx)
+ {
+- if (arch)
++ processor = PROCESSOR_GENERIC;
++
++ switch (family)
+ {
+- switch (family)
+- {
+- case 6:
+- if (model > 9)
+- /* Use the default detection procedure. */
+- processor = PROCESSOR_GENERIC;
+- else if (model == 9)
+- cpu = "c3-2";
+- else if (model >= 6)
+- cpu = "c3";
+- else
+- processor = PROCESSOR_GENERIC;
+- break;
+- case 5:
+- if (has_3dnow)
+- cpu = "winchip2";
+- else if (has_mmx)
+- cpu = "winchip2-c6";
+- else
+- processor = PROCESSOR_GENERIC;
+- break;
+- default:
+- /* We have no idea. */
+- processor = PROCESSOR_GENERIC;
+- }
++ default:
++ /* We have no idea. */
++ break;
++
++ case 5:
++ if (has_3dnow || has_mmx)
++ processor = PROCESSOR_I486;
++ break;
++
++ case 6:
++ if (model > 9 || has_longmode)
++ /* Use the default detection procedure. */
++ ;
++ else if (model == 9)
++ processor = PROCESSOR_PENTIUMPRO;
++ else if (model >= 6)
++ processor = PROCESSOR_I486;
+ }
+ }
+ else
+@@ -687,7 +680,18 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ /* Default. */
+ break;
+ case PROCESSOR_I486:
+- cpu = "i486";
++ if (arch && vendor == signature_CENTAUR_ebx)
++ {
++ if (model >= 6)
++ cpu = "c3";
++ else if (has_3dnow)
++ cpu = "winchip2";
++ else
++ /* Assume WinChip C6. */
++ cpu = "winchip-c6";
++ }
++ else
++ cpu = "i486";
+ break;
+ case PROCESSOR_PENTIUM:
+ if (arch && has_mmx)
+@@ -804,8 +808,13 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ /* It is Pentium M. */
+ cpu = "pentium-m";
+ else if (has_sse)
+- /* It is Pentium III. */
+- cpu = "pentium3";
++ {
++ if (vendor == signature_CENTAUR_ebx)
++ cpu = "c3-2";
++ else
++ /* It is Pentium III. */
++ cpu = "pentium3";
++ }
+ else if (has_mmx)
+ /* It is Pentium II. */
+ cpu = "pentium2";
+@@ -886,6 +895,11 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ else
+ cpu = "prescott";
+ }
++ else if (has_longmode)
++ /* Perhaps some emulator? Assume x86-64, otherwise gcc
++ -march=native would be unusable for 64-bit compilations,
++ as all the CPUs below are 32-bit only. */
++ cpu = "x86-64";
+ else if (has_sse2)
+ cpu = "pentium4";
+ else if (has_cmov)
+@@ -953,7 +967,6 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ const char *avx512ifma = has_avx512ifma ? " -mavx512ifma" : " -mno-avx512ifma";
+ const char *avx512vbmi = has_avx512vbmi ? " -mavx512vbmi" : " -mno-avx512vbmi";
+ const char *clwb = has_clwb ? " -mclwb" : " -mno-clwb";
+- const char *pcommit = has_pcommit ? " -mpcommit" : " -mno-pcommit";
+ const char *mwaitx = has_mwaitx ? " -mmwaitx" : " -mno-mwaitx";
+
+ options = concat (options, mmx, mmx3dnow, sse, sse2, sse3, ssse3,
+@@ -964,7 +977,7 @@ const char *host_detect_local_cpu (int argc, const char **argv)
+ fxsr, xsave, xsaveopt, avx512f, avx512er,
+ avx512cd, avx512pf, prefetchwt1, clflushopt,
+ xsavec, xsaves, avx512dq, avx512bw, avx512vl,
+- avx512ifma, avx512vbmi, clwb, pcommit, mwaitx, NULL);
++ avx512ifma, avx512vbmi, clwb, mwaitx, NULL);
+ }
+
+ done:
+diff --git a/gcc/config/i386/i386-c.c b/gcc/config/i386/i386-c.c
+index f3f90df..8161d61 100644
+--- a/gcc/config/i386/i386-c.c
++++ b/gcc/config/i386/i386-c.c
+@@ -428,8 +428,6 @@ ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
+ def_or_undef (parse_in, "__XSAVES__");
+ if (isa_flag & OPTION_MASK_ISA_MPX)
+ def_or_undef (parse_in, "__MPX__");
+- if (isa_flag & OPTION_MASK_ISA_PCOMMIT)
+- def_or_undef (parse_in, "__PCOMMIT__");
+ if (isa_flag & OPTION_MASK_ISA_CLWB)
+ def_or_undef (parse_in, "__CLWB__");
+ if (isa_flag & OPTION_MASK_ISA_MWAITX)
+diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
+index f96dd66..10de2c9 100644
+--- a/gcc/config/i386/i386.c
++++ b/gcc/config/i386/i386.c
+@@ -2678,7 +2678,6 @@ ix86_target_string (HOST_WIDE_INT isa, int flags, const char *arch,
+ { "-mxsaves", OPTION_MASK_ISA_XSAVES },
+ { "-mmpx", OPTION_MASK_ISA_MPX },
+ { "-mclwb", OPTION_MASK_ISA_CLWB },
+- { "-mpcommit", OPTION_MASK_ISA_PCOMMIT },
+ { "-mmwaitx", OPTION_MASK_ISA_MWAITX },
+ };
+
+@@ -3192,8 +3191,7 @@ ix86_option_override_internal (bool main_args_p,
+ #define PTA_AVX512IFMA (HOST_WIDE_INT_1 << 53)
+ #define PTA_AVX512VBMI (HOST_WIDE_INT_1 << 54)
+ #define PTA_CLWB (HOST_WIDE_INT_1 << 55)
+-#define PTA_PCOMMIT (HOST_WIDE_INT_1 << 56)
+-#define PTA_MWAITX (HOST_WIDE_INT_1 << 57)
++#define PTA_MWAITX (HOST_WIDE_INT_1 << 56)
+
+ #define PTA_CORE2 \
+ (PTA_64BIT | PTA_MMX | PTA_SSE | PTA_SSE2 | PTA_SSE3 | PTA_SSSE3 \
+@@ -3756,9 +3754,6 @@ ix86_option_override_internal (bool main_args_p,
+ if (processor_alias_table[i].flags & PTA_PREFETCHWT1
+ && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_PREFETCHWT1))
+ opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PREFETCHWT1;
+- if (processor_alias_table[i].flags & PTA_PCOMMIT
+- && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_PCOMMIT))
+- opts->x_ix86_isa_flags |= OPTION_MASK_ISA_PCOMMIT;
+ if (processor_alias_table[i].flags & PTA_CLWB
+ && !(opts->x_ix86_isa_flags_explicit & OPTION_MASK_ISA_CLWB))
+ opts->x_ix86_isa_flags |= OPTION_MASK_ISA_CLWB;
+@@ -4772,7 +4767,6 @@ ix86_valid_target_attribute_inner_p (tree args, char *p_strings[],
+ IX86_ATTR_ISA ("avx512vbmi", OPT_mavx512vbmi),
+ IX86_ATTR_ISA ("avx512ifma", OPT_mavx512ifma),
+ IX86_ATTR_ISA ("clwb", OPT_mclwb),
+- IX86_ATTR_ISA ("pcommit", OPT_mpcommit),
+ IX86_ATTR_ISA ("mwaitx", OPT_mmwaitx),
+
+ /* enum options */
+@@ -14292,7 +14286,9 @@ legitimize_tls_address (rtx x, enum tls_model model, bool for_mov)
+ base = get_thread_pointer (tp_mode,
+ for_mov || !TARGET_TLS_DIRECT_SEG_REFS);
+ off = force_reg (tp_mode, off);
+- return gen_rtx_PLUS (tp_mode, base, off);
++ dest = gen_rtx_PLUS (tp_mode, base, off);
++ if (tp_mode != Pmode)
++ dest = convert_to_mode (Pmode, dest, 1);
+ }
+ else
+ {
+@@ -17599,12 +17595,29 @@ ix86_expand_vector_move (machine_mode mode, rtx operands[])
+ of the register, once we have that information we may be able
+ to handle some of them more efficiently. */
+ if (can_create_pseudo_p ()
+- && register_operand (op0, mode)
+ && (CONSTANT_P (op1)
+ || (GET_CODE (op1) == SUBREG
+ && CONSTANT_P (SUBREG_REG (op1))))
+- && !standard_sse_constant_p (op1))
+- op1 = validize_mem (force_const_mem (mode, op1));
++ && ((register_operand (op0, mode)
++ && !standard_sse_constant_p (op1))
++ /* ix86_expand_vector_move_misalign() does not like constants. */
++ || (SSE_REG_MODE_P (mode)
++ && MEM_P (op0)
++ && MEM_ALIGN (op0) < align)))
++ {
++ if (SUBREG_P (op1))
++ {
++ machine_mode imode = GET_MODE (SUBREG_REG (op1));
++ rtx r = force_const_mem (imode, SUBREG_REG (op1));
++ if (r)
++ r = validize_mem (r);
++ else
++ r = force_reg (imode, SUBREG_REG (op1));
++ op1 = simplify_gen_subreg (mode, r, imode, SUBREG_BYTE (op1));
++ }
++ else
++ op1 = validize_mem (force_const_mem (mode, op1));
++ }
+
+ /* We need to check memory alignment for SSE mode since attribute
+ can make operands unaligned. */
+@@ -17615,13 +17628,8 @@ ix86_expand_vector_move (machine_mode mode, rtx operands[])
+ {
+ rtx tmp[2];
+
+- /* ix86_expand_vector_move_misalign() does not like constants ... */
+- if (CONSTANT_P (op1)
+- || (GET_CODE (op1) == SUBREG
+- && CONSTANT_P (SUBREG_REG (op1))))
+- op1 = validize_mem (force_const_mem (mode, op1));
+-
+- /* ... nor both arguments in memory. */
++ /* ix86_expand_vector_move_misalign() does not like both
++ arguments in memory. */
+ if (!register_operand (op0, mode)
+ && !register_operand (op1, mode))
+ op1 = force_reg (mode, op1);
+@@ -17707,7 +17715,7 @@ ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
+ m = adjust_address (op0, mode, 0);
+ emit_insn (extract (m, op1, const0_rtx));
+ m = adjust_address (op0, mode, 16);
+- emit_insn (extract (m, op1, const1_rtx));
++ emit_insn (extract (m, copy_rtx (op1), const1_rtx));
+ }
+ else
+ emit_insn (store_unaligned (op0, op1));
+@@ -18015,7 +18023,7 @@ ix86_expand_vector_move_misalign (machine_mode mode, rtx operands[])
+ m = adjust_address (op0, V2SFmode, 0);
+ emit_insn (gen_sse_storelps (m, op1));
+ m = adjust_address (op0, V2SFmode, 8);
+- emit_insn (gen_sse_storehps (m, op1));
++ emit_insn (gen_sse_storehps (m, copy_rtx (op1)));
+ }
+ }
+ }
+@@ -30492,9 +30500,6 @@ enum ix86_builtins
+ /* CLWB instructions. */
+ IX86_BUILTIN_CLWB,
+
+- /* PCOMMIT instructions. */
+- IX86_BUILTIN_PCOMMIT,
+-
+ /* CLFLUSHOPT instructions. */
+ IX86_BUILTIN_CLFLUSHOPT,
+
+@@ -31282,9 +31287,6 @@ static const struct builtin_description bdesc_special_args[] =
+ { OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_ss_truncatev4siv4hi2_mask_store, "__builtin_ia32_pmovsdw128mem_mask", IX86_BUILTIN_PMOVSDW128_MEM, UNKNOWN, (int) VOID_FTYPE_PV8HI_V4SI_QI },
+ { OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_us_truncatev8siv8hi2_mask_store, "__builtin_ia32_pmovusdw256mem_mask", IX86_BUILTIN_PMOVUSDW256_MEM, UNKNOWN, (int) VOID_FTYPE_PV8HI_V8SI_QI },
+ { OPTION_MASK_ISA_AVX512VL, CODE_FOR_avx512vl_us_truncatev4siv4hi2_mask_store, "__builtin_ia32_pmovusdw128mem_mask", IX86_BUILTIN_PMOVUSDW128_MEM, UNKNOWN, (int) VOID_FTYPE_PV8HI_V4SI_QI },
+-
+- /* PCOMMIT. */
+- { OPTION_MASK_ISA_PCOMMIT, CODE_FOR_pcommit, "__builtin_ia32_pcommit", IX86_BUILTIN_PCOMMIT, UNKNOWN, (int) VOID_FTYPE_VOID },
+ };
+
+ /* Builtins with variable number of arguments. */
+@@ -37748,6 +37750,7 @@ ix86_expand_args_builtin (const struct builtin_description *d,
+ case 5:
+ pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
+ args[2].op, args[3].op, args[4].op);
++ break;
+ case 6:
+ pat = GEN_FCN (icode) (real_target, args[0].op, args[1].op,
+ args[2].op, args[3].op, args[4].op,
+@@ -38123,6 +38126,7 @@ ix86_expand_round_builtin (const struct builtin_description *d,
+ case 5:
+ pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
+ args[2].op, args[3].op, args[4].op);
++ break;
+ case 6:
+ pat = GEN_FCN (icode) (target, args[0].op, args[1].op,
+ args[2].op, args[3].op, args[4].op,
+diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
+index 884cda3..62c5b6c 100644
+--- a/gcc/config/i386/i386.h
++++ b/gcc/config/i386/i386.h
+@@ -150,8 +150,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+ #define TARGET_PREFETCHWT1_P(x) TARGET_ISA_PREFETCHWT1_P(x)
+ #define TARGET_MPX TARGET_ISA_MPX
+ #define TARGET_MPX_P(x) TARGET_ISA_MPX_P(x)
+-#define TARGET_PCOMMIT TARGET_ISA_PCOMMIT
+-#define TARGET_PCOMMIT_P(x) TARGET_ISA_PCOMMIT_P(x)
+ #define TARGET_CLWB TARGET_ISA_CLWB
+ #define TARGET_CLWB_P(x) TARGET_ISA_CLWB_P(x)
+ #define TARGET_MWAITX TARGET_ISA_MWAITX
+diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md
+index 7553a70..6e19875 100644
+--- a/gcc/config/i386/i386.md
++++ b/gcc/config/i386/i386.md
+@@ -255,9 +255,6 @@
+ ;; For CLWB support
+ UNSPECV_CLWB
+
+- ;; For PCOMMIT support
+- UNSPECV_PCOMMIT
+-
+ ;; For CLFLUSHOPT support
+ UNSPECV_CLFLUSHOPT
+
+@@ -2974,7 +2971,7 @@
+ (match_operand:TF 1 "general_operand" "C ,xm,x,*roF,*rC"))]
+ "(TARGET_64BIT || TARGET_SSE)
+ && !(MEM_P (operands[0]) && MEM_P (operands[1]))
+- && (!can_create_pseudo_p ()
++ && (lra_in_progress || reload_completed
+ || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
+ || GET_CODE (operands[1]) != CONST_DOUBLE
+ || (optimize_function_for_size_p (cfun)
+@@ -3044,7 +3041,7 @@
+ (match_operand:XF 1 "general_operand"
+ "fm,f,G,roF,r , *roF,*r,F ,C"))]
+ "!(MEM_P (operands[0]) && MEM_P (operands[1]))
+- && (!can_create_pseudo_p ()
++ && (lra_in_progress || reload_completed
+ || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
+ || GET_CODE (operands[1]) != CONST_DOUBLE
+ || (optimize_function_for_size_p (cfun)
+@@ -3098,7 +3095,7 @@
+ (match_operand:DF 1 "general_operand"
+ "Yf*fm,Yf*f,G ,roF,r ,*roF,*r,F ,rm,rC,C ,F ,C,v,m,v,C ,*x,m ,*x,Yj,r"))]
+ "!(MEM_P (operands[0]) && MEM_P (operands[1]))
+- && (!can_create_pseudo_p ()
++ && (lra_in_progress || reload_completed
+ || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
+ || GET_CODE (operands[1]) != CONST_DOUBLE
+ || (optimize_function_for_size_p (cfun)
+@@ -3281,7 +3278,7 @@
+ (match_operand:SF 1 "general_operand"
+ "Yf*fm,Yf*f,G ,rmF,rF,C,v,m,v,Yj,r ,*y ,m ,*y,*Yn,r"))]
+ "!(MEM_P (operands[0]) && MEM_P (operands[1]))
+- && (!can_create_pseudo_p ()
++ && (lra_in_progress || reload_completed
+ || (ix86_cmodel == CM_MEDIUM || ix86_cmodel == CM_LARGE)
+ || GET_CODE (operands[1]) != CONST_DOUBLE
+ || (optimize_function_for_size_p (cfun)
+@@ -8364,7 +8361,7 @@
+ [(set (match_operand:HI 0 "nonimmediate_operand" "=r,rm,!k")
+ (any_or:HI
+ (match_operand:HI 1 "nonimmediate_operand" "%0,0,k")
+- (match_operand:HI 2 "general_operand" "<g>,r<i>,k")))
++ (match_operand:HI 2 "general_operand" "rmn,rn,k")))
+ (clobber (reg:CC FLAGS_REG))]
+ "ix86_binary_operator_ok (<CODE>, HImode, operands)"
+ "@
+@@ -8446,7 +8443,10 @@
+ (clobber (reg:CC FLAGS_REG))]
+ "TARGET_AVX512F"
+ {
+- if (which_alternative == 1 && <MODE>mode == QImode && TARGET_AVX512DQ)
++ if (which_alternative == 0)
++ return "#";
++
++ if (<MODE>mode == QImode && TARGET_AVX512DQ)
+ return "kxnorb\t{%2, %1, %0|%0, %1, %2}";
+ return "kxnorw\t{%2, %1, %0|%0, %1, %2}";
+ }
+@@ -9285,7 +9285,7 @@
+ "ix86_expand_binary_operator (ASHIFT, <MODE>mode, operands); DONE;")
+
+ (define_insn "*ashl<mode>3_doubleword"
+- [(set (match_operand:DWI 0 "register_operand" "=&r,r")
++ [(set (match_operand:DWI 0 "register_operand" "=&r,&r")
+ (ashift:DWI (match_operand:DWI 1 "reg_or_pm1_operand" "n,0")
+ (match_operand:QI 2 "nonmemory_operand" "<S>c,<S>c")))
+ (clobber (reg:CC FLAGS_REG))]
+@@ -9918,7 +9918,7 @@
+ (set_attr "mode" "<MODE>")])
+
+ (define_insn_and_split "*<shift_insn><mode>3_doubleword"
+- [(set (match_operand:DWI 0 "register_operand" "=r")
++ [(set (match_operand:DWI 0 "register_operand" "=&r")
+ (any_shiftrt:DWI (match_operand:DWI 1 "register_operand" "0")
+ (match_operand:QI 2 "nonmemory_operand" "<S>c")))
+ (clobber (reg:CC FLAGS_REG))]
+@@ -10483,8 +10483,9 @@
+ [(set (match_dup 0)
+ (rotatert:SWI48 (match_dup 1) (match_dup 2)))]
+ {
+- operands[2]
+- = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - INTVAL (operands[2]));
++ int bitsize = GET_MODE_BITSIZE (<MODE>mode);
++
++ operands[2] = GEN_INT ((bitsize - INTVAL (operands[2])) % bitsize);
+ })
+
+ (define_split
+@@ -10550,8 +10551,9 @@
+ [(set (match_dup 0)
+ (zero_extend:DI (rotatert:SI (match_dup 1) (match_dup 2))))]
+ {
+- operands[2]
+- = GEN_INT (GET_MODE_BITSIZE (SImode) - INTVAL (operands[2]));
++ int bitsize = GET_MODE_BITSIZE (SImode);
++
++ operands[2] = GEN_INT ((bitsize - INTVAL (operands[2])) % bitsize);
+ })
+
+ (define_split
+@@ -11645,7 +11647,8 @@
+ (zero_extend (match_dup 1)))]
+ "(peep2_reg_dead_p (3, operands[1])
+ || operands_match_p (operands[1], operands[3]))
+- && ! reg_overlap_mentioned_p (operands[3], operands[0])"
++ && ! reg_overlap_mentioned_p (operands[3], operands[0])
++ && ! reg_set_p (operands[3], operands[4])"
+ [(parallel [(set (match_dup 5) (match_dup 0))
+ (match_dup 4)])
+ (set (strict_low_part (match_dup 6))
+@@ -11688,7 +11691,8 @@
+ (clobber (reg:CC FLAGS_REG))])]
+ "(peep2_reg_dead_p (3, operands[1])
+ || operands_match_p (operands[1], operands[3]))
+- && ! reg_overlap_mentioned_p (operands[3], operands[0])"
++ && ! reg_overlap_mentioned_p (operands[3], operands[0])
++ && ! reg_set_p (operands[3], operands[4])"
+ [(parallel [(set (match_dup 5) (match_dup 0))
+ (match_dup 4)])
+ (set (strict_low_part (match_dup 6))
+@@ -18871,13 +18875,6 @@
+ [(set_attr "type" "other")
+ (set_attr "length" "3")])
+
+-(define_insn "pcommit"
+- [(unspec_volatile [(const_int 0)] UNSPECV_PCOMMIT)]
+- "TARGET_PCOMMIT"
+- "pcommit"
+- [(set_attr "type" "other")
+- (set_attr "length" "4")])
+-
+ (define_insn "clwb"
+ [(unspec_volatile [(match_operand 0 "address_operand" "p")]
+ UNSPECV_CLWB)]
+diff --git a/gcc/config/i386/i386.opt b/gcc/config/i386/i386.opt
+index dd46e26..6a4e2b4 100644
+--- a/gcc/config/i386/i386.opt
++++ b/gcc/config/i386/i386.opt
+@@ -747,8 +747,8 @@ Target Report Mask(ISA_CLWB) Var(ix86_isa_flags) Save
+ Support CLWB instruction
+
+ mpcommit
+-Target Report Mask(ISA_PCOMMIT) Var(ix86_isa_flags) Save
+-Support PCOMMIT instruction
++Target Undocumented Warn(%<-mpcommit%> was deprecated)
++;; Deprecated
+
+ mfxsr
+ Target Report Mask(ISA_FXSR) Var(ix86_isa_flags) Save
+diff --git a/gcc/config/i386/pcommitintrin.h b/gcc/config/i386/pcommitintrin.h
+deleted file mode 100644
+index f9bc2f8..0000000
+--- a/gcc/config/i386/pcommitintrin.h
++++ /dev/null
+@@ -1,49 +0,0 @@
+-/* Copyright (C) 2013-2015 Free Software Foundation, Inc.
+-
+- This file is part of GCC.
+-
+- GCC is free software; you can redistribute it and/or modify
+- it under the terms of the GNU General Public License as published by
+- the Free Software Foundation; either version 3, or (at your option)
+- any later version.
+-
+- GCC 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 General Public License for more details.
+-
+- Under Section 7 of GPL version 3, you are granted additional
+- permissions described in the GCC Runtime Library Exception, version
+- 3.1, as published by the Free Software Foundation.
+-
+- You should have received a copy of the GNU General Public License and
+- a copy of the GCC Runtime Library Exception along with this program;
+- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#if !defined _X86INTRIN_H_INCLUDED
+-# error "Never use <pcommitintrin.h> directly; include <x86intrin.h> instead."
+-#endif
+-
+-#ifndef _PCOMMITINTRIN_H_INCLUDED
+-#define _PCOMMITINTRIN_H_INCLUDED
+-
+-#ifndef __PCOMMIT__
+-#pragma GCC push_options
+-#pragma GCC target("pcommit")
+-#define __DISABLE_PCOMMIT__
+-#endif /* __PCOMMIT__ */
+-
+-extern __inline void
+-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+-_mm_pcommit (void)
+-{
+- __builtin_ia32_pcommit ();
+-}
+-
+-#ifdef __DISABLE_PCOMMIT__
+-#undef __DISABLE_PCOMMIT__
+-#pragma GCC pop_options
+-#endif /* __DISABLE_PCOMMIT__ */
+-
+-#endif /* _PCOMMITINTRIN_H_INCLUDED */
+diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md
+index df50e7d..f7f10ed 100644
+--- a/gcc/config/i386/sse.md
++++ b/gcc/config/i386/sse.md
+@@ -4494,7 +4494,7 @@
+ (define_insn "<floatsuffix>float<sseintvecmodelower><mode>2<mask_name><round_name>"
+ [(set (match_operand:VF2_AVX512VL 0 "register_operand" "=v")
+ (any_float:VF2_AVX512VL
+- (match_operand:<sseintvecmode> 1 "nonimmediate_operand" "vm")))]
++ (match_operand:<sseintvecmode> 1 "nonimmediate_operand" "<round_constraint>")))]
+ "TARGET_AVX512DQ"
+ "vcvt<floatsuffix>qq2pd\t{<round_mask_op2>%1, %0<mask_operand2>|%0<mask_operand2>, %1<round_mask_op2>}"
+ [(set_attr "type" "ssecvt")
+@@ -10979,7 +10979,6 @@
+ gcc_assert (TARGET_AVX);
+ case MODE_V4SF:
+ gcc_assert (TARGET_SSE);
+- gcc_assert (!<mask_applied>);
+ tmp = "<logic>ps";
+ break;
+
+@@ -11866,7 +11865,7 @@
+ (const_int 12) (const_int 13)
+ (const_int 14) (const_int 15)]))))]
+ "TARGET_AVX512DQ"
+- "vinsert<shuffletype>32x8\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x0}"
++ "vinsert<shuffletype>32x8\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x0}"
+ [(set_attr "type" "sselog")
+ (set_attr "length_immediate" "1")
+ (set_attr "prefix" "evex")
+@@ -11883,7 +11882,7 @@
+ (const_int 6) (const_int 7)]))
+ (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")))]
+ "TARGET_AVX512DQ"
+- "vinsert<shuffletype>32x8\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x1}"
++ "vinsert<shuffletype>32x8\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x1}"
+ [(set_attr "type" "sselog")
+ (set_attr "length_immediate" "1")
+ (set_attr "prefix" "evex")
+@@ -11898,7 +11897,7 @@
+ (parallel [(const_int 4) (const_int 5)
+ (const_int 6) (const_int 7)]))))]
+ "TARGET_AVX512F"
+- "vinsert<shuffletype>64x4\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x0}"
++ "vinsert<shuffletype>64x4\t{$0x0, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x0}"
+ [(set_attr "type" "sselog")
+ (set_attr "length_immediate" "1")
+ (set_attr "prefix" "evex")
+@@ -11913,7 +11912,7 @@
+ (const_int 2) (const_int 3)]))
+ (match_operand:<ssehalfvecmode> 2 "nonimmediate_operand" "vm")))]
+ "TARGET_AVX512F"
+- "vinsert<shuffletype>64x4\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, $0x1}"
++ "vinsert<shuffletype>64x4\t{$0x1, %2, %1, %0<mask_operand3>|%0<mask_operand3>, %1, %2, 0x1}"
+ [(set_attr "type" "sselog")
+ (set_attr "length_immediate" "1")
+ (set_attr "prefix" "evex")
+diff --git a/gcc/config/i386/stringop.opt b/gcc/config/i386/stringop.opt
+deleted file mode 100644
+index 6b6d1e0..0000000
+--- a/gcc/config/i386/stringop.opt
++++ /dev/null
+@@ -1,31 +0,0 @@
+-/* Definitions for stringop option handling for IA-32.
+- Copyright (C) 2013-2015 Free Software Foundation, Inc.
+-
+-This file is part of GCC.
+-
+-GCC is free software; you can redistribute it and/or modify
+-it under the terms of the GNU General Public License as published by
+-the Free Software Foundation; either version 3, or (at your option)
+-any later version.
+-
+-GCC 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 General Public License for more details.
+-
+-You should have received a copy of the GNU General Public License
+-along with GCC; see the files COPYING3. If not,
+-see <http://www.gnu.org/licenses/>. */
+-
+-Enum(stringop_alg) String(rep_byte) Value(rep_prefix_1_byte)
+-
+-#undef DEF_ENUM
+-#define DEF_ENUM EnumValue
+-
+-#undef DEF_ALG
+-#define DEF_ALG(alg, name) Enum(stringop_alg) String(name) Value(alg)
+-
+-#include "stringop.def"
+-
+-#undef DEF_ENUM
+-#undef DEF_ALG
+diff --git a/gcc/config/i386/x86intrin.h b/gcc/config/i386/x86intrin.h
+index 6f7b1f6..0d1bb5f 100644
+--- a/gcc/config/i386/x86intrin.h
++++ b/gcc/config/i386/x86intrin.h
+@@ -77,8 +77,6 @@
+
+ #include <clwbintrin.h>
+
+-#include <pcommitintrin.h>
+-
+ #include <clflushoptintrin.h>
+
+ #include <xsavesintrin.h>
+diff --git a/gcc/config/pa/pa.h b/gcc/config/pa/pa.h
+index 8314ba3..818a7a6 100644
+--- a/gcc/config/pa/pa.h
++++ b/gcc/config/pa/pa.h
+@@ -298,9 +298,23 @@ typedef struct GTY(()) machine_function
+ /* A bit-field declared as `int' forces `int' alignment for the struct. */
+ #define PCC_BITFIELD_TYPE_MATTERS 1
+
+-/* No data type wants to be aligned rounder than this. */
++/* No data type wants to be aligned rounder than this. The long double
++ type has 16-byte alignment on the 64-bit target even though it was never
++ implemented in hardware. The software implementation only needs 8-byte
++ alignment. This matches the biggest alignment of the HP compilers. */
+ #define BIGGEST_ALIGNMENT (2 * BITS_PER_WORD)
+
++/* Alignment, in bits, a C conformant malloc implementation has to provide.
++ The HP-UX malloc implementation provides a default alignment of 8 bytes.
++ It should be 16 bytes on the 64-bit target since long double has 16-byte
++ alignment. It can be increased with mallopt but it's non critical since
++ long double was never implemented in hardware. The glibc implementation
++ currently provides 8-byte alignment. It should be 16 bytes since various
++ POSIX types such as pthread_mutex_t require 16-byte alignment. Again,
++ this is non critical since 16-byte alignment is no longer needed for
++ atomic operations. */
++#define MALLOC_ABI_ALIGNMENT (TARGET_SOM ? 64 : 128)
++
+ /* Get around hp-ux assembler bug, and make strcpy of constants fast. */
+ #define CONSTANT_ALIGNMENT(EXP, ALIGN) \
+ (TREE_CODE (EXP) == STRING_CST \
+diff --git a/gcc/config/phoenix.h b/gcc/config/phoenix.h
+new file mode 100644
+index 0000000..9ffb958
+--- /dev/null
++++ b/gcc/config/phoenix.h
+@@ -0,0 +1,33 @@
++/* Base configuration file for all Phoenix-RTOS targets.
++ Copyright (C) 2016 Free Software Foundation, Inc.
++
++This file is part of GCC.
++
++GCC is free software; you can redistribute it and/or modify
++it under the terms of the GNU General Public License as published by
++the Free Software Foundation; either version 3, or (at your option)
++any later version.
++
++GCC 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 General Public License for more details.
++
++You should have received a copy of the GNU General Public License
++along with GCC; see the file COPYING3. If not see
++<http://www.gnu.org/licenses/>. */
++
++#undef TARGET_OS_CPP_BUILTINS
++#define TARGET_OS_CPP_BUILTINS() \
++ do { \
++ builtin_define_std ("phoenix"); \
++ builtin_define_std ("unix"); \
++ builtin_assert ("system=phoenix"); \
++ builtin_assert ("system=unix"); \
++ } while(0);
++
++#define STD_LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
++
++/* This will prevent selecting 'unsigned long int' instead of 'unsigned int' as 'uint32_t' in stdint-newlib.h. */
++#undef STDINT_LONG32
++#define STDINT_LONG32 0
+diff --git a/gcc/config/rl78/rl78-expand.md b/gcc/config/rl78/rl78-expand.md
+index 0335a4d..3836a41 100644
+--- a/gcc/config/rl78/rl78-expand.md
++++ b/gcc/config/rl78/rl78-expand.md
+@@ -159,7 +159,7 @@
+ [(set (match_operand:HI 0 "register_operand")
+ (mult:HI (zero_extend:HI (match_operand:QI 1 "register_operand"))
+ (zero_extend:HI (match_operand:QI 2 "register_operand"))))]
+- "!TARGET_G10"
++ ""
+ ""
+ )
+
+diff --git a/gcc/config/rl78/rl78-real.md b/gcc/config/rl78/rl78-real.md
+index f6ab7ff..3f3e9c3 100644
+--- a/gcc/config/rl78/rl78-real.md
++++ b/gcc/config/rl78/rl78-real.md
+@@ -179,7 +179,7 @@
+ [(set (match_operand:HI 0 "register_operand" "=A,A")
+ (mult:HI (match_operand:HI 1 "rl78_nonfar_operand" "0,0")
+ (match_operand:HI 2 "rl78_24_operand" "N,i")))]
+- "rl78_real_insns_ok () && !TARGET_G10"
++ "rl78_real_insns_ok ()"
+ "@
+ shlw\t%0, 1
+ shlw\t%0, 2"
+@@ -189,7 +189,7 @@
+ [(set (match_operand:HI 0 "nonimmediate_operand" "=A")
+ (mult:HI (zero_extend:HI (match_operand:QI 1 "general_operand" "%a"))
+ (zero_extend:HI (match_operand:QI 2 "general_operand" "x"))))]
+- "rl78_real_insns_ok () && !TARGET_G10"
++ "rl78_real_insns_ok ()"
+ "mulu\t%2"
+ )
+
+diff --git a/gcc/config/rl78/rl78-virt.md b/gcc/config/rl78/rl78-virt.md
+index e90e156..cbdb988 100644
+--- a/gcc/config/rl78/rl78-virt.md
++++ b/gcc/config/rl78/rl78-virt.md
+@@ -116,7 +116,7 @@
+ [(set (match_operand:HI 0 "register_operand" "=vm")
+ (mult:HI (match_operand:HI 1 "rl78_nonfar_operand" "%vim")
+ (match_operand:HI 2 "rl78_24_operand" "Ni")))]
+- "rl78_virt_insns_ok () && !TARGET_G10"
++ "rl78_virt_insns_ok ()"
+ "v.mulu\t%0, %1, %2"
+ [(set_attr "valloc" "umul")]
+ )
+@@ -125,7 +125,7 @@
+ [(set (match_operand:HI 0 "register_operand" "=vm")
+ (mult:HI (zero_extend:HI (match_operand:QI 1 "rl78_nonfar_operand" "%vim"))
+ (zero_extend:HI (match_operand:QI 2 "general_operand" "vim"))))]
+- "rl78_virt_insns_ok () && !TARGET_G10"
++ "rl78_virt_insns_ok ()"
+ "v.mulu\t%0, %2"
+ [(set_attr "valloc" "umul")]
+ )
+diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
+index c96a8c4..c66bfb0 100644
+--- a/gcc/config/rs6000/rs6000.c
++++ b/gcc/config/rs6000/rs6000.c
+@@ -5180,8 +5180,8 @@ rs6000_file_start (void)
+ }
+
+ #ifdef USING_ELFOS_H
+- if (rs6000_default_cpu == 0 || rs6000_default_cpu[0] == '\0'
+- || !global_options_set.x_rs6000_cpu_index)
++ if (!(rs6000_default_cpu && rs6000_default_cpu[0])
++ && !global_options_set.x_rs6000_cpu_index)
+ {
+ fputs ("\t.machine ", asm_out_file);
+ if ((rs6000_isa_flags & OPTION_MASK_DIRECT_MOVE) != 0)
+@@ -13102,6 +13102,7 @@ altivec_expand_ld_builtin (tree exp, rtx target, bool *expandedp)
+ break;
+ case ALTIVEC_BUILTIN_LD_INTERNAL_2di:
+ icode = CODE_FOR_vector_altivec_load_v2di;
++ break;
+ case ALTIVEC_BUILTIN_LD_INTERNAL_1ti:
+ icode = CODE_FOR_vector_altivec_load_v1ti;
+ break;
+@@ -13163,6 +13164,7 @@ altivec_expand_st_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
+ break;
+ case ALTIVEC_BUILTIN_ST_INTERNAL_2di:
+ icode = CODE_FOR_vector_altivec_store_v2di;
++ break;
+ case ALTIVEC_BUILTIN_ST_INTERNAL_1ti:
+ icode = CODE_FOR_vector_altivec_store_v1ti;
+ break;
+@@ -17232,6 +17234,7 @@ rs6000_secondary_reload (bool in_p,
+ && MEM_P (SUBREG_REG (x))));
+
+ sri->icode = CODE_FOR_nothing;
++ sri->t_icode = CODE_FOR_nothing;
+ sri->extra_cost = 0;
+ icode = ((in_p)
+ ? reg_addr[mode].reload_load
+@@ -25856,53 +25859,54 @@ rs6000_output_function_epilogue (FILE *file,
+ seems to set the bit when not optimizing. */
+ fprintf (file, "%d\n", ((float_parms << 1) | (! optimize)));
+
+- if (! optional_tbtab)
+- return;
+-
+- /* Optional fields follow. Some are variable length. */
+-
+- /* Parameter types, left adjusted bit fields: 0 fixed, 10 single float,
+- 11 double float. */
+- /* There is an entry for each parameter in a register, in the order that
+- they occur in the parameter list. Any intervening arguments on the
+- stack are ignored. If the list overflows a long (max possible length
+- 34 bits) then completely leave off all elements that don't fit. */
+- /* Only emit this long if there was at least one parameter. */
+- if (fixed_parms || float_parms)
+- fprintf (file, "\t.long %d\n", parm_info);
+-
+- /* Offset from start of code to tb table. */
+- fputs ("\t.long ", file);
+- ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LT");
+- RS6000_OUTPUT_BASENAME (file, fname);
+- putc ('-', file);
+- rs6000_output_function_entry (file, fname);
+- putc ('\n', file);
++ if (optional_tbtab)
++ {
++ /* Optional fields follow. Some are variable length. */
++
++ /* Parameter types, left adjusted bit fields: 0 fixed, 10 single
++ float, 11 double float. */
++ /* There is an entry for each parameter in a register, in the order
++ that they occur in the parameter list. Any intervening arguments
++ on the stack are ignored. If the list overflows a long (max
++ possible length 34 bits) then completely leave off all elements
++ that don't fit. */
++ /* Only emit this long if there was at least one parameter. */
++ if (fixed_parms || float_parms)
++ fprintf (file, "\t.long %d\n", parm_info);
++
++ /* Offset from start of code to tb table. */
++ fputs ("\t.long ", file);
++ ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LT");
++ RS6000_OUTPUT_BASENAME (file, fname);
++ putc ('-', file);
++ rs6000_output_function_entry (file, fname);
++ putc ('\n', file);
+
+- /* Interrupt handler mask. */
+- /* Omit this long, since we never set the interrupt handler bit
+- above. */
++ /* Interrupt handler mask. */
++ /* Omit this long, since we never set the interrupt handler bit
++ above. */
+
+- /* Number of CTL (controlled storage) anchors. */
+- /* Omit this long, since the has_ctl bit is never set above. */
++ /* Number of CTL (controlled storage) anchors. */
++ /* Omit this long, since the has_ctl bit is never set above. */
+
+- /* Displacement into stack of each CTL anchor. */
+- /* Omit this list of longs, because there are no CTL anchors. */
++ /* Displacement into stack of each CTL anchor. */
++ /* Omit this list of longs, because there are no CTL anchors. */
+
+- /* Length of function name. */
+- if (*fname == '*')
+- ++fname;
+- fprintf (file, "\t.short %d\n", (int) strlen (fname));
++ /* Length of function name. */
++ if (*fname == '*')
++ ++fname;
++ fprintf (file, "\t.short %d\n", (int) strlen (fname));
+
+- /* Function name. */
+- assemble_string (fname, strlen (fname));
++ /* Function name. */
++ assemble_string (fname, strlen (fname));
+
+- /* Register for alloca automatic storage; this is always reg 31.
+- Only emit this if the alloca bit was set above. */
+- if (frame_pointer_needed)
+- fputs ("\t.byte 31\n", file);
++ /* Register for alloca automatic storage; this is always reg 31.
++ Only emit this if the alloca bit was set above. */
++ if (frame_pointer_needed)
++ fputs ("\t.byte 31\n", file);
+
+- fputs ("\t.align 2\n", file);
++ fputs ("\t.align 2\n", file);
++ }
+ }
+ }
+
+@@ -26228,7 +26232,10 @@ rs6000_output_symbol_ref (FILE *file, rtx x)
+ (TREE_CODE (decl) == FUNCTION_DECL
+ ? "[DS]" : "[UA]"),
+ NULL);
+- XSTR (x, 0) = name;
++
++ /* Don't modify name in extern VAR_DECL to include mapping class. */
++ if (TREE_CODE (decl) == FUNCTION_DECL)
++ XSTR (x, 0) = name;
+ }
+
+ if (VTABLE_NAME_P (name))
+@@ -34566,7 +34573,7 @@ insn_is_swappable_p (swap_web_entry *insn_entry, rtx insn,
+ if (GET_CODE (use_body) != SET
+ || GET_CODE (SET_SRC (use_body)) != UNSPEC
+ || XINT (SET_SRC (use_body), 1) != UNSPEC_VSX_XXSPLTW
+- || XEXP (XEXP (SET_SRC (use_body), 0), 1) != const0_rtx)
++ || XVECEXP (SET_SRC (use_body), 0, 1) != const0_rtx)
+ return 0;
+ }
+ }
+diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md
+index 114bc96..2058059 100644
+--- a/gcc/config/rs6000/rs6000.md
++++ b/gcc/config/rs6000/rs6000.md
+@@ -12987,7 +12987,7 @@
+ (const_int 1))
+ (label_ref (match_operand 0 "" ""))
+ (pc)))
+- (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l")
++ (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*wi*c*l")
+ (plus:P (match_dup 1)
+ (const_int -1)))
+ (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
+@@ -13011,7 +13011,7 @@
+ (const_int 1))
+ (pc)
+ (label_ref (match_operand 0 "" ""))))
+- (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l")
++ (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*wi*c*l")
+ (plus:P (match_dup 1)
+ (const_int -1)))
+ (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
+@@ -13037,7 +13037,7 @@
+ (const_int 1))
+ (label_ref (match_operand 0 "" ""))
+ (pc)))
+- (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l")
++ (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*wi*c*l")
+ (plus:P (match_dup 1)
+ (const_int -1)))
+ (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
+@@ -13061,7 +13061,7 @@
+ (const_int 1))
+ (pc)
+ (label_ref (match_operand 0 "" ""))))
+- (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*c*l")
++ (set (match_operand:P 2 "nonimmediate_operand" "=1,*r,m,*d*wi*c*l")
+ (plus:P (match_dup 1)
+ (const_int -1)))
+ (clobber (match_scratch:CC 3 "=X,&x,&x,&x"))
+diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md
+index c112b10..a689c2b 100644
+--- a/gcc/config/rs6000/vsx.md
++++ b/gcc/config/rs6000/vsx.md
+@@ -716,13 +716,27 @@
+ [(set (match_operand:VSX_M 0 "vsx_register_operand" "")
+ (match_operand:VSX_M 1 "memory_operand" ""))]
+ "VECTOR_MEM_VSX_P (<MODE>mode)"
+- "")
++{
++ /* Expand to swaps if needed, prior to swap optimization. */
++ if (!BYTES_BIG_ENDIAN)
++ {
++ rs6000_emit_le_vsx_move (operands[0], operands[1], <MODE>mode);
++ DONE;
++ }
++})
+
+ (define_expand "vsx_store_<mode>"
+ [(set (match_operand:VSX_M 0 "memory_operand" "")
+ (match_operand:VSX_M 1 "vsx_register_operand" ""))]
+ "VECTOR_MEM_VSX_P (<MODE>mode)"
+- "")
++{
++ /* Expand to swaps if needed, prior to swap optimization. */
++ if (!BYTES_BIG_ENDIAN)
++ {
++ rs6000_emit_le_vsx_move (operands[0], operands[1], <MODE>mode);
++ DONE;
++ }
++})
+
+
+ ;; VSX vector floating point arithmetic instructions. The VSX scalar
+diff --git a/gcc/config/s390/s390-modes.def b/gcc/config/s390/s390-modes.def
+index f4c53f8..7385c68 100644
+--- a/gcc/config/s390/s390-modes.def
++++ b/gcc/config/s390/s390-modes.def
+@@ -84,22 +84,6 @@ Requested mode -> Destination CC register mode
+ CCS, CCU, CCT, CCSR, CCUR -> CCZ
+ CCA -> CCAP, CCAN
+
+-Vector comparison modes
+-
+-CCVEQ EQ - - NE (VCEQ)
+-CCVEQANY EQ EQ - NE (VCEQ)
+-
+-CCVH GT - - LE (VCH)
+-CCVHANY GT GT - LE (VCH)
+-CCVHU GTU - - LEU (VCHL)
+-CCVHUANY GTU GTU - LEU (VCHL)
+-
+-CCVFH GT - - UNLE (VFCH)
+-CCVFHANY GT GT - UNLE (VFCH)
+-CCVFHE GE - - UNLT (VFCHE)
+-CCVFHEANY GE GE - UNLT (VFCHE)
+-
+-
+
+
+ *** Comments ***
+@@ -169,14 +153,40 @@ The compare and swap instructions sets the condition code to 0/1 if the
+ operands were equal/unequal. The CCZ1 mode ensures the result can be
+ effectively placed into a register.
+
+-
+-CCV*
+-
+-The variants with and without ANY are generated by the same
+-instructions and therefore are holding the same information. However,
+-when generating a condition code mask they require checking different
+-bits of CC. In that case the variants without ANY represent the
+-results for *all* elements.
++CCVIH, CCVIHU, CCVFH, CCVFHE
++
++These are condition code modes used in instructions setting the
++condition code. The mode determines which comparison to perform (H -
++high, HU - high unsigned, HE - high or equal) and whether it is a
++floating point comparison or not (I - int, F - float).
++
++The comparison operation to be performed needs to be encoded into the
++condition code mode since the comparison operator is not available in
++compare style patterns (set cc (compare (op0) (op1))). So the
++condition code mode is the only information to determine the
++instruction to be used.
++
++CCVIALL, CCVIANY, CCVFALL, CCVFANY
++
++These modes are used in instructions reading the condition code.
++Opposed to the CC producer patterns the comparison operator is
++available. Hence the comparison operation does not need to be part of
++the CC mode. However, we still need to know whether CC has been
++generated by a float or an integer comparison in order to be able to
++invert the condition correctly (int: GT -> LE, float: GT -> UNLE).
++
++The ALL and ANY variants differ only in the usage of CC1 which
++indicates a mixed result across the vector elements. Be aware that
++depending on the comparison code the ALL and ANY variants might
++actually refer to their opposite meaning. I.e. while inverting the
++comparison in (EQ (reg:CCVIALL 33) (const_int 0)) results in (NE
++(reg:CCVIALL 33) (const_int 0)) it in fact describes an ANY comparison
++(inverting "all equal" should be "any not equal") However, the
++middle-end does invert only the comparison operator without touching
++the mode.
++Hence, the ALL/ANY in the mode names refer to the meaning in the
++context of EQ, GT, GE while for the inverted codes it actually means
++ANY/ALL.
+
+ CCRAW
+
+@@ -209,18 +219,18 @@ CC_MODE (CCT3);
+ CC_MODE (CCRAW);
+
+ CC_MODE (CCVEQ);
+-CC_MODE (CCVEQANY);
+
+-CC_MODE (CCVH);
+-CC_MODE (CCVHANY);
+-CC_MODE (CCVHU);
+-CC_MODE (CCVHUANY);
++CC_MODE (CCVIH);
++CC_MODE (CCVIHU);
+
+ CC_MODE (CCVFH);
+-CC_MODE (CCVFHANY);
+ CC_MODE (CCVFHE);
+-CC_MODE (CCVFHEANY);
+
++CC_MODE (CCVIALL);
++CC_MODE (CCVIANY);
++
++CC_MODE (CCVFALL);
++CC_MODE (CCVFANY);
+
+ /* Vector modes. */
+
+diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c
+index c2c58ee..9629525 100644
+--- a/gcc/config/s390/s390.c
++++ b/gcc/config/s390/s390.c
+@@ -785,7 +785,7 @@ s390_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
+ machine_mode mode ATTRIBUTE_UNUSED,
+ int ignore ATTRIBUTE_UNUSED)
+ {
+-#define MAX_ARGS 5
++#define MAX_ARGS 6
+
+ tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
+ unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
+@@ -1242,6 +1242,11 @@ s390_match_ccmode_set (rtx set, machine_mode req_mode)
+
+ gcc_assert (GET_CODE (set) == SET);
+
++ /* These modes are supposed to be used only in CC consumer
++ patterns. */
++ gcc_assert (req_mode != CCVIALLmode && req_mode != CCVIANYmode
++ && req_mode != CCVFALLmode && req_mode != CCVFANYmode);
++
+ if (GET_CODE (SET_DEST (set)) != REG || !CC_REGNO_P (REGNO (SET_DEST (set))))
+ return 1;
+
+@@ -1260,8 +1265,8 @@ s390_match_ccmode_set (rtx set, machine_mode req_mode)
+ case CCT2mode:
+ case CCT3mode:
+ case CCVEQmode:
+- case CCVHmode:
+- case CCVHUmode:
++ case CCVIHmode:
++ case CCVIHUmode:
+ case CCVFHmode:
+ case CCVFHEmode:
+ if (req_mode != set_mode)
+@@ -1719,14 +1724,21 @@ s390_expand_vec_compare_scalar (enum rtx_code *code, rtx cmp1, rtx cmp2,
+ cmp2 = cmp1;
+ cmp1 = tmp;
+ }
+- *cc = gen_rtx_REG (cmp_mode, CC_REGNUM);
++
+ emit_insn (gen_rtx_PARALLEL (VOIDmode,
+ gen_rtvec (2,
+- gen_rtx_SET (VOIDmode, *cc,
++ gen_rtx_SET (VOIDmode,
++ gen_rtx_REG (cmp_mode, CC_REGNUM),
+ gen_rtx_COMPARE (cmp_mode, cmp1,
+ cmp2)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (V2DImode)))));
++
++ /* This is the cc reg how it will be used in the cc mode consumer.
++ It either needs to be CCVFALL or CCVFANY. However, CC1 will
++ never be set by the scalar variants. So it actually doesn't
++ matter which one we choose here. */
++ *cc = gen_rtx_REG (CCVFALLmode, CC_REGNUM);
+ return true;
+ }
+
+@@ -1988,92 +2000,63 @@ s390_branch_condition_mask (rtx code)
+ break;
+
+ /* Vector comparison modes. */
+-
+- case CCVEQmode:
+- switch (GET_CODE (code))
+- {
+- case EQ: return CC0;
+- case NE: return CC3;
+- default: return -1;
+- }
+-
+- case CCVEQANYmode:
+- switch (GET_CODE (code))
+- {
+- case EQ: return CC0 | CC1;
+- case NE: return CC3 | CC1;
+- default: return -1;
+- }
+-
+- /* Integer vector compare modes. */
+-
+- case CCVHmode:
+- switch (GET_CODE (code))
+- {
+- case GT: return CC0;
+- case LE: return CC3;
+- default: return -1;
+- }
+-
+- case CCVHANYmode:
+- switch (GET_CODE (code))
+- {
+- case GT: return CC0 | CC1;
+- case LE: return CC3 | CC1;
+- default: return -1;
+- }
+-
+- case CCVHUmode:
+- switch (GET_CODE (code))
+- {
+- case GTU: return CC0;
+- case LEU: return CC3;
+- default: return -1;
+- }
+-
+- case CCVHUANYmode:
+- switch (GET_CODE (code))
+- {
+- case GTU: return CC0 | CC1;
+- case LEU: return CC3 | CC1;
+- default: return -1;
+- }
+-
+- /* FP vector compare modes. */
+-
+- case CCVFHmode:
++ /* CC2 will never be set. It however is part of the negated
++ masks. */
++ case CCVIALLmode:
+ switch (GET_CODE (code))
+ {
+- case GT: return CC0;
+- case UNLE: return CC3;
++ case EQ:
++ case GTU:
++ case GT:
++ case GE: return CC0;
++ /* The inverted modes are in fact *any* modes. */
++ case NE:
++ case LEU:
++ case LE:
++ case LT: return CC3 | CC1 | CC2;
+ default: return -1;
+ }
+
+- case CCVFHANYmode:
++ case CCVIANYmode:
+ switch (GET_CODE (code))
+ {
+- case GT: return CC0 | CC1;
+- case UNLE: return CC3 | CC1;
++ case EQ:
++ case GTU:
++ case GT:
++ case GE: return CC0 | CC1;
++ /* The inverted modes are in fact *all* modes. */
++ case NE:
++ case LEU:
++ case LE:
++ case LT: return CC3 | CC2;
+ default: return -1;
+ }
+-
+- case CCVFHEmode:
++ case CCVFALLmode:
+ switch (GET_CODE (code))
+ {
++ case EQ:
++ case GT:
+ case GE: return CC0;
+- case UNLT: return CC3;
++ /* The inverted modes are in fact *any* modes. */
++ case NE:
++ case UNLE:
++ case UNLT: return CC3 | CC1 | CC2;
+ default: return -1;
+ }
+
+- case CCVFHEANYmode:
++ case CCVFANYmode:
+ switch (GET_CODE (code))
+ {
++ case EQ:
++ case GT:
+ case GE: return CC0 | CC1;
+- case UNLT: return CC3 | CC1;
++ /* The inverted modes are in fact *all* modes. */
++ case NE:
++ case UNLE:
++ case UNLT: return CC3 | CC2;
+ default: return -1;
+ }
+
+-
+ case CCRAWmode:
+ switch (GET_CODE (code))
+ {
+@@ -6128,13 +6111,15 @@ s390_expand_vec_compare (rtx target, enum rtx_code cond,
+
+ /* Expand the comparison CODE of CMP1 and CMP2 and copy 1 or 0 into
+ TARGET if either all (ALL_P is true) or any (ALL_P is false) of the
+- elements in CMP1 and CMP2 fulfill the comparison. */
++ elements in CMP1 and CMP2 fulfill the comparison.
++ This function is only used to emit patterns for the vx builtins and
++ therefore only handles comparison codes required by the
++ builtins. */
+ void
+ s390_expand_vec_compare_cc (rtx target, enum rtx_code code,
+ rtx cmp1, rtx cmp2, bool all_p)
+ {
+- enum rtx_code new_code = code;
+- machine_mode cmp_mode, full_cmp_mode, scratch_mode;
++ machine_mode cc_producer_mode, cc_consumer_mode, scratch_mode;
+ rtx tmp_reg = gen_reg_rtx (SImode);
+ bool swap_p = false;
+
+@@ -6142,53 +6127,71 @@ s390_expand_vec_compare_cc (rtx target, enum rtx_code code,
+ {
+ switch (code)
+ {
+- case EQ: cmp_mode = CCVEQmode; break;
+- case NE: cmp_mode = CCVEQmode; break;
+- case GT: cmp_mode = CCVHmode; break;
+- case GE: cmp_mode = CCVHmode; new_code = LE; swap_p = true; break;
+- case LT: cmp_mode = CCVHmode; new_code = GT; swap_p = true; break;
+- case LE: cmp_mode = CCVHmode; new_code = LE; break;
+- case GTU: cmp_mode = CCVHUmode; break;
+- case GEU: cmp_mode = CCVHUmode; new_code = LEU; swap_p = true; break;
+- case LTU: cmp_mode = CCVHUmode; new_code = GTU; swap_p = true; break;
+- case LEU: cmp_mode = CCVHUmode; new_code = LEU; break;
+- default: gcc_unreachable ();
++ case EQ:
++ case NE:
++ cc_producer_mode = CCVEQmode;
++ break;
++ case GE:
++ case LT:
++ code = swap_condition (code);
++ swap_p = true;
++ /* fallthrough */
++ case GT:
++ case LE:
++ cc_producer_mode = CCVIHmode;
++ break;
++ case GEU:
++ case LTU:
++ code = swap_condition (code);
++ swap_p = true;
++ /* fallthrough */
++ case GTU:
++ case LEU:
++ cc_producer_mode = CCVIHUmode;
++ break;
++ default:
++ gcc_unreachable ();
+ }
++
+ scratch_mode = GET_MODE (cmp1);
++ /* These codes represent inverted CC interpretations. Inverting
++ an ALL CC mode results in an ANY CC mode and the other way
++ around. Invert the all_p flag here to compensate for
++ that. */
++ if (code == NE || code == LE || code == LEU)
++ all_p = !all_p;
++
++ cc_consumer_mode = all_p ? CCVIALLmode : CCVIANYmode;
+ }
+- else if (GET_MODE (cmp1) == V2DFmode)
++ else if (GET_MODE_CLASS (GET_MODE (cmp1)) == MODE_VECTOR_FLOAT)
+ {
++ bool inv_p = false;
++
+ switch (code)
+ {
+- case EQ: cmp_mode = CCVEQmode; break;
+- case NE: cmp_mode = CCVEQmode; break;
+- case GT: cmp_mode = CCVFHmode; break;
+- case GE: cmp_mode = CCVFHEmode; break;
+- case UNLE: cmp_mode = CCVFHmode; break;
+- case UNLT: cmp_mode = CCVFHEmode; break;
+- case LT: cmp_mode = CCVFHmode; new_code = GT; swap_p = true; break;
+- case LE: cmp_mode = CCVFHEmode; new_code = GE; swap_p = true; break;
++ case EQ: cc_producer_mode = CCVEQmode; break;
++ case NE: cc_producer_mode = CCVEQmode; inv_p = true; break;
++ case GT: cc_producer_mode = CCVFHmode; break;
++ case GE: cc_producer_mode = CCVFHEmode; break;
++ case UNLE: cc_producer_mode = CCVFHmode; inv_p = true; break;
++ case UNLT: cc_producer_mode = CCVFHEmode; inv_p = true; break;
++ case LT: cc_producer_mode = CCVFHmode; code = GT; swap_p = true; break;
++ case LE: cc_producer_mode = CCVFHEmode; code = GE; swap_p = true; break;
+ default: gcc_unreachable ();
+ }
+- scratch_mode = V2DImode;
++ scratch_mode = mode_for_vector (
++ int_mode_for_mode (GET_MODE_INNER (GET_MODE (cmp1))),
++ GET_MODE_NUNITS (GET_MODE (cmp1)));
++ gcc_assert (scratch_mode != BLKmode);
++
++ if (inv_p)
++ all_p = !all_p;
++
++ cc_consumer_mode = all_p ? CCVFALLmode : CCVFANYmode;
+ }
+ else
+ gcc_unreachable ();
+
+- if (!all_p)
+- switch (cmp_mode)
+- {
+- case CCVEQmode: full_cmp_mode = CCVEQANYmode; break;
+- case CCVHmode: full_cmp_mode = CCVHANYmode; break;
+- case CCVHUmode: full_cmp_mode = CCVHUANYmode; break;
+- case CCVFHmode: full_cmp_mode = CCVFHANYmode; break;
+- case CCVFHEmode: full_cmp_mode = CCVFHEANYmode; break;
+- default: gcc_unreachable ();
+- }
+- else
+- /* The modes without ANY match the ALL modes. */
+- full_cmp_mode = cmp_mode;
+-
+ if (swap_p)
+ {
+ rtx tmp = cmp2;
+@@ -6197,9 +6200,9 @@ s390_expand_vec_compare_cc (rtx target, enum rtx_code code,
+ }
+
+ emit_insn (gen_rtx_PARALLEL (VOIDmode,
+- gen_rtvec (2, gen_rtx_SET (VOIDmode,
+- gen_rtx_REG (cmp_mode, CC_REGNUM),
+- gen_rtx_COMPARE (cmp_mode, cmp1, cmp2)),
++ gen_rtvec (2, gen_rtx_SET (VOIDmode,
++ gen_rtx_REG (cc_producer_mode, CC_REGNUM),
++ gen_rtx_COMPARE (cc_producer_mode, cmp1, cmp2)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (scratch_mode)))));
+ emit_move_insn (target, const0_rtx);
+@@ -6207,10 +6210,10 @@ s390_expand_vec_compare_cc (rtx target, enum rtx_code code,
+
+ emit_move_insn (target,
+ gen_rtx_IF_THEN_ELSE (SImode,
+- gen_rtx_fmt_ee (new_code, VOIDmode,
+- gen_rtx_REG (full_cmp_mode, CC_REGNUM),
++ gen_rtx_fmt_ee (code, VOIDmode,
++ gen_rtx_REG (cc_consumer_mode, CC_REGNUM),
+ const0_rtx),
+- target, tmp_reg));
++ tmp_reg, target));
+ }
+
+ /* Generate a vector comparison expression loading either elements of
+diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md
+index e7d9b55..34106e4 100644
+--- a/gcc/config/s390/s390.md
++++ b/gcc/config/s390/s390.md
+@@ -745,7 +745,7 @@
+ ; Used with VFCMP to expand part of the mnemonic
+ ; For fp we have a mismatch: eq in the insn name - e in asm
+ (define_mode_attr asm_fcmp [(CCVEQ "e") (CCVFH "h") (CCVFHE "he")])
+-(define_mode_attr insn_cmp [(CCVEQ "eq") (CCVH "h") (CCVHU "hl") (CCVFH "h") (CCVFHE "he")])
++(define_mode_attr insn_cmp [(CCVEQ "eq") (CCVIH "h") (CCVIHU "hl") (CCVFH "h") (CCVFHE "he")])
+
+
+ (include "vector.md")
+diff --git a/gcc/config/s390/vx-builtins.md b/gcc/config/s390/vx-builtins.md
+index 9cc13ce..d1481fd 100644
+--- a/gcc/config/s390/vx-builtins.md
++++ b/gcc/config/s390/vx-builtins.md
+@@ -36,7 +36,7 @@
+ (V1DF "DI") (V2DF "DI")])
+
+ ; Condition code modes generated by int comparisons
+-(define_mode_iterator VICMP [CCVEQ CCVH CCVHU])
++(define_mode_iterator VICMP [CCVEQ CCVIH CCVIHU])
+
+ ; Comparisons supported by the vec_cmp* builtins
+ (define_code_iterator intcmp [eq gt gtu ge geu lt ltu le leu])
+@@ -1951,24 +1951,24 @@
+
+ (define_expand "vec_cmph<VI_HW:mode>_cc"
+ [(parallel
+- [(set (reg:CCVH CC_REGNUM)
+- (compare:CCVH (match_operand:VI_HW 1 "register_operand" "v")
+- (match_operand:VI_HW 2 "register_operand" "v")))
++ [(set (reg:CCVIH CC_REGNUM)
++ (compare:CCVIH (match_operand:VI_HW 1 "register_operand" "v")
++ (match_operand:VI_HW 2 "register_operand" "v")))
+ (set (match_operand:VI_HW 0 "register_operand" "=v")
+ (gt:VI_HW (match_dup 1) (match_dup 2)))])
+ (set (match_operand:SI 3 "memory_operand" "")
+- (unspec:SI [(reg:CCVH CC_REGNUM)] UNSPEC_CC_TO_INT))]
++ (unspec:SI [(reg:CCVIH CC_REGNUM)] UNSPEC_CC_TO_INT))]
+ "TARGET_VX")
+
+ (define_expand "vec_cmphl<VI_HW:mode>_cc"
+ [(parallel
+- [(set (reg:CCVHU CC_REGNUM)
+- (compare:CCVHU (match_operand:VI_HW 1 "register_operand" "v")
+- (match_operand:VI_HW 2 "register_operand" "v")))
++ [(set (reg:CCVIHU CC_REGNUM)
++ (compare:CCVIHU (match_operand:VI_HW 1 "register_operand" "v")
++ (match_operand:VI_HW 2 "register_operand" "v")))
+ (set (match_operand:VI_HW 0 "register_operand" "=v")
+ (gtu:VI_HW (match_dup 1) (match_dup 2)))])
+ (set (match_operand:SI 3 "memory_operand" "")
+- (unspec:SI [(reg:CCVHU CC_REGNUM)] UNSPEC_CC_TO_INT))]
++ (unspec:SI [(reg:CCVIHU CC_REGNUM)] UNSPEC_CC_TO_INT))]
+ "TARGET_VX")
+
+
+@@ -1983,9 +1983,9 @@
+ [(set_attr "op_type" "VRR")])
+
+ (define_insn "*vec_cmph<VI_HW:mode>_cc"
+- [(set (reg:CCVH CC_REGNUM)
+- (compare:CCVH (match_operand:VI_HW 0 "register_operand" "v")
+- (match_operand:VI_HW 1 "register_operand" "v")))
++ [(set (reg:CCVIH CC_REGNUM)
++ (compare:CCVIH (match_operand:VI_HW 0 "register_operand" "v")
++ (match_operand:VI_HW 1 "register_operand" "v")))
+ (set (match_operand:VI_HW 2 "register_operand" "=v")
+ (gt:VI_HW (match_dup 0) (match_dup 1)))]
+ "TARGET_VX"
+@@ -1993,9 +1993,9 @@
+ [(set_attr "op_type" "VRR")])
+
+ (define_insn "*vec_cmphl<VI_HW:mode>_cc"
+- [(set (reg:CCVHU CC_REGNUM)
+- (compare:CCVHU (match_operand:VI_HW 0 "register_operand" "v")
+- (match_operand:VI_HW 1 "register_operand" "v")))
++ [(set (reg:CCVIHU CC_REGNUM)
++ (compare:CCVIHU (match_operand:VI_HW 0 "register_operand" "v")
++ (match_operand:VI_HW 1 "register_operand" "v")))
+ (set (match_operand:VI_HW 2 "register_operand" "=v")
+ (gtu:VI_HW (match_dup 0) (match_dup 1)))]
+ "TARGET_VX"
+@@ -2029,13 +2029,13 @@
+
+ (define_expand "vec_cmphv2df_cc"
+ [(parallel
+- [(set (reg:CCVH CC_REGNUM)
+- (compare:CCVH (match_operand:V2DF 1 "register_operand" "v")
+- (match_operand:V2DF 2 "register_operand" "v")))
++ [(set (reg:CCVIH CC_REGNUM)
++ (compare:CCVIH (match_operand:V2DF 1 "register_operand" "v")
++ (match_operand:V2DF 2 "register_operand" "v")))
+ (set (match_operand:V2DI 0 "register_operand" "=v")
+ (gt:V2DI (match_dup 1) (match_dup 2)))])
+ (set (match_operand:SI 3 "memory_operand" "")
+- (unspec:SI [(reg:CCVH CC_REGNUM)] UNSPEC_CC_TO_INT))]
++ (unspec:SI [(reg:CCVIH CC_REGNUM)] UNSPEC_CC_TO_INT))]
+ "TARGET_VX")
+
+ (define_expand "vec_cmphev2df_cc"
+@@ -2061,9 +2061,9 @@
+ [(set_attr "op_type" "VRR")])
+
+ (define_insn "*vec_cmphv2df_cc"
+- [(set (reg:CCVH CC_REGNUM)
+- (compare:CCVH (match_operand:V2DF 0 "register_operand" "v")
+- (match_operand:V2DF 1 "register_operand" "v")))
++ [(set (reg:CCVIH CC_REGNUM)
++ (compare:CCVIH (match_operand:V2DF 0 "register_operand" "v")
++ (match_operand:V2DF 1 "register_operand" "v")))
+ (set (match_operand:V2DI 2 "register_operand" "=v")
+ (gt:V2DI (match_dup 0) (match_dup 1)))]
+ "TARGET_VX"
+diff --git a/gcc/config/sh/sh-mem.cc b/gcc/config/sh/sh-mem.cc
+index d092090..a9d7b9a 100644
+--- a/gcc/config/sh/sh-mem.cc
++++ b/gcc/config/sh/sh-mem.cc
+@@ -363,7 +363,7 @@ sh_expand_cmpnstr (rtx *operands)
+ rtx_code_label *L_loop_byte = gen_label_rtx ();
+ rtx_code_label *L_end_loop_byte = gen_label_rtx ();
+
+- rtx len = force_reg (SImode, operands[3]);
++ rtx len = copy_to_mode_reg (SImode, operands[3]);
+ int constp = CONST_INT_P (operands[3]);
+
+ /* Loop on a register count. */
+@@ -674,9 +674,9 @@ sh_expand_setmem (rtx *operands)
+ rtx jump;
+ rtx dest = copy_rtx (operands[0]);
+ rtx dest_addr = copy_addr_to_reg (XEXP (dest, 0));
+- rtx val = force_reg (SImode, operands[2]);
++ rtx val = copy_to_mode_reg (SImode, operands[2]);
+ int align = INTVAL (operands[3]);
+- rtx len = force_reg (SImode, operands[1]);
++ rtx len = copy_to_mode_reg (SImode, operands[1]);
+
+ if (! CONST_INT_P (operands[1]))
+ return;
+diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c
+index 268d6c3..5e44054 100644
+--- a/gcc/config/sparc/sparc.c
++++ b/gcc/config/sparc/sparc.c
+@@ -11967,7 +11967,7 @@ sparc_expand_vec_perm_bmask (machine_mode vmode, rtx sel)
+ }
+
+ /* Always perform the final addition/merge within the bmask insn. */
+- emit_insn (gen_bmasksi_vis (gen_rtx_REG (SImode, 0), sel, t_1));
++ emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), sel, t_1));
+ }
+
+ /* Implement TARGET_FRAME_POINTER_REQUIRED. */
+@@ -12233,7 +12233,7 @@ vector_init_bshuffle (rtx target, rtx elt, machine_mode mode,
+ }
+
+ sel = force_reg (SImode, GEN_INT (bmask));
+- emit_insn (gen_bmasksi_vis (gen_rtx_REG (SImode, 0), sel, const0_rtx));
++ emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), sel, const0_rtx));
+ emit_insn (final_insn);
+ }
+
+@@ -12289,14 +12289,15 @@ sparc_expand_vector_init (rtx target, rtx vals)
+ const machine_mode inner_mode = GET_MODE_INNER (mode);
+ const int n_elts = GET_MODE_NUNITS (mode);
+ int i, n_var = 0;
+- bool all_same;
++ bool all_same = true;
+ rtx mem;
+
+- all_same = true;
+ for (i = 0; i < n_elts; i++)
+ {
+ rtx x = XVECEXP (vals, 0, i);
+- if (!CONSTANT_P (x))
++ if (!(CONST_INT_P (x)
++ || GET_CODE (x) == CONST_DOUBLE
++ || GET_CODE (x) == CONST_FIXED))
+ n_var++;
+
+ if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
+diff --git a/gcc/config/sparc/sparc.md b/gcc/config/sparc/sparc.md
+index 5879dd4..81e9984 100644
+--- a/gcc/config/sparc/sparc.md
++++ b/gcc/config/sparc/sparc.md
+@@ -8380,7 +8380,7 @@
+ (match_operand:DI 2 "register_or_zero_operand" "rJ")))
+ (set (zero_extract:DI (reg:DI GSR_REG) (const_int 32) (const_int 32))
+ (plus:DI (match_dup 1) (match_dup 2)))]
+- "TARGET_VIS2"
++ "TARGET_VIS2 && TARGET_ARCH64"
+ "bmask\t%r1, %r2, %0"
+ [(set_attr "type" "array")])
+
+@@ -8422,7 +8422,7 @@
+ mask |= (INTVAL (XVECEXP (sel, 0, i)) & 0xf) << (28 - i*4);
+ sel = force_reg (SImode, gen_int_mode (mask, SImode));
+
+- emit_insn (gen_bmasksi_vis (gen_rtx_REG (SImode, 0), sel, const0_rtx));
++ emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), sel, const0_rtx));
+ emit_insn (gen_bshufflev8qi_vis (operands[0], operands[1], operands[2]));
+ DONE;
+ })
+diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
+index 5c93ca4..0fbbe21 100644
+--- a/gcc/cp/ChangeLog
++++ b/gcc/cp/ChangeLog
+@@ -1,3 +1,68 @@
++2016-12-08 Nathan Sidwell <nathan@acm.org>
++
++ PR c++/78551
++ * constexpr.c (extract_string_elt): New. Broken out of ...
++ (cxx_eval_array_reference): ... here. Call it.
++ (cxx_eval_store_expression): Convert init by STRING_CST into
++ CONSTRUCTOR, if needed.
++
++2016-08-05 Nathan Sidwell <nathan@acm.org>
++
++ PR c++/68724
++ * pt.c (unify): TRAIT_EXPR is an expr.
++
++2016-07-25 Jason Merrill <jason@redhat.com>
++
++ PR c++/71833
++ * pt.c (coerce_template_parameter_pack): Fix logic for
++ pack index.
++
++2016-07-21 Jason Merrill <jason@redhat.com>
++
++ PR c++/69223
++ * semantics.c (apply_deduced_return_type): Call
++ complete_type_or_else before building the new RESULT_DECL.
++
++ PR c++/71630
++ * pt.c (instantiate_decl): Fix pattern_defined for namespace scope
++ variable templates.
++
++ PR c++/71913
++ * call.c (unsafe_copy_elision_p): It's OK to elide when
++ initializing an unknown object.
++
++2016-07-20 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71909
++ * parser.c (cp_parser_save_member_function_body): Consume
++ __transaction_relaxed or __transaction_atomic with optional
++ attribute. Only skip catch with block if try keyword is seen.
++
++2016-07-19 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-07-18 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71871
++ * typeck.c (build_x_conditional_expr): Revert the 2012-10-25 change.
++
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-06-14 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71528
++ * decl.c (duplicate_decls): For DECL_INITIALIZED_P non-external
++ olddecl vars, preserve their TREE_READONLY bit.
++
++ PR c++/71516
++ * decl.c (complete_vars): Handle gracefully type == error_mark_node.
++
++2016-06-08 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71442
++ * pt.c (tsubst_copy): Only set TREE_USED on DECLs.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/gcc/cp/call.c b/gcc/cp/call.c
+index a095cb4..e9d9dedf 100644
+--- a/gcc/cp/call.c
++++ b/gcc/cp/call.c
+@@ -7029,10 +7029,11 @@ static bool
+ unsafe_copy_elision_p (tree target, tree exp)
+ {
+ tree type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
+- if (type == CLASSTYPE_AS_BASE (type))
++ /* It's safe to elide the copy for a class with no tail padding. */
++ if (tree_int_cst_equal (TYPE_SIZE (type), CLASSTYPE_SIZE (type)))
+ return false;
+- if (!is_base_field_ref (target)
+- && resolves_to_fixed_type_p (target, NULL))
++ /* It's safe to elide the copy if we aren't initializing a base object. */
++ if (!is_base_field_ref (target))
+ return false;
+ tree init = TARGET_EXPR_INITIAL (exp);
+ /* build_compound_expr pushes COMPOUND_EXPR inside TARGET_EXPR. */
+diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
+index 50e2338..e558e69 100644
+--- a/gcc/cp/constexpr.c
++++ b/gcc/cp/constexpr.c
+@@ -1829,6 +1829,27 @@ find_array_ctor_elt (tree ary, tree dindex, bool insert = false)
+ }
+
+
++/* Extract element INDEX consisting of CHARS_PER_ELT chars from
++ STRING_CST STRING. */
++
++static tree
++extract_string_elt (tree string, unsigned chars_per_elt, unsigned index)
++{
++ tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (string)));
++ tree r;
++
++ if (chars_per_elt == 1)
++ r = build_int_cst (type, TREE_STRING_POINTER (string)[index]);
++ else
++ {
++ const unsigned char *ptr
++ = ((const unsigned char *)TREE_STRING_POINTER (string)
++ + index * chars_per_elt);
++ r = native_interpret_expr (type, ptr, chars_per_elt);
++ }
++ return r;
++}
++
+ /* Subroutine of cxx_eval_constant_expression.
+ Attempt to reduce a reference to an array slot. */
+
+@@ -1913,16 +1934,8 @@ cxx_eval_array_reference (const constexpr_ctx *ctx, tree t,
+
+ if (TREE_CODE (ary) == CONSTRUCTOR)
+ return (*CONSTRUCTOR_ELTS (ary))[i].value;
+- else if (elem_nchars == 1)
+- return build_int_cst (cv_unqualified (TREE_TYPE (TREE_TYPE (ary))),
+- TREE_STRING_POINTER (ary)[i]);
+ else
+- {
+- tree type = cv_unqualified (TREE_TYPE (TREE_TYPE (ary)));
+- return native_interpret_expr (type, (const unsigned char *)
+- TREE_STRING_POINTER (ary)
+- + i * elem_nchars, elem_nchars);
+- }
++ return extract_string_elt (ary, elem_nchars, i);
+ /* Don't VERIFY_CONSTANT here. */
+ }
+
+@@ -2838,6 +2851,34 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t,
+ *valp = build_constructor (type, NULL);
+ CONSTRUCTOR_NO_IMPLICIT_ZERO (*valp) = true;
+ }
++ else if (TREE_CODE (*valp) == STRING_CST)
++ {
++ /* An array was initialized with a string constant, and now
++ we're writing into one of its elements. Explode the
++ single initialization into a set of element
++ initializations. */
++ gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
++
++ tree string = *valp;
++ tree elt_type = TREE_TYPE (type);
++ unsigned chars_per_elt = (TYPE_PRECISION (elt_type)
++ / TYPE_PRECISION (char_type_node));
++ unsigned num_elts = TREE_STRING_LENGTH (string) / chars_per_elt;
++ tree ary_ctor = build_constructor (type, NULL);
++
++ vec_safe_reserve (CONSTRUCTOR_ELTS (ary_ctor), num_elts);
++ for (unsigned ix = 0; ix != num_elts; ix++)
++ {
++ constructor_elt elt =
++ {
++ build_int_cst (size_type_node, ix),
++ extract_string_elt (string, chars_per_elt, ix)
++ };
++ CONSTRUCTOR_ELTS (ary_ctor)->quick_push (elt);
++ }
++
++ *valp = ary_ctor;
++ }
+
+ enum tree_code code = TREE_CODE (type);
+ type = refs->pop();
+diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
+index 3d68b63..ce0443c 100644
+--- a/gcc/cp/decl.c
++++ b/gcc/cp/decl.c
+@@ -2023,6 +2023,14 @@ duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
+ if (VAR_P (newdecl))
+ {
+ DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
++ /* For already initialized vars, TREE_READONLY could have been
++ cleared in cp_finish_decl, because the var needs runtime
++ initialization or destruction. Make sure not to set
++ TREE_READONLY on it again. */
++ if (DECL_INITIALIZED_P (olddecl)
++ && !DECL_EXTERNAL (olddecl)
++ && !TREE_READONLY (olddecl))
++ TREE_READONLY (newdecl) = 0;
+ DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
+ DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
+ |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
+@@ -14561,8 +14569,9 @@ complete_vars (tree type)
+ tree var = iv->decl;
+ tree type = TREE_TYPE (var);
+
+- if (TYPE_MAIN_VARIANT (strip_array_types (type))
+- == iv->incomplete_type)
++ if (type != error_mark_node
++ && (TYPE_MAIN_VARIANT (strip_array_types (type))
++ == iv->incomplete_type))
+ {
+ /* Complete the type of the variable. The VAR_DECL itself
+ will be laid out in expand_expr. */
+diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
+index e92fff7..03b93ab 100644
+--- a/gcc/cp/parser.c
++++ b/gcc/cp/parser.c
+@@ -23964,6 +23964,7 @@ cp_parser_save_member_function_body (cp_parser* parser,
+ cp_token *first;
+ cp_token *last;
+ tree fn;
++ bool function_try_block = false;
+
+ /* Create the FUNCTION_DECL. */
+ fn = grokmethod (decl_specifiers, declarator, attributes);
+@@ -23984,9 +23985,43 @@ cp_parser_save_member_function_body (cp_parser* parser,
+ /* Save away the tokens that make up the body of the
+ function. */
+ first = parser->lexer->next_token;
++
++ if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_RELAXED))
++ cp_lexer_consume_token (parser->lexer);
++ else if (cp_lexer_next_token_is_keyword (parser->lexer,
++ RID_TRANSACTION_ATOMIC))
++ {
++ cp_lexer_consume_token (parser->lexer);
++ /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
++ if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)
++ && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE)
++ && (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME)
++ || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
++ && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_SQUARE)
++ && cp_lexer_nth_token_is (parser->lexer, 5, CPP_CLOSE_SQUARE))
++ {
++ cp_lexer_consume_token (parser->lexer);
++ cp_lexer_consume_token (parser->lexer);
++ cp_lexer_consume_token (parser->lexer);
++ cp_lexer_consume_token (parser->lexer);
++ cp_lexer_consume_token (parser->lexer);
++ }
++ else
++ while (cp_next_tokens_can_be_gnu_attribute_p (parser)
++ && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
++ {
++ cp_lexer_consume_token (parser->lexer);
++ if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
++ break;
++ }
++ }
++
+ /* Handle function try blocks. */
+ if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
+- cp_lexer_consume_token (parser->lexer);
++ {
++ cp_lexer_consume_token (parser->lexer);
++ function_try_block = true;
++ }
+ /* We can have braced-init-list mem-initializers before the fn body. */
+ if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
+ {
+@@ -24004,8 +24039,9 @@ cp_parser_save_member_function_body (cp_parser* parser,
+ }
+ cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
+ /* Handle function try blocks. */
+- while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
+- cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
++ if (function_try_block)
++ while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
++ cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
+ last = parser->lexer->next_token;
+
+ /* Save away the inline definition; we will process it when the
+diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
+index 2889795..578fa20 100644
+--- a/gcc/cp/pt.c
++++ b/gcc/cp/pt.c
+@@ -6912,11 +6912,12 @@ coerce_template_parameter_pack (tree parms,
+
+ /* Convert the remaining arguments, which will be a part of the
+ parameter pack "parm". */
++ int first_pack_arg = arg_idx;
+ for (; arg_idx < nargs; ++arg_idx)
+ {
+ tree arg = TREE_VEC_ELT (inner_args, arg_idx);
+ tree actual_parm = TREE_VALUE (parm);
+- int pack_idx = arg_idx - parm_idx;
++ int pack_idx = arg_idx - first_pack_arg;
+
+ if (packed_parms)
+ {
+@@ -6945,12 +6946,12 @@ coerce_template_parameter_pack (tree parms,
+ TREE_VEC_ELT (packed_args, pack_idx) = arg;
+ }
+
+- if (arg_idx - parm_idx < TREE_VEC_LENGTH (packed_args)
++ if (arg_idx - first_pack_arg < TREE_VEC_LENGTH (packed_args)
+ && TREE_VEC_LENGTH (packed_args) > 0)
+ {
+ if (complain & tf_error)
+ error ("wrong number of template arguments (%d, should be %d)",
+- arg_idx - parm_idx, TREE_VEC_LENGTH (packed_args));
++ arg_idx - first_pack_arg, TREE_VEC_LENGTH (packed_args));
+ return error_mark_node;
+ }
+
+@@ -13287,7 +13288,8 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
+ len = TREE_VEC_LENGTH (expanded);
+ /* Set TREE_USED for the benefit of -Wunused. */
+ for (int i = 0; i < len; i++)
+- TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
++ if (DECL_P (TREE_VEC_ELT (expanded, i)))
++ TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
+ }
+
+ if (expanded == error_mark_node)
+@@ -18805,7 +18807,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
+ /* An unresolved overload is a nondeduced context. */
+ if (is_overloaded_fn (parm) || type_unknown_p (parm))
+ return unify_success (explain_p);
+- gcc_assert (EXPR_P (parm));
++ gcc_assert (EXPR_P (parm) || TREE_CODE (parm) == TRAIT_EXPR);
+
+ /* We must be looking at an expression. This can happen with
+ something like:
+@@ -20409,7 +20411,10 @@ instantiate_decl (tree d, int defer_ok,
+ else
+ {
+ deleted_p = false;
+- pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
++ if (DECL_CLASS_SCOPE_P (code_pattern))
++ pattern_defined = ! DECL_IN_AGGR_P (code_pattern);
++ else
++ pattern_defined = ! DECL_EXTERNAL (code_pattern);
+ }
+
+ /* We may be in the middle of deferred access check. Disable it now. */
+diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
+index 74e40a9..6705d1f 100644
+--- a/gcc/cp/semantics.c
++++ b/gcc/cp/semantics.c
+@@ -7698,6 +7698,10 @@ apply_deduced_return_type (tree fco, tree return_type)
+ if (TREE_TYPE (result) == return_type)
+ return;
+
++ if (!processing_template_decl && !VOID_TYPE_P (return_type)
++ && !complete_type_or_else (return_type, NULL_TREE))
++ return;
++
+ /* We already have a DECL_RESULT from start_preparsed_function.
+ Now we need to redo the work it and allocate_struct_function
+ did to reflect the new type. */
+@@ -7713,8 +7717,6 @@ apply_deduced_return_type (tree fco, tree return_type)
+
+ if (!processing_template_decl)
+ {
+- if (!VOID_TYPE_P (TREE_TYPE (result)))
+- complete_type_or_else (TREE_TYPE (result), NULL_TREE);
+ bool aggr = aggregate_value_p (result, fco);
+ #ifdef PCC_STATIC_STRUCT_RETURN
+ cfun->returns_pcc_struct = aggr;
+diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
+index 9e438c9..669f541 100644
+--- a/gcc/cp/typeck.c
++++ b/gcc/cp/typeck.c
+@@ -6125,8 +6125,7 @@ build_x_conditional_expr (location_t loc, tree ifexp, tree op1, tree op2,
+ }
+
+ expr = build_conditional_expr (loc, ifexp, op1, op2, complain);
+- if (processing_template_decl && expr != error_mark_node
+- && TREE_CODE (expr) != VEC_COND_EXPR)
++ if (processing_template_decl && expr != error_mark_node)
+ {
+ tree min = build_min_non_dep (COND_EXPR, expr,
+ orig_ifexp, orig_op1, orig_op2);
+diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
+index 70a0903..d1857b2 100644
+--- a/gcc/doc/extend.texi
++++ b/gcc/doc/extend.texi
+@@ -8625,10 +8625,10 @@ together with checking whether the operations overflowed.
+ @deftypefn {Built-in Function} bool __builtin_add_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
+ @deftypefnx {Built-in Function} bool __builtin_sadd_overflow (int a, int b, int *res)
+ @deftypefnx {Built-in Function} bool __builtin_saddl_overflow (long int a, long int b, long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_saddll_overflow (long long int a, long long int b, long int *res)
++@deftypefnx {Built-in Function} bool __builtin_saddll_overflow (long long int a, long long int b, long long int *res)
+ @deftypefnx {Built-in Function} bool __builtin_uadd_overflow (unsigned int a, unsigned int b, unsigned int *res)
+ @deftypefnx {Built-in Function} bool __builtin_uaddl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_uaddll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
++@deftypefnx {Built-in Function} bool __builtin_uaddll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)
+
+ These built-in functions promote the first two operands into infinite precision signed
+ type and perform addition on those promoted operands. The result is then
+@@ -8651,10 +8651,10 @@ after addition, conditional jump on carry etc.
+ @deftypefn {Built-in Function} bool __builtin_sub_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
+ @deftypefnx {Built-in Function} bool __builtin_ssub_overflow (int a, int b, int *res)
+ @deftypefnx {Built-in Function} bool __builtin_ssubl_overflow (long int a, long int b, long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_ssubll_overflow (long long int a, long long int b, long int *res)
++@deftypefnx {Built-in Function} bool __builtin_ssubll_overflow (long long int a, long long int b, long long int *res)
+ @deftypefnx {Built-in Function} bool __builtin_usub_overflow (unsigned int a, unsigned int b, unsigned int *res)
+ @deftypefnx {Built-in Function} bool __builtin_usubl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_usubll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
++@deftypefnx {Built-in Function} bool __builtin_usubll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)
+
+ These built-in functions are similar to the add overflow checking built-in
+ functions above, except they perform subtraction, subtract the second argument
+@@ -8665,10 +8665,10 @@ from the first one, instead of addition.
+ @deftypefn {Built-in Function} bool __builtin_mul_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)
+ @deftypefnx {Built-in Function} bool __builtin_smul_overflow (int a, int b, int *res)
+ @deftypefnx {Built-in Function} bool __builtin_smull_overflow (long int a, long int b, long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_smulll_overflow (long long int a, long long int b, long int *res)
++@deftypefnx {Built-in Function} bool __builtin_smulll_overflow (long long int a, long long int b, long long int *res)
+ @deftypefnx {Built-in Function} bool __builtin_umul_overflow (unsigned int a, unsigned int b, unsigned int *res)
+ @deftypefnx {Built-in Function} bool __builtin_umull_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)
+-@deftypefnx {Built-in Function} bool __builtin_umulll_overflow (unsigned long long int a, unsigned long long int b, unsigned long int *res)
++@deftypefnx {Built-in Function} bool __builtin_umulll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)
+
+ These built-in functions are similar to the add overflow checking built-in
+ functions above, except they perform multiplication, instead of addition.
+diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi
+index d8d3939..bfedb13 100644
+--- a/gcc/doc/install.texi
++++ b/gcc/doc/install.texi
+@@ -2081,6 +2081,36 @@ When you use this option, you should ensure that @var{dir} includes
+ tools.
+ @end table
+
++@subsubheading Overriding @command{configure} test results
++
++Sometimes, it might be necessary to override the result of some
++@command{configure} test, for example in order to ease porting to a new
++system or work around a bug in a test. The toplevel @command{configure}
++script provides three variables for this:
++
++@table @code
++
++@item build_configargs
++@cindex @code{build_configargs}
++The contents of this variable is passed to all build @command{configure}
++scripts.
++
++@item host_configargs
++@cindex @code{host_configargs}
++The contents of this variable is passed to all host @command{configure}
++scripts.
++
++@item target_configargs
++@cindex @code{target_configargs}
++The contents of this variable is passed to all target @command{configure}
++scripts.
++
++@end table
++
++In order to avoid shell and @command{make} quoting issues for complex
++overrides, you can pass a setting for @env{CONFIG_SITE} and set
++variables in the site file.
++
+ @subheading Java-Specific Options
+
+ The following option applies to the build of the Java front end.
+@@ -2315,35 +2345,6 @@ Do not try to compile and run a test libart program.
+
+ @end table
+
+-@subsubheading Overriding @command{configure} test results
+-
+-Sometimes, it might be necessary to override the result of some
+-@command{configure} test, for example in order to ease porting to a new
+-system or work around a bug in a test. The toplevel @command{configure}
+-script provides three variables for this:
+-
+-@table @code
+-
+-@item build_configargs
+-@cindex @code{build_configargs}
+-The contents of this variable is passed to all build @command{configure}
+-scripts.
+-
+-@item host_configargs
+-@cindex @code{host_configargs}
+-The contents of this variable is passed to all host @command{configure}
+-scripts.
+-
+-@item target_configargs
+-@cindex @code{target_configargs}
+-The contents of this variable is passed to all target @command{configure}
+-scripts.
+-
+-@end table
+-
+-In order to avoid shell and @command{make} quoting issues for complex
+-overrides, you can pass a setting for @env{CONFIG_SITE} and set
+-variables in the site file.
+
+ @html
+ <hr />
+@@ -4446,7 +4447,7 @@ supported as cross-compilation target only.
+ @c alone is too unspecific and must be avoided.
+ @anchor{x-x-solaris2}
+ @heading *-*-solaris2*
+-Support for Solaris 9 has been removed in GCC 4.10. Support for Solaris
++Support for Solaris 9 has been removed in GCC 5. Support for Solaris
+ 8 has been removed in GCC 4.8. Support for Solaris 7 has been removed
+ in GCC 4.6.
+
+@@ -4510,12 +4511,15 @@ features, so better stay with Sun @command{ld}. To use the LTO linker
+ plugin (@option{-fuse-linker-plugin}) with GNU @command{ld}, GNU
+ binutils @emph{must} be configured with @option{--enable-largefile}.
+
+-To enable symbol versioning in @samp{libstdc++} with Sun @command{ld},
++To enable symbol versioning in @samp{libstdc++} with the Sun linker,
+ you need to have any version of GNU @command{c++filt}, which is part of
+ GNU binutils. @samp{libstdc++} symbol versioning will be disabled if no
+ appropriate version is found. Sun @command{c++filt} from the Sun Studio
+ compilers does @emph{not} work.
+
++GNU @command{make} version 3.81 or later is required to build libjava
++with the Sun linker.
++
+ Sun bug 4296832 turns up when compiling X11 headers with GCC 2.95 or
+ newer: @command{g++} will complain that types are missing. These headers
+ assume that omitting the type means @code{int}; this assumption worked for
+diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
+index 039e544..1ca4dcc 100644
+--- a/gcc/doc/invoke.texi
++++ b/gcc/doc/invoke.texi
+@@ -923,7 +923,7 @@ See RS/6000 and PowerPC Options.
+ -mpointers-to-nested-functions -mno-pointers-to-nested-functions @gol
+ -msave-toc-indirect -mno-save-toc-indirect @gol
+ -mpower8-fusion -mno-mpower8-fusion -mpower8-vector -mno-power8-vector @gol
+--mcrypto -mno-crypto -mdirect-move -mno-direct-move @gol
++-mcrypto -mno-crypto -mhtm -mno-htm -mdirect-move -mno-direct-move @gol
+ -mquad-memory -mno-quad-memory @gol
+ -mquad-memory-atomic -mno-quad-memory-atomic @gol
+ -mcompat-align-parm -mno-compat-align-parm @gol
+@@ -18898,7 +18898,7 @@ following options:
+ -mpopcntb -mpopcntd -mpowerpc64 @gol
+ -mpowerpc-gpopt -mpowerpc-gfxopt -msingle-float -mdouble-float @gol
+ -msimple-fpu -mstring -mmulhw -mdlmzb -mmfpgpr -mvsx @gol
+--mcrypto -mdirect-move -mpower8-fusion -mpower8-vector @gol
++-mcrypto -mdirect-move -mhtm -mpower8-fusion -mpower8-vector @gol
+ -mquad-memory -mquad-memory-atomic}
+
+ The particular options set for any particular CPU varies between
+@@ -19065,6 +19065,14 @@ Generate code that uses (does not use) the instructions to move data
+ between the general purpose registers and the vector/scalar (VSX)
+ registers that were added in version 2.07 of the PowerPC ISA.
+
++@item -mhtm
++@itemx -mno-htm
++@opindex mhtm
++@opindex mno-htm
++Enable (disable) the use of the built-in functions that allow direct
++access to the Hardware Transactional Memory (HTM) instructions that
++were added in version 2.07 of the PowerPC ISA.
++
+ @item -mpower8-fusion
+ @itemx -mno-power8-fusion
+ @opindex mpower8-fusion
+diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi
+index a5275f4..141c957 100644
+--- a/gcc/doc/rtl.texi
++++ b/gcc/doc/rtl.texi
+@@ -3525,8 +3525,8 @@ and @code{addr_diff_vec}, where @code{JUMP_LABEL} is @code{NULL_RTX}
+ and the only way to find the labels is to scan the entire body of the
+ insn.
+
+-Return insns count as jumps, but since they do not refer to any
+-labels, their @code{JUMP_LABEL} is @code{NULL_RTX}.
++Return insns count as jumps, but their @code{JUMP_LABEL} is @code{RETURN}
++or @code{SIMPLE_RETURN}.
+
+ @findex call_insn
+ @item call_insn
+diff --git a/gcc/explow.c b/gcc/explow.c
+index de446a9..55b435b 100644
+--- a/gcc/explow.c
++++ b/gcc/explow.c
+@@ -281,12 +281,14 @@ break_out_memory_refs (rtx x)
+ which way). We take advantage of the fact that pointers are not allowed to
+ overflow by commuting arithmetic operations over conversions so that address
+ arithmetic insns can be used. IN_CONST is true if this conversion is inside
+- a CONST. */
++ a CONST. NO_EMIT is true if no insns should be emitted, and instead
++ it should return NULL if it can't be simplified without emitting insns. */
+
+-static rtx
++rtx
+ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED,
+ rtx x, addr_space_t as ATTRIBUTE_UNUSED,
+- bool in_const ATTRIBUTE_UNUSED)
++ bool in_const ATTRIBUTE_UNUSED,
++ bool no_emit ATTRIBUTE_UNUSED)
+ {
+ #ifndef POINTERS_EXTEND_UNSIGNED
+ gcc_assert (GET_MODE (x) == to_mode || GET_MODE (x) == VOIDmode);
+@@ -332,19 +334,16 @@ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED,
+ temp = gen_rtx_LABEL_REF (to_mode, LABEL_REF_LABEL (x));
+ LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
+ return temp;
+- break;
+
+ case SYMBOL_REF:
+ temp = shallow_copy_rtx (x);
+ PUT_MODE (temp, to_mode);
+ return temp;
+- break;
+
+ case CONST:
+- return gen_rtx_CONST (to_mode,
+- convert_memory_address_addr_space_1
+- (to_mode, XEXP (x, 0), as, true));
+- break;
++ temp = convert_memory_address_addr_space_1 (to_mode, XEXP (x, 0), as,
++ true, no_emit);
++ return temp ? gen_rtx_CONST (to_mode, temp) : temp;
+
+ case PLUS:
+ case MULT:
+@@ -360,18 +359,25 @@ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED,
+ && CONST_INT_P (XEXP (x, 1))
+ && ((in_const && POINTERS_EXTEND_UNSIGNED != 0)
+ || XEXP (x, 1) == convert_memory_address_addr_space_1
+- (to_mode, XEXP (x, 1), as, in_const)
++ (to_mode, XEXP (x, 1), as, in_const,
++ no_emit)
+ || POINTERS_EXTEND_UNSIGNED < 0)))
+- return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
+- convert_memory_address_addr_space_1
+- (to_mode, XEXP (x, 0), as, in_const),
+- XEXP (x, 1));
++ {
++ temp = convert_memory_address_addr_space_1 (to_mode, XEXP (x, 0),
++ as, in_const, no_emit);
++ return (temp ? gen_rtx_fmt_ee (GET_CODE (x), to_mode,
++ temp, XEXP (x, 1))
++ : temp);
++ }
+ break;
+
+ default:
+ break;
+ }
+
++ if (no_emit)
++ return NULL_RTX;
++
+ return convert_modes (to_mode, from_mode,
+ x, POINTERS_EXTEND_UNSIGNED);
+ #endif /* defined(POINTERS_EXTEND_UNSIGNED) */
+@@ -386,7 +392,7 @@ convert_memory_address_addr_space_1 (machine_mode to_mode ATTRIBUTE_UNUSED,
+ rtx
+ convert_memory_address_addr_space (machine_mode to_mode, rtx x, addr_space_t as)
+ {
+- return convert_memory_address_addr_space_1 (to_mode, x, as, false);
++ return convert_memory_address_addr_space_1 (to_mode, x, as, false, false);
+ }
+
+
+@@ -500,9 +506,8 @@ memory_address_addr_space (machine_mode mode, rtx x, addr_space_t as)
+ return x;
+ }
+
+-/* If REF is a MEM with an invalid address, change it into a valid address.
+- Pass through anything else unchanged. REF must be an unshared rtx and
+- the function may modify it in-place. */
++/* Convert a mem ref into one with a valid memory address.
++ Pass through anything else unchanged. */
+
+ rtx
+ validize_mem (rtx ref)
+@@ -514,7 +519,8 @@ validize_mem (rtx ref)
+ MEM_ADDR_SPACE (ref)))
+ return ref;
+
+- return replace_equiv_address (ref, XEXP (ref, 0), true);
++ /* Don't alter REF itself, since that is probably a stack slot. */
++ return replace_equiv_address (ref, XEXP (ref, 0));
+ }
+
+ /* If X is a memory reference to a member of an object block, try rewriting
+diff --git a/gcc/expr.c b/gcc/expr.c
+index 5c09550..d72c053 100644
+--- a/gcc/expr.c
++++ b/gcc/expr.c
+@@ -6100,6 +6100,13 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
+ type = lang_hooks.types.type_for_mode
+ (word_mode, TYPE_UNSIGNED (type));
+ value = fold_convert (type, value);
++ /* Make sure the bits beyond the original bitsize are zero
++ so that we can correctly avoid extra zeroing stores in
++ later constructor elements. */
++ tree bitsize_mask
++ = wide_int_to_tree (type, wi::mask (bitsize, false,
++ BITS_PER_WORD));
++ value = fold_build2 (BIT_AND_EXPR, type, value, bitsize_mask);
+ }
+
+ if (BYTES_BIG_ENDIAN)
+diff --git a/gcc/fold-const.c b/gcc/fold-const.c
+index f964ae9..fa58a5a 100644
+--- a/gcc/fold-const.c
++++ b/gcc/fold-const.c
+@@ -2204,7 +2204,6 @@ fold_convertible_p (const_tree type, const_tree arg)
+
+ case REAL_TYPE:
+ case FIXED_POINT_TYPE:
+- case COMPLEX_TYPE:
+ case VECTOR_TYPE:
+ case VOID_TYPE:
+ return TREE_CODE (type) == TREE_CODE (orig);
+@@ -12121,11 +12120,15 @@ fold_binary_loc (location_t loc,
+ || TREE_CODE (arg0) == BIT_IOR_EXPR
+ || TREE_CODE (arg0) == BIT_XOR_EXPR)
+ && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
+- return fold_build2_loc (loc, TREE_CODE (arg0), type,
+- fold_build2_loc (loc, code, type,
+- TREE_OPERAND (arg0, 0), arg1),
+- fold_build2_loc (loc, code, type,
+- TREE_OPERAND (arg0, 1), arg1));
++ {
++ tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
++ tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
++ return fold_build2_loc (loc, TREE_CODE (arg0), type,
++ fold_build2_loc (loc, code, type,
++ arg00, arg1),
++ fold_build2_loc (loc, code, type,
++ arg01, arg1));
++ }
+
+ /* Two consecutive rotates adding up to the some integer
+ multiple of the precision of the type can be ignored. */
+@@ -12134,7 +12137,7 @@ fold_binary_loc (location_t loc,
+ && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
+ && wi::umod_trunc (wi::add (arg1, TREE_OPERAND (arg0, 1)),
+ prec) == 0)
+- return TREE_OPERAND (arg0, 0);
++ return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
+
+ /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
+ (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
+diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
+index 6172f0a..d4ea0e9 100644
+--- a/gcc/fortran/ChangeLog
++++ b/gcc/fortran/ChangeLog
+@@ -1,3 +1,370 @@
++2016-12-22 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78239
++ * decl.c (char_len_param_value): Also check for -fimplicit-none
++ when determining if implicit none is in force.
++
++2016-12-04 Janus Weil <janus@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78443
++ * class.c (add_proc_comp): Add a vtype component for non-overridable
++ procedures that are overriding.
++
++2016-12-01 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78279
++ * dependency.c (identical_array_ref): Convert gcc_assert to conditional
++ and gfc_internal_error.
++
++2016-11-24 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78500
++ * expr.c (gfc_check_vardef_contextm): Fix NULL pointer dereference.
++ * interface.c (matching_typebound_op): Ditto.
++
++2016-11-23 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78297
++ * trans-common.c (finish_equivalences): Do not dereference a NULL pointer.
++
++2016-11-23 Janus Weil <janus@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/66227
++ * simplify.c (gfc_simplify_extends_type_of): Fix missed optimization.
++ Prevent over-simplification. Fix a comment. Add a comment.
++
++2016-11-20 Harald Anlauf <anlauf@gmx.de>
++
++ PR fortran/69741
++ * resolve.c (gfc_resolve_forall): Check for nonscalar index variables.
++
++2016-11-06 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/69544
++ PR fortran/78178
++ * match.c (match_simple_where): Fill in locus for assigment
++ in simple WHERE statement.
++ (gfc_match_where): Likewise.
++
++2016-11-01 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71902
++ * frontend-passes.c (realloc_string_callback): Also check for the
++ lhs being deferred. Name temporary variable "realloc_string".
++
++2016-10-24 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78021
++ * gfc_compare_functions: Strings with different lengths in
++ argument lists compare unequal.
++
++2016-10-24 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/71895
++ * interface.c (gfc_compare_derived_types): Convert gcc_assert()
++ to a gfc_internal_error() to prevent an ICE.
++
++2016-10-24 Paul Thomas <pault@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/61420
++ PR fortran/78013
++ * resolve.c (resolve_variable): Obtain the typespec for a
++ variable expression, when the variable is a function result
++ that is a procedure pointer.
++
++2016-10-17 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/77978
++ * match.c (gfc_match_stopcode): Fix error reporting for several
++ deficiencies in matching stop-codes.
++
++2016-10-05 Steven G. Kargl <kargls@gcc.gnu.org>
++
++ PR fortran/58991
++ PR fortran/58992
++ * resolve.c (resolve_assoc_var): Fix CHARACTER type-spec for a
++ selector in ASSOCIATE.
++ (resolve_fl_variable): Skip checks for an ASSOCIATE variable.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77391
++ * resolve.c (deferred_requirements): New function to check F2008:C402.
++ (resolve_fl_variable,resolve_fl_parameter): Use it.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77380
++ * dependency.c (gfc_check_dependency): Do not assert with
++ -fcoarray=lib.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/61318
++ * interface.c (compare_parameter): Use better locus for error message.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/71859
++ * check.c(numeric_check): Prevent ICE. Issue error for invalid
++ subroutine as an actual argument when numeric argument is expected.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport of trunk
++
++ PR fortran/69867
++ * decl.c (build_struct): Ensure that pointers point to something.
++
++ PR fortran/69962
++ * decl.c (gfc_set_constant_character_len): if expr is not
++ constant issue an error instead of an ICE.
++
++2016-09-30 Steven g. Kargl <kargl@gcc.gnu.org>
++
++ Backport of trunk
++
++ PR fortran/77351
++ * frontend-passes.c (remove_trim,combine_array_constructor): Check for
++ NULL pointer.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/68566
++ * check.c (gfc_check_reshape): Check for constant expression.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/71799
++ * resolve.c(gfc_resolve_iterator): Failure of type conversion need
++ not ICE.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/70006
++ * io.c (gfc_resolve_dt): Use correct locus.
++ * resolve.c (resolve_branch): Ditto.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77420
++ * trans-common.c: Handle array elements in equivalence when
++ the lower and upper bounds of array spec are NULL.
++
++ PR fortran/77460
++ * simplify.c (simplify_transformation_to_scalar): On error, result
++ may be NULL, simply return.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/77506
++ * array.c (gfc_match_array_constructor): CHARACTER(len=*) cannot
++ appear in an array constructor.
++
++ PR fortran/77507
++ * intrinsic.c (add_functions): Use correct keyword.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71067
++ * decl.c (match_data_constant): On error, set 'result' to NULL.
++
++ PR fortran/77260
++ * gcc/fortran/trans-decl.c (generate_local_decl): Suppress warning
++ for unused variable if symbol is entry point.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/69514
++ * array.c (gfc_match_array_constructor): If type-spec is present,
++ walk the array constructor performing possible conversions for
++ numeric types.
++
++2016-09-28 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ backport from trunk
++ PR fortran/71730
++ * decl.c (char_len_param_value): Check return value of
++ gfc_reduce_init_expr().
++
++ PR fortran/77612
++ * decl.c (char_len_param_value): Check parent namespace for
++ seen_implicit_none.
++
++2016-09-28 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ backport from trunk
++ PR fortran/77694
++ * frontend-passes.c (optimize_binop_array_assignment): Check pointer
++ for NULL.
++
++2016-08-13 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/68147
++ * frontend-passes.c (realloc_string_callback): Don't set
++ walk_subtrees.
++
++2016-08-11 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/72698
++ * trans-stmt.c (gfc_trans_allocate): Prevent generating code for
++ copy of zero sized string and with it an ICE.
++
++2016-08-09 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71795
++ * frontend-passes.c (combine_array_constructor): Don't
++ do anything if the expression is inside an array iterator.
++
++2016-08-09 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/69742
++ * frontend-passes.c (cfe-expr_0): Don't register functions
++ from within an ASSOCIATE statement.
++
++2016-08-08 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/60526
++ * decl.c (build_sym): If the name has already been defined as a
++ type, it has a symtree with an upper case letter at the beginning.
++ If such a symtree exists, issue an error and exit. Don't do
++ this if there is no corresponding upper case letter.
++
++2016-08-08 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/70524
++ * trans-array.c (gfc_trans_dummy_array_bias): Ensure that the
++ location information is correctly set.
++ * trans-decl.c (gfc_trans_deferred_vars): Set the locus of the
++ current construct early.
++
++2016-07-29 Steven G. Kargl <kargl@gcc.gnu.org>
++ Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71883
++ * frontend-passes.c (gfc_run_passes): Bail out if there are any
++ errors.
++ * error.c (gfc_internal_error): If there are any errors in the
++ buffer, exit with EXIT_FAILURE.
++
++2016-07-22 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71807
++ * trans-expr.c (gfc_trans_subcomponent_assign): Special casing
++ when allocatable component is set to null() in initializer.
++
++2016-07-22 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/70842
++ * simplify.c (gfc_simplify_len): Only for unlimited polymorphic
++ types replace the expression's _data ref with a _len ref.
++
++2016-07-15 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71764
++ * trans-expr.c (gfc_trans_structure_assign): Remove assert.
++
++2016-07-13 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71623
++ * trans-stmt.c (gfc_trans_allocate): Add code of pre block of typespec
++ in allocate to parent block.
++
++2016-07-11 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71783
++ * frontend-passes.c (create_var): Always allocate a charlen
++ for character variables.
++
++2016-07-08 Cesar Philippidis <cesar@codesourcery.com>
++
++ Backport from trunk:
++ 2016-07-08 Cesar Philippidis <cesar@codesourcery.com>
++
++ * parse.c (matcha): Define.
++ (decode_oacc_directive): Add spec_only local var and set it. Use
++ matcha to parse acc directives except for routine and declare. Return
++ ST_GET_FCN_CHARACTERISTICS if a non-declarative directive could be
++ matched.
++
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-07-01 Jakub Jelinek <jakub@redhat.com>
++
++ PR fortran/71717
++ * trans-openmp.c (gfc_omp_privatize_by_reference): Return false
++ for GFC_DECL_ASSOCIATE_VAR_P with POINTER_TYPE.
++
++ 2016-06-30 Jakub Jelinek <jakub@redhat.com>
++
++ PR fortran/71704
++ * parse.c (matchs, matcho): Move right before decode_omp_directive.
++ If spec_only, only gfc_match the keyword and if successful, goto
++ do_spec_only.
++ (matchds, matchdo): Define.
++ (decode_omp_directive): Add spec_only local var and set it.
++ Use matchds or matchdo macros instead of matchs or matcho
++ for declare target, declare simd, declare reduction and threadprivate
++ directives. Return ST_GET_FCN_CHARACTERISTICS if a non-declarative
++ directive could be matched.
++ (next_statement): For ST_GET_FCN_CHARACTERISTICS restore
++ gfc_current_locus from old_locus even if there is no label.
++
++ PR fortran/71705
++ * trans-openmp.c (gfc_trans_omp_clauses): Set TREE_ADDRESSABLE on
++ decls in to/from clauses.
++
++2016-06-27 Paul Thomas <pault@gcc.gnu.org>
++
++ PR fortran/70673
++ * frontend-passes.c (realloc_string_callback): Add a call to
++ gfc_dep_compare_expr.
++
++2016-06-12 Dominique d'Humieres <dominiq@lps.ens.fr>
++
++ PR fortran/60751
++ * io.c (gfc_resolve_dt): Replace GFC_STD_GNU with GFC_STD_LEGACY.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/gcc/fortran/array.c b/gcc/fortran/array.c
+index b672bc3..980bde0 100644
+--- a/gcc/fortran/array.c
++++ b/gcc/fortran/array.c
+@@ -1057,6 +1057,7 @@ match_array_cons_element (gfc_constructor_base *result)
+ match
+ gfc_match_array_constructor (gfc_expr **result)
+ {
++ gfc_constructor *c;
+ gfc_constructor_base head, new_cons;
+ gfc_undo_change_set changed_syms;
+ gfc_expr *expr;
+@@ -1109,6 +1110,15 @@ gfc_match_array_constructor (gfc_expr **result)
+ gfc_restore_last_undo_checkpoint ();
+ goto cleanup;
+ }
++
++ if (ts.type == BT_CHARACTER
++ && ts.u.cl && !ts.u.cl->length && !ts.u.cl->length_from_typespec)
++ {
++ gfc_error ("Type-spec at %L cannot contain an asterisk for a "
++ "type parameter", &where);
++ gfc_restore_last_undo_checkpoint ();
++ goto cleanup;
++ }
+ }
+ }
+ else if (m == MATCH_ERROR)
+@@ -1162,8 +1172,6 @@ done:
+ be converted. See PR fortran/67803. */
+ if (ts.type == BT_CHARACTER)
+ {
+- gfc_constructor *c;
+-
+ c = gfc_constructor_first (head);
+ for (; c; c = gfc_constructor_next (c))
+ {
+@@ -1186,6 +1194,14 @@ done:
+ }
+ }
+ }
++
++ /* Walk the constructor and ensure type conversion for numeric types. */
++ if (gfc_numeric_ts (&ts))
++ {
++ c = gfc_constructor_first (head);
++ for (; c; c = gfc_constructor_next (c))
++ gfc_convert_type (c->expr, &ts, 1);
++ }
+ }
+ else
+ expr = gfc_get_array_expr (BT_UNKNOWN, 0, &where);
+diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c
+index 049a6fb..c2cc09f 100644
+--- a/gcc/fortran/check.c
++++ b/gcc/fortran/check.c
+@@ -72,6 +72,11 @@ type_check (gfc_expr *e, int n, bt type)
+ static bool
+ numeric_check (gfc_expr *e, int n)
+ {
++ /* Users sometime use a subroutine designator as an actual argument to
++ an intrinsic subprogram that expects an argument with a numeric type. */
++ if (e->symtree && e->symtree->n.sym->attr.subroutine)
++ goto error;
++
+ if (gfc_numeric_ts (&e->ts))
+ return true;
+
+@@ -86,7 +91,9 @@ numeric_check (gfc_expr *e, int n)
+ return true;
+ }
+
+- gfc_error ("%qs argument of %qs intrinsic at %L must be a numeric type",
++error:
++
++ gfc_error ("%qs argument of %qs intrinsic at %L must have a numeric type",
+ gfc_current_intrinsic_arg[n]->name, gfc_current_intrinsic,
+ &e->where);
+
+@@ -3820,7 +3827,7 @@ gfc_check_reshape (gfc_expr *source, gfc_expr *shape,
+ if (!type_check (order, 3, BT_INTEGER))
+ return false;
+
+- if (order->expr_type == EXPR_ARRAY)
++ if (order->expr_type == EXPR_ARRAY && gfc_is_constant_expr (order))
+ {
+ int i, order_size, dim, perm[GFC_MAX_DIMENSIONS];
+ gfc_expr *e;
+diff --git a/gcc/fortran/class.c b/gcc/fortran/class.c
+index 7f9256c..4ab9652 100644
+--- a/gcc/fortran/class.c
++++ b/gcc/fortran/class.c
+@@ -748,7 +748,7 @@ add_proc_comp (gfc_symbol *vtype, const char *name, gfc_typebound_proc *tb)
+ {
+ gfc_component *c;
+
+- if (tb->non_overridable)
++ if (tb->non_overridable && !tb->overridden)
+ return;
+
+ c = gfc_find_component (vtype, name, true, true);
+diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c
+index adea3f3..81f9097 100644
+--- a/gcc/fortran/decl.c
++++ b/gcc/fortran/decl.c
+@@ -404,6 +404,7 @@ match_data_constant (gfc_expr **result)
+ {
+ gfc_error ("Symbol %qs must be a PARAMETER in DATA statement at %C",
+ name);
++ *result = NULL;
+ return MATCH_ERROR;
+ }
+ else if (dt_sym && dt_sym->attr.flavor == FL_DERIVED)
+@@ -759,6 +760,7 @@ char_len_param_value (gfc_expr **expr, bool *deferred)
+ goto syntax;
+ else if ((*expr)->expr_type == EXPR_VARIABLE)
+ {
++ bool t;
+ gfc_expr *e;
+
+ e = gfc_copy_expr (*expr);
+@@ -770,7 +772,17 @@ char_len_param_value (gfc_expr **expr, bool *deferred)
+ && e->ref->u.ar.dimen_type[0] == DIMEN_RANGE)
+ goto syntax;
+
+- gfc_reduce_init_expr (e);
++ t = gfc_reduce_init_expr (e);
++
++ if (!t && e->ts.type == BT_UNKNOWN
++ && e->symtree->n.sym->attr.untyped == 1
++ && (flag_implicit_none
++ || e->symtree->n.sym->ns->seen_implicit_none == 1
++ || e->symtree->n.sym->ns->parent->seen_implicit_none == 1))
++ {
++ gfc_free_expr (e);
++ goto syntax;
++ }
+
+ if ((e->ref && e->ref->type == REF_ARRAY
+ && e->ref->u.ar.type != AR_ELEMENT)
+@@ -1194,10 +1206,37 @@ build_sym (const char *name, gfc_charlen *cl, bool cl_deferred,
+ {
+ symbol_attribute attr;
+ gfc_symbol *sym;
++ int upper;
+
+ if (gfc_get_symbol (name, NULL, &sym))
+ return false;
+
++ /* Check if the name has already been defined as a type. The
++ first letter of the symtree will be in upper case then. Of
++ course, this is only necessary if the upper case letter is
++ actually different. */
++
++ upper = TOUPPER(name[0]);
++ if (upper != name[0])
++ {
++ char u_name[GFC_MAX_SYMBOL_LEN + 1];
++ gfc_symtree *st;
++ int nlen;
++
++ nlen = strlen(name);
++ gcc_assert (nlen <= GFC_MAX_SYMBOL_LEN);
++ strncpy (u_name, name, nlen + 1);
++ u_name[0] = upper;
++
++ st = gfc_find_symtree (gfc_current_ns->sym_root, u_name);
++
++ if (st)
++ {
++ gfc_error ("Symbol %qs at %C also declared as a type", name);
++ return false;
++ }
++ }
++
+ /* Start updating the symbol table. Add basic type attribute if present. */
+ if (current_ts.type != BT_UNKNOWN
+ && (sym->attr.implicit_type == 0
+@@ -1280,10 +1319,14 @@ gfc_set_constant_character_len (int len, gfc_expr *expr, int check_len)
+ gfc_char_t *s;
+ int slen;
+
+- gcc_assert (expr->expr_type == EXPR_CONSTANT);
+-
+ if (expr->ts.type != BT_CHARACTER)
+ return;
++
++ if (expr->expr_type != EXPR_CONSTANT)
++ {
++ gfc_error_now ("CHARACTER length must be a constant at %L", &expr->where);
++ return;
++ }
+
+ slen = expr->value.character.length;
+ if (len != slen)
+@@ -1677,8 +1720,10 @@ build_struct (const char *name, gfc_charlen *cl, gfc_expr **init,
+
+ if (c->initializer->expr_type == EXPR_CONSTANT)
+ gfc_set_constant_character_len (len, c->initializer, -1);
+- else if (mpz_cmp (c->ts.u.cl->length->value.integer,
+- c->initializer->ts.u.cl->length->value.integer))
++ else if (c->initializer
++ && c->initializer->ts.u.cl
++ && mpz_cmp (c->ts.u.cl->length->value.integer,
++ c->initializer->ts.u.cl->length->value.integer))
+ {
+ gfc_constructor *ctor;
+ ctor = gfc_constructor_first (c->initializer->value.constructor);
+diff --git a/gcc/fortran/dependency.c b/gcc/fortran/dependency.c
+index 63c6630..233ba7e 100644
+--- a/gcc/fortran/dependency.c
++++ b/gcc/fortran/dependency.c
+@@ -102,7 +102,9 @@ identical_array_ref (gfc_array_ref *a1, gfc_array_ref *a2)
+
+ if (a1->type == AR_ELEMENT && a2->type == AR_ELEMENT)
+ {
+- gcc_assert (a1->dimen == a2->dimen);
++ if (a1->dimen != a2->dimen)
++ gfc_internal_error ("identical_array_ref(): inconsistent dimensions");
++
+ for (i = 0; i < a1->dimen; i++)
+ {
+ if (gfc_dep_compare_expr (a1->start[i], a2->start[i]) != 0)
+@@ -227,9 +229,26 @@ gfc_dep_compare_functions (gfc_expr *e1, gfc_expr *e2, bool impure_ok)
+ if ((args1->expr == NULL) ^ (args2->expr == NULL))
+ return -2;
+
+- if (args1->expr != NULL && args2->expr != NULL
+- && gfc_dep_compare_expr (args1->expr, args2->expr) != 0)
+- return -2;
++ if (args1->expr != NULL && args2->expr != NULL)
++ {
++ gfc_expr *e1, *e2;
++ e1 = args1->expr;
++ e2 = args2->expr;
++
++ if (gfc_dep_compare_expr (e1, e2) != 0)
++ return -2;
++
++ /* Special case: String arguments which compare equal can have
++ different lengths, which makes them different in calls to
++ procedures. */
++
++ if (e1->expr_type == EXPR_CONSTANT
++ && e1->ts.type == BT_CHARACTER
++ && e2->expr_type == EXPR_CONSTANT
++ && e2->ts.type == BT_CHARACTER
++ && e1->value.character.length != e2->value.character.length)
++ return -2;
++ }
+
+ args1 = args1->next;
+ args2 = args2->next;
+@@ -1253,6 +1272,12 @@ gfc_check_dependency (gfc_expr *expr1, gfc_expr *expr2, bool identical)
+ gfc_constructor *c;
+ int n;
+
++ /* -fcoarray=lib can end up here with expr1->expr_type set to EXPR_FUNCTION
++ and a reference to _F.caf_get, so skip the assert. */
++ if (expr1->expr_type == EXPR_FUNCTION
++ && strcmp (expr1->value.function.name, "_F.caf_get") == 0)
++ return 0;
++
+ gcc_assert (expr1->expr_type == EXPR_VARIABLE);
+
+ switch (expr2->expr_type)
+diff --git a/gcc/fortran/error.c b/gcc/fortran/error.c
+index 0d292ea..18e127f 100644
+--- a/gcc/fortran/error.c
++++ b/gcc/fortran/error.c
+@@ -344,7 +344,7 @@ show_locus (locus *loc, int c1, int c2)
+
+ error_string (f->filename);
+ error_char (':');
+-
++
+ error_integer (LOCATION_LINE (lb->location));
+
+ if ((c1 > 0) || (c2 > 0))
+@@ -394,7 +394,7 @@ show_locus (locus *loc, int c1, int c2)
+ offset = cmax - terminal_width + 5;
+
+ /* Show the line itself, taking care not to print more than what can
+- show up on the terminal. Tabs are converted to spaces, and
++ show up on the terminal. Tabs are converted to spaces, and
+ nonprintable characters are converted to a "\xNN" sequence. */
+
+ p = &(lb->line[offset]);
+@@ -412,7 +412,7 @@ show_locus (locus *loc, int c1, int c2)
+ error_char ('\n');
+
+ /* Show the '1' and/or '2' corresponding to the column of the error
+- locus. Note that a value of -1 for c1 or c2 will simply cause
++ locus. Note that a value of -1 for c1 or c2 will simply cause
+ the relevant number not to be printed. */
+
+ c1 -= offset;
+@@ -477,7 +477,7 @@ show_loci (locus *l1, locus *l2)
+ else
+ m = c1 - c2;
+
+- /* Note that the margin value of 10 here needs to be less than the
++ /* Note that the margin value of 10 here needs to be less than the
+ margin of 5 used in the calculation of offset in show_locus. */
+
+ if (l1->lb != l2->lb || m > terminal_width - 10)
+@@ -504,11 +504,11 @@ show_loci (locus *l1, locus *l2)
+ If a locus pointer is given, the actual source line is printed out
+ and the column is indicated. Since we want the error message at
+ the bottom of any source file information, we must scan the
+- argument list twice -- once to determine whether the loci are
++ argument list twice -- once to determine whether the loci are
+ present and record this for printing, and once to print the error
+ message after and loci have been printed. A maximum of two locus
+ arguments are permitted.
+-
++
+ This function is also called (recursively) by show_locus in the
+ case of included files; however, as show_locus does not resupply
+ any loci, the recursion is at most one level deep. */
+@@ -724,11 +724,11 @@ error_print (const char *type, const char *format0, va_list argp)
+ /* This is a position specifier. See comment above. */
+ while (ISDIGIT (*format))
+ format++;
+-
++
+ /* Skip over the dollar sign. */
+ format++;
+ }
+-
++
+ switch (*format)
+ {
+ case '%':
+@@ -782,7 +782,7 @@ error_printf (const char *gmsgid, ...)
+ }
+
+
+-/* Increment the number of errors, and check whether too many have
++/* Increment the number of errors, and check whether too many have
+ been printed. */
+
+ static void
+@@ -883,10 +883,10 @@ gfc_warning (int opt, const char *gmsgid, va_list ap)
+ ++werrorcount;
+ else if (diagnostic.kind == DK_ERROR)
+ ++werrorcount_buffered;
+- else
++ else
+ ++werrorcount, --warningcount, ++warningcount_buffered;
+ }
+-
++
+ va_end (argp);
+ return ret;
+ }
+@@ -952,7 +952,7 @@ gfc_notify_std_1 (int std, const char *gmsgid, ...)
+ msg1 = _("Warning:");
+ else
+ msg1 = _("Error:");
+-
++
+ switch (std)
+ {
+ case GFC_STD_F2008_TS:
+@@ -1210,7 +1210,7 @@ gfc_diagnostic_starter (diagnostic_context *context,
+ locus. */
+ pp_set_prefix (context->printer, prefix);
+ }
+- else
++ else
+ {
+ /* Otherwise, start again. */
+ pp_clear_output_area(context->printer);
+@@ -1320,8 +1320,8 @@ gfc_warning_check (void)
+ warningcount += warningcount_buffered;
+ werrorcount += werrorcount_buffered;
+ gcc_assert (warningcount_buffered + werrorcount_buffered == 1);
+- diagnostic_action_after_output (global_dc,
+- warningcount_buffered
++ diagnostic_action_after_output (global_dc,
++ warningcount_buffered
+ ? DK_WARNING : DK_ERROR);
+ pp->buffer = tmp_buffer;
+ }
+@@ -1488,9 +1488,14 @@ gfc_error_now_1 (const char *gmsgid, ...)
+ void
+ gfc_internal_error (const char *gmsgid, ...)
+ {
++ int e, w;
+ va_list argp;
+ diagnostic_info diagnostic;
+
++ gfc_get_errors (&w, &e);
++ if (e > 0)
++ exit(EXIT_FAILURE);
++
+ va_start (argp, gmsgid);
+ diagnostic_set_info (&diagnostic, gmsgid, &argp, UNKNOWN_LOCATION, DK_ICE);
+ report_diagnostic (&diagnostic);
+@@ -1516,7 +1521,7 @@ gfc_clear_error (void)
+ bool
+ gfc_error_flag_test (void)
+ {
+- return error_buffer.flag
++ return error_buffer.flag
+ || !gfc_output_buffer_empty_p (pp_error_buffer);
+ }
+
+diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c
+index 2e74375..fa928fe 100644
+--- a/gcc/fortran/expr.c
++++ b/gcc/fortran/expr.c
+@@ -4883,7 +4883,8 @@ gfc_check_vardef_context (gfc_expr* e, bool pointer, bool alloc_obj,
+ component. Note that (normal) assignment to procedure pointers is not
+ possible. */
+ check_intentin = !own_scope;
+- ptr_component = (sym->ts.type == BT_CLASS && CLASS_DATA (sym))
++ ptr_component = (sym->ts.type == BT_CLASS && sym->ts.u.derived
++ && CLASS_DATA (sym))
+ ? CLASS_DATA (sym)->attr.class_pointer : sym->attr.pointer;
+ for (ref = e->ref; ref && check_intentin; ref = ref->next)
+ {
+diff --git a/gcc/fortran/frontend-passes.c b/gcc/fortran/frontend-passes.c
+index cc718e9..c051cc0 100644
+--- a/gcc/fortran/frontend-passes.c
++++ b/gcc/fortran/frontend-passes.c
+@@ -105,6 +105,7 @@ gfc_run_passes (gfc_namespace *ns)
+ doloop_level = 0;
+ doloop_warn (ns);
+ doloop_list.release ();
++ int w, e;
+
+ if (flag_frontend_optimize)
+ {
+@@ -116,6 +117,10 @@ gfc_run_passes (gfc_namespace *ns)
+ expr_array.release ();
+ }
+
++ gfc_get_errors (&w, &e);
++ if (e > 0)
++ return;
++
+ if (flag_realloc_lhs)
+ realloc_strings (ns);
+ }
+@@ -139,23 +144,44 @@ realloc_string_callback (gfc_code **c, int *walk_subtrees,
+ gfc_expr *expr1, *expr2;
+ gfc_code *co = *c;
+ gfc_expr *n;
++ gfc_ref *ref;
++ bool found_substr;
+
+- *walk_subtrees = 0;
+ if (co->op != EXEC_ASSIGN)
+ return 0;
+
+ expr1 = co->expr1;
+ if (expr1->ts.type != BT_CHARACTER || expr1->rank != 0
+- || !expr1->symtree->n.sym->attr.allocatable)
++ || !gfc_expr_attr(expr1).allocatable
++ || !expr1->ts.deferred)
+ return 0;
+
+ expr2 = gfc_discard_nops (co->expr2);
+ if (expr2->expr_type != EXPR_VARIABLE)
+ return 0;
+
++ found_substr = false;
++ for (ref = expr2->ref; ref; ref = ref->next)
++ {
++ if (ref->type == REF_SUBSTRING)
++ {
++ found_substr = true;
++ break;
++ }
++ }
++ if (!found_substr)
++ return 0;
++
+ if (!gfc_check_dependency (expr1, expr2, true))
+ return 0;
+
++ /* gfc_check_dependency doesn't always pick up identical expressions.
++ However, eliminating the above sends the compiler into an infinite
++ loop on valid expressions. Without this check, the gimplifier emits
++ an ICE for a = a, where a is deferred character length. */
++ if (!gfc_dep_compare_expr (expr1, expr2))
++ return 0;
++
+ current_code = c;
+ inserted_block = NULL;
+ changed_statement = NULL;
+@@ -624,12 +650,10 @@ create_var (gfc_expr * e)
+ {
+ gfc_expr *length;
+
++ symbol->ts.u.cl = gfc_new_charlen (ns, NULL);
+ length = constant_string_length (e);
+ if (length)
+- {
+- symbol->ts.u.cl = gfc_new_charlen (ns, NULL);
+- symbol->ts.u.cl->length = length;
+- }
++ symbol->ts.u.cl->length = length;
+ else
+ symbol->attr.allocatable = 1;
+ }
+@@ -701,7 +725,7 @@ cfe_expr_0 (gfc_expr **e, int *walk_subtrees,
+
+ /* Don't do this optimization within OMP workshare. */
+
+- if (in_omp_workshare)
++ if (in_omp_workshare || in_assoc_list)
+ {
+ *walk_subtrees = 0;
+ return 0;
+@@ -1006,6 +1030,9 @@ optimize_binop_array_assignment (gfc_code *c, gfc_expr **rhs, bool seen_op)
+ {
+ gfc_expr *e;
+
++ if (!*rhs)
++ return false;
++
+ e = *rhs;
+ if (e->expr_type == EXPR_OP)
+ {
+@@ -1082,6 +1109,8 @@ remove_trim (gfc_expr *rhs)
+ bool ret;
+
+ ret = false;
++ if (!rhs)
++ return ret;
+
+ /* Check for a // b // trim(c). Looping is probably not
+ necessary because the parser usually generates
+@@ -1211,9 +1240,17 @@ combine_array_constructor (gfc_expr *e)
+ if (forall_level > 0)
+ return false;
+
++ /* Inside an iterator, things can get hairy; we are likely to create
++ an invalid temporary variable. */
++ if (iterator_level > 0)
++ return false;
++
+ op1 = e->value.op.op1;
+ op2 = e->value.op.op2;
+
++ if (!op1 || !op2)
++ return false;
++
+ if (op1->expr_type == EXPR_ARRAY && op2->rank == 0)
+ scalar_first = false;
+ else if (op2->expr_type == EXPR_ARRAY && op1->rank == 0)
+diff --git a/gcc/fortran/interface.c b/gcc/fortran/interface.c
+index 8571a74..6cb84b6 100644
+--- a/gcc/fortran/interface.c
++++ b/gcc/fortran/interface.c
+@@ -398,7 +398,8 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
+ if (derived1 == derived2)
+ return 1;
+
+- gcc_assert (derived1 && derived2);
++ if (!derived1 || !derived2)
++ gfc_internal_error ("gfc_compare_derived_types: invalid derived type");
+
+ /* Special case for comparing derived types across namespaces. If the
+ true names and module names are the same and the module name is
+@@ -2026,7 +2027,7 @@ compare_parameter (gfc_symbol *formal, gfc_expr *actual,
+ {
+ if (where)
+ gfc_error ("Type mismatch in argument %qs at %L; passed %s to %s",
+- formal->name, &actual->where, gfc_typename (&actual->ts),
++ formal->name, where, gfc_typename (&actual->ts),
+ gfc_typename (&formal->ts));
+ return 0;
+ }
+@@ -3651,7 +3652,7 @@ matching_typebound_op (gfc_expr** tb_base,
+
+ if (base->expr->ts.type == BT_CLASS)
+ {
+- if (CLASS_DATA (base->expr) == NULL
++ if (!base->expr->ts.u.derived || CLASS_DATA (base->expr) == NULL
+ || !gfc_expr_attr (base->expr).class_ok)
+ continue;
+ derived = CLASS_DATA (base->expr)->ts.u.derived;
+diff --git a/gcc/fortran/intrinsic.c b/gcc/fortran/intrinsic.c
+index 3a971cb..55c733f 100644
+--- a/gcc/fortran/intrinsic.c
++++ b/gcc/fortran/intrinsic.c
+@@ -1205,7 +1205,8 @@ add_functions (void)
+ *z = "z", *ln = "len", *ut = "unit", *han = "handler",
+ *num = "number", *tm = "time", *nm = "name", *md = "mode",
+ *vl = "values", *p1 = "path1", *p2 = "path2", *com = "command",
+- *ca = "coarray", *sub = "sub", *dist = "distance", *failed="failed";
++ *ca = "coarray", *sub = "sub", *dist = "distance", *failed="failed",
++ *c_ptr_1 = "c_ptr_1", *c_ptr_2 = "c_ptr_2";
+
+ int di, dr, dd, dl, dc, dz, ii;
+
+@@ -2775,8 +2776,8 @@ add_functions (void)
+ /* The following functions are part of ISO_C_BINDING. */
+ add_sym_2 ("c_associated", GFC_ISYM_C_ASSOCIATED, CLASS_INQUIRY, ACTUAL_NO,
+ BT_LOGICAL, dl, GFC_STD_F2003, gfc_check_c_associated, NULL, NULL,
+- "C_PTR_1", BT_VOID, 0, REQUIRED,
+- "C_PTR_2", BT_VOID, 0, OPTIONAL);
++ c_ptr_1, BT_VOID, 0, REQUIRED,
++ c_ptr_2, BT_VOID, 0, OPTIONAL);
+ make_from_module();
+
+ add_sym_1 ("c_loc", GFC_ISYM_C_LOC, CLASS_INQUIRY, ACTUAL_NO,
+diff --git a/gcc/fortran/io.c b/gcc/fortran/io.c
+index de91ea9..b41d8f2 100644
+--- a/gcc/fortran/io.c
++++ b/gcc/fortran/io.c
+@@ -3005,7 +3005,7 @@ gfc_resolve_dt (gfc_dt *dt, locus *loc)
+ }
+
+ if (dt->extra_comma
+- && !gfc_notify_std (GFC_STD_GNU, "Comma before i/o item list at %L",
++ && !gfc_notify_std (GFC_STD_LEGACY, "Comma before i/o item list at %L",
+ &dt->extra_comma->where))
+ return false;
+
+@@ -3050,7 +3050,7 @@ gfc_resolve_dt (gfc_dt *dt, locus *loc)
+ && dt->format_label->defined == ST_LABEL_UNKNOWN)
+ {
+ gfc_error ("FORMAT label %d at %L not defined", dt->format_label->value,
+- &dt->format_label->where);
++ loc);
+ return false;
+ }
+
+diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c
+index bf8439a..c32eef7 100644
+--- a/gcc/fortran/match.c
++++ b/gcc/fortran/match.c
+@@ -2608,20 +2608,92 @@ gfc_match_cycle (void)
+ }
+
+
+-/* Match a number or character constant after an (ERROR) STOP or PAUSE
+- statement. */
++/* Match a stop-code after an (ERROR) STOP or PAUSE statement. The
++ requirements for a stop-code differ in the standards.
++
++Fortran 95 has
++
++ R840 stop-stmt is STOP [ stop-code ]
++ R841 stop-code is scalar-char-constant
++ or digit [ digit [ digit [ digit [ digit ] ] ] ]
++
++Fortran 2003 matches Fortran 95 except R840 and R841 are now R849 and R850.
++Fortran 2008 has
++
++ R855 stop-stmt is STOP [ stop-code ]
++ R856 allstop-stmt is ALL STOP [ stop-code ]
++ R857 stop-code is scalar-default-char-constant-expr
++ or scalar-int-constant-expr
++
++For free-form source code, all standards contain a statement of the form:
++
++ A blank shall be used to separate names, constants, or labels from
++ adjacent keywords, names, constants, or labels.
++
++A stop-code is not a name, constant, or label. So, under Fortran 95 and 2003,
++
++ STOP123
++
++is valid, but it is invalid Fortran 2008. */
+
+ static match
+ gfc_match_stopcode (gfc_statement st)
+ {
+- gfc_expr *e;
++ gfc_expr *e = NULL;
+ match m;
++ bool f95, f03;
+
+- e = NULL;
++ /* Set f95 for -std=f95. */
++ f95 = gfc_option.allow_std == (GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77
++ | GFC_STD_F2008_OBS);
++
++ /* Set f03 for -std=f2003. */
++ f03 = gfc_option.allow_std == (GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77
++ | GFC_STD_F2008_OBS | GFC_STD_F2003);
++
++ /* Look for a blank between STOP and the stop-code for F2008 or later. */
++ if (gfc_current_form != FORM_FIXED && !(f95 || f03))
++ {
++ char c = gfc_peek_ascii_char ();
++
++ /* Look for end-of-statement. There is no stop-code. */
++ if (c == '\n' || c == '!' || c == ';')
++ goto done;
++
++ if (c != ' ')
++ {
++ gfc_error ("Blank required in %s statement near %C",
++ gfc_ascii_statement (st));
++ return MATCH_ERROR;
++ }
++ }
+
+ if (gfc_match_eos () != MATCH_YES)
+ {
+- m = gfc_match_init_expr (&e);
++ int stopcode;
++ locus old_locus;
++
++ /* First look for the F95 or F2003 digit [...] construct. */
++ old_locus = gfc_current_locus;
++ m = gfc_match_small_int (&stopcode);
++ if (m == MATCH_YES && (f95 || f03))
++ {
++ if (stopcode < 0)
++ {
++ gfc_error ("STOP code at %C cannot be negative");
++ return MATCH_ERROR;
++ }
++
++ if (stopcode > 99999)
++ {
++ gfc_error ("STOP code at %C contains too many digits");
++ return MATCH_ERROR;
++ }
++ }
++
++ /* Reset the locus and now load gfc_expr. */
++ gfc_current_locus = old_locus;
++ m = gfc_match_expr (&e);
+ if (m == MATCH_ERROR)
+ goto cleanup;
+ if (m == MATCH_NO)
+@@ -2662,6 +2734,22 @@ gfc_match_stopcode (gfc_statement st)
+
+ if (e != NULL)
+ {
++ gfc_simplify_expr (e, 0);
++
++ /* Test for F95 and F2003 style STOP stop-code. */
++ if (e->expr_type != EXPR_CONSTANT && (f95 || f03))
++ {
++ gfc_error ("STOP code at %L must be a scalar CHARACTER constant or "
++ "digit[digit[digit[digit[digit]]]]", &e->where);
++ goto cleanup;
++ }
++
++ /* Use the machinery for an initialization expression to reduce the
++ stop-code to a constant. */
++ gfc_init_expr_flag = true;
++ gfc_reduce_init_expr (e);
++ gfc_init_expr_flag = false;
++
+ if (!(e->ts.type == BT_CHARACTER || e->ts.type == BT_INTEGER))
+ {
+ gfc_error ("STOP code at %L must be either INTEGER or CHARACTER type",
+@@ -2671,8 +2759,7 @@ gfc_match_stopcode (gfc_statement st)
+
+ if (e->rank != 0)
+ {
+- gfc_error ("STOP code at %L must be scalar",
+- &e->where);
++ gfc_error ("STOP code at %L must be scalar", &e->where);
+ goto cleanup;
+ }
+
+@@ -2684,8 +2771,7 @@ gfc_match_stopcode (gfc_statement st)
+ goto cleanup;
+ }
+
+- if (e->ts.type == BT_INTEGER
+- && e->ts.kind != gfc_default_integer_kind)
++ if (e->ts.type == BT_INTEGER && e->ts.kind != gfc_default_integer_kind)
+ {
+ gfc_error ("STOP code at %L must be default integer KIND=%d",
+ &e->where, (int) gfc_default_integer_kind);
+@@ -2693,6 +2779,8 @@ gfc_match_stopcode (gfc_statement st)
+ }
+ }
+
++done:
++
+ switch (st)
+ {
+ case ST_STOP:
+@@ -5842,6 +5930,7 @@ match_simple_where (void)
+
+ c->next = XCNEW (gfc_code);
+ *c->next = new_st;
++ c->next->loc = gfc_current_locus;
+ gfc_clear_new_st ();
+
+ new_st.op = EXEC_WHERE;
+@@ -5898,8 +5987,12 @@ gfc_match_where (gfc_statement *st)
+ c = gfc_get_code (EXEC_WHERE);
+ c->expr1 = expr;
+
++ /* Put in the assignment. It will not be processed by add_statement, so we
++ need to copy the location here. */
++
+ c->next = XCNEW (gfc_code);
+ *c->next = new_st;
++ c->next->loc = gfc_current_locus;
+ gfc_clear_new_st ();
+
+ new_st.op = EXEC_WHERE;
+diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c
+index 6394e2e..8ed027d 100644
+--- a/gcc/fortran/parse.c
++++ b/gcc/fortran/parse.c
+@@ -564,21 +564,12 @@ decode_statement (void)
+ return ST_NONE;
+ }
+
+-/* Like match, but set a flag simd_matched if keyword matched. */
+-#define matchs(keyword, subr, st) \
++/* Like match and if spec_only, goto do_spec_only without actually
++ matching. */
++#define matcha(keyword, subr, st) \
+ do { \
+- if (match_word_omp_simd (keyword, subr, &old_locus, \
+- &simd_matched) == MATCH_YES) \
+- return st; \
+- else \
+- undo_new_statement (); \
+- } while (0);
+-
+-/* Like match, but don't match anything if not -fopenmp. */
+-#define matcho(keyword, subr, st) \
+- do { \
+- if (!flag_openmp) \
+- ; \
++ if (spec_only && gfc_match (keyword) == MATCH_YES) \
++ goto do_spec_only; \
+ else if (match_word (keyword, subr, &old_locus) \
+ == MATCH_YES) \
+ return st; \
+@@ -591,6 +582,7 @@ decode_oacc_directive (void)
+ {
+ locus old_locus;
+ char c;
++ bool spec_only = false;
+
+ gfc_enforce_clean_symbol_state ();
+
+@@ -605,6 +597,10 @@ decode_oacc_directive (void)
+ return ST_NONE;
+ }
+
++ if (gfc_current_state () == COMP_FUNCTION
++ && gfc_current_block ()->result->ts.kind == -1)
++ spec_only = true;
++
+ gfc_unset_implicit_pure (NULL);
+
+ old_locus = gfc_current_locus;
+@@ -618,45 +614,47 @@ decode_oacc_directive (void)
+ switch (c)
+ {
+ case 'c':
+- match ("cache", gfc_match_oacc_cache, ST_OACC_CACHE);
++ matcha ("cache", gfc_match_oacc_cache, ST_OACC_CACHE);
+ break;
+ case 'd':
+- match ("data", gfc_match_oacc_data, ST_OACC_DATA);
++ matcha ("data", gfc_match_oacc_data, ST_OACC_DATA);
+ match ("declare", gfc_match_oacc_declare, ST_OACC_DECLARE);
+ break;
+ case 'e':
+- match ("end data", gfc_match_omp_eos, ST_OACC_END_DATA);
+- match ("end host_data", gfc_match_omp_eos, ST_OACC_END_HOST_DATA);
+- match ("end kernels loop", gfc_match_omp_eos, ST_OACC_END_KERNELS_LOOP);
+- match ("end kernels", gfc_match_omp_eos, ST_OACC_END_KERNELS);
+- match ("end loop", gfc_match_omp_eos, ST_OACC_END_LOOP);
+- match ("end parallel loop", gfc_match_omp_eos, ST_OACC_END_PARALLEL_LOOP);
+- match ("end parallel", gfc_match_omp_eos, ST_OACC_END_PARALLEL);
+- match ("enter data", gfc_match_oacc_enter_data, ST_OACC_ENTER_DATA);
+- match ("exit data", gfc_match_oacc_exit_data, ST_OACC_EXIT_DATA);
++ matcha ("end data", gfc_match_omp_eos, ST_OACC_END_DATA);
++ matcha ("end host_data", gfc_match_omp_eos, ST_OACC_END_HOST_DATA);
++ matcha ("end kernels loop", gfc_match_omp_eos, ST_OACC_END_KERNELS_LOOP);
++ matcha ("end kernels", gfc_match_omp_eos, ST_OACC_END_KERNELS);
++ matcha ("end loop", gfc_match_omp_eos, ST_OACC_END_LOOP);
++ matcha ("end parallel loop", gfc_match_omp_eos,
++ ST_OACC_END_PARALLEL_LOOP);
++ matcha ("end parallel", gfc_match_omp_eos, ST_OACC_END_PARALLEL);
++ matcha ("enter data", gfc_match_oacc_enter_data, ST_OACC_ENTER_DATA);
++ matcha ("exit data", gfc_match_oacc_exit_data, ST_OACC_EXIT_DATA);
+ break;
+ case 'h':
+- match ("host_data", gfc_match_oacc_host_data, ST_OACC_HOST_DATA);
++ matcha ("host_data", gfc_match_oacc_host_data, ST_OACC_HOST_DATA);
+ break;
+ case 'p':
+- match ("parallel loop", gfc_match_oacc_parallel_loop, ST_OACC_PARALLEL_LOOP);
+- match ("parallel", gfc_match_oacc_parallel, ST_OACC_PARALLEL);
++ matcha ("parallel loop", gfc_match_oacc_parallel_loop, ST_OACC_PARALLEL_LOOP);
++ matcha ("parallel", gfc_match_oacc_parallel, ST_OACC_PARALLEL);
+ break;
+ case 'k':
+- match ("kernels loop", gfc_match_oacc_kernels_loop, ST_OACC_KERNELS_LOOP);
+- match ("kernels", gfc_match_oacc_kernels, ST_OACC_KERNELS);
++ matcha ("kernels loop", gfc_match_oacc_kernels_loop,
++ ST_OACC_KERNELS_LOOP);
++ matcha ("kernels", gfc_match_oacc_kernels, ST_OACC_KERNELS);
+ break;
+ case 'l':
+- match ("loop", gfc_match_oacc_loop, ST_OACC_LOOP);
++ matcha ("loop", gfc_match_oacc_loop, ST_OACC_LOOP);
+ break;
+ case 'r':
+ match ("routine", gfc_match_oacc_routine, ST_OACC_ROUTINE);
+ break;
+ case 'u':
+- match ("update", gfc_match_oacc_update, ST_OACC_UPDATE);
++ matcha ("update", gfc_match_oacc_update, ST_OACC_UPDATE);
+ break;
+ case 'w':
+- match ("wait", gfc_match_oacc_wait, ST_OACC_WAIT);
++ matcha ("wait", gfc_match_oacc_wait, ST_OACC_WAIT);
+ break;
+ }
+
+@@ -671,14 +669,72 @@ decode_oacc_directive (void)
+ gfc_error_recovery ();
+
+ return ST_NONE;
++
++ do_spec_only:
++ reject_statement ();
++ gfc_clear_error ();
++ gfc_buffer_error (false);
++ gfc_current_locus = old_locus;
++ return ST_GET_FCN_CHARACTERISTICS;
+ }
+
++/* Like match, but set a flag simd_matched if keyword matched
++ and if spec_only, goto do_spec_only without actually matching. */
++#define matchs(keyword, subr, st) \
++ do { \
++ if (spec_only && gfc_match (keyword) == MATCH_YES) \
++ goto do_spec_only; \
++ if (match_word_omp_simd (keyword, subr, &old_locus, \
++ &simd_matched) == MATCH_YES) \
++ return st; \
++ else \
++ undo_new_statement (); \
++ } while (0);
++
++/* Like match, but don't match anything if not -fopenmp
++ and if spec_only, goto do_spec_only without actually matching. */
++#define matcho(keyword, subr, st) \
++ do { \
++ if (!flag_openmp) \
++ ; \
++ else if (spec_only && gfc_match (keyword) == MATCH_YES) \
++ goto do_spec_only; \
++ else if (match_word (keyword, subr, &old_locus) \
++ == MATCH_YES) \
++ return st; \
++ else \
++ undo_new_statement (); \
++ } while (0);
++
++/* Like match, but set a flag simd_matched if keyword matched. */
++#define matchds(keyword, subr, st) \
++ do { \
++ if (match_word_omp_simd (keyword, subr, &old_locus, \
++ &simd_matched) == MATCH_YES) \
++ return st; \
++ else \
++ undo_new_statement (); \
++ } while (0);
++
++/* Like match, but don't match anything if not -fopenmp. */
++#define matchdo(keyword, subr, st) \
++ do { \
++ if (!flag_openmp) \
++ ; \
++ else if (match_word (keyword, subr, &old_locus) \
++ == MATCH_YES) \
++ return st; \
++ else \
++ undo_new_statement (); \
++ } while (0);
++
+ static gfc_statement
+ decode_omp_directive (void)
+ {
+ locus old_locus;
+ char c;
+ bool simd_matched = false;
++ bool spec_only = false;
+
+ gfc_enforce_clean_symbol_state ();
+
+@@ -693,6 +749,10 @@ decode_omp_directive (void)
+ return ST_NONE;
+ }
+
++ if (gfc_current_state () == COMP_FUNCTION
++ && gfc_current_block ()->result->ts.kind == -1)
++ spec_only = true;
++
+ gfc_unset_implicit_pure (NULL);
+
+ old_locus = gfc_current_locus;
+@@ -721,12 +781,12 @@ decode_omp_directive (void)
+ matcho ("critical", gfc_match_omp_critical, ST_OMP_CRITICAL);
+ break;
+ case 'd':
+- matchs ("declare reduction", gfc_match_omp_declare_reduction,
+- ST_OMP_DECLARE_REDUCTION);
+- matchs ("declare simd", gfc_match_omp_declare_simd,
+- ST_OMP_DECLARE_SIMD);
+- matcho ("declare target", gfc_match_omp_declare_target,
+- ST_OMP_DECLARE_TARGET);
++ matchds ("declare reduction", gfc_match_omp_declare_reduction,
++ ST_OMP_DECLARE_REDUCTION);
++ matchds ("declare simd", gfc_match_omp_declare_simd,
++ ST_OMP_DECLARE_SIMD);
++ matchdo ("declare target", gfc_match_omp_declare_target,
++ ST_OMP_DECLARE_TARGET);
+ matchs ("distribute parallel do simd",
+ gfc_match_omp_distribute_parallel_do_simd,
+ ST_OMP_DISTRIBUTE_PARALLEL_DO_SIMD);
+@@ -846,8 +906,8 @@ decode_omp_directive (void)
+ matcho ("teams distribute", gfc_match_omp_teams_distribute,
+ ST_OMP_TEAMS_DISTRIBUTE);
+ matcho ("teams", gfc_match_omp_teams, ST_OMP_TEAMS);
+- matcho ("threadprivate", gfc_match_omp_threadprivate,
+- ST_OMP_THREADPRIVATE);
++ matchdo ("threadprivate", gfc_match_omp_threadprivate,
++ ST_OMP_THREADPRIVATE);
+ break;
+ case 'w':
+ matcho ("workshare", gfc_match_omp_workshare, ST_OMP_WORKSHARE);
+@@ -870,6 +930,13 @@ decode_omp_directive (void)
+ gfc_error_recovery ();
+
+ return ST_NONE;
++
++ do_spec_only:
++ reject_statement ();
++ gfc_clear_error ();
++ gfc_buffer_error (false);
++ gfc_current_locus = old_locus;
++ return ST_GET_FCN_CHARACTERISTICS;
+ }
+
+ static gfc_statement
+@@ -1290,10 +1357,13 @@ next_statement (void)
+
+ gfc_buffer_error (false);
+
+- if (st == ST_GET_FCN_CHARACTERISTICS && gfc_statement_label != NULL)
++ if (st == ST_GET_FCN_CHARACTERISTICS)
+ {
+- gfc_free_st_label (gfc_statement_label);
+- gfc_statement_label = NULL;
++ if (gfc_statement_label != NULL)
++ {
++ gfc_free_st_label (gfc_statement_label);
++ gfc_statement_label = NULL;
++ }
+ gfc_current_locus = old_locus;
+ }
+
+diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
+index 9a8bd9a..bf60517 100644
+--- a/gcc/fortran/resolve.c
++++ b/gcc/fortran/resolve.c
+@@ -5015,6 +5015,11 @@ resolve_variable (gfc_expr *e)
+
+ if (sym->ts.type != BT_UNKNOWN)
+ gfc_variable_attr (e, &e->ts);
++ else if (sym->attr.flavor == FL_PROCEDURE
++ && sym->attr.function && sym->result
++ && sym->result->ts.type != BT_UNKNOWN
++ && sym->result->attr.proc_pointer)
++ e->ts = sym->result->ts;
+ else
+ {
+ /* Must be a simple variable reference. */
+@@ -6418,15 +6423,15 @@ gfc_resolve_iterator (gfc_iterator *iter, bool real_ok, bool own_scope)
+ /* Convert start, end, and step to the same type as var. */
+ if (iter->start->ts.kind != iter->var->ts.kind
+ || iter->start->ts.type != iter->var->ts.type)
+- gfc_convert_type (iter->start, &iter->var->ts, 2);
++ gfc_convert_type (iter->start, &iter->var->ts, 1);
+
+ if (iter->end->ts.kind != iter->var->ts.kind
+ || iter->end->ts.type != iter->var->ts.type)
+- gfc_convert_type (iter->end, &iter->var->ts, 2);
++ gfc_convert_type (iter->end, &iter->var->ts, 1);
+
+ if (iter->step->ts.kind != iter->var->ts.kind
+ || iter->step->ts.type != iter->var->ts.type)
+- gfc_convert_type (iter->step, &iter->var->ts, 2);
++ gfc_convert_type (iter->step, &iter->var->ts, 1);
+
+ if (iter->start->expr_type == EXPR_CONSTANT
+ && iter->end->expr_type == EXPR_CONSTANT
+@@ -8060,6 +8065,18 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target)
+ /* Mark this as an associate variable. */
+ sym->attr.associate_var = 1;
+
++ /* Fix up the type-spec for CHARACTER types. */
++ if (sym->ts.type == BT_CHARACTER && !sym->attr.select_type_temporary)
++ {
++ if (!sym->ts.u.cl)
++ sym->ts.u.cl = target->ts.u.cl;
++
++ if (!sym->ts.u.cl->length)
++ sym->ts.u.cl->length
++ = gfc_get_int_expr (gfc_default_integer_kind,
++ NULL, target->value.character.length);
++ }
++
+ /* If the target is a good class object, so is the associate variable. */
+ if (sym->ts.type == BT_CLASS && gfc_expr_attr (target).class_ok)
+ sym->attr.class_ok = 1;
+@@ -8752,7 +8769,7 @@ resolve_branch (gfc_st_label *label, gfc_code *code)
+ if (label->defined == ST_LABEL_UNKNOWN)
+ {
+ gfc_error ("Label %d referenced at %L is never defined", label->value,
+- &label->where);
++ &code->loc);
+ return;
+ }
+
+@@ -9117,16 +9134,15 @@ gfc_resolve_forall (gfc_code *code, gfc_namespace *ns, int forall_save)
+ static gfc_expr **var_expr;
+ static int total_var = 0;
+ static int nvar = 0;
+- int old_nvar, tmp;
++ int i, old_nvar, tmp;
+ gfc_forall_iterator *fa;
+- int i;
+
+ old_nvar = nvar;
+
+ /* Start to resolve a FORALL construct */
+ if (forall_save == 0)
+ {
+- /* Count the total number of FORALL index in the nested FORALL
++ /* Count the total number of FORALL indices in the nested FORALL
+ construct in order to allocate the VAR_EXPR with proper size. */
+ total_var = gfc_count_forall_iterators (code);
+
+@@ -9134,19 +9150,25 @@ gfc_resolve_forall (gfc_code *code, gfc_namespace *ns, int forall_save)
+ var_expr = XCNEWVEC (gfc_expr *, total_var);
+ }
+
+- /* The information about FORALL iterator, including FORALL index start, end
+- and stride. The FORALL index can not appear in start, end or stride. */
++ /* The information about FORALL iterator, including FORALL indices start, end
++ and stride. An outer FORALL indice cannot appear in start, end or stride. */
+ for (fa = code->ext.forall_iterator; fa; fa = fa->next)
+ {
++ /* Fortran 20008: C738 (R753). */
++ if (fa->var->ref && fa->var->ref->type == REF_ARRAY)
++ {
++ gfc_error ("FORALL index-name at %L must be a scalar variable "
++ "of type integer", &fa->var->where);
++ continue;
++ }
++
+ /* Check if any outer FORALL index name is the same as the current
+ one. */
+ for (i = 0; i < nvar; i++)
+ {
+ if (fa->var->symtree->n.sym == var_expr[i]->symtree->n.sym)
+- {
+- gfc_error ("An outer FORALL construct already has an index "
+- "with this name %L", &fa->var->where);
+- }
++ gfc_error ("An outer FORALL construct already has an index "
++ "with this name %L", &fa->var->where);
+ }
+
+ /* Record the current FORALL index. */
+@@ -11214,6 +11236,27 @@ resolve_fl_variable_derived (gfc_symbol *sym, int no_init_flag)
+ }
+
+
++/* F2008, C402 (R401): A colon shall not be used as a type-param-value
++ except in the declaration of an entity or component that has the POINTER
++ or ALLOCATABLE attribute. */
++
++static bool
++deferred_requirements (gfc_symbol *sym)
++{
++ if (sym->ts.deferred
++ && !(sym->attr.pointer
++ || sym->attr.allocatable
++ || sym->attr.omp_udr_artificial_var))
++ {
++ gfc_error ("Entity %qs at %L has a deferred type parameter and "
++ "requires either the POINTER or ALLOCATABLE attribute",
++ sym->name, &sym->declared_at);
++ return false;
++ }
++ return true;
++}
++
++
+ /* Resolve symbols with flavor variable. */
+
+ static bool
+@@ -11253,19 +11296,10 @@ resolve_fl_variable (gfc_symbol *sym, int mp_flag)
+ }
+
+ /* Constraints on deferred type parameter. */
+- if (sym->ts.deferred
+- && !(sym->attr.pointer
+- || sym->attr.allocatable
+- || sym->attr.omp_udr_artificial_var))
+- {
+- gfc_error ("Entity %qs at %L has a deferred type parameter and "
+- "requires either the pointer or allocatable attribute",
+- sym->name, &sym->declared_at);
+- specification_expr = saved_specification_expr;
+- return false;
+- }
++ if (!deferred_requirements (sym))
++ return false;
+
+- if (sym->ts.type == BT_CHARACTER)
++ if (sym->ts.type == BT_CHARACTER && !sym->attr.associate_var)
+ {
+ /* Make sure that character string variables with assumed length are
+ dummy arguments. */
+@@ -13214,6 +13248,10 @@ resolve_fl_parameter (gfc_symbol *sym)
+ return false;
+ }
+
++ /* Constraints on deferred type parameter. */
++ if (!deferred_requirements (sym))
++ return false;
++
+ /* Make sure a parameter that has been implicitly typed still
+ matches the implicit type, since PARAMETER statements can precede
+ IMPLICIT statements. */
+diff --git a/gcc/fortran/simplify.c b/gcc/fortran/simplify.c
+index e4df72c..39e1cb9 100644
+--- a/gcc/fortran/simplify.c
++++ b/gcc/fortran/simplify.c
+@@ -490,6 +490,8 @@ simplify_transformation_to_scalar (gfc_expr *result, gfc_expr *array, gfc_expr *
+ }
+
+ result = op (result, gfc_copy_expr (a));
++ if (!result)
++ return result;
+ }
+
+ return result;
+@@ -2284,7 +2286,7 @@ gfc_simplify_extends_type_of (gfc_expr *a, gfc_expr *mold)
+ if (UNLIMITED_POLY (a) || UNLIMITED_POLY (mold))
+ return NULL;
+
+- /* Return .false. if the dynamic type can never be the same. */
++ /* Return .false. if the dynamic type can never be an extension. */
+ if ((a->ts.type == BT_CLASS && mold->ts.type == BT_CLASS
+ && !gfc_type_is_extension_of
+ (mold->ts.u.derived->components->ts.u.derived,
+@@ -2294,18 +2296,19 @@ gfc_simplify_extends_type_of (gfc_expr *a, gfc_expr *mold)
+ mold->ts.u.derived->components->ts.u.derived))
+ || (a->ts.type == BT_DERIVED && mold->ts.type == BT_CLASS
+ && !gfc_type_is_extension_of
+- (a->ts.u.derived,
+- mold->ts.u.derived->components->ts.u.derived)
+- && !gfc_type_is_extension_of
+ (mold->ts.u.derived->components->ts.u.derived,
+ a->ts.u.derived))
+ || (a->ts.type == BT_CLASS && mold->ts.type == BT_DERIVED
+ && !gfc_type_is_extension_of
+ (mold->ts.u.derived,
+- a->ts.u.derived->components->ts.u.derived)))
++ a->ts.u.derived->components->ts.u.derived)
++ && !gfc_type_is_extension_of
++ (a->ts.u.derived->components->ts.u.derived,
++ mold->ts.u.derived)))
+ return gfc_get_logical_expr (gfc_default_logical_kind, &a->where, false);
+
+- if (mold->ts.type == BT_DERIVED
++ /* Return .true. if the dynamic type is guaranteed to be an extension. */
++ if (a->ts.type == BT_CLASS && mold->ts.type == BT_DERIVED
+ && gfc_type_is_extension_of (mold->ts.u.derived,
+ a->ts.u.derived->components->ts.u.derived))
+ return gfc_get_logical_expr (gfc_default_logical_kind, &a->where, true);
+@@ -3713,8 +3716,12 @@ gfc_simplify_len (gfc_expr *e, gfc_expr *kind)
+ }
+ else if (e->expr_type == EXPR_VARIABLE && e->ts.type == BT_CHARACTER
+ && e->symtree->n.sym
++ && e->symtree->n.sym->ts.type != BT_DERIVED
+ && e->symtree->n.sym->assoc && e->symtree->n.sym->assoc->target
+- && e->symtree->n.sym->assoc->target->ts.type == BT_DERIVED)
++ && e->symtree->n.sym->assoc->target->ts.type == BT_DERIVED
++ && e->symtree->n.sym->assoc->target->symtree->n.sym
++ && UNLIMITED_POLY (e->symtree->n.sym->assoc->target->symtree->n.sym))
++
+ /* The expression in assoc->target points to a ref to the _data component
+ of the unlimited polymorphic entity. To get the _len component the last
+ _data ref needs to be stripped and a ref to the _len component added. */
+diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
+index a40194f..f9855f6 100644
+--- a/gcc/fortran/trans-array.c
++++ b/gcc/fortran/trans-array.c
+@@ -5928,7 +5928,12 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc,
+ return;
+ }
+
++ loc.nextc = NULL;
+ gfc_save_backend_locus (&loc);
++ /* loc.nextc is not set by save_backend_locus but the location routines
++ depend on it. */
++ if (loc.nextc == NULL)
++ loc.nextc = loc.lb->line;
+ gfc_set_backend_locus (&sym->declared_at);
+
+ /* Descriptor type. */
+diff --git a/gcc/fortran/trans-common.c b/gcc/fortran/trans-common.c
+index 8064d89..f393419 100644
+--- a/gcc/fortran/trans-common.c
++++ b/gcc/fortran/trans-common.c
+@@ -810,13 +810,21 @@ element_number (gfc_array_ref *ar)
+ if (ar->dimen_type[i] != DIMEN_ELEMENT)
+ gfc_internal_error ("element_number(): Bad dimension type");
+
+- mpz_sub (n, *get_mpz (ar->start[i]), *get_mpz (as->lower[i]));
++ if (as && as->lower[i])
++ mpz_sub (n, *get_mpz (ar->start[i]), *get_mpz (as->lower[i]));
++ else
++ mpz_sub_ui (n, *get_mpz (ar->start[i]), 1);
+
+ mpz_mul (n, n, multiplier);
+ mpz_add (offset, offset, n);
+
+- mpz_sub (extent, *get_mpz (as->upper[i]), *get_mpz (as->lower[i]));
+- mpz_add_ui (extent, extent, 1);
++ if (as && as->upper[i] && as->lower[i])
++ {
++ mpz_sub (extent, *get_mpz (as->upper[i]), *get_mpz (as->lower[i]));
++ mpz_add_ui (extent, extent, 1);
++ }
++ else
++ mpz_set_ui (extent, 0);
+
+ if (mpz_sgn (extent) < 0)
+ mpz_set_ui (extent, 0);
+@@ -1239,8 +1247,12 @@ finish_equivalences (gfc_namespace *ns)
+ {
+ c = gfc_get_common_head ();
+ /* We've lost the real location, so use the location of the
+- enclosing procedure. */
+- c->where = ns->proc_name->declared_at;
++ enclosing procedure. If we're in a BLOCK DATA block, then
++ use the location in the sym_root. */
++ if (ns->proc_name)
++ c->where = ns->proc_name->declared_at;
++ else if (ns->is_block_data)
++ c->where = ns->sym_root->n.sym->declared_at;
+ strcpy (c->name, z->module);
+ }
+ else
+diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c
+index fb44fa1..d9bb0bc 100644
+--- a/gcc/fortran/trans-decl.c
++++ b/gcc/fortran/trans-decl.c
+@@ -3975,6 +3975,8 @@ gfc_trans_deferred_vars (gfc_symbol * proc_sym, gfc_wrapped_block * block)
+ else if (proc_sym->as)
+ {
+ tree result = TREE_VALUE (current_fake_result_decl);
++ gfc_save_backend_locus (&loc);
++ gfc_set_backend_locus (&proc_sym->declared_at);
+ gfc_trans_dummy_array_bias (proc_sym, result, block);
+
+ /* An automatic character length, pointer array result. */
+@@ -3984,8 +3986,6 @@ gfc_trans_deferred_vars (gfc_symbol * proc_sym, gfc_wrapped_block * block)
+ tmp = NULL;
+ if (proc_sym->ts.deferred)
+ {
+- gfc_save_backend_locus (&loc);
+- gfc_set_backend_locus (&proc_sym->declared_at);
+ gfc_start_block (&init);
+ tmp = gfc_null_and_pass_deferred_len (proc_sym, &init, &loc);
+ gfc_add_init_cleanup (block, gfc_finish_block (&init), tmp);
+@@ -5191,9 +5191,19 @@ generate_local_decl (gfc_symbol * sym)
+ }
+ else if (!sym->attr.use_assoc)
+ {
+- gfc_warning (OPT_Wunused_variable,
+- "Unused variable %qs declared at %L",
+- sym->name, &sym->declared_at);
++ /* Corner case: the symbol may be an entry point. At this point,
++ it may appear to be an unused variable. Suppress warning. */
++ bool enter = false;
++ gfc_entry_list *el;
++
++ for (el = sym->ns->entries; el; el=el->next)
++ if (strcmp(sym->name, el->sym->name) == 0)
++ enter = true;
++
++ if (!enter)
++ gfc_warning (OPT_Wunused_variable,
++ "Unused variable %qs declared at %L",
++ sym->name, &sym->declared_at);
+ if (sym->backend_decl != NULL_TREE)
+ TREE_NO_WARNING(sym->backend_decl) = 1;
+ }
+@@ -6068,7 +6078,7 @@ gfc_generate_function_code (gfc_namespace * ns)
+ function has already called cgraph_create_node, which also created
+ the cgraph node for this function. */
+ if (!has_coarray_vars || flag_coarray != GFC_FCOARRAY_LIB)
+- (void) cgraph_node::create (fndecl);
++ (void) cgraph_node::get_create (fndecl);
+ }
+ else
+ cgraph_node::finalize_function (fndecl, true);
+diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c
+index 6f0bf61..682fb0ec 100644
+--- a/gcc/fortran/trans-expr.c
++++ b/gcc/fortran/trans-expr.c
+@@ -7012,6 +7012,12 @@ gfc_trans_subcomponent_assign (tree dest, gfc_component * cm, gfc_expr * expr,
+ tmp = gfc_trans_alloc_subarray_assign (tmp, cm, expr);
+ gfc_add_expr_to_block (&block, tmp);
+ }
++ else if (init && cm->attr.allocatable && expr->expr_type == EXPR_NULL)
++ {
++ /* NULL initialization for allocatable components. */
++ gfc_add_modify (&block, dest, fold_convert (TREE_TYPE (dest),
++ null_pointer_node));
++ }
+ else if (init && (cm->attr.allocatable
+ || (cm->ts.type == BT_CLASS && CLASS_DATA (cm)->attr.allocatable
+ && expr->ts.type != BT_CLASS)))
+@@ -7158,7 +7164,6 @@ gfc_trans_structure_assign (tree dest, gfc_expr * expr, bool init)
+ {
+ gfc_se se, lse;
+
+- gcc_assert (cm->backend_decl == NULL);
+ gfc_init_se (&se, NULL);
+ gfc_init_se (&lse, NULL);
+ gfc_conv_expr (&se, gfc_constructor_first (expr->value.constructor)->expr);
+diff --git a/gcc/fortran/trans-openmp.c b/gcc/fortran/trans-openmp.c
+index a413ac9..970cd40 100644
+--- a/gcc/fortran/trans-openmp.c
++++ b/gcc/fortran/trans-openmp.c
+@@ -71,6 +71,7 @@ gfc_omp_privatize_by_reference (const_tree decl)
+ if (GFC_DECL_GET_SCALAR_POINTER (decl)
+ || GFC_DECL_GET_SCALAR_ALLOCATABLE (decl)
+ || GFC_DECL_CRAY_POINTEE (decl)
++ || GFC_DECL_ASSOCIATE_VAR_P (decl)
+ || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
+ return false;
+
+@@ -2180,6 +2181,8 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses,
+ tree decl = gfc_get_symbol_decl (n->sym);
+ if (gfc_omp_privatize_by_reference (decl))
+ decl = build_fold_indirect_ref (decl);
++ else if (DECL_P (decl))
++ TREE_ADDRESSABLE (decl) = 1;
+ if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (decl)))
+ {
+ tree type = TREE_TYPE (decl);
+diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c
+index 25c2a0c..4891201 100644
+--- a/gcc/fortran/trans-stmt.c
++++ b/gcc/fortran/trans-stmt.c
+@@ -5303,7 +5303,8 @@ gfc_trans_allocate (gfc_code * code)
+ stmtblock_t block;
+ stmtblock_t post;
+ tree nelems;
+- bool upoly_expr, tmp_expr3_len_flag = false, al_len_needs_set;
++ bool upoly_expr, tmp_expr3_len_flag = false, al_len_needs_set,
++ do_assign = true;
+ gfc_symtree *newsym = NULL;
+
+ if (!code->ext.alloc.list)
+@@ -5393,6 +5394,14 @@ gfc_trans_allocate (gfc_code * code)
+ expr3_len = se.string_length;
+ gfc_add_block_to_block (&block, &se.pre);
+ gfc_add_block_to_block (&post, &se.post);
++ /* Special case when string in expr3 is zero. */
++ if (code->expr3->ts.type == BT_CHARACTER
++ && integer_zerop (se.string_length))
++ {
++ expr3 = expr3_tmp = NULL_TREE;
++ expr3_len = integer_zero_node;
++ do_assign = false;
++ }
+ }
+ /* else expr3 = NULL_TREE set above. */
+ }
+@@ -5415,7 +5424,16 @@ gfc_trans_allocate (gfc_code * code)
+ gfc_add_block_to_block (&block, &se.pre);
+ gfc_add_block_to_block (&post, &se.post);
+
+- if (!VAR_P (se.expr))
++ /* Special case when string in expr3 is zero. */
++ if (code->expr3->ts.type == BT_CHARACTER
++ && integer_zerop (se.string_length))
++ {
++ gfc_init_se (&se, NULL);
++ expr3_len = integer_zero_node;
++ tmp = NULL_TREE;
++ do_assign = false;
++ }
++ else if (!VAR_P (se.expr))
+ {
+ tree var;
+
+@@ -5651,9 +5669,11 @@ gfc_trans_allocate (gfc_code * code)
+ tmp = gfc_get_char_type (code->ext.alloc.ts.kind);
+ tmp = TYPE_SIZE_UNIT (tmp);
+ tmp = fold_convert (TREE_TYPE (se_sz.expr), tmp);
++ gfc_add_block_to_block (&block, &se_sz.pre);
+ expr3_esize = fold_build2_loc (input_location, MULT_EXPR,
+ TREE_TYPE (se_sz.expr),
+ tmp, se_sz.expr);
++ expr3_esize = gfc_evaluate_now (expr3_esize, &block);
+ }
+ }
+
+@@ -5848,6 +5868,7 @@ gfc_trans_allocate (gfc_code * code)
+ source= or mold= expression. */
+ gfc_init_se (&se_sz, NULL);
+ gfc_conv_expr (&se_sz, code->ext.alloc.ts.u.cl->length);
++ gfc_add_block_to_block (&block, &se_sz.pre);
+ gfc_add_modify (&block, al_len,
+ fold_convert (TREE_TYPE (al_len),
+ se_sz.expr));
+@@ -5932,11 +5953,19 @@ gfc_trans_allocate (gfc_code * code)
+ specified by a type spec for deferred length character
+ arrays or unlimited polymorphic objects without a
+ source= or mold= expression. */
+- gfc_init_se (&se_sz, NULL);
+- gfc_conv_expr (&se_sz, code->ext.alloc.ts.u.cl->length);
+- gfc_add_modify (&block, al_len,
+- fold_convert (TREE_TYPE (al_len),
+- se_sz.expr));
++ if (expr3_esize == NULL_TREE || code->ext.alloc.ts.kind != 1)
++ {
++ gfc_init_se (&se_sz, NULL);
++ gfc_conv_expr (&se_sz, code->ext.alloc.ts.u.cl->length);
++ gfc_add_block_to_block (&block, &se_sz.pre);
++ gfc_add_modify (&block, al_len,
++ fold_convert (TREE_TYPE (al_len),
++ se_sz.expr));
++ }
++ else
++ gfc_add_modify (&block, al_len,
++ fold_convert (TREE_TYPE (al_len),
++ expr3_esize));
+ }
+ else
+ /* No length information needed, because type to allocate
+@@ -5945,7 +5974,7 @@ gfc_trans_allocate (gfc_code * code)
+ fold_convert (TREE_TYPE (al_len),
+ integer_zero_node));
+ }
+- if (code->expr3 && !code->expr3->mold)
++ if (code->expr3 && !code->expr3->mold && do_assign)
+ {
+ /* Initialization via SOURCE block
+ (or static default initializer). */
+diff --git a/gcc/fwprop.c b/gcc/fwprop.c
+index fc64ec9..bc837c4 100644
+--- a/gcc/fwprop.c
++++ b/gcc/fwprop.c
+@@ -1013,10 +1013,27 @@ try_fwprop_subst (df_ref use, rtx *loc, rtx new_rtx, rtx_insn *def_insn,
+ making a new one if one does not already exist. */
+ if (set_reg_equal)
+ {
+- if (dump_file)
+- fprintf (dump_file, " Setting REG_EQUAL note\n");
++ /* If there are any paradoxical SUBREGs, don't add REG_EQUAL note,
++ because the bits in there can be anything and so might not
++ match the REG_EQUAL note content. See PR70574. */
++ subrtx_var_iterator::array_type array;
++ FOR_EACH_SUBRTX_VAR (iter, array, *loc, NONCONST)
++ {
++ rtx x = *iter;
++ if (SUBREG_P (x) && paradoxical_subreg_p (x))
++ {
++ set_reg_equal = false;
++ break;
++ }
++ }
+
+- note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (new_rtx));
++ if (set_reg_equal)
++ {
++ if (dump_file)
++ fprintf (dump_file, " Setting REG_EQUAL note\n");
++
++ note = set_unique_reg_note (insn, REG_EQUAL, copy_rtx (new_rtx));
++ }
+ }
+ }
+
+@@ -1314,14 +1331,19 @@ forward_propagate_and_simplify (df_ref use, rtx_insn *def_insn, rtx def_set)
+ that isn't mentioned in USE_SET, as the note would be invalid
+ otherwise. We also don't want to install a note if we are merely
+ propagating a pseudo since verifying that this pseudo isn't dead
+- is a pain; moreover such a note won't help anything. */
++ is a pain; moreover such a note won't help anything.
++ If the use is a paradoxical subreg, make sure we don't add a
++ REG_EQUAL note for it, because it is not equivalent, it is one
++ possible value for it, but we can't rely on it holding that value.
++ See PR70574. */
+ set_reg_equal = (note == NULL_RTX
+ && REG_P (SET_DEST (use_set))
+ && !REG_P (src)
+ && !(GET_CODE (src) == SUBREG
+ && REG_P (SUBREG_REG (src)))
+ && !reg_mentioned_p (SET_DEST (use_set),
+- SET_SRC (use_set)));
++ SET_SRC (use_set))
++ && !paradoxical_subreg_p (DF_REF_REG (use)));
+ }
+
+ if (GET_MODE (*loc) == VOIDmode)
+diff --git a/gcc/gcc.c b/gcc/gcc.c
+index d956c36..64d2e34 100644
+--- a/gcc/gcc.c
++++ b/gcc/gcc.c
+@@ -5148,8 +5148,9 @@ do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
+ if (files_differ)
+ #endif
+ {
+- temp_filename = save_string (temp_filename,
+- temp_filename_length + 1);
++ temp_filename
++ = save_string (temp_filename,
++ temp_filename_length - 1);
+ obstack_grow (&obstack, temp_filename,
+ temp_filename_length);
+ arg_going = 1;
+diff --git a/gcc/gcov.c b/gcc/gcov.c
+index 796b1b9..ea2dbf4 100644
+--- a/gcc/gcov.c
++++ b/gcc/gcov.c
+@@ -725,7 +725,7 @@ process_file (const char *file_name)
+
+ fns = fn->next;
+ fn->next = NULL;
+- if (fn->counts)
++ if (fn->counts || no_data_file)
+ {
+ unsigned src = fn->src;
+ unsigned line = fn->line;
+diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
+index 78c50a9..7950cb6 100644
+--- a/gcc/gimple-fold.c
++++ b/gcc/gimple-fold.c
+@@ -948,21 +948,21 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
+ {
+ tree src_base, dest_base, fn;
+ HOST_WIDE_INT src_offset = 0, dest_offset = 0;
+- HOST_WIDE_INT size = -1;
+- HOST_WIDE_INT maxsize = -1;
++ HOST_WIDE_INT maxsize;
+
+ srcvar = TREE_OPERAND (src, 0);
+- src_base = get_ref_base_and_extent (srcvar, &src_offset,
+- &size, &maxsize);
++ src_base = get_addr_base_and_unit_offset (srcvar, &src_offset);
++ if (src_base == NULL)
++ src_base = srcvar;
+ destvar = TREE_OPERAND (dest, 0);
+- dest_base = get_ref_base_and_extent (destvar, &dest_offset,
+- &size, &maxsize);
++ dest_base = get_addr_base_and_unit_offset (destvar,
++ &dest_offset);
++ if (dest_base == NULL)
++ dest_base = destvar;
+ if (tree_fits_uhwi_p (len))
+ maxsize = tree_to_uhwi (len);
+ else
+ maxsize = -1;
+- src_offset /= BITS_PER_UNIT;
+- dest_offset /= BITS_PER_UNIT;
+ if (SSA_VAR_P (src_base)
+ && SSA_VAR_P (dest_base))
+ {
+diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
+index fef5905..4c4610e 100644
+--- a/gcc/gimple-ssa-strength-reduction.c
++++ b/gcc/gimple-ssa-strength-reduction.c
+@@ -1918,7 +1918,7 @@ replace_ref (tree *expr, slsr_cand_t c)
+ if (align < TYPE_ALIGN (acc_type))
+ acc_type = build_aligned_type (acc_type, align);
+
+- add_expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (c->base_expr),
++ add_expr = fold_build2 (POINTER_PLUS_EXPR, c->cand_type,
+ c->base_expr, c->stride);
+ mem_ref = fold_build2 (MEM_REF, acc_type, add_expr,
+ wide_int_to_tree (c->cand_type, c->index));
+@@ -2191,35 +2191,41 @@ create_add_on_incoming_edge (slsr_cand_t c, tree basis_name,
+ basis_type = TREE_TYPE (basis_name);
+ lhs = make_temp_ssa_name (basis_type, NULL, "slsr");
+
++ /* Occasionally people convert integers to pointers without a
++ cast, leading us into trouble if we aren't careful. */
++ enum tree_code plus_code
++ = POINTER_TYPE_P (basis_type) ? POINTER_PLUS_EXPR : PLUS_EXPR;
++
+ if (known_stride)
+ {
+ tree bump_tree;
+- enum tree_code code = PLUS_EXPR;
++ enum tree_code code = plus_code;
+ widest_int bump = increment * wi::to_widest (c->stride);
+- if (wi::neg_p (bump))
++ if (wi::neg_p (bump) && !POINTER_TYPE_P (basis_type))
+ {
+ code = MINUS_EXPR;
+ bump = -bump;
+ }
+
+- bump_tree = wide_int_to_tree (basis_type, bump);
++ tree stride_type = POINTER_TYPE_P (basis_type) ? sizetype : basis_type;
++ bump_tree = wide_int_to_tree (stride_type, bump);
+ new_stmt = gimple_build_assign (lhs, code, basis_name, bump_tree);
+ }
+ else
+ {
+ int i;
+- bool negate_incr = (!address_arithmetic_p && wi::neg_p (increment));
++ bool negate_incr = !POINTER_TYPE_P (basis_type) && wi::neg_p (increment);
+ i = incr_vec_index (negate_incr ? -increment : increment);
+ gcc_assert (i >= 0);
+
+ if (incr_vec[i].initializer)
+ {
+- enum tree_code code = negate_incr ? MINUS_EXPR : PLUS_EXPR;
++ enum tree_code code = negate_incr ? MINUS_EXPR : plus_code;
+ new_stmt = gimple_build_assign (lhs, code, basis_name,
+ incr_vec[i].initializer);
+ }
+ else if (increment == 1)
+- new_stmt = gimple_build_assign (lhs, PLUS_EXPR, basis_name, c->stride);
++ new_stmt = gimple_build_assign (lhs, plus_code, basis_name, c->stride);
+ else if (increment == -1)
+ new_stmt = gimple_build_assign (lhs, MINUS_EXPR, basis_name,
+ c->stride);
+@@ -2538,13 +2544,13 @@ record_increment (slsr_cand_t c, widest_int increment, bool is_phi_adjust)
+ /* Optimistically record the first occurrence of this increment
+ as providing an initializer (if it does); we will revise this
+ opinion later if it doesn't dominate all other occurrences.
+- Exception: increments of -1, 0, 1 never need initializers;
++ Exception: increments of 0, 1 never need initializers;
+ and phi adjustments don't ever provide initializers. */
+ if (c->kind == CAND_ADD
+ && !is_phi_adjust
+ && c->index == increment
+ && (wi::gts_p (increment, 1)
+- || wi::lts_p (increment, -1))
++ || wi::lts_p (increment, 0))
+ && (gimple_assign_rhs_code (c->cand_stmt) == PLUS_EXPR
+ || gimple_assign_rhs_code (c->cand_stmt) == POINTER_PLUS_EXPR))
+ {
+@@ -2854,10 +2860,9 @@ analyze_increments (slsr_cand_t first_dep, machine_mode mode, bool speed)
+ else if (incr == 0
+ || incr == 1
+ || (incr == -1
+- && (gimple_assign_rhs_code (first_dep->cand_stmt)
+- != POINTER_PLUS_EXPR)))
++ && !POINTER_TYPE_P (first_dep->cand_type)))
+ incr_vec[i].cost = COST_NEUTRAL;
+-
++
+ /* FORNOW: If we need to add an initializer, give up if a cast from
+ the candidate's type to its stride's type can lose precision.
+ This could eventually be handled better by expressly retaining the
+@@ -3144,7 +3149,7 @@ insert_initializers (slsr_cand_t c)
+ if (!profitable_increment_p (i)
+ || incr == 1
+ || (incr == -1
+- && gimple_assign_rhs_code (c->cand_stmt) != POINTER_PLUS_EXPR)
++ && (!POINTER_TYPE_P (lookup_cand (c->basis)->cand_type)))
+ || incr == 0)
+ continue;
+
+diff --git a/gcc/gimplify.c b/gcc/gimplify.c
+index 250d660..c571c66 100644
+--- a/gcc/gimplify.c
++++ b/gcc/gimplify.c
+@@ -4095,7 +4095,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
+ }
+
+ /* Vector types use CONSTRUCTOR all the way through gimple
+- compilation as a general initializer. */
++ compilation as a general initializer. */
+ FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
+ {
+ enum gimplify_status tret;
+@@ -4103,6 +4103,10 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
+ fb_rvalue);
+ if (tret == GS_ERROR)
+ ret = GS_ERROR;
++ else if (TREE_STATIC (ctor)
++ && !initializer_constant_valid_p (ce->value,
++ TREE_TYPE (ce->value)))
++ TREE_STATIC (ctor) = 0;
+ }
+ if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
+ TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
+@@ -4116,24 +4120,23 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
+
+ if (ret == GS_ERROR)
+ return GS_ERROR;
+- else if (want_value)
++ /* If we have gimplified both sides of the initializer but have
++ not emitted an assignment, do so now. */
++ if (*expr_p)
++ {
++ tree lhs = TREE_OPERAND (*expr_p, 0);
++ tree rhs = TREE_OPERAND (*expr_p, 1);
++ gassign *init = gimple_build_assign (lhs, rhs);
++ gimplify_seq_add_stmt (pre_p, init);
++ }
++ if (want_value)
+ {
+ *expr_p = object;
+ return GS_OK;
+ }
+ else
+ {
+- /* If we have gimplified both sides of the initializer but have
+- not emitted an assignment, do so now. */
+- if (*expr_p)
+- {
+- tree lhs = TREE_OPERAND (*expr_p, 0);
+- tree rhs = TREE_OPERAND (*expr_p, 1);
+- gassign *init = gimple_build_assign (lhs, rhs);
+- gimplify_seq_add_stmt (pre_p, init);
+- *expr_p = NULL;
+- }
+-
++ *expr_p = NULL;
+ return GS_ALL_DONE;
+ }
+ }
+diff --git a/gcc/incpath.c b/gcc/incpath.c
+index 6c54ca6..f0ae7d8 100644
+--- a/gcc/incpath.c
++++ b/gcc/incpath.c
+@@ -255,8 +255,9 @@ remove_duplicates (cpp_reader *pfile, struct cpp_dir *head,
+
+ if (stat (cur->name, &st))
+ {
+- /* Dirs that don't exist are silently ignored, unless verbose. */
+- if (errno != ENOENT)
++ /* Dirs that don't exist or have denied permissions are
++ silently ignored, unless verbose. */
++ if ((errno != ENOENT) && (errno != EPERM))
+ cpp_errno (pfile, CPP_DL_ERROR, cur->name);
+ else
+ {
+diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c
+index 729bc06..216e4ed 100644
+--- a/gcc/ipa-icf.c
++++ b/gcc/ipa-icf.c
+@@ -172,16 +172,13 @@ symbol_compare_collection::symbol_compare_collection (symtab_node *node)
+
+ /* Constructor for key value pair, where _ITEM is key and _INDEX is a target. */
+
+-sem_usage_pair::sem_usage_pair (sem_item *_item, unsigned int _index):
+- item (_item), index (_index)
++sem_usage_pair::sem_usage_pair (sem_item *_item, unsigned int _index)
++: item (_item), index (_index)
+ {
+ }
+
+-/* Semantic item constructor for a node of _TYPE, where STACK is used
+- for bitmap memory allocation. */
+-
+-sem_item::sem_item (sem_item_type _type,
+- bitmap_obstack *stack): type(_type), hash(0)
++sem_item::sem_item (sem_item_type _type, bitmap_obstack *stack)
++: type(_type), hash(-1), m_hash_set (false)
+ {
+ setup (stack);
+ }
+@@ -191,8 +188,8 @@ sem_item::sem_item (sem_item_type _type,
+ with computed _HASH. */
+
+ sem_item::sem_item (sem_item_type _type, symtab_node *_node,
+- hashval_t _hash, bitmap_obstack *stack): type(_type),
+- node (_node), hash (_hash)
++ bitmap_obstack *stack)
++: type(_type), node (_node), hash (-1), m_hash_set (false)
+ {
+ decl = node->decl;
+ setup (stack);
+@@ -268,6 +265,12 @@ sem_item::target_supports_symbol_aliases_p (void)
+ #endif
+ }
+
++void sem_item::set_hash (hashval_t h)
++{
++ hash = h;
++ m_hash_set = true;
++}
++
+ /* Semantic function constructor that uses STACK as bitmap memory stack. */
+
+ sem_function::sem_function (bitmap_obstack *stack): sem_item (FUNC, stack),
+@@ -277,12 +280,8 @@ sem_function::sem_function (bitmap_obstack *stack): sem_item (FUNC, stack),
+ bb_sorted.create (0);
+ }
+
+-/* Constructor based on callgraph node _NODE with computed hash _HASH.
+- Bitmap STACK is used for memory allocation. */
+-sem_function::sem_function (cgraph_node *node, hashval_t hash,
+- bitmap_obstack *stack):
+- sem_item (FUNC, node, hash, stack),
+- m_checker (NULL), m_compared_func (NULL)
++sem_function::sem_function (cgraph_node *node, bitmap_obstack *stack)
++: sem_item (FUNC, node, stack), m_checker (NULL), m_compared_func (NULL)
+ {
+ bb_sizes.create (0);
+ bb_sorted.create (0);
+@@ -315,7 +314,7 @@ sem_function::get_bb_hash (const sem_bb *basic_block)
+ hashval_t
+ sem_function::get_hash (void)
+ {
+- if(!hash)
++ if(!m_hash_set)
+ {
+ inchash::hash hstate;
+ hstate.add_int (177454); /* Random number for function type. */
+@@ -345,7 +344,7 @@ sem_function::get_hash (void)
+ hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (decl));
+ hstate.add_flag (DECL_CXX_DESTRUCTOR_P (decl));
+
+- hash = hstate.end ();
++ set_hash (hstate.end ());
+ }
+
+ return hash;
+@@ -1533,7 +1532,7 @@ sem_function::parse (cgraph_node *node, bitmap_obstack *stack)
+ || DECL_STATIC_DESTRUCTOR (node->decl))
+ return NULL;
+
+- sem_function *f = new sem_function (node, 0, stack);
++ sem_function *f = new sem_function (node, stack);
+
+ f->init ();
+
+@@ -1637,19 +1636,12 @@ sem_function::bb_dict_test (vec<int> *bb_dict, int source, int target)
+ return (*bb_dict)[source] == target;
+ }
+
+-
+-/* Semantic variable constructor that uses STACK as bitmap memory stack. */
+-
+ sem_variable::sem_variable (bitmap_obstack *stack): sem_item (VAR, stack)
+ {
+ }
+
+-/* Constructor based on varpool node _NODE with computed hash _HASH.
+- Bitmap STACK is used for memory allocation. */
+-
+-sem_variable::sem_variable (varpool_node *node, hashval_t _hash,
+- bitmap_obstack *stack): sem_item(VAR,
+- node, _hash, stack)
++sem_variable::sem_variable (varpool_node *node, bitmap_obstack *stack)
++: sem_item (VAR, node, stack)
+ {
+ gcc_checking_assert (node);
+ gcc_checking_assert (get_node ());
+@@ -1947,7 +1939,7 @@ sem_variable::parse (varpool_node *node, bitmap_obstack *stack)
+ || node->alias)
+ return NULL;
+
+- sem_variable *v = new sem_variable (node, 0, stack);
++ sem_variable *v = new sem_variable (node, stack);
+
+ v->init ();
+
+@@ -1959,7 +1951,7 @@ sem_variable::parse (varpool_node *node, bitmap_obstack *stack)
+ hashval_t
+ sem_variable::get_hash (void)
+ {
+- if (hash)
++ if (m_hash_set)
+ return hash;
+
+ /* All WPA streamed in symbols should have their hashes computed at compile
+@@ -1973,7 +1965,7 @@ sem_variable::get_hash (void)
+ if (DECL_SIZE (decl) && tree_fits_shwi_p (DECL_SIZE (decl)))
+ hstate.add_wide_int (tree_to_shwi (DECL_SIZE (decl)));
+ add_expr (ctor, hstate);
+- hash = hstate.end ();
++ set_hash (hstate.end ());
+
+ return hash;
+ }
+@@ -2114,8 +2106,9 @@ sem_variable::dump_to_file (FILE *file)
+
+ unsigned int sem_item_optimizer::class_id = 0;
+
+-sem_item_optimizer::sem_item_optimizer (): worklist (0), m_classes (0),
+- m_classes_count (0), m_cgraph_node_hooks (NULL), m_varpool_node_hooks (NULL)
++sem_item_optimizer::sem_item_optimizer ()
++: worklist (0), m_classes (0), m_classes_count (0), m_cgraph_node_hooks (NULL),
++ m_varpool_node_hooks (NULL)
+ {
+ m_items.create (0);
+ bitmap_obstack_initialize (&m_bmstack);
+@@ -2235,13 +2228,17 @@ sem_item_optimizer::read_section (lto_file_decl_data *file_data,
+ {
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
+
+- m_items.safe_push (new sem_function (cnode, hash, &m_bmstack));
++ sem_function *fn = new sem_function (cnode, &m_bmstack);
++ fn->set_hash (hash);
++ m_items.safe_push (fn);
+ }
+ else
+ {
+ varpool_node *vnode = dyn_cast <varpool_node *> (node);
+
+- m_items.safe_push (new sem_variable (vnode, hash, &m_bmstack));
++ sem_variable *var = new sem_variable (vnode, &m_bmstack);
++ var->set_hash (hash);
++ m_items.safe_push (var);
+ }
+ }
+
+@@ -2552,7 +2549,7 @@ sem_item_optimizer::update_hash_by_addr_refs ()
+ {
+ tree class_type
+ = method_class_type (TREE_TYPE (m_items[i]->decl));
+- inchash::hash hstate (m_items[i]->hash);
++ inchash::hash hstate (m_items[i]->get_hash ());
+
+ if (TYPE_NAME (class_type)
+ && DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (class_type)))
+@@ -2560,7 +2557,7 @@ sem_item_optimizer::update_hash_by_addr_refs ()
+ (IDENTIFIER_HASH_VALUE
+ (DECL_ASSEMBLER_NAME (TYPE_NAME (class_type))));
+
+- m_items[i]->hash = hstate.end ();
++ m_items[i]->set_hash (hstate.end ());
+ }
+ }
+ }
+@@ -2574,7 +2571,7 @@ sem_item_optimizer::update_hash_by_addr_refs ()
+
+ /* Global hash value replace current hash values. */
+ for (unsigned i = 0; i < m_items.length (); i++)
+- m_items[i]->hash = m_items[i]->global_hash;
++ m_items[i]->set_hash (m_items[i]->global_hash);
+ }
+
+ /* Congruence classes are built by hash value. */
+@@ -2586,7 +2583,7 @@ sem_item_optimizer::build_hash_based_classes (void)
+ {
+ sem_item *item = m_items[i];
+
+- congruence_class_group *group = get_group_by_hash (item->hash,
++ congruence_class_group *group = get_group_by_hash (item->get_hash (),
+ item->type);
+
+ if (!group->classes.length ())
+diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h
+index 98a3d4a..7c476fc 100644
+--- a/gcc/ipa-icf.h
++++ b/gcc/ipa-icf.h
+@@ -152,10 +152,8 @@ public:
+ sem_item (sem_item_type _type, bitmap_obstack *stack);
+
+ /* Semantic item constructor for a node of _TYPE, where STACK is used
+- for bitmap memory allocation. The item is based on symtab node _NODE
+- with computed _HASH. */
+- sem_item (sem_item_type _type, symtab_node *_node, hashval_t _hash,
+- bitmap_obstack *stack);
++ for bitmap memory allocation. The item is based on symtab node _NODE. */
++ sem_item (sem_item_type _type, symtab_node *_node, bitmap_obstack *stack);
+
+ virtual ~sem_item ();
+
+@@ -182,6 +180,9 @@ public:
+ /* References independent hash function. */
+ virtual hashval_t get_hash (void) = 0;
+
++ /* Set new hash value of the item. */
++ void set_hash (hashval_t hash);
++
+ /* Merges instance with an ALIAS_ITEM, where alias, thunk or redirection can
+ be applied. */
+ virtual bool merge (sem_item *alias_item) = 0;
+@@ -235,9 +236,6 @@ public:
+ /* A set with symbol table references. */
+ hash_set <symtab_node *> refs_set;
+
+- /* Hash of item. */
+- hashval_t hash;
+-
+ /* Temporary hash used where hash values of references are added. */
+ hashval_t global_hash;
+ protected:
+@@ -256,6 +254,12 @@ protected:
+ symtab_node *n1, symtab_node *n2,
+ bool address);
+
++ /* Hash of item. */
++ hashval_t hash;
++
++ /* Indicated whether a hash value has been set or not. */
++ bool m_hash_set;
++
+ private:
+ /* Initialize internal data structures. Bitmap STACK is used for
+ bitmap memory allocation process. */
+@@ -268,9 +272,9 @@ public:
+ /* Semantic function constructor that uses STACK as bitmap memory stack. */
+ sem_function (bitmap_obstack *stack);
+
+- /* Constructor based on callgraph node _NODE with computed hash _HASH.
++ /* Constructor based on callgraph node _NODE.
+ Bitmap STACK is used for memory allocation. */
+- sem_function (cgraph_node *_node, hashval_t _hash, bitmap_obstack *stack);
++ sem_function (cgraph_node *_node, bitmap_obstack *stack);
+
+ ~sem_function ();
+
+@@ -377,10 +381,10 @@ public:
+ /* Semantic variable constructor that uses STACK as bitmap memory stack. */
+ sem_variable (bitmap_obstack *stack);
+
+- /* Constructor based on callgraph node _NODE with computed hash _HASH.
++ /* Constructor based on callgraph node _NODE.
+ Bitmap STACK is used for memory allocation. */
+
+- sem_variable (varpool_node *_node, hashval_t _hash, bitmap_obstack *stack);
++ sem_variable (varpool_node *_node, bitmap_obstack *stack);
+
+ inline virtual void init_wpa (void) {}
+
+diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
+index a4cdae9..8bfc649 100644
+--- a/gcc/ipa-pure-const.c
++++ b/gcc/ipa-pure-const.c
+@@ -1961,10 +1961,25 @@ pass_nothrow::execute (function *)
+ }
+
+ node->set_nothrow_flag (true);
++
++ bool cfg_changed = false;
++ if (self_recursive_p (node))
++ FOR_EACH_BB_FN (this_block, cfun)
++ if (gimple g = last_stmt (this_block))
++ if (is_gimple_call (g))
++ {
++ tree callee_t = gimple_call_fndecl (g);
++ if (callee_t
++ && recursive_call_p (current_function_decl, callee_t)
++ && maybe_clean_eh_stmt (g)
++ && gimple_purge_dead_eh_edges (this_block))
++ cfg_changed = true;
++ }
++
+ if (dump_file)
+ fprintf (dump_file, "Function found to be nothrow: %s\n",
+ current_function_name ());
+- return 0;
++ return cfg_changed ? TODO_cleanup_cfg : 0;
+ }
+
+ } // anon namespace
+diff --git a/gcc/ira-build.c b/gcc/ira-build.c
+index 189f340..c278da4 100644
+--- a/gcc/ira-build.c
++++ b/gcc/ira-build.c
+@@ -2291,7 +2291,7 @@ mark_loops_for_removal (void)
+ );
+ }
+ qsort (sorted_loops, n, sizeof (ira_loop_tree_node_t), loop_compare_func);
+- for (i = 0; n - i + 1 > IRA_MAX_LOOPS_NUM; i++)
++ for (i = 0; i < n - IRA_MAX_LOOPS_NUM; i++)
+ {
+ sorted_loops[i]->to_remove_p = true;
+ if (internal_flag_ira_verbose > 1 && ira_dump_file != NULL)
+diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c
+index 81d3208..0a6e501 100644
+--- a/gcc/ira-lives.c
++++ b/gcc/ira-lives.c
+@@ -1042,7 +1042,7 @@ find_call_crossed_cheap_reg (rtx_insn *insn)
+ break;
+ }
+
+- if (reg_overlap_mentioned_p (reg, PATTERN (prev)))
++ if (reg_set_p (reg, prev))
+ break;
+ }
+ prev = PREV_INSN (prev);
+diff --git a/gcc/match.pd b/gcc/match.pd
+index 405fec6..251f2ad 100644
+--- a/gcc/match.pd
++++ b/gcc/match.pd
+@@ -370,12 +370,16 @@ along with GCC; see the file COPYING3. If not see
+ (ne (bit_and:c (bit_not @0) @1) integer_zerop)
+ (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
+- (lt @0 @1)))
++ (if (TYPE_UNSIGNED (TREE_TYPE (@1)))
++ (lt @0 @1))
++ (gt @0 @1)))
+ (simplify
+ (ne (bit_ior:c (bit_not @0) @1) integer_zerop)
+ (if (INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ && TYPE_PRECISION (TREE_TYPE (@1)) == 1)
+- (le @0 @1)))
++ (if (TYPE_UNSIGNED (TREE_TYPE (@1)))
++ (le @0 @1))
++ (ge @0 @1)))
+
+ /* ~~x -> x */
+ (simplify
+@@ -750,7 +754,8 @@ along with GCC; see the file COPYING3. If not see
+
+ /* A truncation to an unsigned type (a zero-extension) should be
+ canonicalized as bitwise and of a mask. */
+- (if (final_int && inter_int && inside_int
++ (if (GIMPLE /* PR70366: doing this in GENERIC breaks -Wconversion. */
++ && final_int && inter_int && inside_int
+ && final_prec == inside_prec
+ && final_prec > inter_prec
+ && inter_unsignedp)
+diff --git a/gcc/omp-low.c b/gcc/omp-low.c
+index 3f08b72..55afc60 100644
+--- a/gcc/omp-low.c
++++ b/gcc/omp-low.c
+@@ -9123,9 +9123,15 @@ expand_omp_target (struct omp_region *region)
+ make_edge (else_bb, new_bb, EDGE_FALLTHRU);
+
+ device = tmp_var;
++ gsi = gsi_last_bb (new_bb);
++ }
++ else
++ {
++ gsi = gsi_last_bb (new_bb);
++ device = force_gimple_operand_gsi (&gsi, device, true, NULL_TREE,
++ true, GSI_SAME_STMT);
+ }
+
+- gsi = gsi_last_bb (new_bb);
+ t = gimple_omp_target_data_arg (entry_stmt);
+ if (t == NULL)
+ {
+diff --git a/gcc/ree.c b/gcc/ree.c
+index 48765b6..69dfe90 100644
+--- a/gcc/ree.c
++++ b/gcc/ree.c
+@@ -529,6 +529,14 @@ get_defs (rtx_insn *insn, rtx reg, vec<rtx_insn *> *dest)
+ return NULL;
+ if (DF_REF_INSN_INFO (ref_link->ref) == NULL)
+ return NULL;
++ /* As global regs are assumed to be defined at each function call
++ dataflow can report a call_insn as being a definition of REG.
++ But we can't do anything with that in this pass so proceed only
++ if the instruction really sets REG in a way that can be deduced
++ from the RTL structure. */
++ if (global_regs[REGNO (reg)]
++ && !set_of (reg, DF_REF_INSN (ref_link->ref)))
++ return NULL;
+ }
+
+ if (dest)
+@@ -627,7 +635,7 @@ make_defs_and_copies_lists (rtx_insn *extend_insn, const_rtx set_pat,
+
+ /* Initialize the work list. */
+ if (!get_defs (extend_insn, src_reg, &state->work_list))
+- gcc_unreachable ();
++ return false;
+
+ is_insn_visited = XCNEWVEC (bool, max_insn_uid);
+
+diff --git a/gcc/rtl.h b/gcc/rtl.h
+index 22e50f3..fb216b6 100644
+--- a/gcc/rtl.h
++++ b/gcc/rtl.h
+@@ -2609,6 +2609,8 @@ extern unsigned int subreg_highpart_offset (machine_mode,
+ machine_mode);
+ extern int byte_lowpart_offset (machine_mode, machine_mode);
+ extern rtx make_safe_from (rtx, rtx);
++extern rtx convert_memory_address_addr_space_1 (machine_mode, rtx,
++ addr_space_t, bool, bool);
+ extern rtx convert_memory_address_addr_space (machine_mode, rtx,
+ addr_space_t);
+ #define convert_memory_address(to_mode,x) \
+diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
+index cdad71f..c85ae3e 100644
+--- a/gcc/simplify-rtx.c
++++ b/gcc/simplify-rtx.c
+@@ -1438,7 +1438,14 @@ simplify_unary_operation_1 (enum rtx_code code, machine_mode mode, rtx op)
+ && REG_P (SUBREG_REG (op))
+ && REG_POINTER (SUBREG_REG (op))
+ && GET_MODE (SUBREG_REG (op)) == Pmode)))
+- return convert_memory_address (Pmode, op);
++ {
++ temp
++ = convert_memory_address_addr_space_1 (Pmode, op,
++ ADDR_SPACE_GENERIC, false,
++ true);
++ if (temp)
++ return temp;
++ }
+ #endif
+ break;
+
+@@ -1559,7 +1566,14 @@ simplify_unary_operation_1 (enum rtx_code code, machine_mode mode, rtx op)
+ && REG_P (SUBREG_REG (op))
+ && REG_POINTER (SUBREG_REG (op))
+ && GET_MODE (SUBREG_REG (op)) == Pmode)))
+- return convert_memory_address (Pmode, op);
++ {
++ temp
++ = convert_memory_address_addr_space_1 (Pmode, op,
++ ADDR_SPACE_GENERIC, false,
++ true);
++ if (temp)
++ return temp;
++ }
+ #endif
+ break;
+
+diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
+index 64e7f75..beac229 100644
+--- a/gcc/testsuite/ChangeLog
++++ b/gcc/testsuite/ChangeLog
+@@ -1,3 +1,785 @@
++2016-12-22 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78239
++ * gfortran.dg/fimplicit_none_1.f90: New test.
++ * gfortran.dg/fimplicit_none_2.f90: New test.
++
++2016-12-14 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/78731
++ * gcc.dg/torture/pr78731.c: New testcase.
++
++2016-12-14 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-25 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ PR tree-optimization/77673
++ * gcc.dg/pr77673.c: New test.
++
++2016-12-13 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-17 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ PR target/77933
++ * gcc.target/arm/pr77933-1.c: New test.
++ * gcc.target/arm/pr77933-2.c: Likewise.
++
++2016-12-12 Bernd Schmidt <bschmidt@redhat.com>
++
++ Backport from mainline
++ 2016-11-07 Bernd Schmidt <bschmidt@redhat.com>
++
++ PR rtl-optimization/77309
++ * gcc.dg/torture/pr77309.c: New test.
++
++2016-12-08 Nathan Sidwell <nathan@acm.org>
++
++ PR c++/78551
++ * g++.dg/cpp1y/pr78551.C: New.
++
++2016-12-07 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ Backport from mainline
++ 2016-11-16 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ * gcc.target/arm/empty_fiq_handler.c: New test.
++
++ Backport from mainline
++ 2016-11-21 Thomas Preud'homme <thomas.preudhomme@arm.com>
++
++ * gcc.target/arm/empty_fiq_handler.c: Skip if -mthumb is passed in and
++ target is Thumb-only.
++
++2016-12-04 Janus Weil <janus@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78443
++ * gfortran.dg/typebound_proc_35.f90: New test case.
++
++2016-12-02 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-10-21 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR rtl-optimization/78038
++ * gcc.target/aarch64/pr78038.c: New test.
++
++2016-12-02 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-12-02 Andreas Krebbel <krebbel@linux.vnet.ibm.com>
++
++ * gcc.target/s390/vector/vec-scalar-cmp-1.c: Fix and harden the
++ pattern checks.
++ * gcc.target/s390/zvector/vec-cmp-1.c: New test.
++
++2016-12-01 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78279
++ * gfortran.dg/pr78279.f90: New test.
++
++2016-11-24 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78500
++ * gfortran.dg/class_result_4.f90: New test.
++
++2016-11-23 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/78297
++ * gfortran.dg/pr78297.f90: New test.
++
++2016-11-23 Janus Weil <janus@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/66227
++ * gfortran.dg/extends_type_of_3.f90: Fix and extend the test case.
++
++2016-11-20 Harald Anlauf <anlauf@gmx.de>
++
++ PR fortran/69741
++ * gfortran.dg/forall_18.f90: New testcase.
++
++2016-11-11 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/78310
++ * gcc.target/i386/pr78310.c: New test.
++
++2016-11-09 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/78262
++ * gcc.target/i386/pr78262.c: New test.
++
++2016-11-06 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/69544
++ PR fortran/78178
++ * gfortran.dg/where_5.f90: New test.
++ * gfortran.dg/where_6.f90: New test.
++
++2016-11-05 Martin Sebor <msebor@redhat.com>
++
++ Backport from trunk.
++ PR c/71115
++ * gcc.dg/init-excess-2.c: New test.
++ * gcc.dg/Woverride-init-1.c: Adjust.
++ * gcc.dg/Woverride-init-2.c: Same.
++
++2016-11-03 Martin Liska <mliska@suse.cz>
++
++ Backport from mainline
++ 2016-08-12 Martin Liska <mliska@suse.cz>
++
++ * g++.dg/gcov/gcov-16.C: New test.
++ * lib/gcov.exp: Support new argument for run-gcov function.
++
++2016-11-02 Will Schmidt <will_schmidt@vnet.ibm.com>
++
++ Backport from trunk
++ 2016-10-26 Will Schmidt <will_schmidt@vnet.ibm.com>
++
++ PR middle-end/72747
++ * c-c++-common/pr72747-1.c: New test.
++ * c-c++-common/pr72747-2.c: Likewise.
++
++2016-11-02 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ * lib/target-supports.exp (check_gc_sections_available): Use
++ -print-prog-name=ld to determine linker used.
++
++2016-10-31 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71902
++ * gfortran.dg/dependency_47.f90: New test.
++ * gfortran.dg/dependency_49.f90: New test.
++
++2016-10-31 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78123
++ * gfortran.dg/fmt_t_9.f: New test.
++
++2016-10-24 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/78021
++ * gfortran.dg/string_length_3.f90: New test.
++
++2016-10-24 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ PR fortran/71895
++ * gfortran.dg/pr71895.f90: New test.
++
++2016-10-24 Paul Thomas <pault@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/61420
++ PR fortran/78013
++ * gfortran.dg/proc_ptr_49.f90: New test.
++
++2016-10-23 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-10-17 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR tree-optimization/77916
++ * gcc.dg/torture/pr77916.c: New.
++
++2016-10-19 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/77991
++ * gcc.target/i386/pr77991.c: New test.
++
++2016-10-17 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/77978
++ * gfortran.dg/pr77978_1.f90: New test.
++ * gfortran.dg/pr77978_2.f90: Ditto.
++ * gfortran.dg/pr77978_3.f90: Ditto.
++
++2016-10-17 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-10-13 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR tree-optimization/77937
++ * gcc.dg/torture/pr77937-1.c: New.
++ * gcc.dg/torture/pr77937-2.c: New.
++
++2016-10-17 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-10-13 Martin Liska <mliska@suse.cz>
++
++ PR tree-optimization/77943
++ * g++.dg/tree-ssa/pr77943.C: New test.
++
++2016-10-15 Eric Botcazou <ebotcazou@adacore.com>
++
++ * gcc.target/sparc/bmaskbshuf.c: Rename to...
++ * gcc.target/sparc/bmaskbshuf-1.c: ...this.
++ * gcc.target/sparc/bmaskbshuf-2.c: New test.
++
++2016-10-13 Andrew Senkevich <andrew.senkevich@intel.com>
++
++ Backport from trunk
++ * gcc.target/i386/pcommit-1.c: Deleted test.
++ * gcc.target/i386/sse-12.c: Deleted -pcommit option.
++ * gcc.target/i386/sse-13.c: Ditto.
++ * gcc.target/i386/sse-14.c: Ditto.
++ * gcc.target/i386/sse-22.c: Ditto.
++ * gcc.target/i386/sse-23.c: Ditto.
++ * g++.dg/other/i386-2.C: Ditto.
++ * g++.dg/other/i386-3.C: Ditto.
++
++2016-10-10 Eric Botcazou <ebotcazou@adacore.com>
++
++ * gnat.dg/biased_subtype.adb: New test.
++
++2016-10-05 Steven G. Kargl <kargls@gcc.gnu.org>
++
++ PR fortran/58991
++ PR fortran/58992
++ * gfortran.dg/associate_22.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77391
++ * gfortran.dg/pr77391.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77380
++ * gfortran.dg/pr77380.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/61318
++ * gfortran.dg/pr61318.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/71859
++ * check.c(numeric_check): Prevent ICE. Issue error for invalid
++ subroutine as an actual argument when numeric argument is expected.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/69867
++ * gfortran.dg/pr69867.f90: New test.
++
++ PR fortran/69962
++ * gfortran.dg/pr69962.f90: New test.
++
++2016-09-30 Steven g. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77351
++ * gfortran.dg/pr77351.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/68566
++ * gfortran.dg/pr68566.f90: new test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/71799
++ * gfortran.dg/pr71799.f90: New test.
++
++2016-09-30 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/70006
++ * gfortran.dg/pr70006.f90: New test.
++
++2016-09-29 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk
++ PR libgfortran/77707
++ * gfortran.dg/inquire_17.f90: New test.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++
++ PR fortran/77420
++ * gfortran.dg/pr77420_1.f90: New test.
++ * gfortran.dg/pr77420_2.f90: Ditto.
++ * gfortran.dg/pr77420_3.f90: New test. Requires ...
++ * gfortran.dg/pr77420_4.f90: this file.
++
++ PR fortran/77460
++ * gfortran.dg/pr77460.f90: New test.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/77506
++ * gfortran.dg/pr77506.f90: New test.
++
++ PR fortran/77507
++ * gfortran.dg/pr77507.f90: New test.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71067
++ * gfortran.dg/pr71067_1.f90: New test.
++ * gfortran.dg/pr71067_2.f90: Ditto.
++
++ PR fortran/77260
++ * gfortran.dg/pr77260_1.f90: New test.
++ * gfortran.dg/pr77260_2.f90: Ditto.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++ Louis Krupp <lkrupp@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/69514
++ * gfortran.dg/pr69514_1.f90: New test.
++ * gfortran.dg/pr69514_2.f90: New test.
++
++2016-09-28 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ backport from trunk
++ PR fortran/71730
++ * gfortran.dg/pr71730.f90: New test.
++ * gfortran.dg/bounds_check_strlen_2.f90: Fix invalid code.
++ * gfortran.dg/array_constructor_27.f03: Update dg-error message.
++ * gfortran.dg/array_constructor_26.f03: Ditto.
++
++ PR fortran/77612
++ * gfortran.dg/pr77612.f90: New test.
++
++2016-09-28 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ backport from trunk
++ PR fortran/77694
++ * gfortran.dg/pr77694.f90: New test.
++
++2016-09-28 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ backport from mainline
++ 2016-09-23 Bernd Edlinger <bernd.edlinger@hotmail.de>
++ Tom de Vries <tom@codesourcery.com>
++
++ PR testsuite/77411
++ * c-c++-common/ubsan/object-size-9.c: Call __builtin_exit in C++.
++
++2016-09-27 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/77478
++ * gcc.dg/torture/pr77478.c: New testcase.
++
++2016-09-27 Senthil Kumar Selvaraj <senthil_kumar.selvaraj@atmel.com>
++
++ Backport from trunk r227496
++
++ PR target/65210
++ * gcc.target/avr/pr65210.c: New test.
++
++2016-09-21 Uros Bizjak <ubizjak@gmail.com>
++
++ * gcc.c-torture/unsorted/dump-noaddr.x: Remove debug statements.
++
++2016-09-21 Georg-Johann Lay <avr@gjlay.de>
++
++ Backport from 2016-09-21 trunk r240306.
++
++ PR target/77326
++ * gcc.target/avr/torture/pr77326.c: New test.
++
++2016-09-07 Dominique d'Humieres <dominiq@lps.ens.fr>
++
++ PR debug/57519
++ * g++.dg/debug/dwarf2/imported-decl-2.C: Likewise.
++
++2016-09-06 Uros Bizjak <ubizjak@gmail.com>
++
++ * gfortran.dg/c_by_val_1.f: Correct the call to c_to_c and c_to_c8.
++
++2016-08-29 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/77403
++ * gcc.target/i386/pr77403.c: New test.
++
++2016-08-29 Tom de Vries <tom@codesourcery.com>
++
++ backport from trunk:
++ 2015-09-17 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ PR sanitizer/64078
++ * c-c++-common/ubsan/object-size-9.c (s): Add alignment attribute.
++ (f2, f3): Make the function static.
++ * c-c++-common/ubsan/object-size-10.c (a, b): Add alignment attribute.
++
++2016-08-29 Tom de Vries <tom@codesourcery.com>
++
++ backport from trunk:
++ PR testsuite/65940
++ 2016-02-01 Uros Bizjak <ubizjak@gmail.com>
++
++ * g++.dg/other/anon5.C (dg-opetions): Use -gdwarf-2 instead of -g.
++
++2016-08-28 Tom de Vries <tom@codesourcery.com>
++
++ PR testsuite/77034
++ Backported from mainline
++ 2016-07-25 Jason Merrill <jason@redhat.com>
++
++ * g++.dg/init/elide5.C (operator new): Use decltype(sizeof(1)) instead
++ of unsigned long.
++
++2016-08-26 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-04-20 Andrew Pinski <apinski@cavium.com>
++ Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR target/64971
++ * gcc.c-torture/compile/pr37433-1.c: New testcase.
++
++2016-08-25 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ Backport from mainline
++ 2016-08-11 Bill Schmidt <wschmidt@linux.vnet.ibm.com>
++
++ PR target/72863
++ * gcc.target/powerpc/pr72863.c: New test.
++
++2016-08-25 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ Backport from mainline
++ 2016-07-12 Kyrylo Tkachov <kyrylo.tkachov@arm.com>
++
++ PR middle-end/71700
++ * gcc.c-torture/execute/pr71700.c: New test.
++
++2016-08-22 Uros Bizjak <ubizjak@gmail.com>
++
++ Backport from mainline
++ 2016-08-14 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/76342
++ * gcc.target/i386/pr76342.c: New test.
++
++2016-08-13 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ * gfortran.dg/realloc_on_assign_26.f90: New test case.
++
++2016-08-12 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ Backport from mainline
++ 2016-08-11 Bernd Edlinger <bernd.edlinger@hotmail.de>
++
++ PR tree-optimization/71083
++ * gcc.c-torture/execute/pr71083.c: New test.
++ * gnat.dg/loop_optimization23.adb: New test.
++ * gnat.dg/loop_optimization23_pkg.ads: New test.
++ * gnat.dg/loop_optimization23_pkg.adb: New test.
++
++2016-08-11 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk.
++ PR fortran/71123
++ * gfortran.dg/namelist_90.f: New test.
++
++2016-08-11 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/72698
++ * gfortran.dg/allocate_with_source_20.f03: New test.
++
++2016-08-09 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/71795
++ * gfortran.dg/array_constructor_50.f90: New test.
++
++2016-08-09 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ PR fortran/69742
++ * gfortran.dg/associate_21.f90: New test.
++
++2016-08-08 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ PR fortran/60526
++ * gfortran.dg/type_decl_4.f90: New test.
++
++2016-08-08 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/70524
++ * gfortran.dg/dependency_48.f90: New test.
++
++2016-08-08 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ PR fortran/70040
++ Backport from trunk
++ * gfortran.dg/pr70040.f90: New testcase.
++
++2016-08-05 Nathan Sidwell <nathan@acm.org>
++
++ PR c++/68724
++ * g++.dg/cpp0x/pr68724.C: New.
++
++2016-07-29 Paul Thomas <pault@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71883
++ * gfortran.dg/pr71883.f90 : New test.
++
++2016-07-22 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71807
++ * gfortran.dg/null_9.f90: New test.
++
++2016-07-22 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/70842
++ * gfortran.dg/select_type_35.f03: New test.
++
++2016-07-20 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71909
++ * g++.dg/parse/pr71909.C: New test.
++ * g++.dg/tm/pr71909.C: New test.
++
++2016-07-20 Martin Jambor <mjambor@suse.cz>
++
++ PR fortran/71688
++ * gfortran.dg/pr71688.f90: New test.
++
++2016-07-19 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71874
++ * g++.dg/torture/pr71874.C: New test.
++
++ Backported from mainline
++ 2016-07-18 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71871
++ * g++.dg/ext/vector31.C: New test.
++
++ 2016-07-11 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71758
++ * c-c++-common/gomp/pr71758.c: New test.
++ * gfortran.dg/gomp/pr71758.f90: New test.
++
++2016-07-15 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71764
++ * gfortran.dg/pr71764.f90: New test.
++
++2016-07-13 Andre Vehreschild <vehre@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71623
++ * gfortran.dg/deferred_character_18.f90: New test.
++
++2016-07-12 Segher Boessenkool <segher@kernel.crashing.org>
++
++ Backport from mainline
++ 2016-07-06 Segher Boessenkool <segher@kernel.crashing.org>
++
++ PR target/70098
++ PR target/71763
++ * gcc.target/powerpc/pr71763.c: New file.
++
++2016-07-11 Thomas Koenig <tkoenig@gcc.gnu.org>
++
++ Backport from trunk:
++ PR fortran/71783
++ * gfortran.dg/dependency_46.f90: New test.
++
++2016-07-08 Cesar Philippidis <cesar@codesourcery.com>
++
++ Backport from trunk:
++ 2016-07-08 Cesar Philippidis <cesar@codesourcery.com>
++
++ * gfortran.dg/goacc/pr71704.f90: New test.
++
++2016-07-08 Martin Liska <mliska@suse.cz>
++
++ Backported from mainline
++ 2016-07-08 Martin Liska <mliska@suse.cz>
++
++ * gcc.dg/torture/pr71606.c: New test.
++
++2016-07-07 Segher Boessenkool <segher@kernel.crashing.org>
++
++ PR target/69019
++ * gcc.target/powerpc/ti_math1.c: Allow addze as well as adde.
++
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-03-02 Jakub Jelinek <jakub@redhat.com>
++
++ PR c/68062
++ * c-c++-common/vector-compare-4.c: Add -Wno-psabi to dg-options.
++
++ 2016-02-02 Segher Boessenkool <segher@kernel.crashing.org>
++
++ * c-c++-common/vector-compare-4.c: Prune "non-standard ABI extension"
++ warning.
++
++ 2016-06-30 Jakub Jelinek <jakub@redhat.com>
++
++ PR fortran/71704
++ * gfortran.dg/gomp/pr71704.f90: New test.
++
++ PR fortran/71705
++ * gfortran.dg/gomp/pr71705.f90: New test.
++
++ 2016-06-28 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71626
++ * gcc.c-torture/execute/pr71626-1.c: New test.
++ * gcc.c-torture/execute/pr71626-2.c: New test.
++
++ 2016-06-21 Jakub Jelinek <jakub@redhat.com>
++
++ PR tree-optimization/71588
++ * gcc.dg/pr71558.c: New test.
++
++ 2016-06-20 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71581
++ * gcc.dg/pr71581.c: New test.
++
++ 2016-06-14 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71528
++ * g++.dg/opt/pr71528.C: New test.
++
++ PR c++/71516
++ * g++.dg/init/pr71516.C: New test.
++
++ 2016-06-10 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71494
++ * gcc.c-torture/execute/pr71494.c: New test.
++
++ 2016-06-13 Jakub Jelinek <jakub@redhat.com>
++
++ PR sanitizer/71498
++ * c-c++-common/ubsan/bounds-13.c: New test.
++
++ 2016-04-13 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/70641
++ * g++.dg/opt/pr70641.C: New test.
++
++ PR middle-end/70633
++ * gcc.c-torture/compile/pr70633.c: New test.
++
++ PR debug/70628
++ * gcc.dg/torture/pr70628.c: New test.
++
++ 2016-04-08 Jakub Jelinek <jakub@redhat.com>
++
++ PR rtl-optimization/70574
++ * gcc.target/i386/avx2-pr70574.c: New test.
++
++ 2016-04-05 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/70336
++ * c-c++-common/pr70336.c: New test.
++ * gcc.dg/torture/builtin-isinf_sign-1.c (foo): Guard tests
++ no longer optimized away at -O0 with #ifndef __OPTIMIZE__.
++
++2016-07-07 Richard Biener <rguenther@suse.de>
++
++ Backport from mainline
++ 2016-06-07 Richard Biener <rguenther@suse.de>
++
++ PR middle-end/71423
++ * gcc.dg/torture/pr71423.c: New testcase.
++
++ 2016-06-08 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/71452
++ * gcc.dg/torture/pr71452.c: New testcase.
++
++ 2016-06-14 Richard Biener <rguenther@suse.de>
++
++ PR tree-optimization/71522
++ * gcc.dg/torture/pr71522.c: New testcase.
++
++2016-06-30 Jakub Jelinek <jakub@redhat.com>
++
++ PR middle-end/71693
++ * gcc.c-torture/compile/pr71693.c: New test.
++
++2016-06-27 Paul Thomas <pault@gcc.gnu.org>
++
++ PR fortran/70673
++ * gfortran.dg/pr70673.f90: New test.
++
++2016-06-20 Georg-Johann Lay <avr@gjlay.de>
++ Pitchumani Sivanupandi <pitchumani.s@atmel.com>
++
++ Backport from 2016-06-20 trunk r237589, r236558.
++
++ PR target/71103
++ * gcc.target/avr/pr71103.c: New test.
++ * gcc.target/avr/torture/pr71103-2.c: New test.
++
++2016-06-16 Jakub Jelinek <jakub@redhat.com>
++
++ PR target/71554
++ * gcc.c-torture/execute/pr71554.c: New test.
++
++2016-06-12 Dominique d'Humieres <dominiq@lps.ens.fr>
++
++ PR target/60751
++ * gfortran.dg/comma_IO_extension_1.f90: New test.
++ * gfortran.dg/comma_IO_extension_2.f90: Likewise.
++ * gfortran.dg/array_constructor_49.f90: Remove extra comma in WRITE
++ statement.
++ * gfortran.dg/graphite/pr38083.f90: Likewise.
++ * gfortran.dg/guality/pr41558.f90: Likewise.
++ * gfortran.dg/integer_exponentiation_6.F90: Likewise and add
++ missing format.
++
++2016-06-08 Jakub Jelinek <jakub@redhat.com>
++
++ PR c++/71442
++ * g++.dg/cpp0x/Wunused-variable-1.C: New test.
++
++2016-06-07 Uros Bizjak <ubizjak@gmail.com>
++
++ PR target/71389
++ * g++.dg/pr71389.C: New test.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+@@ -31,7 +813,7 @@
+ * gcc.dg/pr69634.c: New.
+
+ 2016-03-23 Patrick Palka <ppalka@gcc.gnu.org>
+-
++
+ PR c++/70347
+ * g++.dg/cpp1y/nsdmi-union1.C: New test.
+
+@@ -42,7 +824,7 @@
+
+ 2016-03-24 Richard Henderson <rth@redhat.com>
+
+- PR middle-end/69845
++ PR middle-end/69845
+ * gcc.dg/tree-ssa/pr69845-1.c: New test.
+ * gcc.dg/tree-ssa/pr69845-2.c: New test.
+
+@@ -105,8 +887,8 @@
+ PR middle-end/67278
+ * gcc.dg/simd-7.c: Add -w -Wno-psabi to dg-options.
+
+- PR target/67278
+- * gcc.dg/simd-8.c: Add -w -Wno-psabi to dg-options.
++ PR target/67278
++ * gcc.dg/simd-8.c: Add -w -Wno-psabi to dg-options.
+
+ 2016-05-20 Richard Biener <rguenther@suse.de>
+
+@@ -130,13 +912,13 @@
+ * gcc.dg/torture/pr70941.c: New testcase.
+
+ 2016-05-06 Jakub Jelinek <jakub@redhat.com>
+-
++
+ PR middle-end/70941
+ * gcc.dg/torture/pr70941.c (abort): Remove prototype.
+ (a, b, c, d): Change type from char to signed char.
+ (main): Compare against (signed char) -1634678893 instead of
+ hardcoded -109. Use __builtin_abort instead of abort.
+-
++
+ 2016-05-06 Richard Biener <rguenther@suse.de>
+
+ PR middle-end/70931
+diff --git a/gcc/testsuite/c-c++-common/gomp/pr71758.c b/gcc/testsuite/c-c++-common/gomp/pr71758.c
+new file mode 100644
+index 0000000..d3c8697
+--- /dev/null
++++ b/gcc/testsuite/c-c++-common/gomp/pr71758.c
+@@ -0,0 +1,10 @@
++/* PR middle-end/71758 */
++
++void
++foo (int *p)
++{
++ long long i = 0;
++ #pragma omp target device (i)
++ ;
++ #pragma omp target update device (i) to (p[0])
++}
+diff --git a/gcc/testsuite/c-c++-common/pr70336.c b/gcc/testsuite/c-c++-common/pr70336.c
+new file mode 100644
+index 0000000..095bd56
+--- /dev/null
++++ b/gcc/testsuite/c-c++-common/pr70336.c
+@@ -0,0 +1,37 @@
++/* PR c++/70336 */
++/* { dg-do compile } */
++/* { dg-options "-Wconversion" } */
++
++void
++f1 (unsigned char * x, int y, int z)
++{
++ x[z / 8] |= (unsigned char) (0x80 >> y); /* { dg-bogus "may alter its value" } */
++}
++
++unsigned char
++f2 (unsigned char x, int y)
++{
++ x = x | (unsigned char) (0x80 >> y); /* { dg-bogus "may alter its value" } */
++ return x;
++}
++
++unsigned char
++f3 (unsigned char x, int y)
++{
++ x = x | (unsigned char) (y & 255); /* { dg-bogus "may alter its value" } */
++ return x;
++}
++
++unsigned char
++f4 (unsigned char x, unsigned char y)
++{
++ x = x | (unsigned char) (y & 255); /* { dg-bogus "may alter its value" } */
++ return x;
++}
++
++unsigned char
++f5 (unsigned char x, int y)
++{
++ x = (unsigned char) (y & 255); /* { dg-bogus "may alter its value" } */
++ return x;
++}
+diff --git a/gcc/testsuite/c-c++-common/pr72747-1.c b/gcc/testsuite/c-c++-common/pr72747-1.c
+new file mode 100644
+index 0000000..e87069d
+--- /dev/null
++++ b/gcc/testsuite/c-c++-common/pr72747-1.c
+@@ -0,0 +1,16 @@
++/* { dg-do compile } */
++/* { dg-require-effective-target powerpc_altivec_ok } */
++/* { dg-options "-maltivec -fdump-tree-gimple" } */
++
++/* PR 72747: Test that cascaded definition is happening for constant vectors. */
++
++#include <altivec.h>
++
++int main (int argc, char *argv[])
++{
++ __vector int v1,v2;
++ v1 = v2 = vec_splats ((int) 42);
++ return 0;
++}
++/* { dg-final { scan-tree-dump-times " v2 = { 42, 42, 42, 42 }" 1 "gimple" } } */
++
+diff --git a/gcc/testsuite/c-c++-common/pr72747-2.c b/gcc/testsuite/c-c++-common/pr72747-2.c
+new file mode 100644
+index 0000000..24a4364
+--- /dev/null
++++ b/gcc/testsuite/c-c++-common/pr72747-2.c
+@@ -0,0 +1,18 @@
++/* { dg-do compile } */
++/* { dg-require-effective-target powerpc_altivec_ok } */
++/* { dg-options "-c -maltivec -fdump-tree-gimple" } */
++
++/* PR 72747: test that cascaded definition is happening for non constants. */
++
++void foo ()
++{
++ extern int i;
++ __vector int v,w;
++ v = w = (vector int) { i };
++}
++
++int main (int argc, char *argv[])
++{
++ return 0;
++}
++/* { dg-final { scan-tree-dump-times " w = " 1 "gimple" } } */
+diff --git a/gcc/testsuite/c-c++-common/ubsan/bounds-13.c b/gcc/testsuite/c-c++-common/ubsan/bounds-13.c
+new file mode 100644
+index 0000000..25b0467
+--- /dev/null
++++ b/gcc/testsuite/c-c++-common/ubsan/bounds-13.c
+@@ -0,0 +1,31 @@
++/* PR sanitizer/71498 */
++/* { dg-do run } */
++/* { dg-options "-fsanitize=bounds -Wno-array-bounds" } */
++
++struct S { int a[100]; int b, c; } s;
++
++__attribute__((noinline, noclone)) int
++foo (int x)
++{
++ return s.a[x];
++}
++
++__attribute__((noinline, noclone)) int
++bar (int x)
++{
++ static int *d = &s.a[99];
++ asm volatile ("" : : "r" (&d));
++ return s.a[x];
++}
++
++int
++main ()
++{
++ volatile int a = 0;
++ a += foo (100);
++ a += bar (100);
++ return 0;
++}
++
++/* { dg-output "index 100 out of bounds for type 'int \\\[100\\\]'\[^\n\r]*(\n|\r\n|\r)" } */
++/* { dg-output "\[^\n\r]*index 100 out of bounds for type 'int \\\[100\\\]'\[^\n\r]*(\n|\r\n|\r)" } */
+diff --git a/gcc/testsuite/c-c++-common/ubsan/object-size-10.c b/gcc/testsuite/c-c++-common/ubsan/object-size-10.c
+index ebc8582..8aa00bf 100644
+--- a/gcc/testsuite/c-c++-common/ubsan/object-size-10.c
++++ b/gcc/testsuite/c-c++-common/ubsan/object-size-10.c
+@@ -2,8 +2,8 @@
+ /* { dg-skip-if "" { *-*-* } { "*" } { "-O2" } } */
+ /* { dg-options "-fsanitize=undefined" } */
+
+-static char a[128];
+-static int b[128];
++static char a[128] __attribute__ ((aligned(4096)));
++static int b[128] __attribute__ ((aligned(4096)));
+
+ __attribute__ ((noinline, noclone)) int
+ fn1 (int i)
+diff --git a/gcc/testsuite/c-c++-common/ubsan/object-size-9.c b/gcc/testsuite/c-c++-common/ubsan/object-size-9.c
+index 829c822..297a751 100644
+--- a/gcc/testsuite/c-c++-common/ubsan/object-size-9.c
++++ b/gcc/testsuite/c-c++-common/ubsan/object-size-9.c
+@@ -11,7 +11,7 @@ struct C { C () : d("abcdefg"), e(1) {} C (const C &x) { __builtin_memcpy (d, x.
+ #endif
+ struct U { int a : 5; int b : 19; int c : 8; };
+ struct S { struct U d[10]; };
+-struct S s;
++struct S s __attribute__ ((aligned(4096)));
+
+ int
+ f1 (struct T x, int i)
+@@ -27,7 +27,7 @@ f1 (struct T x, int i)
+ /* { dg-output "\[^\n\r]*\\^\[^\n\r]*(\n|\r\n|\r)" } */
+
+ #ifdef __cplusplus
+-struct C
++static struct C
+ f2 (int i)
+ {
+ struct C x;
+@@ -41,7 +41,7 @@ f2 (int i)
+ /* { dg-output "\[^\n\r]*\[^\n\r]*(\n|\r\n|\r)" { target { c++ } } } */
+ /* { dg-output "\[^\n\r]*\\^\[^\n\r]*(\n|\r\n|\r)" { target { c++ } } } */
+
+-struct C
++static struct C
+ f3 (int i)
+ {
+ struct C x;
+@@ -93,5 +93,9 @@ main (void)
+ #endif
+ f4 (12);
+ f5 (12);
++#ifdef __cplusplus
++ /* Stack may be smashed by f2/f3 above. */
++ __builtin_exit (0);
++#endif
+ return 0;
+ }
+diff --git a/gcc/testsuite/c-c++-common/vector-compare-4.c b/gcc/testsuite/c-c++-common/vector-compare-4.c
+index b44f474..e7d37eb 100644
+--- a/gcc/testsuite/c-c++-common/vector-compare-4.c
++++ b/gcc/testsuite/c-c++-common/vector-compare-4.c
+@@ -1,6 +1,8 @@
+ /* PR c/68062 */
+ /* { dg-do compile } */
+-/* { dg-options "-Wsign-compare" } */
++/* { dg-options "-Wsign-compare -Wno-psabi" } */
++/* Ignore warning on some powerpc configurations. */
++/* { dg-prune-output "non-standard ABI extension" } */
+
+ typedef signed char __attribute__ ((vector_size (4))) v4qi;
+ typedef unsigned char __attribute__ ((vector_size (4))) uv4qi;
+diff --git a/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C b/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C
+new file mode 100644
+index 0000000..39592b2
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C
+@@ -0,0 +1,37 @@
++// PR c++/71442
++// { dg-do compile { target c++11 } }
++// { dg-options "-Wunused-variable" }
++
++struct C
++{
++ template<typename... Ts>
++ int operator()(Ts &&...)
++ {
++ return sizeof...(Ts);
++ }
++};
++
++int
++foo ()
++{
++ C {} (1, 1L, 1LL, 1.0);
++}
++
++template<int N>
++void
++bar ()
++{
++ char a; // { dg-warning "unused variable" }
++ short b; // { dg-warning "unused variable" }
++ int c; // { dg-warning "unused variable" }
++ long d; // { dg-warning "unused variable" }
++ long long e; // { dg-warning "unused variable" }
++ float f; // { dg-warning "unused variable" }
++ double g; // { dg-warning "unused variable" }
++}
++
++void
++baz ()
++{
++ bar <0> ();
++}
+diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-deduce3.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-deduce3.C
+new file mode 100644
+index 0000000..68ac29c
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-deduce3.C
+@@ -0,0 +1,15 @@
++// PR c++/69223
++// { dg-do compile { target c++11 } }
++
++template <class T> struct A
++{
++ T x[20];
++};
++
++int main()
++{
++ auto l = [](const A<int>& i){ return i; };
++ A<int> a;
++
++ l(a);
++}
+diff --git a/gcc/testsuite/g++.dg/cpp0x/pr68724.C b/gcc/testsuite/g++.dg/cpp0x/pr68724.C
+new file mode 100644
+index 0000000..ff6d84d
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp0x/pr68724.C
+@@ -0,0 +1,15 @@
++// PR 68724 ICE in unificiation
++// { dg-do compile { target c++11 } }
++
++template <typename _Tp, _Tp>
++struct integral_constant
++{
++};
++
++integral_constant<bool, true> inst;
++
++template <typename _Tp>
++struct integral_constant<bool, __is_enum(_Tp)> // { dg-error "" }
++{
++};
++
+diff --git a/gcc/testsuite/g++.dg/cpp0x/variadic-nested1.C b/gcc/testsuite/g++.dg/cpp0x/variadic-nested1.C
+new file mode 100644
+index 0000000..abfb49a
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp0x/variadic-nested1.C
+@@ -0,0 +1,9 @@
++// PR c++/71833
++// { dg-do compile { target c++11 } }
++
++template < typename ... Ts > struct A
++{
++ template < Ts ..., typename ... Us > struct B {};
++};
++
++A <>::B < int > e;
+diff --git a/gcc/testsuite/g++.dg/cpp1y/feat-cxx11.C b/gcc/testsuite/g++.dg/cpp1y/feat-cxx11.C
+index 67f75a7..53e7ded 100644
+--- a/gcc/testsuite/g++.dg/cpp1y/feat-cxx11.C
++++ b/gcc/testsuite/g++.dg/cpp1y/feat-cxx11.C
+@@ -77,10 +77,10 @@
+ # error "__cpp_attributes != 200809"
+ #endif
+
+-#ifndef __cpp_rvalue_reference
+-# error "__cpp_rvalue_reference"
+-#elif __cpp_rvalue_reference != 200610
+-# error "__cpp_rvalue_reference != 200610"
++#ifndef __cpp_rvalue_references
++# error "__cpp_rvalue_references"
++#elif __cpp_rvalue_references != 200610
++# error "__cpp_rvalue_references != 200610"
+ #endif
+
+ #ifndef __cpp_variadic_templates
+diff --git a/gcc/testsuite/g++.dg/cpp1y/feat-cxx14.C b/gcc/testsuite/g++.dg/cpp1y/feat-cxx14.C
+index 1292966..29b0794 100644
+--- a/gcc/testsuite/g++.dg/cpp1y/feat-cxx14.C
++++ b/gcc/testsuite/g++.dg/cpp1y/feat-cxx14.C
+@@ -71,10 +71,10 @@
+ # error "__cpp_attributes != 200809"
+ #endif
+
+-#ifndef __cpp_rvalue_reference
+-# error "__cpp_rvalue_reference"
+-#elif __cpp_rvalue_reference != 200610
+-# error "__cpp_rvalue_reference != 200610"
++#ifndef __cpp_rvalue_references
++# error "__cpp_rvalue_references"
++#elif __cpp_rvalue_references != 200610
++# error "__cpp_rvalue_references != 200610"
+ #endif
+
+ #ifndef __cpp_variadic_templates
+diff --git a/gcc/testsuite/g++.dg/cpp1y/feat-cxx98-neg.C b/gcc/testsuite/g++.dg/cpp1y/feat-cxx98-neg.C
+index 9c25fc3..9a3a109 100644
+--- a/gcc/testsuite/g++.dg/cpp1y/feat-cxx98-neg.C
++++ b/gcc/testsuite/g++.dg/cpp1y/feat-cxx98-neg.C
+@@ -42,8 +42,8 @@
+ # error "__cpp_attributes" // { dg-error "error" }
+ #endif
+
+-#ifndef __cpp_rvalue_reference
+-# error "__cpp_rvalue_reference" // { dg-error "error" }
++#ifndef __cpp_rvalue_references
++# error "__cpp_rvalue_references" // { dg-error "error" }
+ #endif
+
+ #ifndef __cpp_variadic_templates
+diff --git a/gcc/testsuite/g++.dg/cpp1y/pr78551.C b/gcc/testsuite/g++.dg/cpp1y/pr78551.C
+new file mode 100644
+index 0000000..a549fff
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp1y/pr78551.C
+@@ -0,0 +1,32 @@
++// { dg-do compile { target c++14 } }
++
++// PR c++/78551 ICE in constexpr evaluation overwriting array
++// intialized by string constant.
++
++constexpr char Foo (char x, int ix)
++{
++ char d[4] = "012";
++ d[0] = x;
++ return d[ix];
++}
++
++static const char a = Foo ('a', 1);
++static const char b = Foo ('a', 0);
++
++static_assert (a == '1', "");
++static_assert (b == 'a', "");
++
++struct A {
++ union {
++ long s;
++ char d[4];
++ };
++ constexpr A (char x)
++ : d("012")
++ { d[0] = x; }
++};
++
++static constexpr A c{'a'};
++
++static_assert (c.d[0] == 'a', "");
++static_assert (c.d[1] == '1', "");
+diff --git a/gcc/testsuite/g++.dg/cpp1y/var-templ53.C b/gcc/testsuite/g++.dg/cpp1y/var-templ53.C
+new file mode 100644
+index 0000000..3e30d67
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/cpp1y/var-templ53.C
+@@ -0,0 +1,10 @@
++// PR c++/71630
++// { dg-do compile { target c++14 } }
++
++template <class T>
++extern T pi;
++
++int main()
++{
++ return pi<int>;
++}
+diff --git a/gcc/testsuite/g++.dg/debug/dwarf2/imported-decl-2.C b/gcc/testsuite/g++.dg/debug/dwarf2/imported-decl-2.C
+index ce01f72..b5087e7 100644
+--- a/gcc/testsuite/g++.dg/debug/dwarf2/imported-decl-2.C
++++ b/gcc/testsuite/g++.dg/debug/dwarf2/imported-decl-2.C
+@@ -1,5 +1,5 @@
+ // { dg-do compile }
+-// { dg-options "-gdwarf-2 -dA -O0 -fno-merge-debug-strings" }
++// { dg-options "-gdwarf-2 -gno-strict-dwarf -dA -O0 -fno-merge-debug-strings" }
+
+ class AAAA
+ {
+diff --git a/gcc/testsuite/g++.dg/ext/vector31.C b/gcc/testsuite/g++.dg/ext/vector31.C
+new file mode 100644
+index 0000000..a056839
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/ext/vector31.C
+@@ -0,0 +1,29 @@
++// PR c++/71871
++// { dg-do compile }
++
++typedef unsigned int V __attribute__ ((__vector_size__ (32)));
++
++template <int N>
++void
++foo (V *x)
++{
++ V a = *x;
++ a = a ? a : -1;
++ *x = a;
++}
++
++template <typename T>
++void
++bar (T *x)
++{
++ T a = *x;
++ a = a ? a : -1;
++ *x = a;
++}
++
++void
++test (V *x, V *y)
++{
++ foo<0> (x);
++ bar<V> (y);
++}
+diff --git a/gcc/testsuite/g++.dg/gcov/gcov-16.C b/gcc/testsuite/g++.dg/gcov/gcov-16.C
+new file mode 100644
+index 0000000..f09d406
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/gcov/gcov-16.C
+@@ -0,0 +1,10 @@
++// PR gcov-profile/64634
++// { dg-options "-fprofile-arcs -ftest-coverage" }
++// { dg-do run { target native } }
++
++int main()
++{
++ return 0; /* count(#####) */
++}
++
++// { dg-final { run-gcov remove-gcda gcov-16.C } }
+diff --git a/gcc/testsuite/g++.dg/init/elide5.C b/gcc/testsuite/g++.dg/init/elide5.C
+new file mode 100644
+index 0000000..e52d55f
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/init/elide5.C
+@@ -0,0 +1,26 @@
++// PR c++/71913
++// { dg-do link { target c++11 } }
++
++void* operator new(decltype(sizeof(1)), void* p) { return p; }
++
++struct IndirectReturn {
++ IndirectReturn() {}
++ // Undefined so we get a link error if the indirect return value is copied
++ IndirectReturn(const IndirectReturn&);
++ IndirectReturn& operator=(const IndirectReturn&) = delete;
++ ~IndirectReturn() {}
++};
++
++IndirectReturn foo() { return IndirectReturn(); }
++
++void bar(void* ptr) {
++ new (ptr) IndirectReturn(foo());
++}
++
++alignas (alignof (IndirectReturn))
++unsigned char c[sizeof(IndirectReturn)];
++
++int main()
++{
++ bar(c);
++}
+diff --git a/gcc/testsuite/g++.dg/init/pr71516.C b/gcc/testsuite/g++.dg/init/pr71516.C
+new file mode 100644
+index 0000000..0b9aec4
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/init/pr71516.C
+@@ -0,0 +1,10 @@
++// PR c++/71516
++// { dg-do compile }
++
++struct A; // { dg-message "forward declaration of" }
++struct B
++{
++ static A a;
++};
++A B::a = A(); // { dg-error "has initializer but incomplete type|invalid use of incomplete type" }
++struct A {};
+diff --git a/gcc/testsuite/g++.dg/opt/pr70641.C b/gcc/testsuite/g++.dg/opt/pr70641.C
+new file mode 100644
+index 0000000..99af742
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/opt/pr70641.C
+@@ -0,0 +1,10 @@
++// PR c++/70641
++// { dg-do compile }
++// { dg-options "-O2" }
++
++void
++foo ()
++{
++ try { foo (); }
++ catch (...) { __builtin_abort (); }
++}
+diff --git a/gcc/testsuite/g++.dg/opt/pr71528.C b/gcc/testsuite/g++.dg/opt/pr71528.C
+new file mode 100644
+index 0000000..bfe0622
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/opt/pr71528.C
+@@ -0,0 +1,23 @@
++// PR c++/71528
++// { dg-do run }
++// { dg-options "-O2" }
++
++extern int &x;
++int y;
++
++int &
++foo ()
++{
++ return y;
++}
++
++int &x = foo ();
++
++int
++main ()
++{
++ if (&x != &y)
++ __builtin_abort ();
++}
++
++extern int &x;
+diff --git a/gcc/testsuite/g++.dg/other/anon5.C b/gcc/testsuite/g++.dg/other/anon5.C
+index 4e4cc44..2a6f57f 100644
+--- a/gcc/testsuite/g++.dg/other/anon5.C
++++ b/gcc/testsuite/g++.dg/other/anon5.C
+@@ -1,6 +1,6 @@
+ // PR c++/34094
+ // { dg-do link { target { ! { *-*-darwin* *-*-hpux* *-*-solaris2.* } } } }
+-// { dg-options "-g" }
++// { dg-options "-gdwarf-2" }
+ // Ignore additional message on powerpc-ibm-aix
+ // { dg-prune-output "obtain more information" } */
+ // Ignore additional messages on Linux/x86 with PIE
+diff --git a/gcc/testsuite/g++.dg/other/i386-2.C b/gcc/testsuite/g++.dg/other/i386-2.C
+index 887eb18..fd3a6b1 100644
+--- a/gcc/testsuite/g++.dg/other/i386-2.C
++++ b/gcc/testsuite/g++.dg/other/i386-2.C
+@@ -1,5 +1,5 @@
+ /* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+-/* { dg-options "-O -pedantic-errors -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mpcommit -mmwaitx" } */
++/* { dg-options "-O -pedantic-errors -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mmwaitx" } */
+
+ /* Test that {,x,e,p,t,s,w,a,b,i}mmintrin.h, mm3dnow.h, fma4intrin.h,
+ xopintrin.h, abmintrin.h, bmiintrin.h, tbmintrin.h, lwpintrin.h,
+diff --git a/gcc/testsuite/g++.dg/other/i386-3.C b/gcc/testsuite/g++.dg/other/i386-3.C
+index 9555ccb..08bd04c 100644
+--- a/gcc/testsuite/g++.dg/other/i386-3.C
++++ b/gcc/testsuite/g++.dg/other/i386-3.C
+@@ -1,5 +1,5 @@
+ /* { dg-do compile { target i?86-*-* x86_64-*-* } } */
+-/* { dg-options "-O -fkeep-inline-functions -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mpcommit -mmwaitx" } */
++/* { dg-options "-O -fkeep-inline-functions -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mmwaitx" } */
+
+ /* Test that {,x,e,p,t,s,w,a,b,i}mmintrin.h, mm3dnow.h, fma4intrin.h,
+ xopintrin.h, abmintrin.h, bmiintrin.h, tbmintrin.h, lwpintrin.h,
+diff --git a/gcc/testsuite/g++.dg/parse/pr71909.C b/gcc/testsuite/g++.dg/parse/pr71909.C
+new file mode 100644
+index 0000000..ee592bf
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/parse/pr71909.C
+@@ -0,0 +1,22 @@
++// PR c++/71909
++// { dg-do compile }
++
++struct S
++{
++ S () try : m (0) {}
++ catch (...) {}
++ void foo () try {}
++ catch (int) {}
++ catch (...) {}
++ int m;
++};
++
++struct T
++{
++ T () : m (0) {}
++ catch (...) {} // { dg-error "expected unqualified-id before" }
++ void foo () {}
++ catch (int) {} // { dg-error "expected unqualified-id before" }
++ catch (...) {} // { dg-error "expected unqualified-id before" }
++ int m;
++};
+diff --git a/gcc/testsuite/g++.dg/pr71389.C b/gcc/testsuite/g++.dg/pr71389.C
+new file mode 100644
+index 0000000..023abe1
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/pr71389.C
+@@ -0,0 +1,23 @@
++// { dg-do compile { target i?86-*-* x86_64-*-* } }
++// { dg-options "-std=c++11 -O3 -march=ivybridge" }
++
++#include <functional>
++
++extern int le_s6, le_s9, le_s11;
++long foo_v14[16][16];
++
++void fn1() {
++ std::array<std::array<int, 16>, 16> v13;
++ for (; le_s6;)
++ for (int k1 = 2; k1 < 4; k1 = k1 + 1) {
++ for (int n1 = 0; n1 < le_s9; n1 = 8) {
++ *foo_v14[6] = 20923310;
++ for (int i2 = n1; i2 < n1 + 8; i2 = i2 + 1)
++ v13.at(5).at(i2 + 6 - n1) = 306146921;
++ }
++
++ for (int l2 = 0; l2 < le_s11; l2 = l2 + 1)
++ *(l2 + v13.at(5).begin()) = 306146921;
++ }
++ v13.at(le_s6 - 4);
++}
+diff --git a/gcc/testsuite/g++.dg/tm/pr71909.C b/gcc/testsuite/g++.dg/tm/pr71909.C
+new file mode 100644
+index 0000000..941f231
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/tm/pr71909.C
+@@ -0,0 +1,18 @@
++// PR c++/71909
++// { dg-do compile { target c++11 } }
++// { dg-options "-fgnu-tm" }
++
++struct S
++{
++ S () __transaction_atomic [[outer]] try : m {0} {} catch (int) {} catch (...) {}
++ int m;
++};
++
++struct T
++{
++ T () __transaction_atomic __attribute__((outer)) try : m {0} {} catch (int) {} catch (...) {}
++ int m;
++};
++
++void foo () __transaction_atomic [[outer]] try {} catch (int) {} catch (...) {}
++void bar () __transaction_atomic __attribute__((outer)) try {} catch (int) {} catch (...) {}
+diff --git a/gcc/testsuite/g++.dg/torture/pr71452.C b/gcc/testsuite/g++.dg/torture/pr71452.C
+new file mode 100644
+index 0000000..3ebe3a1
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/torture/pr71452.C
+@@ -0,0 +1,10 @@
++// { dg-do run }
++
++int main()
++{
++ bool b;
++ *(char *)&b = 123;
++ if (*(char *)&b != 123)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/g++.dg/torture/pr71874.C b/gcc/testsuite/g++.dg/torture/pr71874.C
+new file mode 100644
+index 0000000..d9b4e2f
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/torture/pr71874.C
+@@ -0,0 +1,12 @@
++// PR middle-end/71874
++// { dg-do run }
++
++int
++main ()
++{
++ char str[] = "abcdefghijklmnopqrstuvwxyzABCDEF";
++ __builtin_memmove (str + 20, str + 15, 11);
++ if (__builtin_strcmp (str, "abcdefghijklmnopqrstpqrstuvwxyzF") != 0)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr77943.C b/gcc/testsuite/g++.dg/tree-ssa/pr77943.C
+new file mode 100644
+index 0000000..ef7954a
+--- /dev/null
++++ b/gcc/testsuite/g++.dg/tree-ssa/pr77943.C
+@@ -0,0 +1,25 @@
++/* { dg-do run } */
++/* { dg-options "-O2 -std=c++11" } */
++
++void thrower[[gnu::noinline]]() {
++ throw 1;
++}
++
++inline void fatal() noexcept {thrower();}
++inline void notFatal() {thrower();}
++
++void func(bool callFatal) {
++ if (callFatal) {
++ fatal();
++ } else {
++ notFatal();
++ }
++}
++
++int main(int argc, const char* argv[]) {
++ try {
++ bool callFatal = argc > 1;
++ func(callFatal);
++ } catch (...) {
++ }
++}
+diff --git a/gcc/testsuite/gcc.c-torture/compile/pr37433-1.c b/gcc/testsuite/gcc.c-torture/compile/pr37433-1.c
+new file mode 100644
+index 0000000..c69e969
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/compile/pr37433-1.c
+@@ -0,0 +1,13 @@
++void
++regex_subst (void)
++{
++ const void *subst = "";
++ (*(void (*)(int))subst) (0);
++}
++
++void
++foobar (void)
++{
++ int x;
++ (*(void (*)(void))&x) ();
++}
+diff --git a/gcc/testsuite/gcc.c-torture/compile/pr70633.c b/gcc/testsuite/gcc.c-torture/compile/pr70633.c
+new file mode 100644
+index 0000000..6d783cb
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/compile/pr70633.c
+@@ -0,0 +1,12 @@
++/* PR middle-end/70633 */
++
++typedef long V __attribute__((vector_size (4 * sizeof (long))));
++
++void foo (V *);
++
++void
++bar (void)
++{
++ V b = { (long) bar, 0, 0, 0 };
++ foo (&b);
++}
+diff --git a/gcc/testsuite/gcc.c-torture/compile/pr71693.c b/gcc/testsuite/gcc.c-torture/compile/pr71693.c
+new file mode 100644
+index 0000000..fc9249c
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/compile/pr71693.c
+@@ -0,0 +1,10 @@
++/* PR middle-end/71693 */
++
++unsigned short v;
++
++void
++foo (int x)
++{
++ v = ((((unsigned short) (0x0001 | (x & 0x0070) | 0x0100) & 0x00ffU) << 8)
++ | (((unsigned short) (0x0001 | (x & 0x0070) | 0x0100) >> 8) & 0x00ffU));
++}
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71083.c b/gcc/testsuite/gcc.c-torture/execute/pr71083.c
+new file mode 100644
+index 0000000..0574434
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71083.c
+@@ -0,0 +1,43 @@
++struct lock_chain {
++ unsigned int irq_context: 2,
++ depth: 6,
++ base: 24;
++};
++
++__attribute__((noinline, noclone))
++struct lock_chain * foo (struct lock_chain *chain)
++{
++ int i;
++ for (i = 0; i < 100; i++)
++ {
++ chain[i+1].base = chain[i].base;
++ }
++ return chain;
++}
++
++struct lock_chain1 {
++ char x;
++ unsigned short base;
++} __attribute__((packed));
++
++__attribute__((noinline, noclone))
++struct lock_chain1 * bar (struct lock_chain1 *chain)
++{
++ int i;
++ for (i = 0; i < 100; i++)
++ {
++ chain[i+1].base = chain[i].base;
++ }
++ return chain;
++}
++
++struct lock_chain test [101];
++struct lock_chain1 test1 [101];
++
++int
++main ()
++{
++ foo (test);
++ bar (test1);
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71494.c b/gcc/testsuite/gcc.c-torture/execute/pr71494.c
+new file mode 100644
+index 0000000..f962f2c
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71494.c
+@@ -0,0 +1,22 @@
++/* PR middle-end/71494 */
++
++int
++main ()
++{
++ void *label = &&out;
++ int i = 0;
++ void test (void)
++ {
++ label = &&out2;
++ goto *label;
++ out2:;
++ i++;
++ }
++ goto *label;
++ out:
++ i += 2;
++ test ();
++ if (i != 3)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71554.c b/gcc/testsuite/gcc.c-torture/execute/pr71554.c
+new file mode 100644
+index 0000000..f0cb4bb
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71554.c
+@@ -0,0 +1,28 @@
++/* PR target/71554 */
++
++int v;
++
++__attribute__ ((noinline, noclone)) void
++bar (void)
++{
++ v++;
++}
++
++__attribute__ ((noinline, noclone))
++void
++foo (unsigned int x)
++{
++ signed int y = ((-__INT_MAX__ - 1) / 2);
++ signed int r;
++ if (__builtin_mul_overflow (x, y, &r))
++ bar ();
++}
++
++int
++main ()
++{
++ foo (2);
++ if (v)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71626-1.c b/gcc/testsuite/gcc.c-torture/execute/pr71626-1.c
+new file mode 100644
+index 0000000..26cfa96
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71626-1.c
+@@ -0,0 +1,19 @@
++/* PR middle-end/71626 */
++
++typedef __INTPTR_TYPE__ V __attribute__((__vector_size__(sizeof (__INTPTR_TYPE__))));
++
++__attribute__((noinline, noclone)) V
++foo ()
++{
++ V v = { (__INTPTR_TYPE__) foo };
++ return v;
++}
++
++int
++main ()
++{
++ V v = foo ();
++ if (v[0] != (__INTPTR_TYPE__) foo)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71626-2.c b/gcc/testsuite/gcc.c-torture/execute/pr71626-2.c
+new file mode 100644
+index 0000000..4a27c54
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71626-2.c
+@@ -0,0 +1,4 @@
++/* PR middle-end/71626 */
++/* { dg-additional-options "-fpic" { target fpic } } */
++
++#include "pr71626-1.c"
+diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71700.c b/gcc/testsuite/gcc.c-torture/execute/pr71700.c
+new file mode 100644
+index 0000000..80afd38
+--- /dev/null
++++ b/gcc/testsuite/gcc.c-torture/execute/pr71700.c
+@@ -0,0 +1,19 @@
++struct S
++{
++ signed f0 : 16;
++ unsigned f1 : 1;
++};
++
++int b;
++static struct S c[] = {{-1, 0}, {-1, 0}};
++struct S d;
++
++int
++main ()
++{
++ struct S e = c[0];
++ d = e;
++ if (d.f1 != 0)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.c-torture/unsorted/dump-noaddr.x b/gcc/testsuite/gcc.c-torture/unsorted/dump-noaddr.x
+index a8174e0..814c127 100644
+--- a/gcc/testsuite/gcc.c-torture/unsorted/dump-noaddr.x
++++ b/gcc/testsuite/gcc.c-torture/unsorted/dump-noaddr.x
+@@ -18,7 +18,6 @@ proc dump_compare { src options } {
+ foreach dump1 [lsort [glob -nocomplain dump1/*]] {
+ regsub dump1/ $dump1 dump2/ dump2
+ set dumptail "gcc.c-torture/unsorted/[file tail $dump1]"
+- #puts "$option $dump1"
+ set tmp [ diff "$dump1" "$dump2" ]
+ if { $tmp == 0 } {
+ untested "$dumptail, $option comparison"
+@@ -27,14 +26,11 @@ proc dump_compare { src options } {
+ } else {
+ fail "$dumptail, $option comparison"
+ }
+- #exec diff $dump1 $dump2
+ }
+ }
+ file delete -force dump1
+ file delete -force dump2
+ }
+
+-catch {dump_compare $src $options} result
+-puts $result
+-verbose result
++dump_compare $src $options
+ return 1
+diff --git a/gcc/testsuite/gcc.dg/Woverride-init-1.c b/gcc/testsuite/gcc.dg/Woverride-init-1.c
+index 29eca30..b01d8a2 100644
+--- a/gcc/testsuite/gcc.dg/Woverride-init-1.c
++++ b/gcc/testsuite/gcc.dg/Woverride-init-1.c
+@@ -10,19 +10,19 @@ union u { char a; long long b; };
+ struct s s0 = {
+ .a = 1,
+ .b = 2,
+- .a = 3, /* { dg-warning "initialized field overwritten|near init" } */
+- 4, /* { dg-warning "initialized field overwritten|near init" } */
++ .a = 3, /* { dg-warning "initialized field overwritten" } */
++ 4, /* { dg-warning "initialized field overwritten" } */
+ 5
+ };
+
+ union u u0 = {
+ .a = 1,
+- .b = 2, /* { dg-warning "initialized field overwritten|near init" } */
+- .a = 3 }; /* { dg-warning "initialized field overwritten|near init" } */
++ .b = 2, /* { dg-warning "initialized field overwritten" } */
++ .a = 3 }; /* { dg-warning "initialized field overwritten" } */
+
+ int a[5] = {
+ [0] = 1,
+ [1] = 2,
+- [0] = 3, /* { dg-warning "initialized field overwritten|near init" } */
++ [0] = 3, /* { dg-warning "initialized field overwritten" } */
+ [2] = 4
+ };
+diff --git a/gcc/testsuite/gcc.dg/Woverride-init-2.c b/gcc/testsuite/gcc.dg/Woverride-init-2.c
+index c5490b5..d0ece89 100644
+--- a/gcc/testsuite/gcc.dg/Woverride-init-2.c
++++ b/gcc/testsuite/gcc.dg/Woverride-init-2.c
+@@ -10,19 +10,19 @@ union u { char a; long long b; };
+ struct s s0 = {
+ .a = 1,
+ .b = 2,
+- .a = 3, /* { dg-warning "initialized field overwritten|near init" } */
+- 4, /* { dg-warning "initialized field overwritten|near init" } */
++ .a = 3, /* { dg-warning "initialized field overwritten" } */
++ 4, /* { dg-warning "initialized field overwritten" } */
+ 5
+ };
+
+ union u u0 = {
+ .a = 1,
+- .b = 2, /* { dg-warning "initialized field overwritten|near init" } */
+- .a = 3 }; /* { dg-warning "initialized field overwritten|near init" } */
++ .b = 2, /* { dg-warning "initialized field overwritten" } */
++ .a = 3 }; /* { dg-warning "initialized field overwritten" } */
+
+ int a[5] = {
+ [0] = 1,
+ [1] = 2,
+- [0] = 3, /* { dg-warning "initialized field overwritten|near init" } */
++ [0] = 3, /* { dg-warning "initialized field overwritten" } */
+ [2] = 4
+ };
+diff --git a/gcc/testsuite/gcc.dg/init-excess-2.c b/gcc/testsuite/gcc.dg/init-excess-2.c
+new file mode 100644
+index 0000000..0e91b60
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/init-excess-2.c
+@@ -0,0 +1,48 @@
++/* Test for diagnostics about excess initializers when using a macro
++ defined in a system header:
++ c/71115 - Missing warning: excess elements in struct initializer. */
++/* { dg-do compile } */
++/* { dg-options "" } */
++/* { dg-require-effective-target int32plus } */
++
++#include <stddef.h>
++
++int* a[1] = {
++ 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
++
++const char str[1] = {
++ 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
++
++struct S {
++ int *a;
++} s = {
++ 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
++
++struct __attribute__ ((designated_init)) S2 {
++ int *a;
++} s2 = {
++ NULL /* { dg-warning "positional initialization|near init" } */
++};
++
++union U {
++ int *a;
++} u = {
++ 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
++
++int __attribute__ ((vector_size (16))) ivec = {
++ 0, 0, 0, 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
++
++int* scal = {
++ 0,
++ NULL /* { dg-warning "excess elements|near init" } */
++};
+diff --git a/gcc/testsuite/gcc.dg/pr71558.c b/gcc/testsuite/gcc.dg/pr71558.c
+new file mode 100644
+index 0000000..33a648e
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr71558.c
+@@ -0,0 +1,17 @@
++/* PR tree-optimization/71588 */
++
++/* strcpy must not be pure, but make sure we don't ICE even when
++ it is declared incorrectly. */
++char *strcpy (char *, const char *) __attribute__ ((__pure__));
++__SIZE_TYPE__ strlen (const char *);
++void *malloc (__SIZE_TYPE__);
++
++char a[20];
++
++char *
++foo (void)
++{
++ __SIZE_TYPE__ b = strlen (a);
++ char *c = malloc (b);
++ return strcpy (c, a);
++}
+diff --git a/gcc/testsuite/gcc.dg/pr71581.c b/gcc/testsuite/gcc.dg/pr71581.c
+new file mode 100644
+index 0000000..d82eb1e
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr71581.c
+@@ -0,0 +1,24 @@
++/* PR middle-end/71581 */
++/* { dg-do compile } */
++/* { dg-options "-Wuninitialized" } */
++
++_Complex float
++f1 (void)
++{
++ float x;
++ return x; /* { dg-warning "is used uninitialized in this function" } */
++}
++
++_Complex double
++f2 (void)
++{
++ double x;
++ return x; /* { dg-warning "is used uninitialized in this function" } */
++}
++
++_Complex int
++f3 (void)
++{
++ int x;
++ return x; /* { dg-warning "is used uninitialized in this function" } */
++}
+diff --git a/gcc/testsuite/gcc.dg/pr77673.c b/gcc/testsuite/gcc.dg/pr77673.c
+new file mode 100644
+index 0000000..e03bcb9
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/pr77673.c
+@@ -0,0 +1,19 @@
++/* { dg-do compile { target fpic } } */
++/* { dg-require-effective-target bswap32 } */
++/* { dg-options "-O2 -fPIC -fdump-tree-bswap" } */
++/* { dg-additional-options "-march=z900" { target s390*-*-* } } */
++
++void mach_parse_compressed(unsigned char* ptr, unsigned long int* val)
++{
++ if (ptr[0] < 0xC0U) {
++ *val = ptr[0] + ptr[1];
++ return;
++ }
++
++ *val = ((unsigned long int)(ptr[0]) << 24)
++ | ((unsigned long int)(ptr[1]) << 16)
++ | ((unsigned long int)(ptr[2]) << 8)
++ | ptr[3];
++}
++
++/* { dg-final { scan-tree-dump-not "load_dst_\\d+ =.* if \\(" "bswap" } } */
+diff --git a/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c b/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c
+index 6dc2326..adfffcd 100644
+--- a/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c
++++ b/gcc/testsuite/gcc.dg/torture/builtin-isinf_sign-1.c
+@@ -24,6 +24,7 @@ foo (float f, double d, long double ld)
+ != (__builtin_isinf(ld) ? (__builtin_signbitl(ld) ? -1 : 1) : 0))
+ link_error (__LINE__);
+
++#ifdef __OPTIMIZE__
+ /* In boolean contexts, GCC will fold the inner conditional
+ expression to 1. So isinf_sign folds to plain isinf. */
+
+@@ -33,6 +34,7 @@ foo (float f, double d, long double ld)
+ link_error (__LINE__);
+ if ((_Bool)__builtin_isinf_sign(ld) != (__builtin_isinf(ld) != 0))
+ link_error (__LINE__);
++#endif
+
+ if ((__builtin_isinf_sign(f) != 0) != (__builtin_isinf(f) != 0))
+ link_error (__LINE__);
+diff --git a/gcc/testsuite/gcc.dg/torture/pr70628.c b/gcc/testsuite/gcc.dg/torture/pr70628.c
+new file mode 100644
+index 0000000..00acae7
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr70628.c
+@@ -0,0 +1,46 @@
++/* PR debug/70628 */
++/* { dg-do compile } */
++/* { dg-options "-g -w" } */
++
++struct S { char s[64]; int *t; } *a;
++char b[64];
++int *foo (void);
++struct S *bar (int *);
++int baz (void);
++
++void
++test (const char *p, long q)
++{
++ int *c;
++ c = foo ();
++ while (a = bar (c))
++ {
++ if (__builtin_strstr (p, "ABCD")
++ || __builtin_strstr (p, "EFGHI")
++ || __builtin_strstr (p, "JKL")
++ || __builtin_strstr (p, "MNOPQR")
++ || __builtin_strstr (p, "STUV")
++ || __builtin_strstr (p, "WXYZabcd")
++ || __builtin_strstr (p, "efghij")
++ || __builtin_strstr (p, "klmno")
++ || __builtin_strstr (p, "pqrstuvw")
++ || __builtin_strstr (b, "MNOPQR") != "EFGHI"
++ || __builtin_strstr (b, "JKL"))
++ if (__builtin_strstr (a->s, "xyz12"))
++ continue;
++ __builtin_printf ("%p\n", a->t);
++ }
++ bar (c);
++ while (a)
++ if (__builtin_strstr (p, "ABCD")
++ || __builtin_strstr (p, "EFGHI")
++ || __builtin_strstr (p, "JKL")
++ || __builtin_strstr (p, "MNOPQR")
++ || __builtin_strstr (p, "STUV")
++ || __builtin_strstr (p, "WXYZabcd")
++ || __builtin_strstr (p, "efghij")
++ || __builtin_strstr (p, "klmno")
++ || __builtin_strstr (p, "pqrstuvw")
++ || __builtin_strstr ((const char *) q, "MNOPQR"))
++ baz ();
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr71423.c b/gcc/testsuite/gcc.dg/torture/pr71423.c
+new file mode 100644
+index 0000000..06a613f
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr71423.c
+@@ -0,0 +1,20 @@
++/* { dg-do run } */
++
++struct S1
++{
++ int f1:1;
++};
++
++volatile struct S1 b = { 0 };
++
++int
++main ()
++{
++ char c = b.f1;
++ b.f1 = 1;
++
++ if (b.f1 > -1 || c)
++ __builtin_abort ();
++
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr71452.c b/gcc/testsuite/gcc.dg/torture/pr71452.c
+new file mode 100644
+index 0000000..8948d39
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr71452.c
+@@ -0,0 +1,10 @@
++/* { dg-do run } */
++
++int main()
++{
++ _Bool b;
++ *(char *)&b = 123;
++ if (*(char *)&b != 123)
++ __builtin_abort ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr71522.c b/gcc/testsuite/gcc.dg/torture/pr71522.c
+new file mode 100644
+index 0000000..953c4c7
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr71522.c
+@@ -0,0 +1,27 @@
++/* { dg-do run } */
++
++#if __SIZEOF_LONG_DOUBLE__ == 16
++#define STR "AAAAAAAAAAAAAAA"
++#elif __SIZEOF_LONG_DOUBLE__ == 12
++#define STR "AAAAAAAAAAA"
++#elif __SIZEOF_LONG_DOUBLE__ == 8
++#define STR "AAAAAAA"
++#elif __SIZEOF_LONG_DOUBLE__ == 4
++#define STR "AAA"
++#else
++#define STR "A"
++#endif
++
++int main()
++{
++ long double d;
++ char s[sizeof d];
++
++ __builtin_memcpy(&d, STR, sizeof d);
++ __builtin_memcpy(&s, &d, sizeof s);
++
++ if (__builtin_strncmp (s, STR, sizeof s) != 0)
++ __builtin_abort ();
++
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr71606.c b/gcc/testsuite/gcc.dg/torture/pr71606.c
+new file mode 100644
+index 0000000..b0cc26a
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr71606.c
+@@ -0,0 +1,11 @@
++_Complex a;
++void fn1 ();
++
++int main () {
++ fn1 (a);
++ return 0;
++}
++
++void fn1 (__complex__ long double p1) {
++ __imag__ p1 = 6.0L;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr77309.c b/gcc/testsuite/gcc.dg/torture/pr77309.c
+new file mode 100644
+index 0000000..5bdbc0a
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr77309.c
+@@ -0,0 +1,14 @@
++/* { dg-do run } */
++
++int a, b;
++
++int main ()
++{
++ long c = 1 % (2 ^ b);
++ c = -c & ~(~(b ^ ~b) || a);
++
++ if (c >= 0)
++ __builtin_abort ();
++
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr77478.c b/gcc/testsuite/gcc.dg/torture/pr77478.c
+new file mode 100644
+index 0000000..b5965bf
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr77478.c
+@@ -0,0 +1,22 @@
++/* { dg-do run } */
++/* { dg-additional-options "-ffast-math" } */
++
++static const float A[10] = {1};
++
++float
++foo(float *f, int n)
++{
++ int i, j;
++ float a = 0, b = 0;
++ for (i = n/2; i < n; i++)
++ a += f[i]*.1f;
++ for (i = n/2, j = 0; i < n; i++, j++)
++ b += f[i]*A[j]+a*A[j];
++ return b;
++}
++
++int main()
++{
++ float a[21] = {0};
++ return foo(a+1, 20) + foo(a, 20);
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr77916.c b/gcc/testsuite/gcc.dg/torture/pr77916.c
+new file mode 100644
+index 0000000..f29f099
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr77916.c
+@@ -0,0 +1,20 @@
++/* { dg-do compile } */
++/* { dg-options "-O3 -Wno-int-conversion" } */
++
++/* PR77916: This failed with "error: invalid (pointer) operands to plus/minus"
++ after SLSR. */
++
++typedef struct
++{
++ void *f1;
++} S;
++
++S *a;
++int b;
++
++void
++fn1 (void)
++{
++ for (; b; b++, a++)
++ a->f1 = b;
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr77937-1.c b/gcc/testsuite/gcc.dg/torture/pr77937-1.c
+new file mode 100644
+index 0000000..8661d24
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr77937-1.c
+@@ -0,0 +1,15 @@
++/* { dg-do compile } */
++/* { dg-options "-O3" } */
++/* { dg-additional-options "-march=amdfam10" { target i?86-*-* x86_64-*-* } } */
++
++int *a;
++int b, c, d;
++void fn1(char *p1, int p2) {
++ int x;
++ while (1) {
++ x = 0;
++ for (; x < 8; x++)
++ p1[0] = -a[0] * d + p1[0] * c + 1 >> b >> 1;
++ p1 += p2;
++ }
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr77937-2.c b/gcc/testsuite/gcc.dg/torture/pr77937-2.c
+new file mode 100644
+index 0000000..37b4fd6
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr77937-2.c
+@@ -0,0 +1,18 @@
++/* { dg-do compile } */
++/* { dg-options "-O3" } */
++/* { dg-additional-options "-march=amdfam10" { target i?86-*-* x86_64-*-* } } */
++
++extern int fn2(int);
++extern int fn3(int);
++int a, b, c;
++void fn1(long p1) {
++ char *d;
++ for (;; d += p1) {
++ d[0] = fn2(1 >> a);
++ fn3(0);
++ fn3(c >> a);
++ d[1] = fn3(d[1] * b + c >> a);
++ d[4] = fn3(d[4] * b + c >> a);
++ d[5] = fn3(d[5] * b + c >> a);
++ }
++}
+diff --git a/gcc/testsuite/gcc.dg/torture/pr78731.c b/gcc/testsuite/gcc.dg/torture/pr78731.c
+new file mode 100644
+index 0000000..5a4d43b
+--- /dev/null
++++ b/gcc/testsuite/gcc.dg/torture/pr78731.c
+@@ -0,0 +1,41 @@
++/* { dg-do run } */
++
++#include <stdio.h>
++#include <stdlib.h>
++
++#define GENERAL 1
++#define BRACKETS 2
++#define QUOTES 3
++
++void __attribute__((noinline,noclone))
++foo(char *qb, char* into)
++{
++ int state = QUOTES;
++ int save_state = BRACKETS;
++
++ while (qb)
++ {
++ switch (state)
++ {
++ case BRACKETS:
++ exit(0);
++ case GENERAL:
++ abort ();
++ case QUOTES:
++ state = save_state;
++ save_state = GENERAL;
++ break;
++ default: ;
++ }
++ printf("State %d btw GENERAL %d\n", state, GENERAL);
++ }
++ abort ();
++}
++
++int main()
++{
++ char *b = "123";
++ char out[4];
++ foo(b, out);
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.target/aarch64/pr78038.c b/gcc/testsuite/gcc.target/aarch64/pr78038.c
+new file mode 100644
+index 0000000..76d97d3
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/aarch64/pr78038.c
+@@ -0,0 +1,28 @@
++/* { dg-do compile } */
++/* { dg-options "-O2" } */
++
++/* PR rtl-optimization/78038.
++ Make sure ree can gracefully handle extensions of the global
++ variable register after a call. */
++
++typedef void (*test_fptr_t) (void);
++void
++test_f (void)
++{
++}
++test_fptr_t test_fptr = test_f;
++
++struct test2_s
++{
++ int f;
++};
++
++register struct test2_s *g __asm__("x28");
++
++void
++do_something ()
++{
++ test_fptr ();
++ struct test2_s *p1 = 0;
++ *p1 = *g;
++}
+diff --git a/gcc/testsuite/gcc.target/arm/empty_fiq_handler.c b/gcc/testsuite/gcc.target/arm/empty_fiq_handler.c
+new file mode 100644
+index 0000000..8313f21
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/arm/empty_fiq_handler.c
+@@ -0,0 +1,12 @@
++/* { dg-do compile } */
++/* { dg-skip-if "" { ! arm_cortex_m } { "-mthumb" } } */
++
++/* Below code used to trigger an ICE due to missing constraints for
++ sp = fp + cst pattern. */
++
++void fiq_handler (void) __attribute__((interrupt ("FIQ")));
++
++void
++fiq_handler (void)
++{
++}
+diff --git a/gcc/testsuite/gcc.target/arm/pr77933-1.c b/gcc/testsuite/gcc.target/arm/pr77933-1.c
+new file mode 100644
+index 0000000..95cf68e
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/arm/pr77933-1.c
+@@ -0,0 +1,46 @@
++/* { dg-do run } */
++/* { dg-options "-O2" } */
++
++__attribute__ ((noinline, noclone)) void
++clobber_lr_and_highregs (void)
++{
++ __asm__ volatile ("" : : : "r8", "r9", "lr");
++}
++
++int
++main (void)
++{
++ int ret;
++
++ __asm volatile ("mov\tr4, #0xf4\n\t"
++ "mov\tr5, #0xf5\n\t"
++ "mov\tr6, #0xf6\n\t"
++ "mov\tr7, #0xf7\n\t"
++ "mov\tr0, #0xf8\n\t"
++ "mov\tr8, r0\n\t"
++ "mov\tr0, #0xfa\n\t"
++ "mov\tr10, r0"
++ : : : "r0", "r4", "r5", "r6", "r7", "r8", "r10");
++
++ clobber_lr_and_highregs ();
++
++ __asm volatile ("cmp\tr4, #0xf4\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr5, #0xf5\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr6, #0xf6\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr7, #0xf7\n\t"
++ "bne\tfail\n\t"
++ "mov\tr0, r8\n\t"
++ "cmp\tr0, #0xf8\n\t"
++ "bne\tfail\n\t"
++ "mov\tr0, r10\n\t"
++ "cmp\tr0, #0xfa\n\t"
++ "bne\tfail\n\t"
++ "mov\t%0, #1\n"
++ "fail:\n\t"
++ "sub\tr0, #1"
++ : "=r" (ret) : :);
++ return ret;
++}
+diff --git a/gcc/testsuite/gcc.target/arm/pr77933-2.c b/gcc/testsuite/gcc.target/arm/pr77933-2.c
+new file mode 100644
+index 0000000..9028c4f
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/arm/pr77933-2.c
+@@ -0,0 +1,47 @@
++/* { dg-do run } */
++/* { dg-skip-if "" { ! { arm_thumb1_ok || arm_thumb2_ok } } } */
++/* { dg-options "-mthumb -O2 -mtpcs-leaf-frame" } */
++
++__attribute__ ((noinline, noclone)) void
++clobber_lr_and_highregs (void)
++{
++ __asm__ volatile ("" : : : "r8", "r9", "lr");
++}
++
++int
++main (void)
++{
++ int ret;
++
++ __asm volatile ("mov\tr4, #0xf4\n\t"
++ "mov\tr5, #0xf5\n\t"
++ "mov\tr6, #0xf6\n\t"
++ "mov\tr7, #0xf7\n\t"
++ "mov\tr0, #0xf8\n\t"
++ "mov\tr8, r0\n\t"
++ "mov\tr0, #0xfa\n\t"
++ "mov\tr10, r0"
++ : : : "r0", "r4", "r5", "r6", "r7", "r8", "r10");
++
++ clobber_lr_and_highregs ();
++
++ __asm volatile ("cmp\tr4, #0xf4\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr5, #0xf5\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr6, #0xf6\n\t"
++ "bne\tfail\n\t"
++ "cmp\tr7, #0xf7\n\t"
++ "bne\tfail\n\t"
++ "mov\tr0, r8\n\t"
++ "cmp\tr0, #0xf8\n\t"
++ "bne\tfail\n\t"
++ "mov\tr0, r10\n\t"
++ "cmp\tr0, #0xfa\n\t"
++ "bne\tfail\n\t"
++ "mov\t%0, #1\n"
++ "fail:\n\t"
++ "sub\tr0, #1"
++ : "=r" (ret) : :);
++ return ret;
++}
+diff --git a/gcc/testsuite/gcc.target/avr/pr65210.c b/gcc/testsuite/gcc.target/avr/pr65210.c
+new file mode 100644
+index 0000000..1aed441
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/avr/pr65210.c
+@@ -0,0 +1,7 @@
++/* { dg-do compile } */
++
++/* This testcase exposes PR65210. Usage of the io_low attribute
++ causes assertion failure because code only looks for the io
++ attribute if SYMBOL_FLAG_IO is set. */
++
++volatile char q __attribute__((io_low,address(0x81)));
+diff --git a/gcc/testsuite/gcc.target/avr/pr71103.c b/gcc/testsuite/gcc.target/avr/pr71103.c
+new file mode 100644
+index 0000000..43244d1
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/avr/pr71103.c
+@@ -0,0 +1,16 @@
++/* { dg-do compile } */
++/* { dg-options "-O1" } */
++
++struct ResponseStruct{
++ unsigned char responseLength;
++ char *response;
++};
++
++static char response[5];
++struct ResponseStruct something(){
++ struct ResponseStruct returnValue;
++ returnValue.responseLength = 5;
++ returnValue.response = response;
++ return returnValue;
++}
++
+diff --git a/gcc/testsuite/gcc.target/avr/torture/pr71103-2.c b/gcc/testsuite/gcc.target/avr/torture/pr71103-2.c
+new file mode 100644
+index 0000000..480ad05
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/avr/torture/pr71103-2.c
+@@ -0,0 +1,118 @@
++/* Use -g0 so that this test case doesn't just fail because
++ of PR52472. */
++
++/* { dg-do compile } */
++/* { dg-options "-std=gnu99 -g0" } */
++
++struct S12
++{
++ char c;
++ const char *p;
++};
++
++struct S12f
++{
++ char c;
++ struct S12f (*f)(void);
++};
++
++struct S12labl
++{
++ char c;
++ void **labl;
++};
++
++struct S121
++{
++ char c;
++ const char *p;
++ char d;
++};
++
++const char str[5] = "abcd";
++
++struct S12 test_S12_0 (void)
++{
++ struct S12 s;
++ s.c = 'A';
++ s.p = str;
++ return s;
++}
++
++struct S12 test_S12_4 (void)
++{
++ struct S12 s;
++ s.c = 'A';
++ s.p = str + 4;
++ return s;
++}
++
++struct S12f test_S12f (void)
++{
++ struct S12f s;
++ s.c = 'A';
++ s.f = test_S12f;
++ return s;
++}
++
++struct S121 test_S121 (void)
++{
++ struct S121 s;
++ s.c = 'c';
++ s.p = str + 4;
++ s.d = 'd';
++ return s;
++}
++
++extern void use_S12lab (struct S12labl*);
++
++struct S12labl test_S12lab (void)
++{
++ struct S12labl s;
++labl:;
++ s.c = 'A';
++ s.labl = &&labl;
++ return s;
++}
++
++#ifdef __MEMX
++
++struct S13
++{
++ char c;
++ const __memx char *p;
++};
++
++const __memx char str_x[] = "abcd";
++
++struct S13 test_S13_0 (void)
++{
++ struct S13 s;
++ s.c = 'A';
++ s.p = str_x;
++ return s;
++}
++
++struct S13 test_S13_4a (void)
++{
++ struct S13 s;
++ s.c = 'A';
++ s.p = str_x + 4;
++ return s;
++}
++
++#ifdef __FLASH1
++
++const __flash1 char str_1[] = "abcd";
++
++struct S13 test_13_4b (void)
++{
++ struct S13 s;
++ s.c = 'A';
++ s.p = str_1 + 4;
++ return s;
++}
++
++#endif /* have __flash1 */
++#endif /* have __memx */
++
+diff --git a/gcc/testsuite/gcc.target/avr/torture/pr77326.c b/gcc/testsuite/gcc.target/avr/torture/pr77326.c
+new file mode 100644
+index 0000000..7fe11ec
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/avr/torture/pr77326.c
+@@ -0,0 +1,26 @@
++/* { dg-do run } */
++/* { dg-options "-Wl,--defsym,test1=0" } */
++
++extern void test1 (void) __attribute__((weak));
++
++__attribute__((noinline,noclone))
++static void va_pseudo (int flag, ...)
++{
++ __asm ("nop":);
++}
++
++__attribute__((noinline,noclone))
++static void func (void)
++{
++ va_pseudo (0, 0, 0, 0);
++
++ if (test1)
++ __builtin_abort ();
++}
++
++int main (void)
++{
++ func();
++ __builtin_exit (0);
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.target/i386/avx2-pr70574.c b/gcc/testsuite/gcc.target/i386/avx2-pr70574.c
+new file mode 100644
+index 0000000..c9867dd
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/avx2-pr70574.c
+@@ -0,0 +1,26 @@
++/* PR rtl-optimization/70574 */
++/* { dg-do run { target lp64 } } */
++/* { dg-require-effective-target avx2 } */
++/* { dg-options "-O -frerun-cse-after-loop -fno-tree-ccp -mcmodel=medium -mavx2" } */
++/* { dg-additional-options "-fPIC" { target fpic } } */
++
++#include "avx2-check.h"
++
++typedef char A __attribute__((vector_size (32)));
++typedef short B __attribute__((vector_size (32)));
++
++int
++foo (int x, __int128 y, __int128 z, A w)
++{
++ y <<= 64;
++ w *= (A) { 0, -1, z, 0, ~y };
++ return w[0] + ((B) { x, 0, y, 0, -1 } | 1)[4];
++}
++
++static void
++avx2_test ()
++{
++ int x = foo (0, 0, 0, (A) {});
++ if (x != -1)
++ __builtin_abort ();
++}
+diff --git a/gcc/testsuite/gcc.target/i386/pcommit-1.c b/gcc/testsuite/gcc.target/i386/pcommit-1.c
+deleted file mode 100644
+index dc4bc9d..0000000
+--- a/gcc/testsuite/gcc.target/i386/pcommit-1.c
++++ /dev/null
+@@ -1,11 +0,0 @@
+-/* { dg-do compile } */
+-/* { dg-options "-O2 -mpcommit" } */
+-/* { dg-final { scan-assembler "pcommit" } } */
+-
+-#include "x86intrin.h"
+-
+-void
+-test_pcommit ()
+-{
+- _mm_pcommit ();
+-}
+diff --git a/gcc/testsuite/gcc.target/i386/pr76342.c b/gcc/testsuite/gcc.target/i386/pr76342.c
+new file mode 100644
+index 0000000..d492b00
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/pr76342.c
+@@ -0,0 +1,11 @@
++/* PR target/76342 */
++/* { dg-do compile } */
++/* { dg-options "-mavx512f" } */
++
++#include <immintrin.h>
++
++__m512i
++test()
++{
++ return _mm512_undefined_epi32 ();
++}
+diff --git a/gcc/testsuite/gcc.target/i386/pr77403.c b/gcc/testsuite/gcc.target/i386/pr77403.c
+new file mode 100644
+index 0000000..9f6775a
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/pr77403.c
+@@ -0,0 +1,15 @@
++/* { dg-do assemble } */
++/* { dg-require-effective-target int128 } */
++/* { dg-require-effective-target avx512f } */
++/* { dg-require-effective-target masm_intel } */
++/* { dg-options "-O -mavx512f -masm=intel" } */
++
++typedef __int128 V __attribute__((vector_size(64)));
++
++V v;
++
++void
++foo()
++{
++ v ^= (V){1};
++}
+diff --git a/gcc/testsuite/gcc.target/i386/pr77991.c b/gcc/testsuite/gcc.target/i386/pr77991.c
+new file mode 100644
+index 0000000..6784fbc
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/pr77991.c
+@@ -0,0 +1,19 @@
++/* { dg-do compile { target { ! ia32 } } } */
++/* { dg-require-effective-target maybe_x32 } */
++/* { dg-options "-O2 -mx32 -maddress-mode=short" } */
++
++struct rcu_reader_data
++{
++ unsigned ctr;
++ _Bool waiting;
++}
++
++extern __thread rcu_reader;
++
++void rcu_read_lock()
++{
++ struct rcu_reader_data *x = &rcu_reader;
++ _Bool val = 0;
++
++ __atomic_store(&x->waiting, &val, 0);
++}
+diff --git a/gcc/testsuite/gcc.target/i386/pr78262.c b/gcc/testsuite/gcc.target/i386/pr78262.c
+new file mode 100644
+index 0000000..a0ead417
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/pr78262.c
+@@ -0,0 +1,32 @@
++/* { dg-do run } */
++/* { dg-require-effective-target int128 } */
++/* { dg-options "-O -fschedule-insns" } */
++
++typedef unsigned char u8;
++typedef unsigned __int128 u128;
++
++static u128 u128_0;
++static u128 *p128;
++
++u128 __attribute__ ((noinline, noclone))
++foo(u8 u8_0)
++{
++ p128 = &u128_0;
++ u128_0 = u8_0;
++ u128_0 = u128_0 << 127 | u128_0 >> 1;
++ u128_0 >>= (u8)u128_0;
++ return 2 + u128_0;
++}
++
++int
++main()
++{
++ u128 x = foo(5);
++ if (p128 != &u128_0)
++ __builtin_abort();
++ if (u128_0 != ((u128)2 << 124))
++ __builtin_abort();
++ if (x != ((u128)2 << 124) + 2)
++ __builtin_abort();
++ return 0;
++}
+diff --git a/gcc/testsuite/gcc.target/i386/pr78310.c b/gcc/testsuite/gcc.target/i386/pr78310.c
+new file mode 100644
+index 0000000..dfeae4c
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/i386/pr78310.c
+@@ -0,0 +1,15 @@
++/* { dg-do compile { target { ! ia32 } } } */
++/* { dg-options "-O -mbmi2" } */
++
++unsigned long long a;
++int b;
++
++int
++fn1(int p1)
++{
++ p1 &= 1;
++ p1 &= (short)~p1;
++ b = a;
++ a = a << p1 | a >> (64 - p1);
++ return p1 + 1 + a;
++}
+diff --git a/gcc/testsuite/gcc.target/i386/sse-12.c b/gcc/testsuite/gcc.target/i386/sse-12.c
+index 1db0d8b..83f07ec 100644
+--- a/gcc/testsuite/gcc.target/i386/sse-12.c
++++ b/gcc/testsuite/gcc.target/i386/sse-12.c
+@@ -3,7 +3,7 @@
+ popcntintrin.h and mm_malloc.h are usable
+ with -O -std=c89 -pedantic-errors. */
+ /* { dg-do compile } */
+-/* { dg-options "-O -std=c89 -pedantic-errors -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512bw -mavx512dq -mavx512vl -mavx512vbmi -mavx512ifma -mclwb -mpcommit -mmwaitx" } */
++/* { dg-options "-O -std=c89 -pedantic-errors -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512bw -mavx512dq -mavx512vl -mavx512vbmi -mavx512ifma -mclwb -mmwaitx" } */
+
+ #include <x86intrin.h>
+
+diff --git a/gcc/testsuite/gcc.target/i386/sse-13.c b/gcc/testsuite/gcc.target/i386/sse-13.c
+index 13d9eb8..40dde9c 100644
+--- a/gcc/testsuite/gcc.target/i386/sse-13.c
++++ b/gcc/testsuite/gcc.target/i386/sse-13.c
+@@ -1,5 +1,5 @@
+ /* { dg-do compile } */
+-/* { dg-options "-O2 -Werror-implicit-function-declaration -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512vl -mavx512dq -mavx512bw -mavx512vbmi -mavx512ifma -mclwb -mpcommit -mmwaitx" } */
++/* { dg-options "-O2 -Werror-implicit-function-declaration -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512vl -mavx512dq -mavx512bw -mavx512vbmi -mavx512ifma -mclwb -mmwaitx" } */
+
+ #include <mm_malloc.h>
+
+diff --git a/gcc/testsuite/gcc.target/i386/sse-14.c b/gcc/testsuite/gcc.target/i386/sse-14.c
+index 52f7802..4750fa1 100644
+--- a/gcc/testsuite/gcc.target/i386/sse-14.c
++++ b/gcc/testsuite/gcc.target/i386/sse-14.c
+@@ -1,5 +1,5 @@
+ /* { dg-do compile } */
+-/* { dg-options "-O0 -Werror-implicit-function-declaration -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mpcommit -mmwaitx" } */
++/* { dg-options "-O0 -Werror-implicit-function-declaration -march=k8 -msse4a -m3dnow -mavx -mavx2 -mfma4 -mxop -maes -mpclmul -mpopcnt -mabm -mlzcnt -mbmi -mbmi2 -mtbm -mlwp -mfsgsbase -mrdrnd -mf16c -mfma -mrtm -mrdseed -mprfchw -madx -mfxsr -mxsaveopt -mavx512f -mavx512er -mavx512cd -mavx512pf -msha -mprefetchwt1 -mxsavec -mxsaves -mclflushopt -mavx512dq -mavx512bw -mavx512vl -mavx512ifma -mavx512vbmi -mclwb -mmwaitx" } */
+ /* { dg-add-options bind_pic_locally } */
+
+ #include <mm_malloc.h>
+diff --git a/gcc/testsuite/gcc.target/i386/sse-22.c b/gcc/testsuite/gcc.target/i386/sse-22.c
+index 72017f5..39a40ca 100644
+--- a/gcc/testsuite/gcc.target/i386/sse-22.c
++++ b/gcc/testsuite/gcc.target/i386/sse-22.c
+@@ -699,7 +699,7 @@ test_2 (_mm_clmulepi64_si128, __m128i, __m128i, __m128i, 1)
+
+ /* x86intrin.h (FMA4/XOP/LWP/BMI/BMI2/TBM/LZCNT/FMA). */
+ #ifdef DIFFERENT_PRAGMAS
+-#pragma GCC target ("fma4,xop,lwp,bmi,bmi2,tbm,lzcnt,fma,rdseed,prfchw,adx,fxsr,xsaveopt,xsavec,xsaves,clflushopt,clwb,pcommit")
++#pragma GCC target ("fma4,xop,lwp,bmi,bmi2,tbm,lzcnt,fma,rdseed,prfchw,adx,fxsr,xsaveopt,xsavec,xsaves,clflushopt,clwb")
+ #endif
+ #include <x86intrin.h>
+ /* xopintrin.h */
+diff --git a/gcc/testsuite/gcc.target/i386/sse-23.c b/gcc/testsuite/gcc.target/i386/sse-23.c
+index a3660f8..a00c1dd 100644
+--- a/gcc/testsuite/gcc.target/i386/sse-23.c
++++ b/gcc/testsuite/gcc.target/i386/sse-23.c
+@@ -594,6 +594,6 @@
+ #define __builtin_ia32_extracti64x2_256_mask(A, E, C, D) __builtin_ia32_extracti64x2_256_mask(A, 1, C, D)
+ #define __builtin_ia32_extractf64x2_256_mask(A, E, C, D) __builtin_ia32_extractf64x2_256_mask(A, 1, C, D)
+
+-#pragma GCC target ("sse4a,3dnow,avx,avx2,fma4,xop,aes,pclmul,popcnt,abm,lzcnt,bmi,bmi2,tbm,lwp,fsgsbase,rdrnd,f16c,fma,rtm,rdseed,prfchw,adx,fxsr,xsaveopt,avx512f,avx512er,avx512cd,avx512pf,sha,prefetchwt1,xsavec,xsaves,clflushopt,avx512bw,avx512dq,avx512vl,avx512vbmi,avx512ifma,clwb,pcommit,mwaitx")
++#pragma GCC target ("sse4a,3dnow,avx,avx2,fma4,xop,aes,pclmul,popcnt,abm,lzcnt,bmi,bmi2,tbm,lwp,fsgsbase,rdrnd,f16c,fma,rtm,rdseed,prfchw,adx,fxsr,xsaveopt,avx512f,avx512er,avx512cd,avx512pf,sha,prefetchwt1,xsavec,xsaves,clflushopt,avx512bw,avx512dq,avx512vl,avx512vbmi,avx512ifma,clwb,mwaitx")
+
+ #include <x86intrin.h>
+diff --git a/gcc/testsuite/gcc.target/powerpc/pr71763.c b/gcc/testsuite/gcc.target/powerpc/pr71763.c
+new file mode 100644
+index 0000000..7910a90
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/powerpc/pr71763.c
+@@ -0,0 +1,27 @@
++// PR target/71763
++// { dg-do compile }
++// { dg-options "-O1 -mvsx" }
++// { dg-xfail-if "PR70098" { lp64 && powerpc64_no_dm } }
++// { dg-prune-output ".*internal compiler error.*" }
++
++int a, b;
++float c;
++
++void fn2(void);
++
++void fn1(void)
++{
++ long d;
++
++ for (d = 3; d; d--) {
++ for (a = 0; a <= 1; a++) {
++ b &= 1;
++ if (b) {
++ for (;;) {
++ fn2();
++ c = d;
++ }
++ }
++ }
++ }
++}
+diff --git a/gcc/testsuite/gcc.target/powerpc/pr72863.c b/gcc/testsuite/gcc.target/powerpc/pr72863.c
+new file mode 100644
+index 0000000..26328f2
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/powerpc/pr72863.c
+@@ -0,0 +1,27 @@
++/* { dg-do compile { target { powerpc64le-*-* } } } */
++/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
++/* { dg-options "-mcpu=power8 -O3" } */
++/* { dg-final { scan-assembler "lxvd2x" } } */
++/* { dg-final { scan-assembler "stxvd2x" } } */
++/* { dg-final { scan-assembler-not "xxpermdi" } } */
++
++#include <altivec.h>
++
++extern unsigned char *src, *dst;
++
++void b(void)
++{
++ int i;
++
++ unsigned char *s8 = src;
++ unsigned char *d8 = dst;
++
++ for (i = 0; i < 100; i++) {
++ vector unsigned char vs = vec_vsx_ld(0, s8);
++ vector unsigned char vd = vec_vsx_ld(0, d8);
++ vector unsigned char vr = vec_xor(vs, vd);
++ vec_vsx_st(vr, 0, d8);
++ s8 += 16;
++ d8 += 16;
++ }
++}
+diff --git a/gcc/testsuite/gcc.target/powerpc/ti_math1.c b/gcc/testsuite/gcc.target/powerpc/ti_math1.c
+index cdf9251..6f4ae64 100644
+--- a/gcc/testsuite/gcc.target/powerpc/ti_math1.c
++++ b/gcc/testsuite/gcc.target/powerpc/ti_math1.c
+@@ -1,7 +1,7 @@
+ /* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
+ /* { dg-options "-O2" } */
+ /* { dg-final { scan-assembler-times "addc" 1 } } */
+-/* { dg-final { scan-assembler-times "adde" 1 } } */
++/* { dg-final { scan-assembler-times "addz?e" 1 } } */
+ /* { dg-final { scan-assembler-times "subfc" 1 } } */
+ /* { dg-final { scan-assembler-times "subfe" 1 } } */
+ /* { dg-final { scan-assembler-not "subf " } } */
+diff --git a/gcc/testsuite/gcc.target/s390/vector/vec-scalar-cmp-1.c b/gcc/testsuite/gcc.target/s390/vector/vec-scalar-cmp-1.c
+index b79120f..5e61abf 100644
+--- a/gcc/testsuite/gcc.target/s390/vector/vec-scalar-cmp-1.c
++++ b/gcc/testsuite/gcc.target/s390/vector/vec-scalar-cmp-1.c
+@@ -1,16 +1,7 @@
+ /* Check that we use the scalar variants of vector compares. */
+
+ /* { dg-do compile { target { s390*-*-* } } } */
+-/* { dg-options "-O3 -mzarch -march=z13" } */
+-
+-/* { dg-final { scan-assembler-times "wfcedbs\t%v\[0-9\]*,%v0,%v2" 2 } } */
+-/* { dg-final { scan-assembler-times "wfchdbs\t%v\[0-9\]*,%v0,%v2" 1 } } */
+-/* { dg-final { scan-assembler-times "wfchedbs\t%v\[0-9\]*,%v2,%v0" 1 } } */
+-/* { dg-final { scan-assembler-times "wfchdbs\t%v\[0-9\]*,%v2,%v0" 1 } } */
+-/* { dg-final { scan-assembler-times "wfchedbs\t%v\[0-9\]*,%v2,%v0" 1 } } */
+-/* { dg-final { scan-assembler-times "locrne" 5 } } */
+-/* { dg-final { scan-assembler-times "locrno" 1 } } */
+-
++/* { dg-options "-O3 -mzarch -march=z13 -fno-asynchronous-unwind-tables" } */
+
+ int
+ eq (double a, double b)
+@@ -18,32 +9,44 @@ eq (double a, double b)
+ return a == b;
+ }
+
++/* { dg-final { scan-assembler "eq:\n\twfcedbs\t%v\[0-9\]*,%v0,%v2\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocrne\t%r2,%r1" } } */
++
+ int
+ ne (double a, double b)
+ {
+ return a != b;
+ }
+
++/* { dg-final { scan-assembler "ne:\n\twfcedbs\t%v\[0-9\]*,%v0,%v2\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocre\t%r2,%r1" } } */
++
+ int
+ gt (double a, double b)
+ {
+ return a > b;
+ }
+
++/* { dg-final { scan-assembler "gt:\n\twfchdbs\t%v\[0-9\]*,%v0,%v2\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocrne\t%r2,%r1" } } */
++
+ int
+ ge (double a, double b)
+ {
+ return a >= b;
+ }
+
++/* { dg-final { scan-assembler "ge:\n\twfchedbs\t%v\[0-9\]*,%v0,%v2\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocrne\t%r2,%r1" } } */
++
+ int
+ lt (double a, double b)
+ {
+ return a < b;
+ }
+
++/* { dg-final { scan-assembler "lt:\n\twfchdbs\t%v\[0-9\]*,%v2,%v0\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocrne\t%r2,%r1" } } */
++
+ int
+ le (double a, double b)
+ {
+ return a <= b;
+ }
++
++/* { dg-final { scan-assembler "le:\n\twfchedbs\t%v\[0-9\]*,%v2,%v0\n\tlhi\t%r1,0\n\tlhi\t%r2,1\n\tlocrne\t%r2,%r1" } } */
+diff --git a/gcc/testsuite/gcc.target/s390/zvector/vec-cmp-1.c b/gcc/testsuite/gcc.target/s390/zvector/vec-cmp-1.c
+new file mode 100644
+index 0000000..438da2a
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/s390/zvector/vec-cmp-1.c
+@@ -0,0 +1,174 @@
++/* { dg-do compile { target { s390*-*-* } } } */
++/* { dg-options "-O3 -mzarch -march=z13 -mzvector -fno-asynchronous-unwind-tables" } */
++
++#include <vecintrin.h>
++
++int __attribute__((noinline,noclone))
++all_eq_double (vector double a, vector double b)
++{
++ return vec_all_eq (a, b);
++}
++/* { dg-final { scan-assembler-times all_eq_double:\n\tvfcedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_ne_double (vector double a, vector double b)
++{
++ return vec_all_ne (a, b);
++}
++/* { dg-final { scan-assembler-times all_ne_double:\n\tvfcedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrnle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_gt_double (vector double a, vector double b)
++{
++ return vec_all_gt (a, b);
++}
++/* { dg-final { scan-assembler-times all_gt_double:\n\tvfchdbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_lt_double (vector double a, vector double b)
++{
++ return vec_all_lt (a, b);
++}
++/* { dg-final { scan-assembler-times all_lt_double:\n\tvfchdbs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_ge_double (vector double a, vector double b)
++{
++ return vec_all_ge (a, b);
++}
++/* { dg-final { scan-assembler-times all_ge_double:\n\tvfchedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_le_double (vector double a, vector double b)
++{
++ return vec_all_le (a, b);
++}
++/* { dg-final { scan-assembler-times all_le_double:\n\tvfchedbs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_eq_double (vector double a, vector double b)
++{
++ return vec_any_eq (a, b);
++}
++/* { dg-final { scan-assembler-times any_eq_double:\n\tvfcedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_ne_double (vector double a, vector double b)
++{
++ return vec_any_ne (a, b);
++}
++/* { dg-final { scan-assembler-times any_ne_double:\n\tvfcedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrne\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_gt_double (vector double a, vector double b)
++{
++ return vec_any_gt (a, b);
++}
++/* { dg-final { scan-assembler-times any_gt_double:\n\tvfchdbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_lt_double (vector double a, vector double b)
++{
++ return vec_any_lt (a, b);
++}
++/* { dg-final { scan-assembler-times any_lt_double:\n\tvfchdbs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_ge_double (vector double a, vector double b)
++{
++ return vec_any_ge (a, b);
++}
++/* { dg-final { scan-assembler-times any_ge_double:\n\tvfchedbs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_le_double (vector double a, vector double b)
++{
++ return vec_any_le (a, b);
++}
++/* { dg-final { scan-assembler-times any_le_double:\n\tvfchedbs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_eq_int (vector int a, vector int b)
++{
++ return vec_all_eq (a, b);
++}
++/* { dg-final { scan-assembler-times all_eq_int:\n\tvceqfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_ne_int (vector int a, vector int b)
++{
++ return vec_all_ne (a, b);
++}
++/* { dg-final { scan-assembler-times all_ne_int:\n\tvceqfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrnle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_gt_int (vector int a, vector int b)
++{
++ return vec_all_gt (a, b);
++}
++/* { dg-final { scan-assembler-times all_gt_int:\n\tvchfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_lt_int (vector int a, vector int b)
++{
++ return vec_all_lt (a, b);
++}
++/* { dg-final { scan-assembler-times all_lt_int:\n\tvchfs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocre\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_ge_int (vector int a, vector int b)
++{
++ return vec_all_ge (a, b);
++}
++/* { dg-final { scan-assembler-times all_ge_int:\n\tvchfs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrnle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++all_le_int (vector int a, vector int b)
++{
++ return vec_all_le (a, b);
++}
++/* { dg-final { scan-assembler-times all_le_int:\n\tvchfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrnle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_eq_int (vector int a, vector int b)
++{
++ return vec_any_eq (a, b);
++}
++/* { dg-final { scan-assembler-times any_eq_int:\n\tvceqfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_ne_int (vector int a, vector int b)
++{
++ return vec_any_ne (a, b);
++}
++/* { dg-final { scan-assembler-times any_ne_int:\n\tvceqfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrne\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_gt_int (vector int a, vector int b)
++{
++ return vec_any_gt (a, b);
++}
++/* { dg-final { scan-assembler-times any_gt_int:\n\tvchfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_lt_int (vector int a, vector int b)
++{
++ return vec_any_lt (a, b);
++}
++/* { dg-final { scan-assembler-times any_lt_int:\n\tvchfs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrle\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_ge_int (vector int a, vector int b)
++{
++ return vec_any_ge (a, b);
++}
++/* { dg-final { scan-assembler-times any_ge_int:\n\tvchfs\t%v\[0-9\]*,%v26,%v24\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrne\t%r2,%r1 1 } } */
++
++int __attribute__((noinline,noclone))
++any_le_int (vector int a, vector int b)
++{
++ return vec_any_le (a, b);
++}
++/* { dg-final { scan-assembler-times any_le_int:\n\tvchfs\t%v\[0-9\]*,%v24,%v26\n\tlhi\t%r1,1\n\tlhi\t%r2,0\n\tlocrne\t%r2,%r1 1 } } */
++
++
+diff --git a/gcc/testsuite/gcc.target/sparc/bmaskbshuf.c b/gcc/testsuite/gcc.target/sparc/bmaskbshuf-1.c
+similarity index 100%
+rename from gcc/testsuite/gcc.target/sparc/bmaskbshuf.c
+rename to gcc/testsuite/gcc.target/sparc/bmaskbshuf-1.c
+diff --git a/gcc/testsuite/gcc.target/sparc/bmaskbshuf-2.c b/gcc/testsuite/gcc.target/sparc/bmaskbshuf-2.c
+new file mode 100644
+index 0000000..874e3db
+--- /dev/null
++++ b/gcc/testsuite/gcc.target/sparc/bmaskbshuf-2.c
+@@ -0,0 +1,42 @@
++/* { dg-do run } */
++/* { dg-require-effective-target ultrasparc_vis2_hw } */
++/* { dg-options "-mcpu=ultrasparc3 -O" } */
++
++typedef unsigned int Vect __attribute__((vector_size(8)));
++
++extern void abort (void);
++
++Vect a, b, c, d;
++
++__attribute__((noinline, noclone)) void test (void)
++{
++ Vect mask = { 2, 2 };
++ int i;
++
++ c = __builtin_shuffle (a, mask);
++ d = __builtin_shuffle (a, b, mask);
++
++ __asm__ ("" : : "r" (&c), "r" (&d) : "memory");
++
++ for (i = 0; i < 2; ++i)
++ if (c[i] != a[mask[i] & 1])
++ abort ();
++ else if (mask[i] & 2)
++ {
++ if (d[i] != b[mask[i] & 1])
++ abort ();
++ }
++}
++
++int main (void)
++{
++ int i;
++ for (i = 0; i < 2; ++i)
++ {
++ a[i] = i + 2;
++ b[i] = 2 + i + 2;
++ }
++
++ test ();
++ return 0;
++}
+diff --git a/gcc/testsuite/gfortran.dg/allocate_with_source_20.f03 b/gcc/testsuite/gfortran.dg/allocate_with_source_20.f03
+new file mode 100644
+index 0000000..67b50ec
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/allocate_with_source_20.f03
+@@ -0,0 +1,21 @@
++! { dg-do run }
++
++! Check that PR72698 is fixed.
++! Contributed by Gerhard Steinmetz
++
++module m
++contains
++ integer function f()
++ f = 4
++ end
++end
++program p
++ use m
++ character(3), parameter :: c = 'abc'
++ character(:), allocatable :: z
++ allocate (z, source=repeat(c(2:1), f()))
++ if (len(z) /= 0) call abort()
++ if (z /= "") call abort()
++end
++
++
+diff --git a/gcc/testsuite/gfortran.dg/array_constructor_26.f03 b/gcc/testsuite/gfortran.dg/array_constructor_26.f03
+index 9993099..bb40d09 100644
+--- a/gcc/testsuite/gfortran.dg/array_constructor_26.f03
++++ b/gcc/testsuite/gfortran.dg/array_constructor_26.f03
+@@ -10,7 +10,6 @@ MODULE WinData
+ INTEGER (1), PARAMETER :: MAXFLD = 25_1, MAXHED = 5_1, MAXCHR = 80_1
+ integer :: i
+ TYPE TWindowData
+- CHARACTER (MAX_FLD_HED, 1) :: DWFdHd(MAXFLD) = [(" ", i = 1, MAXFLD)]
+- ! { dg-error "specification expression" "" { target *-*-* } 13 }
++ CHARACTER (MAX_FLD_HED, 1) :: DWFdHd(MAXFLD) = [(" ", i = 1, MAXFLD)] ! { dg-error "Scalar INTEGER expression" }
+ END TYPE TWindowData
+ END MODULE WinData
+diff --git a/gcc/testsuite/gfortran.dg/array_constructor_27.f03 b/gcc/testsuite/gfortran.dg/array_constructor_27.f03
+index 21adac8..de0217a 100644
+--- a/gcc/testsuite/gfortran.dg/array_constructor_27.f03
++++ b/gcc/testsuite/gfortran.dg/array_constructor_27.f03
+@@ -8,8 +8,7 @@
+ implicit none
+
+ type t
+- character (a) :: arr (1) = [ "a" ]
+- ! { dg-error "specification expression" "" { target *-*-* } 11 }
++ character (a) :: arr (1) = [ "a" ] ! { dg-error "Scalar INTEGER expression" }
+ end type t
+
+ end
+diff --git a/gcc/testsuite/gfortran.dg/array_constructor_49.f90 b/gcc/testsuite/gfortran.dg/array_constructor_49.f90
+index 6a198d6..a54ab54 100644
+--- a/gcc/testsuite/gfortran.dg/array_constructor_49.f90
++++ b/gcc/testsuite/gfortran.dg/array_constructor_49.f90
+@@ -6,7 +6,7 @@
+ program t
+ integer :: ndim=2, ndfp=4, i
+ character (len=8) :: line
+- write (unit=line,fmt='(4I2)'), (/ ( i, i = 1, ndfp ) /) + ndim
++ write (unit=line,fmt='(4I2)') (/ ( i, i = 1, ndfp ) /) + ndim
+ if (line /= ' 3 4 5 6') call abort
+ end program t
+ ! { dg-final { scan-tree-dump-times "__var" 3 "original" } }
+diff --git a/gcc/testsuite/gfortran.dg/array_constructor_50.f90 b/gcc/testsuite/gfortran.dg/array_constructor_50.f90
+new file mode 100644
+index 0000000..c22c980
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/array_constructor_50.f90
+@@ -0,0 +1,21 @@
++! { dg-do run }
++! PR 71795 - wrong result when putting an array constructor
++! instide an iterator.
++ program test
++
++ implicit none
++ integer :: i,n
++ logical, dimension(1) :: ra
++ logical :: rs
++ integer, allocatable :: a(:)
++
++ allocate ( a(1) )
++
++ n = 1
++ a = 2
++
++ ra = (/ (any(a(i).eq.(/1,2,3/)) ,i=1,n) /)
++ if (.not. all(ra)) call abort
++ rs = any ( (/ (any(a(i).eq.(/1,2,3/)) ,i=1,n) /) )
++ if (.not. rs) call abort
++ end program test
+diff --git a/gcc/testsuite/gfortran.dg/associate_21.f90 b/gcc/testsuite/gfortran.dg/associate_21.f90
+new file mode 100644
+index 0000000..a7bbaba
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/associate_21.f90
+@@ -0,0 +1,19 @@
++! { dg-do compile }
++! { dg-options "-ffrontend-optimize" }
++! PR 69742 - this used to ICE with front-end optimizatoin
++! Original test case by Marco Restelli.
++program p
++ implicit none
++ integer, allocatable :: i(:), j
++
++ allocate( i(5) )
++ i = (/( j , j=1,5 )/)
++
++ ! The ICE appears when "size(i)" is used twice in associate
++ associate( i5 => i(size(i):size(i)) ) ! this gives ICE
++ !associate( i5 => i(size(2*i):size(i)) ) ! this works
++ i5 = 2
++ end associate
++
++ write(*,*) i
++end program p
+diff --git a/gcc/testsuite/gfortran.dg/associate_22.f90 b/gcc/testsuite/gfortran.dg/associate_22.f90
+new file mode 100644
+index 0000000..1558992
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/associate_22.f90
+@@ -0,0 +1,37 @@
++! { dg-do run }
++program foo
++
++ implicit none
++
++ character(len=4) :: s
++ character(len=10) :: a
++
++ ! This works.
++ s = 'abc'
++ associate(t => s)
++ if (trim(t) /= 'abc') call abort
++ end associate
++
++ ! This failed.
++ associate(u => 'abc')
++ if (trim(u) /= 'abc') call abort
++ end associate
++
++ ! This failed.
++ a = s // 'abc'
++ associate(v => s // 'abc')
++ if (trim(v) /= trim(a)) call abort
++ end associate
++
++ ! This failed.
++ a = trim(s) // 'abc'
++ associate(w => trim(s) // 'abc')
++ if (trim(w) /= trim(a)) call abort
++ end associate
++
++ ! This failed.
++ associate(x => trim('abc'))
++ if (trim(x) /= 'abc') call abort
++ end associate
++
++end program foo
+diff --git a/gcc/testsuite/gfortran.dg/bounds_check_strlen_2.f90 b/gcc/testsuite/gfortran.dg/bounds_check_strlen_2.f90
+index 241db66..73c2ea8 100644
+--- a/gcc/testsuite/gfortran.dg/bounds_check_strlen_2.f90
++++ b/gcc/testsuite/gfortran.dg/bounds_check_strlen_2.f90
+@@ -11,8 +11,8 @@ CONTAINS
+
+ SUBROUTINE test (str, n)
+ IMPLICIT NONE
+- CHARACTER(len=n) :: str
+ INTEGER :: n
++ CHARACTER(len=n) :: str
+ END SUBROUTINE test
+
+ SUBROUTINE test2 (str)
+diff --git a/gcc/testsuite/gfortran.dg/c_assoc_2.f03 b/gcc/testsuite/gfortran.dg/c_assoc_2.f03
+index 275e88e..5d77249 100644
+--- a/gcc/testsuite/gfortran.dg/c_assoc_2.f03
++++ b/gcc/testsuite/gfortran.dg/c_assoc_2.f03
+@@ -20,7 +20,7 @@ contains
+ call abort()
+ end if
+
+- if(.not. c_associated()) then ! { dg-error "Missing actual argument 'C_PTR_1' in call to 'c_associated'" }
++ if(.not. c_associated()) then ! { dg-error "Missing actual argument 'c_ptr_1' in call to 'c_associated'" }
+ call abort()
+ end if
+
+diff --git a/gcc/testsuite/gfortran.dg/c_assoc_4.f90 b/gcc/testsuite/gfortran.dg/c_assoc_4.f90
+index 5421a36..8a7fe73 100644
+--- a/gcc/testsuite/gfortran.dg/c_assoc_4.f90
++++ b/gcc/testsuite/gfortran.dg/c_assoc_4.f90
+@@ -9,6 +9,6 @@ PROGRAM test
+
+ TYPE (C_PTR) :: x, y
+
+- PRINT *, C_ASSOCIATED([x,y]) ! { dg-error "'C_PTR_1' argument of 'c_associated' intrinsic at .1. must be a scalar" }
++ PRINT *, C_ASSOCIATED([x,y]) ! { dg-error "'c_ptr_1' argument of 'c_associated' intrinsic at .1. must be a scalar" }
+
+ END PROGRAM test
+diff --git a/gcc/testsuite/gfortran.dg/c_by_val_1.f b/gcc/testsuite/gfortran.dg/c_by_val_1.f
+index af1e25a..3c5c3d7 100644
+--- a/gcc/testsuite/gfortran.dg/c_by_val_1.f
++++ b/gcc/testsuite/gfortran.dg/c_by_val_1.f
+@@ -9,8 +9,8 @@ C { dg-options "-ff2c -w -O0" }
+ real(8) a8, b8, c8
+ integer(4) i, j, k
+ integer(8) i8, j8, k8
+- complex u, v, w, c_to_c
+- complex(8) u8, v8, w8, c_to_c8
++ complex u, v, w
++ complex(8) u8, v8, w8
+
+ a = 42.0
+ b = 0.0
+@@ -39,13 +39,13 @@ C { dg-options "-ff2c -w -O0" }
+ u = (-1.0, 2.0)
+ v = (1.0, -2.0)
+ w = u
+- v = c_to_c (%VAL (u), %REF (w), %LOC (w))
++ call c_to_c (v, %VAL (u), %REF (w), %LOC (w))
+ if ((4.0 * u).ne.v) call abort ()
+
+ u8 = (-1.0, 2.0)
+ v8 = (1.0, -2.0)
+ w8 = u8
+- v8 = c_to_c8 (%VAL (u8), %REF (w8), %LOC (w8))
++ call c_to_c8 (v8, %VAL (u8), %REF (w8), %LOC (w8))
+ if ((4.0 * u8).ne.v8) call abort ()
+
+ stop
+diff --git a/gcc/testsuite/gfortran.dg/class_result_4.f90 b/gcc/testsuite/gfortran.dg/class_result_4.f90
+new file mode 100644
+index 0000000..4b22a3c
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/class_result_4.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++! PR fortran/78500
++class(t) function f() ! { dg-error "must be dummy, allocatable or pointer" }
++ f = 1 ! { dg-error "variable must not be polymorphic" }
++end
++
+diff --git a/gcc/testsuite/gfortran.dg/coarray_collectives_1.f90 b/gcc/testsuite/gfortran.dg/coarray_collectives_1.f90
+index a09a81f..cdb3993 100644
+--- a/gcc/testsuite/gfortran.dg/coarray_collectives_1.f90
++++ b/gcc/testsuite/gfortran.dg/coarray_collectives_1.f90
+@@ -14,7 +14,7 @@ program test
+ integer(8) :: i8
+ character(len=19, kind=4) :: msg4
+
+- call co_sum("abc") ! { dg-error "must be a numeric type" }
++ call co_sum("abc") ! { dg-error "must have a numeric type" }
+ call co_max(cmplx(1.0,0.0)) ! { dg-error "shall be of type integer, real or character" }
+ call co_min(cmplx(0.0,1.0)) ! { dg-error "shall be of type integer, real or character" }
+
+diff --git a/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90 b/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90
+new file mode 100644
+index 0000000..abbb69d
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90
+@@ -0,0 +1,8 @@
++! { dg-do compile }
++! PR 60751
++! Contributed by Walter Spector <w6ws@earthlink.net>
++program extracomma
++ implicit none
++
++ write (*,*), 1, 2, 3 ! { dg-warning "Legacy Extension: Comma before i/o item list" }
++end program
+diff --git a/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90 b/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90
+new file mode 100644
+index 0000000..5e80a17
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90
+@@ -0,0 +1,9 @@
++! { dg-do compile }
++! { dg-options "-std=legacy" }
++! PR 60751
++! Contributed by Walter Spector <w6ws@earthlink.net>
++program extracomma
++ implicit none
++
++ write (*,*), 1, 2, 3
++end program
+diff --git a/gcc/testsuite/gfortran.dg/deferred_character_18.f90 b/gcc/testsuite/gfortran.dg/deferred_character_18.f90
+new file mode 100644
+index 0000000..5a9d725
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/deferred_character_18.f90
+@@ -0,0 +1,13 @@
++!{ dg-do run }
++
++! Check fix for PR fortran/71623
++
++program allocatemvce
++ implicit none
++ character(len=:), allocatable :: string
++ integer, dimension(4), target :: array = [1,2,3,4]
++ integer, dimension(:), pointer :: array_ptr
++ array_ptr => array
++ ! The allocate used to segfault
++ allocate(character(len=size(array_ptr))::string)
++end program allocatemvce
+diff --git a/gcc/testsuite/gfortran.dg/dependency_46.f90 b/gcc/testsuite/gfortran.dg/dependency_46.f90
+new file mode 100644
+index 0000000..28942a8
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/dependency_46.f90
+@@ -0,0 +1,11 @@
++! { dg-do compile }
++! PR 71783 - this used to ICE due to a missing charlen for the temporary.
++! Test case by Toon Moene.
++
++SUBROUTINE prtdata(ilen)
++ INTEGER :: ilen
++ character(len=ilen), allocatable :: cline(:)
++ allocate(cline(2))
++ cline(1) = 'a'
++ cline(2) = cline(1)
++END SUBROUTINE prtdata
+diff --git a/gcc/testsuite/gfortran.dg/dependency_47.f90 b/gcc/testsuite/gfortran.dg/dependency_47.f90
+new file mode 100644
+index 0000000..4888771
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/dependency_47.f90
+@@ -0,0 +1,14 @@
++! { dg-do compile }
++! Make sure there is only one instance of a temporary variable here.
++! { dg-options "-fdump-tree-original" }
++
++SUBROUTINE prtdata(ilen)
++ INTEGER :: ilen
++ character(len=ilen), allocatable :: cline(:)
++ allocate(cline(2))
++ cline(1) = 'a'
++ cline(1)(2:3) = cline(1)(1:2)
++ cline(2) = cline(1)
++ print *,c
++END SUBROUTINE prtdata
++! { dg-final { scan-tree-dump-not "__var_" "original" } }
+diff --git a/gcc/testsuite/gfortran.dg/dependency_48.f90 b/gcc/testsuite/gfortran.dg/dependency_48.f90
+new file mode 100644
+index 0000000..6470019
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/dependency_48.f90
+@@ -0,0 +1,26 @@
++! { dg-do compile }
++! { dg-options "-frepack-arrays -Warray-temporaries -O" }
++
++! Same as dependency_35 but with repack-arrays
++
++module foo
++ implicit none
++contains
++ pure function bar(i,j) ! { dg-warning "Creating array temporary at \\(1\\)" }
++ integer, intent(in) :: i,j
++ integer, dimension(2,2) :: bar
++ bar = 33
++ end function bar
++end module foo
++
++program main
++ use foo
++ implicit none
++ integer a(2,2), b(2,2),c(2,2), d(2,2), e(2)
++
++ read (*,*) b, c, d
++ a = matmul(b,c) + d
++ a = b + bar(3,4)
++ a = bar(3,4)*5 + b
++ e = sum(b,1) + 3
++end program main
+diff --git a/gcc/testsuite/gfortran.dg/dependency_49.f90 b/gcc/testsuite/gfortran.dg/dependency_49.f90
+new file mode 100644
+index 0000000..73d517e
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/dependency_49.f90
+@@ -0,0 +1,14 @@
++! { dg-do compile }
++! { dg-options "-fdump-tree-original" }
++! PR fortran/71902 - make sure that component references are followed
++! for dependency analysis.
++program main
++ type foo
++ character(len=:), allocatable :: x
++ end type foo
++ type(foo) :: a
++ a%x = 'asdf'
++ a%x = a%x(2:3)
++ print *,a%x
++end program main
++! { dg-final { scan-tree-dump-times "__var_1" 4 "original" } }
+diff --git a/gcc/testsuite/gfortran.dg/extends_type_of_3.f90 b/gcc/testsuite/gfortran.dg/extends_type_of_3.f90
+index 346542f..533af2b 100644
+--- a/gcc/testsuite/gfortran.dg/extends_type_of_3.f90
++++ b/gcc/testsuite/gfortran.dg/extends_type_of_3.f90
+@@ -3,9 +3,7 @@
+ !
+ ! PR fortran/41580
+ !
+-! Compile-time simplification of SAME_TYPE_AS
+-! and EXTENDS_TYPE_OF.
+-!
++! Compile-time simplification of SAME_TYPE_AS and EXTENDS_TYPE_OF.
+
+ implicit none
+ type t1
+@@ -37,6 +35,8 @@ logical, parameter :: p6 = same_type_as(a1,a1) ! T
+
+ if (p1 .or. p2 .or. p3 .or. p4 .or. .not. p5 .or. .not. p6) call should_not_exist()
+
++if (same_type_as(b1,b1) .neqv. .true.) call should_not_exist()
++
+ ! Not (trivially) compile-time simplifiable:
+ if (same_type_as(b1,a1) .neqv. .true.) call abort()
+ if (same_type_as(b1,a11) .neqv. .false.) call abort()
+@@ -49,6 +49,7 @@ if (same_type_as(b1,a1) .neqv. .false.) call abort()
+ if (same_type_as(b1,a11) .neqv. .true.) call abort()
+ deallocate(b1)
+
++
+ ! .true. -> same type
+ if (extends_type_of(a1,a1) .neqv. .true.) call should_not_exist()
+ if (extends_type_of(a11,a11) .neqv. .true.) call should_not_exist()
+@@ -78,34 +79,48 @@ if (extends_type_of(a2,b11) .neqv. .false.) call should_not_exist()
+ ! type extension possible, compile-time checkable
+ if (extends_type_of(a1,a11) .neqv. .false.) call should_not_exist()
+ if (extends_type_of(a11,a1) .neqv. .true.) call should_not_exist()
+-if (extends_type_of(a1,a11) .neqv. .false.) call should_not_exist()
+
+ if (extends_type_of(b1,a1) .neqv. .true.) call should_not_exist()
+ if (extends_type_of(b11,a1) .neqv. .true.) call should_not_exist()
+ if (extends_type_of(b11,a11) .neqv. .true.) call should_not_exist()
+-if (extends_type_of(b1,a11) .neqv. .false.) call should_not_exist()
+
+-if (extends_type_of(a1,b11) .neqv. .false.) call abort()
++if (extends_type_of(a1,b11) .neqv. .false.) call should_not_exist()
++
+
+ ! Special case, simplified at tree folding:
+ if (extends_type_of(b1,b1) .neqv. .true.) call abort()
+
+ ! All other possibilities are not compile-time checkable
+ if (extends_type_of(b11,b1) .neqv. .true.) call abort()
+-!if (extends_type_of(b1,b11) .neqv. .false.) call abort() ! FAILS due to PR 47189
++if (extends_type_of(b1,b11) .neqv. .false.) call abort()
+ if (extends_type_of(a11,b11) .neqv. .true.) call abort()
++
+ allocate(t11 :: b11)
+ if (extends_type_of(a11,b11) .neqv. .true.) call abort()
+ deallocate(b11)
++
+ allocate(t111 :: b11)
+ if (extends_type_of(a11,b11) .neqv. .false.) call abort()
+ deallocate(b11)
++
+ allocate(t11 :: b1)
+ if (extends_type_of(a11,b1) .neqv. .true.) call abort()
+ deallocate(b1)
+
++allocate(t11::b1)
++if (extends_type_of(b1,a11) .neqv. .true.) call abort()
++deallocate(b1)
++
++allocate(b1,source=a11)
++if (extends_type_of(b1,a11) .neqv. .true.) call abort()
++deallocate(b1)
++
++allocate( b1,source=a1)
++if (extends_type_of(b1,a11) .neqv. .false.) call abort()
++deallocate(b1)
++
+ end
+
+-! { dg-final { scan-tree-dump-times "abort" 13 "original" } }
++! { dg-final { scan-tree-dump-times "abort" 16 "original" } }
+ ! { dg-final { scan-tree-dump-times "should_not_exist" 0 "original" } }
+ ! { dg-final { cleanup-tree-dump "original" } }
+diff --git a/gcc/testsuite/gfortran.dg/fimplicit_none_1.f90 b/gcc/testsuite/gfortran.dg/fimplicit_none_1.f90
+new file mode 100644
+index 0000000..997584e
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/fimplicit_none_1.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++! { dg-options "-fimplicit-none" }
++subroutine s(n) ! { dg-error "has no IMPLICIT type" }
++ character(n) :: c ! { dg-error "Scalar INTEGER expression expected" }
++ c = 'c' ! { dg-error "has no IMPLICIT type" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/fimplicit_none_2.f90 b/gcc/testsuite/gfortran.dg/fimplicit_none_2.f90
+new file mode 100644
+index 0000000..fa8a8f4
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/fimplicit_none_2.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++! { dg-options "-fimplicit-none" }
++! PR fortran/78239 - used to ICE
++program p
++ character(*), parameter :: z(2) = [character(n) :: 'x', 'y'] ! { dg-error "Scalar INTEGER expression expected" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/fmt_t_9.f b/gcc/testsuite/gfortran.dg/fmt_t_9.f
+new file mode 100644
+index 0000000..bfe0361d
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/fmt_t_9.f
+@@ -0,0 +1,41 @@
++! { dg-options "-ffixed-line-length-none -std=gnu" }
++! { dg-do run }
++! PR78123 Short reads with T edit descriptor not padding correctly
++ PROGRAM tformat
++C
++ INTEGER MXFLTL
++ PARAMETER (MXFLTL = 99999)
++ INTEGER IFLGHT, NFLCYC, IFLTSQ(MXFLTL), IDXBLK, LMAX, LMIN, I
++C
++ OPEN(29, status='scratch')
++ WRITE(29, '(a)') " 1 1 1 TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 72 122 4"
++ WRITE(29, '(a)') ""
++ WRITE(29, '(a)') " 451 402012011201120112011200120112011201120112011201120111971201120112011201120112011201"
++ WRITE(29, '(a)') " 451 4020 866 866 866 866 866 866 866 866 865 866 865 866 866 866 866 866 866 866 865 866"
++ REWIND(29)
++C The error occurs in the following loop:
++ 10 CONTINUE
++ READ(29,1010 ) IDXBLK, LMAX, LMIN
++1010 FORMAT(8X,I4,T51,2I5) ! wrong if this format is used
++c write(6,fmt='("IDXBLK,LMAX,LMIN=",3I5)')IDXBLK,LMAX,LMIN
++ IF (IDXBLK .EQ. 0) GO TO 20
++ GO TO 10
++C
++ 20 CONTINUE
++ READ(29,1040,END=100) IFLGHT, NFLCYC,
++ & (IFLTSQ(I), I=1,NFLCYC)
++1040 FORMAT(I5,I5,2X,(T13,20I4))
++c write(6,fmt='(2i6)') IFLGHT,NFLCYC
++c write(6,fmt='(20I4)') (IFLTSQ(I), I=1,NFLCYC)
++c write(6,*) "Program is correct"
++ close(29)
++ if (IFLGHT.ne.451) call abort
++ if (NFLCYC.ne.40) call abort
++ stop
++C
++ 100 CONTINUE
++C write(6,*) "End of file encountered (wrong)"
++ close (29)
++ call abort
++ STOP
++ END
+diff --git a/gcc/testsuite/gfortran.dg/forall_18.f90 b/gcc/testsuite/gfortran.dg/forall_18.f90
+new file mode 100644
+index 0000000..3cfe547
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/forall_18.f90
+@@ -0,0 +1,16 @@
++! { dg-do compile }
++! PR fortran/69741 - improve error message for nonscalar FORALL index variables
++!
++subroutine check
++ integer :: ii(2), i
++ real :: a(3,2)
++
++ forall (ii(1)=1:3, i=1:2) ! { dg-error "scalar variable of type integer" }
++ a(ii(1),i) = ii(1) * i
++ end forall
++
++ forall (j=1:3, ii(2)=1:2) ! { dg-error "scalar variable of type integer" }
++ a(j,ii(2)) = j * ii(2)
++ end forall
++
++end subroutine check
+diff --git a/gcc/testsuite/gfortran.dg/goacc/pr71704.f90 b/gcc/testsuite/gfortran.dg/goacc/pr71704.f90
+new file mode 100644
+index 0000000..6f5e28c
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/goacc/pr71704.f90
+@@ -0,0 +1,49 @@
++! PR fortran/71704
++! { dg-do compile }
++
++real function f1 ()
++!$acc routine (f1)
++ f1 = 1
++end
++
++real function f2 (a)
++ integer a
++ !$acc enter data copyin(a)
++ f2 = 1
++end
++
++real function f3 (a)
++ integer a
++!$acc enter data copyin(a)
++ f3 = 1
++end
++
++real function f4 ()
++!$acc wait
++ f4 = 1
++end
++
++real function f5 (a)
++ integer a
++!$acc update device(a)
++ f5 = 1
++end
++
++real function f6 ()
++!$acc parallel
++!$acc end parallel
++ f6 = 1
++end
++
++real function f7 ()
++!$acc kernels
++!$acc end kernels
++ f7 = 1
++end
++
++real function f8 ()
++!$acc data
++!$acc end data
++ f8 = 1
++end
++
+diff --git a/gcc/testsuite/gfortran.dg/gomp/pr71704.f90 b/gcc/testsuite/gfortran.dg/gomp/pr71704.f90
+new file mode 100644
+index 0000000..5c1c003
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/gomp/pr71704.f90
+@@ -0,0 +1,58 @@
++! PR fortran/71704
++! { dg-do compile }
++
++real function f0 ()
++!$omp declare simd (f0)
++ f0 = 1
++end
++
++real function f1 ()
++!$omp declare target (f1)
++ f1 = 1
++end
++
++real function f2 ()
++!$omp declare reduction (foo : integer : omp_out = omp_out + omp_in) &
++!$omp & initializer (omp_priv = 0)
++ f2 = 1
++end
++
++real function f3 ()
++ real, save :: t
++!$omp threadprivate (t)
++ f3 = 1
++end
++
++real function f4 ()
++!$omp taskwait
++ f4 = 1
++end
++
++real function f5 ()
++!$omp barrier
++ f5 = 1
++end
++
++real function f6 ()
++!$omp parallel
++!$omp end parallel
++ f6 = 1
++end
++
++real function f7 ()
++!$omp single
++!$omp end single
++ f7 = 1
++end
++
++real function f8 ()
++!$omp critical
++!$omp end critical
++ f8 = 1
++end
++
++real function f9 ()
++!$omp critical
++!$omp end critical
++ f9 = 1
++end
+diff --git a/gcc/testsuite/gfortran.dg/gomp/pr71705.f90 b/gcc/testsuite/gfortran.dg/gomp/pr71705.f90
+new file mode 100644
+index 0000000..4813aac
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/gomp/pr71705.f90
+@@ -0,0 +1,7 @@
++! PR fortran/71705
++! { dg-do compile }
++
++ real :: x
++ x = 0.0
++ !$omp target update to(x)
++end
+diff --git a/gcc/testsuite/gfortran.dg/gomp/pr71758.f90 b/gcc/testsuite/gfortran.dg/gomp/pr71758.f90
+new file mode 100644
+index 0000000..47215ba
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/gomp/pr71758.f90
+@@ -0,0 +1,10 @@
++! PR middle-end/71758
++
++subroutine pr71758 (p)
++ integer(8) :: i
++ integer :: p(20)
++ i = 0
++ !$omp target device(i)
++ !$omp end target
++ !$omp target update to(p(1:1)) device(i)
++end subroutine
+diff --git a/gcc/testsuite/gfortran.dg/graphite/pr38083.f90 b/gcc/testsuite/gfortran.dg/graphite/pr38083.f90
+index da8c3cc..34d6ca8 100644
+--- a/gcc/testsuite/gfortran.dg/graphite/pr38083.f90
++++ b/gcc/testsuite/gfortran.dg/graphite/pr38083.f90
+@@ -8,7 +8,7 @@ SUBROUTINE IVSORT (IL,IH,NSEGS,IOUNIT)
+ 10 IF (IL .GE. IH) GO TO 80
+ 20 NSEGS = (IH + IL) / 2
+ IF (NSEGS .GT. MAXSGS) THEN
+- WRITE (IOUNIT),MAXSGS
++ WRITE (IOUNIT) MAXSGS
+ ENDIF
+ 80 NSEGS = NSEGS - 1
+ 90 IF (IH - IL .GE. 11) GO TO 20
+diff --git a/gcc/testsuite/gfortran.dg/guality/pr41558.f90 b/gcc/testsuite/gfortran.dg/guality/pr41558.f90
+index 8a84de4..840b238 100644
+--- a/gcc/testsuite/gfortran.dg/guality/pr41558.f90
++++ b/gcc/testsuite/gfortran.dg/guality/pr41558.f90
+@@ -5,7 +5,7 @@
+
+ subroutine f (s)
+ character(len=3) :: s
+- write (*,*), s ! { dg-final { gdb-test 7 "s" "'foo'" } }
++ write (*,*) s ! { dg-final { gdb-test 7 "s" "'foo'" } }
+ end
+ call f ('foo')
+ end
+diff --git a/gcc/testsuite/gfortran.dg/ieee/pr77507.f90 b/gcc/testsuite/gfortran.dg/ieee/pr77507.f90
+new file mode 100644
+index 0000000..a72a091
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/ieee/pr77507.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++Program p
++ Use ieee_arithmetic
++ Use iso_c_binding
++ Print *, ieee_value(x=1.0, class=ieee_negative_inf)
++ Print *, c_associated(c_ptr_1=c_null_ptr)
++End Program
+diff --git a/gcc/testsuite/gfortran.dg/inquire_17.f90 b/gcc/testsuite/gfortran.dg/inquire_17.f90
+new file mode 100644
+index 0000000..8a722f0
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/inquire_17.f90
+@@ -0,0 +1,10 @@
++! { dg-do run }
++! PR77707 formatted direct access: nextrec off by one
++program directaccess_formatted
++ integer nextrec
++ open(10, status='scratch', form='formatted', access='direct', recl=10*4)
++ write(10,'(10i4)',rec=9) 1,2,3,4,5,6,7,8,9,10
++ inquire(unit=10,nextrec=nextrec)
++ if (nextrec.ne.10) call abort
++ close(10)
++end
+diff --git a/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90 b/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90
+index 55c2543..4236ee6 100644
+--- a/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90
++++ b/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90
+@@ -1,4 +1,4 @@
+ ! { dg-options "-fno-range-check" }
+ program test
+- write (*), (2_8 ** 64009999_8) / 2
++ write (*,*) (2_8 ** 64009999_8) / 2
+ end program test
+diff --git a/gcc/testsuite/gfortran.dg/intrinsic_numeric_arg.f b/gcc/testsuite/gfortran.dg/intrinsic_numeric_arg.f
+index 3257d45..445c39e 100644
+--- a/gcc/testsuite/gfortran.dg/intrinsic_numeric_arg.f
++++ b/gcc/testsuite/gfortran.dg/intrinsic_numeric_arg.f
+@@ -4,6 +4,6 @@
+ LOGICAL Z
+ CHARACTER A
+ REAL R
+- R = ABS(Z) ! { dg-error " must be a numeric type" }
+- R = ABS(A) ! { dg-error " must be a numeric type" }
++ R = ABS(Z) ! { dg-error " must have a numeric type" }
++ R = ABS(A) ! { dg-error " must have a numeric type" }
+ END
+diff --git a/gcc/testsuite/gfortran.dg/namelist_90.f b/gcc/testsuite/gfortran.dg/namelist_90.f
+new file mode 100644
+index 0000000..9c0ae5b
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/namelist_90.f
+@@ -0,0 +1,28 @@
++! { dg-do run }
++! PR71123 Namelist read failure on Windows
++ implicit none
++ integer :: i, ierr
++ real(8), dimension(30) :: senid, res
++ character(2) :: crlf = char(13) // char(10)
++ namelist /fith/ senid
++ do i=1,30
++ res(i) = i
++ enddo
++ senid = 99.0
++ open(unit=7,file='test.out',form='formatted',
++ * status='new',action='readwrite', access='stream')
++ write(7,'(a)') "&fith" // crlf
++ write(7,'(a)') "senid= 1.0 , 2.0 , 3.0 , 4.0 , 5.0 ," // crlf
++ write(7,'(a)') "6.0 , 7.0 , 8.0 , 9.0 , 10.0 , 11.0 ," // crlf
++ write(7,'(a)') "12.0 , 13.0 , 14.0 , 15.0 , 16.0 , 17.0 ," // crlf
++ write(7,'(a)') "18.0 , 19.0 , 20.0 , 21.0 , 22.0 , 23.0 ," // crlf
++ write(7,'(a)') "24.0 , 25.0 , 26.0 , 27.0 , 28.0 , 29.0 ," // crlf
++ write(7,'(a)') "30.0 ," // crlf
++ write(7,'(a)') "/" // crlf
++ close(7)
++ open(unit=7,file='test.out',form='formatted')
++ read(7,nml=fith, iostat=ierr)
++ close(7, status="delete")
++ if (ierr.ne.0) call abort
++ if (any(senid.ne.res)) call abort
++ end
+diff --git a/gcc/testsuite/gfortran.dg/null_9.f90 b/gcc/testsuite/gfortran.dg/null_9.f90
+new file mode 100644
+index 0000000..9afd938
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/null_9.f90
+@@ -0,0 +1,30 @@
++! { dg-do run }
++
++MODULE fold_convert_loc_ice
++ IMPLICIT NONE
++ PRIVATE
++
++ TYPE, PUBLIC :: ta
++ PRIVATE
++ INTEGER :: a_comp
++ END TYPE ta
++
++ TYPE, PUBLIC :: tb
++ TYPE(ta), ALLOCATABLE :: b_comp
++ END TYPE tb
++
++ PUBLIC :: proc
++CONTAINS
++ SUBROUTINE proc
++ TYPE(tb) :: b
++
++ b = tb(null())
++ if (allocated( b%b_comp )) call abort()
++ END SUBROUTINE proc
++END MODULE fold_convert_loc_ice
++
++ USE fold_convert_loc_ice
++
++ call proc()
++END
++
+diff --git a/gcc/testsuite/gfortran.dg/pr61318.f90 b/gcc/testsuite/gfortran.dg/pr61318.f90
+new file mode 100644
+index 0000000..4e7e862
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr61318.f90
+@@ -0,0 +1,23 @@
++! { dg-do compile }
++!
++module gbl_message
++ type :: mytype
++ integer(kind=4) :: e
++ end type mytype
++ type(mytype), parameter :: seve = mytype(1)
++end module gbl_message
++
++module gbl_interfaces
++ interface
++ subroutine gagout(message)
++ character(len=*), intent(in) :: message
++ end subroutine gagout
++ end interface
++end module gbl_interfaces
++
++program test
++ use gbl_message
++ use gbl_interfaces
++ call gagout(seve%e,'Some string') ! { dg-error "Type mismatch in argument" }
++end program test
++! { dg-final { cleanup-modules "gbl_interfaces gbl_message" } }
+diff --git a/gcc/testsuite/gfortran.dg/pr68566.f90 b/gcc/testsuite/gfortran.dg/pr68566.f90
+new file mode 100644
+index 0000000..160e9ac
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr68566.f90
+@@ -0,0 +1,13 @@
++! { dg-do run }
++program p
++ character(len=20) s1, s2
++ integer, allocatable :: n(:)
++ n = [2,1]
++ s1 = '1 5 2 6 3 0 4 0'
++ write(s2,'(8(I0,1x))') reshape ([1,2,3,4,5,6], [2,4], [0,0], [2,1])
++ if (trim(s1) /= trim(s2)) call abort
++ write(s2,'(8(I0,1x))') reshape ([1,2,3,4,5,6], [2,4], [0,0], n)
++ if (trim(s1) /= trim(s2)) call abort
++ write(s2,'(8(I0,1x))') reshape ([1,2,3,4,5,6], [2,4], [0,0], [n])
++ if (trim(s1) /= trim(s2)) call abort
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr69514_1.f90 b/gcc/testsuite/gfortran.dg/pr69514_1.f90
+new file mode 100644
+index 0000000..d72a450
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr69514_1.f90
+@@ -0,0 +1,5 @@
++! { dg-do run }
++program foo
++ real, parameter :: x(3) = 2.0 * [real :: 1, 2, 3 ]
++ if (any(x /= [2., 4., 6.])) call abort
++end program foo
+diff --git a/gcc/testsuite/gfortran.dg/pr69514_2.f90 b/gcc/testsuite/gfortran.dg/pr69514_2.f90
+new file mode 100644
+index 0000000..0a5e816
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr69514_2.f90
+@@ -0,0 +1,49 @@
++! { dg-do run }
++program p
++ implicit none
++
++ real , parameter :: arr(3) = [ real :: 2, 2.5, (1.5, 2.5) ]
++ real , parameter :: ari(3) = [ integer :: 2, 2.5, (1.5, 2.5) ]
++ real , parameter :: arc(3) = [ complex :: 2, 2.5, (1.5, 2.5) ]
++ integer, parameter :: air(3) = [ real :: 2, 2.5, (1.5, 2.5) ]
++ integer, parameter :: aii(3) = [ integer :: 2, 2.5, (1.5, 2.5) ]
++ integer, parameter :: aic(3) = [ complex :: 2, 2.5, (1.5, 2.5) ]
++ complex, parameter :: acr(3) = [ real :: 2, 2.5, (1.5, 2.5) ]
++ complex, parameter :: aci(3) = [ integer :: 2, 2.5, (1.5, 2.5) ]
++ complex, parameter :: acc(3) = [ complex :: 2, 2.5, (1.5, 2.5) ]
++
++ real , parameter :: mrr(3) = 4.5 * [ real :: 2, 2.5, (3.5, 4.0) ]
++ real , parameter :: mri(3) = 4.5 * [ integer :: 2, 2.5, (3.5, 4.0) ]
++ real , parameter :: mrc(3) = 4.5 * [ complex :: 2, 2.5, (3.5, 4.0) ]
++ integer, parameter :: mir(3) = 4 * [ real :: 2, 2.5, (3.5, 4.0) ]
++ integer, parameter :: mii(3) = 4 * [ integer :: 2, 2.5, (3.5, 4.0) ]
++ integer, parameter :: mic(3) = 4 * [ complex :: 2, 2.5, (3.5, 4.0) ]
++ complex, parameter :: mcr(3) = (4.5, 5.5) * [ real :: 2, 2.5, (3.5, 4.0) ]
++ complex, parameter :: mci(3) = (4.5, 5.5) * [ integer :: 2, 2.5, (3.5, 4.0) ]
++ complex, parameter :: mcc(3) = (4.5, 5.5) * [ complex :: 2, 2.5, (3.5, 4.0) ]
++
++ if (any(arr /= [2.00, 2.50, 1.50])) call abort
++ if (any(ari /= [2.00, 2.00, 1.00])) call abort
++ if (any(arc /= [2.00, 2.50, 1.50])) call abort
++
++ if (any(air /= [2, 2, 1])) call abort
++ if (any(aii /= [2, 2, 1])) call abort
++ if (any(aic /= [2, 2, 1])) call abort
++
++ if (any(acr /= [(2.00, 0.00), (2.50, 0.00), (1.50, 0.00)])) call abort
++ if (any(aci /= [(2.00, 0.00), (2.00, 0.00), (1.00, 0.00)])) call abort
++ if (any(acc /= [(2.00, 0.00), (2.50, 0.00), (1.50, 2.50)])) call abort
++
++ if (any(mrr /= [9.00, 11.25, 15.75])) call abort
++ if (any(mri /= [9.00, 9.00, 13.50])) call abort
++ if (any(mrc /= [9.00, 11.25, 15.75])) call abort
++
++ if (any(mir /= [8, 10, 14])) call abort
++ if (any(mii /= [8, 8, 12])) call abort
++ if (any(mic /= [8, 10, 14])) call abort
++
++ if (any(mcr /= [(9.00, 11.00), (11.25, 13.75), (15.75, 19.25)])) call abort
++ if (any(mci /= [(9.00, 11.00), ( 9.00, 11.00), (13.50, 16.50)])) call abort
++ if (any(mcc /= [(9.00, 11.00), (11.25, 13.75), (-6.25, 37.25)])) call abort
++
++end program p
+diff --git a/gcc/testsuite/gfortran.dg/pr69867.f90 b/gcc/testsuite/gfortran.dg/pr69867.f90
+new file mode 100644
+index 0000000..132d5e8
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr69867.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++program p
++ type t
++ character(1) :: c(1)=[1] ! { dg-error "convert INTEGER.4. to CHARACTER.1." }
++ end type
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr69962.f90 b/gcc/testsuite/gfortran.dg/pr69962.f90
+new file mode 100644
+index 0000000..2684398
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr69962.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++program p
++ integer :: n = 1
++ character(3), parameter :: x(2) = ['abc', 'xyz']
++ character(2), parameter :: y(2) = [x(2)(2:3), x(n)(1:2)] ! { dg-error "CHARACTER length must be a constant" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr70006.f90 b/gcc/testsuite/gfortran.dg/pr70006.f90
+new file mode 100644
+index 0000000..b8fbb3c
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr70006.f90
+@@ -0,0 +1,9 @@
++! { dg-do compile}
++program test
++ print 1, 'string 1' ! { dg-error "FORMAT label 1" " " { target *-*-* } 3 }
++ print 1, 'string 2' ! { dg-error "FORMAT label 1" " " { target *-*-* } 4 }
++!1 format(a)
++ goto 2 ! { dg-error "Label 2 referenced" " " { target *-*-* } 6 }
++ goto 2 ! { dg-error "Label 2 referenced" " " { target *-*-* } 7 }
++!2 continue
++end program
+diff --git a/gcc/testsuite/gfortran.dg/pr70040.f90 b/gcc/testsuite/gfortran.dg/pr70040.f90
+new file mode 100644
+index 0000000..080083e
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr70040.f90
+@@ -0,0 +1,19 @@
++! { dg-do compile }
++! PR 70040 - used to cause an ICE.
++! Test case by Martin Reinecke
++program bugrep
++ implicit none
++ type :: string
++ character (len=:), allocatable :: s
++ end type
++
++ integer l
++ type(string), allocatable, dimension(:) :: foo
++ character(len=:),allocatable ::tmp
++ allocate(foo(20))
++ do l= 1, 20
++ tmp = foo(5)%s
++ foo(5)%s = foo(l)%s
++ foo(l)%s = tmp
++ enddo
++end program
+diff --git a/gcc/testsuite/gfortran.dg/pr70673.f90 b/gcc/testsuite/gfortran.dg/pr70673.f90
+new file mode 100644
+index 0000000..67856e0
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr70673.f90
+@@ -0,0 +1,25 @@
++! { dg-do run }
++!
++! Test the fix for PR70673
++!
++! Contributed by David Kinniburgh <davidgkinniburgh@yahoo.co.uk>
++!
++module m
++contains
++ subroutine s(inp)
++ character(*), intent(in) :: inp
++ character(:), allocatable :: a
++ a = a ! This used to ICE.
++ a = inp
++ a = a ! This used to ICE too
++ if ((len (a) .ne. 5) .or. (a .ne. "hello")) call abort
++ a = a(2:3) ! Make sure that temporary creation is not broken.
++ if ((len (a) .ne. 2) .or. (a .ne. "el")) call abort
++ deallocate (a)
++ a = a ! This would ICE too.
++ end subroutine s
++end module m
++
++ use m
++ call s("hello")
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71067_1.f90 b/gcc/testsuite/gfortran.dg/pr71067_1.f90
+new file mode 100644
+index 0000000..76fbcfb
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71067_1.f90
+@@ -0,0 +1,5 @@
++program p
++ integer :: i = 0
++ integer :: z(2)
++ data z /2*i/ ! { dg-error "must be a PARAMETER in DATA" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71067_2.f90 b/gcc/testsuite/gfortran.dg/pr71067_2.f90
+new file mode 100644
+index 0000000..6fac4c5
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71067_2.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++program p
++ integer :: a(2), b(2), c(2)
++ data a /2*b1'/ ! { dg-error "must be a PARAMETER in DATA" }
++ data b /2*o1' ! { dg-error "must be a PARAMETER in DATA" }
++ data c /2*z1 ! { dg-error "must be a PARAMETER in DATA" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71688.f90 b/gcc/testsuite/gfortran.dg/pr71688.f90
+new file mode 100644
+index 0000000..dbb6d18
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71688.f90
+@@ -0,0 +1,13 @@
++! { dg-do compile }
++! { dg-options "-fcoarray=lib" }
++
++program p
++ call s
++contains
++ subroutine s
++ real :: x[*] = 1
++ block
++ end block
++ x = 2
++ end
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71730.f90 b/gcc/testsuite/gfortran.dg/pr71730.f90
+new file mode 100644
+index 0000000..f0d48c4
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71730.f90
+@@ -0,0 +1,5 @@
++! { dg-do compile }
++subroutine foo
++ implicit none
++ character(len=bar) :: a ! { dg-error "Scalar INTEGER expression" }
++end subroutine foo
+diff --git a/gcc/testsuite/gfortran.dg/pr71764.f90 b/gcc/testsuite/gfortran.dg/pr71764.f90
+new file mode 100644
+index 0000000..48176f8
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71764.f90
+@@ -0,0 +1,34 @@
++! { dg-do run }
++! PR71764
++program p
++ use iso_c_binding, only: c_ptr, c_null_ptr, c_ptr, c_associated, c_loc
++ logical, target :: rls
++ real, target :: t = 3.14
++ type(c_ptr) :: nullptr,c
++ real, pointer :: k
++ nullptr = c_null_ptr
++ c = nullptr
++ rls = c_associated(c)
++ if (rls) call abort
++ if (c_associated(c)) call abort
++ c = c_loc(rls)
++ if (.not. c_associated(c)) call abort
++ c = nullptr
++ if (c_associated(c)) call abort
++ c = c_loc(t)
++ k => t
++ call association_test(k, c)
++contains
++ subroutine association_test(a,b)
++ use iso_c_binding, only: c_associated, c_loc, c_ptr
++ implicit none
++ real, pointer :: a
++ type(c_ptr) :: b
++ if(c_associated(b, c_loc(a))) then
++ return
++ else
++ call abort
++ end if
++ end subroutine association_test
++end
++
+diff --git a/gcc/testsuite/gfortran.dg/pr71799.f90 b/gcc/testsuite/gfortran.dg/pr71799.f90
+new file mode 100644
+index 0000000..32be5f7
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71799.f90
+@@ -0,0 +1,10 @@
++! { dg-do compile }
++subroutine test2(s)
++integer(1) :: i
++integer (8) :: s
++
++do i = 10, HUGE(i) - 10, 222 ! { dg-error "overflow converting" }
++ s = s + 1
++end do
++
++end subroutine test2
+diff --git a/gcc/testsuite/gfortran.dg/pr71859.f90 b/gcc/testsuite/gfortran.dg/pr71859.f90
+new file mode 100644
+index 0000000..0dc6177
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71859.f90
+@@ -0,0 +1,8 @@
++! { dg-do compile }
++program p
++ call s(1)
++ x = abs(s) ! { dg-error "must have a numeric type" }
++end
++subroutine s(n)
++ print *, n
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71883.f90 b/gcc/testsuite/gfortran.dg/pr71883.f90
+new file mode 100644
+index 0000000..23ed6a6
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71883.f90
+@@ -0,0 +1,38 @@
++! { dg-do compile }
++!
++! Test the fix for pr71883, in which an ICE would follow the error.
++!
++! Contributed by Gerhard Steinmetz <gerhard.steinmetz.fortran@t-online.de>
++!
++program p
++ character(3), allocatable :: z(:,:)
++ z(1:2,1:2) = 'abc'
++ z(2,1) = z(12) ! { dg-error "Rank mismatch in array reference" }
++ z(21) = z(1,2) ! { dg-error "Rank mismatch in array reference" }
++contains
++ subroutine a
++ character(3), allocatable :: z(:,:)
++ z(1:2,1:2) = 'abc'
++ z(2,1) = z(-1) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(99) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(huge(0)) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(-huge(0)) ! { dg-error "Rank mismatch in array reference" }
++ z(-1) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(99) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(huge(0)) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(-huge(0)) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ end subroutine
++
++ subroutine b
++ character(:), allocatable :: z(:,:)
++ z(1:2,1:2) = 'abc'
++ z(2,1) = z(-1) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(99) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(huge(0)) ! { dg-error "Rank mismatch in array reference" }
++ z(2,1) = z(-huge(0)) ! { dg-error "Rank mismatch in array reference" }
++ z(-1) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(99) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(huge(0)) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ z(-huge(0)) = z(2,1) ! { dg-error "Rank mismatch in array reference" }
++ end subroutine
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr71895.f90 b/gcc/testsuite/gfortran.dg/pr71895.f90
+new file mode 100644
+index 0000000..e5d4002
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr71895.f90
+@@ -0,0 +1,10 @@
++! { dg-do compile }
++program p
++ type t
++ integer :: n
++ end type
++ type(t) :: x
++ class(t) :: y ! { dg-error "must be dummy, allocatable or pointer" }
++ print *, extends_type_of(x, y)
++ print *, extends_type_of(y, x)
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr77260_1.f90 b/gcc/testsuite/gfortran.dg/pr77260_1.f90
+new file mode 100644
+index 0000000..0d2ead6
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77260_1.f90
+@@ -0,0 +1,25 @@
++! { dg-do compile }
++! { dg-options "-Wall" }
++module foo
++
++ implicit none
++
++ private
++ public f1,f2
++
++ contains
++
++ integer function f1()
++ integer f2
++ f1=5
++ entry f2
++ f2=8
++ end function
++end module
++
++program test
++ use foo
++ implicit none
++ print *,f2()
++end program
++! { dg-final { cleanup-modules "foo" } }
+diff --git a/gcc/testsuite/gfortran.dg/pr77260_2.f90 b/gcc/testsuite/gfortran.dg/pr77260_2.f90
+new file mode 100644
+index 0000000..ea8da4f
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77260_2.f90
+@@ -0,0 +1,26 @@
++! { dg-do compile }
++! { dg-options "-Wall" }
++module foo
++
++ implicit none
++
++ private
++ public f1,f2
++
++ contains
++
++ integer function f1()
++ integer f2
++ integer f3 ! { dg-warning "Unused variable" }
++ f1=5
++ entry f2
++ f2=8
++ end function
++end module
++
++program test
++ use foo
++ implicit none
++ print *,f2()
++end program
++! { dg-final { cleanup-modules "foo" } }
+diff --git a/gcc/testsuite/gfortran.dg/pr77351.f90 b/gcc/testsuite/gfortran.dg/pr77351.f90
+new file mode 100644
+index 0000000..76ce5c5
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77351.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++program p
++ integer :: z(4) = [1, 2, 3, 4]
++ print *, any(shape(z) /= [4,1]) ! { dg-error "shape for elemental binary" }
++end
++! { dg-excess-errors "operands are incommensurate" }
+diff --git a/gcc/testsuite/gfortran.dg/pr77380.f90 b/gcc/testsuite/gfortran.dg/pr77380.f90
+new file mode 100644
+index 0000000..f369be6
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77380.f90
+@@ -0,0 +1,6 @@
++! { dg-do compile }
++! { dg-options "-fcoarray=lib -O2" }
++program p
++ integer :: z(2)[*] = 1
++ z(:)[1] = z(:)[*] ! { dg-error "must be a scalar at" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr77391.f90 b/gcc/testsuite/gfortran.dg/pr77391.f90
+new file mode 100644
+index 0000000..b3a455a
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77391.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++program picky
++character(len=:), parameter :: a="whoops" ! { dg-error "POINTER or ALLOCATABLE" }
++character(len=:) :: b="whoops" ! { dg-error "POINTER or ALLOCATABLE" }
++character(len=:) :: good
++pointer good
++end program picky
+diff --git a/gcc/testsuite/gfortran.dg/pr77420_1.f90 b/gcc/testsuite/gfortran.dg/pr77420_1.f90
+new file mode 100644
+index 0000000..7652d69
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77420_1.f90
+@@ -0,0 +1,15 @@
++! { dg-do compile }
++module test_equivalence
++ real, private :: array1(100)
++ real, private :: array2(100)
++ equivalence(array1(3),array2(3))
++end module test_equivalence
++
++module mymodule
++ use test_equivalence
++ real, dimension(:), allocatable :: array1
++end module mymodule
++
++program test
++ use mymodule
++end program test
+diff --git a/gcc/testsuite/gfortran.dg/pr77420_2.f90 b/gcc/testsuite/gfortran.dg/pr77420_2.f90
+new file mode 100644
+index 0000000..4826801
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77420_2.f90
+@@ -0,0 +1,15 @@
++! { dg-do compile }
++module test_equivalence
++ real, private :: array1(100)
++ real, private :: array2(100)
++ equivalence(array1,array2)
++end module test_equivalence
++
++module mymodule
++ use test_equivalence
++ real, dimension(:), allocatable :: array1
++end module mymodule
++
++program test
++ use mymodule
++end program test
+diff --git a/gcc/testsuite/gfortran.dg/pr77420_3.f90 b/gcc/testsuite/gfortran.dg/pr77420_3.f90
+new file mode 100644
+index 0000000..cf95ac0
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77420_3.f90
+@@ -0,0 +1,9 @@
++! { dg-do link }
++! { dg-additional-sources pr77420_4.f90 }
++!
++module h5global
++ implicit none
++ integer :: h5p_default_f, h5p_flags
++ equivalence(h5p_flags, h5p_default_f)
++end module h5global
++! { dg-final { cleanup-modules "h5global" } }
+diff --git a/gcc/testsuite/gfortran.dg/pr77420_4.f90 b/gcc/testsuite/gfortran.dg/pr77420_4.f90
+new file mode 100644
+index 0000000..8a60878
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77420_4.f90
+@@ -0,0 +1,10 @@
++! { dg-do compile { target { ! *-*-* } } }
++!
++program bug
++ use H5GLOBAL
++ implicit none
++ integer :: i
++ i=H5P_DEFAULT_F
++end program bug
++
++
+diff --git a/gcc/testsuite/gfortran.dg/pr77460.f90 b/gcc/testsuite/gfortran.dg/pr77460.f90
+new file mode 100644
+index 0000000..5e28a99
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77460.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++ double precision, parameter :: x = huge(1d0)
++ print*, sum((/x,-x/))
++ print*, sum((/x,x,-x,-x/)) ! { dg-error "overflow" }
++ print*, sum((/x,-x,1d0/))
++ print*, sum((/1d0,x,-x/))
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr77506.f90 b/gcc/testsuite/gfortran.dg/pr77506.f90
+new file mode 100644
+index 0000000..70d874e
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77506.f90
+@@ -0,0 +1,4 @@
++! { dg-do compile }
++program foo
++ print *, [character(len=*)::'ab','cd'] ! { dg-error "contain an asterisk" }
++end program foo
+diff --git a/gcc/testsuite/gfortran.dg/pr77612.f90 b/gcc/testsuite/gfortran.dg/pr77612.f90
+new file mode 100644
+index 0000000..7bc5a49
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77612.f90
+@@ -0,0 +1,13 @@
++! { dg-do compile }
++
++program bad_len
++
++ implicit none
++
++contains
++
++ subroutine sub
++ character(len = ICE) :: line ! { dg-error "INTEGER expression expected" }
++ end subroutine
++
++end program
+diff --git a/gcc/testsuite/gfortran.dg/pr77694.f90 b/gcc/testsuite/gfortran.dg/pr77694.f90
+new file mode 100644
+index 0000000..d9dc01b
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77694.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++! { dg-options -O }
++program p
++ logical x(2), y(2)
++ x = .true.
++ y = .nt. x ! { dg-error "Unknown operator" }
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr77978_1.f90 b/gcc/testsuite/gfortran.dg/pr77978_1.f90
+new file mode 100644
+index 0000000..a158f1b
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77978_1.f90
+@@ -0,0 +1,23 @@
++! { dg-do compile }
++! { dg-options "-std=f95" }
++subroutine a1
++ integer, parameter :: i = -666
++ stop i ! { dg-error "cannot be negative" }
++end subroutine a1
++
++subroutine a2
++ stop -666 ! { dg-error "cannot be negative" }
++end subroutine a2
++
++subroutine a3
++ integer, parameter :: i = 123456
++ stop i ! { dg-error "too many digits" }
++end subroutine a3
++
++subroutine a4
++ stop 123456 ! { dg-error "too many digits" }
++end subroutine a4
++
++!subroutine a5
++! stop merge(667,668,.true.)
++!end subroutine a5
+diff --git a/gcc/testsuite/gfortran.dg/pr77978_2.f90 b/gcc/testsuite/gfortran.dg/pr77978_2.f90
+new file mode 100644
+index 0000000..d6f2e78
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77978_2.f90
+@@ -0,0 +1,5 @@
++! { dg-do compile }
++! { dg-options "-std=f2008" }
++subroutine a1
++ stop666 ! { dg-error "Blank required in STOP" }
++end subroutine a1
+diff --git a/gcc/testsuite/gfortran.dg/pr77978_3.f90 b/gcc/testsuite/gfortran.dg/pr77978_3.f90
+new file mode 100644
+index 0000000..0a3557b
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr77978_3.f90
+@@ -0,0 +1,23 @@
++! { dg-do compile }
++! { dg-options "-std=f2008" }
++subroutine a1
++ integer, parameter :: i = -666
++ stop i
++end subroutine a1
++
++subroutine a2
++ stop -666
++end subroutine a2
++
++subroutine a3
++ integer, parameter :: i = 123456
++ stop i
++end subroutine a3
++
++subroutine a4
++ stop 123456
++end subroutine a4
++
++subroutine a5
++ stop merge(667,668,.true.)
++end subroutine a5
+diff --git a/gcc/testsuite/gfortran.dg/pr78279.f90 b/gcc/testsuite/gfortran.dg/pr78279.f90
+new file mode 100644
+index 0000000..cb01752
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr78279.f90
+@@ -0,0 +1,10 @@
++! { dg-do compile }
++! { dg-options "-Ofast" }
++program p
++ integer :: i
++ real :: z(2,4)
++ z = 0.0
++ do i = 1, 3
++ if ( z(i) > z(1,i+1) ) print *, i ! { dg-error "mismatch in array reference" }
++ end do
++end
+diff --git a/gcc/testsuite/gfortran.dg/pr78297.f90 b/gcc/testsuite/gfortran.dg/pr78297.f90
+new file mode 100644
+index 0000000..9c3d1aa
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/pr78297.f90
+@@ -0,0 +1,11 @@
++! { dg-do compile }
++module m
++ real :: a(2), b(2)
++ real :: c(2), d(2)
++ equivalence (a, b)
++ equivalence (c, d)
++ common /xcom/ a
++end
++block data
++ use m
++end block data
+diff --git a/gcc/testsuite/gfortran.dg/proc_ptr_49.f90 b/gcc/testsuite/gfortran.dg/proc_ptr_49.f90
+new file mode 100644
+index 0000000..cb540a4
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/proc_ptr_49.f90
+@@ -0,0 +1,50 @@
++! { dg-do compile }
++!
++! Tests the fix for PRs 78013 and 61420, both of which gave a
++! no IMPLICIT type message for the procedure pointer at assignment.
++!
++module m
++
++ implicit none
++
++ abstract interface
++ function I_f() result( r )
++ real :: r
++ end function I_f
++ end interface
++
++ type, abstract :: a_t
++ private
++ procedure(I_f), nopass, pointer :: m_f => null()
++ contains
++ private
++ procedure, pass(this), public :: f => get_f
++ end type a_t
++
++contains
++
++ function get_f( this ) result( f_ptr ) ! Error message here.
++ class(a_t), intent(in) :: this
++ procedure(I_f), pointer :: f_ptr
++ f_ptr => this%m_f ! Error here :-)
++ end function get_f
++
++end module m
++
++module test
++ implicit none
++
++ type functions
++ contains
++ procedure, nopass :: get_pf => get_it ! Error here
++ end type
++
++ class(functions), allocatable :: f
++
++contains
++
++ function get_it() ! Error message here.
++ procedure (real), pointer :: get_it
++ end function
++
++end module
+diff --git a/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90 b/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90
+new file mode 100644
+index 0000000..4791c24
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/realloc_on_assign_26.f90
+@@ -0,0 +1,12 @@
++! { dg-do run }
++! PR 68147 - no temprorary within the IF statement.
++! Original test case by Martin Reinecke.
++program test
++ implicit none
++ character(len=:),allocatable ::name
++ name="./a.out"
++ if (index(name,"/") /= 0) THEN
++ name=name(3:)
++ if (name .ne. "a.out") call abort
++ endif
++end program
+diff --git a/gcc/testsuite/gfortran.dg/select_type_35.f03 b/gcc/testsuite/gfortran.dg/select_type_35.f03
+new file mode 100644
+index 0000000..92d2f27
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/select_type_35.f03
+@@ -0,0 +1,41 @@
++! { dg-do run }
++!
++! Contributed by Nathanael Huebbe
++! Check fix for PR/70842
++
++program foo
++
++ TYPE, ABSTRACT :: t_Intermediate
++ END TYPE t_Intermediate
++
++ type, extends(t_Intermediate) :: t_Foo
++ character(:), allocatable :: string
++ end type t_Foo
++
++ class(t_Foo), allocatable :: obj
++
++ allocate(obj)
++ obj%string = "blabarfoo"
++
++ call bar(obj)
++
++ deallocate(obj)
++contains
++ subroutine bar(me)
++ class(t_Intermediate), target :: me
++
++ class(*), pointer :: alias
++
++ select type(me)
++ type is(t_Foo)
++ if (len(me%string) /= 9) call abort()
++ end select
++
++ alias => me
++ select type(alias)
++ type is(t_Foo)
++ if (len(alias%string) /= 9) call abort()
++ end select
++ end subroutine bar
++end program foo
++
+diff --git a/gcc/testsuite/gfortran.dg/string_length_3.f90 b/gcc/testsuite/gfortran.dg/string_length_3.f90
+new file mode 100644
+index 0000000..e745eb9f
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/string_length_3.f90
+@@ -0,0 +1,19 @@
++! { dg-do run }
++! { dg-options "-ffrontend-optimize -fdump-tree-original" }
++! PR 78021 - calls to mylen were folded after shortening the
++! argument list.
++
++PROGRAM test_o_char
++ implicit none
++ integer :: n
++ n = mylen('c') + mylen('c ')
++ if (n /= 5) call abort
++CONTAINS
++
++ FUNCTION mylen(c)
++ CHARACTER(len=*),INTENT(in) :: c
++ INTEGER :: mylen
++ mylen=LEN(c)
++ END FUNCTION mylen
++END PROGRAM test_o_char
++! { dg-final { scan-tree-dump-times "__var" 0 "original" } }
+diff --git a/gcc/testsuite/gfortran.dg/type_decl_4.f90 b/gcc/testsuite/gfortran.dg/type_decl_4.f90
+new file mode 100644
+index 0000000..2aa1d7e
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/type_decl_4.f90
+@@ -0,0 +1,7 @@
++! { dg-do compile }
++program main
++ type Xx
++ end type Xx
++ real :: Xx ! { dg-error "Symbol 'xx' at .* also declared as a type" }
++
++end program main
+diff --git a/gcc/testsuite/gfortran.dg/typebound_proc_35.f90 b/gcc/testsuite/gfortran.dg/typebound_proc_35.f90
+new file mode 100644
+index 0000000..18b1ed9
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/typebound_proc_35.f90
+@@ -0,0 +1,88 @@
++! { dg-do run }
++!
++! PR 78443: [OOP] Incorrect behavior with non_overridable keyword
++!
++! Contributed by federico <perini@wisc.edu>
++
++module types
++ implicit none
++
++
++ ! Abstract parent class and its child type
++ type, abstract :: P1
++ contains
++ procedure :: test => test1
++ procedure (square_interface), deferred :: square
++ endtype
++
++ ! Deferred procedure interface
++ abstract interface
++ function square_interface( this, x ) result( y )
++ import P1
++ class(P1) :: this
++ real :: x, y
++ end function square_interface
++ end interface
++
++ type, extends(P1) :: C1
++ contains
++ procedure, non_overridable :: square => C1_square
++ endtype
++
++ ! Non-abstract parent class and its child type
++ type :: P2
++ contains
++ procedure :: test => test2
++ procedure :: square => P2_square
++ endtype
++
++ type, extends(P2) :: C2
++ contains
++ procedure, non_overridable :: square => C2_square
++ endtype
++
++contains
++
++ real function test1( this, x )
++ class(P1) :: this
++ real :: x
++ test1 = this % square( x )
++ end function
++
++ real function test2( this, x )
++ class(P2) :: this
++ real :: x
++ test2 = this % square( x )
++ end function
++
++ function P2_square( this, x ) result( y )
++ class(P2) :: this
++ real :: x, y
++ y = -100. ! dummy
++ end function
++
++ function C1_square( this, x ) result( y )
++ class(C1) :: this
++ real :: x, y
++ y = x**2
++ end function
++
++ function C2_square( this, x ) result( y )
++ class(C2) :: this
++ real :: x, y
++ y = x**2
++ end function
++
++end module
++
++program main
++ use types
++ implicit none
++ type(P2) :: t1
++ type(C2) :: t2
++ type(C1) :: t3
++
++ if ( t1 % test( 2. ) /= -100.) call abort()
++ if ( t2 % test( 2. ) /= 4.) call abort()
++ if ( t3 % test( 2. ) /= 4.) call abort()
++end program
+diff --git a/gcc/testsuite/gfortran.dg/where_5.f90 b/gcc/testsuite/gfortran.dg/where_5.f90
+new file mode 100644
+index 0000000..5ada63d
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/where_5.f90
+@@ -0,0 +1,15 @@
++! { dg-do compile }
++! { dg-options "-Wcharacter-truncation" }
++subroutine where_ice (i,j)
++
++ implicit none
++
++ character(8) :: y(10,10,2)
++
++ integer :: i
++ integer :: j
++
++ character(12) :: txt(5)
++ where (txt(1:3) /= '' ) y(1:3,i,j) = txt(1:3) ! { dg-warning "CHARACTER expression will be truncated" }
++
++end subroutine where_ice
+diff --git a/gcc/testsuite/gfortran.dg/where_6.f90 b/gcc/testsuite/gfortran.dg/where_6.f90
+new file mode 100644
+index 0000000..c7c43db
+--- /dev/null
++++ b/gcc/testsuite/gfortran.dg/where_6.f90
+@@ -0,0 +1,15 @@
++! { dg-do compile }
++! { dg-options "-Wcharacter-truncation" }
++subroutine where_ice (i,j)
++
++ implicit none
++
++ character(8) :: y(10,10,2)
++
++ integer :: i
++ integer :: j
++
++ character(12) :: txt(5)
++ if (.true.) where (txt(1:3) /= '' ) y(1:3,i,j) = txt(1:3) ! { dg-warning "CHARACTER expression will be truncated" }
++
++end subroutine where_ice
+diff --git a/gcc/testsuite/gnat.dg/biased_subtype.adb b/gcc/testsuite/gnat.dg/biased_subtype.adb
+new file mode 100644
+index 0000000..3833022
+--- /dev/null
++++ b/gcc/testsuite/gnat.dg/biased_subtype.adb
+@@ -0,0 +1,20 @@
++-- { dg-do run }
++-- { dg-options "-gnatws" }
++
++procedure Biased_Subtype is
++
++ CIM_Max_AA : constant := 9_999_999;
++ CIM_Min_AA : constant := -999_999;
++
++ type TIM_AA is range CIM_Min_AA..CIM_Max_AA + 1;
++ for TIM_AA'Size use 24;
++
++ subtype STIM_AA is TIM_AA range TIM_AA(CIM_Min_AA)..TIM_AA(CIM_Max_AA);
++
++ SAA : STIM_AA := 1;
++
++begin
++ if Integer(SAA) /= 1 then
++ raise Program_Error;
++ end if;
++end;
+diff --git a/gcc/testsuite/gnat.dg/loop_optimization23.adb b/gcc/testsuite/gnat.dg/loop_optimization23.adb
+new file mode 100644
+index 0000000..4f3af50
+--- /dev/null
++++ b/gcc/testsuite/gnat.dg/loop_optimization23.adb
+@@ -0,0 +1,14 @@
++-- { dg-do run }
++-- { dg-options "-O3" }
++-- PR tree-optimization/71083
++with Loop_Optimization23_Pkg;
++use Loop_Optimization23_Pkg;
++procedure Loop_Optimization23 is
++ Test : ArrayOfStructB;
++begin
++ Test (0).b.b := 9999;
++ Foo (Test);
++ if Test (100).b.b /= 9999 then
++ raise Program_Error;
++ end if;
++end;
+diff --git a/gcc/testsuite/gnat.dg/loop_optimization23_pkg.adb b/gcc/testsuite/gnat.dg/loop_optimization23_pkg.adb
+new file mode 100644
+index 0000000..a5fc90d
+--- /dev/null
++++ b/gcc/testsuite/gnat.dg/loop_optimization23_pkg.adb
+@@ -0,0 +1,11 @@
++-- { dg-do compile }
++-- { dg-options "-O3" }
++-- PR tree-optimization/71083
++package body Loop_Optimization23_Pkg is
++ procedure Foo (X : in out ArrayOfStructB) is
++ begin
++ for K in 0..99 loop
++ X (K+1).b.b := X (K).b.b;
++ end loop;
++ end Foo;
++end Loop_Optimization23_Pkg;
+diff --git a/gcc/testsuite/gnat.dg/loop_optimization23_pkg.ads b/gcc/testsuite/gnat.dg/loop_optimization23_pkg.ads
+new file mode 100644
+index 0000000..016ad82
+--- /dev/null
++++ b/gcc/testsuite/gnat.dg/loop_optimization23_pkg.ads
+@@ -0,0 +1,17 @@
++-- PR tree-optimization/71083
++package Loop_Optimization23_Pkg is
++ type Nibble is mod 2**4;
++ type Int24 is mod 2**24;
++ type StructA is record
++ a : Nibble;
++ b : Int24;
++ end record;
++ pragma Pack(StructA);
++ type StructB is record
++ a : Nibble;
++ b : StructA;
++ end record;
++ pragma Pack(StructB);
++ type ArrayOfStructB is array(0..100) of StructB;
++ procedure Foo (X : in out ArrayOfStructB);
++end Loop_Optimization23_Pkg;
+diff --git a/gcc/testsuite/lib/gcov.exp b/gcc/testsuite/lib/gcov.exp
+index 229a396..5b2a04d 100644
+--- a/gcc/testsuite/lib/gcov.exp
++++ b/gcc/testsuite/lib/gcov.exp
+@@ -20,15 +20,27 @@
+ global GCOV
+
+ #
++# clean-gcov-file -- delete a working file the compiler creates for gcov
++#
++# TESTCASE is the name of the test.
++# SUFFIX is file suffix
++
++proc clean-gcov-file { testcase suffix } {
++ set basename [file tail $testcase]
++ set base [file rootname $basename]
++ remote_file host delete $base.$suffix
++}
++
++#
+ # clean-gcov -- delete the working files the compiler creates for gcov
+ #
+ # TESTCASE is the name of the test.
+ #
+ proc clean-gcov { testcase } {
+- set basename [file tail $testcase]
+- set base [file rootname $basename]
+- remote_file host delete $base.gcno $base.gcda \
+- $basename.gcov $base.h.gcov
++ clean-gcov-file $testcase "gcno"
++ clean-gcov-file $testcase "gcda"
++ clean-gcov-file $testcase "gcov"
++ clean-gcov-file $testcase "h.gcov"
+ }
+
+ #
+@@ -305,6 +317,7 @@ proc run-gcov { args } {
+ set gcov_verify_branches 0
+ set gcov_verify_lines 1
+ set gcov_verify_intermediate 0
++ set gcov_remove_gcda 0
+ set xfailed 0
+
+ foreach a $args {
+@@ -317,6 +330,8 @@ proc run-gcov { args } {
+ set gcov_verify_calls 0
+ set gcov_verify_branches 0
+ set gcov_verify_lines 0
++ } elseif { $a == "remove-gcda" } {
++ set gcov_remove_gcda 1
+ } elseif { $gcov_args == "" } {
+ set gcov_args $a
+ } else {
+@@ -332,6 +347,11 @@ proc run-gcov { args } {
+ # Extract the test file name from the arguments.
+ set testcase [lindex $gcov_args end]
+
++ if { $gcov_remove_gcda } {
++ verbose "Removing $testcase.gcda"
++ clean-gcov-file $testcase "gcda"
++ }
++
+ verbose "Running $GCOV $testcase" 2
+ set testcase [remote_download host $testcase]
+ set result [remote_exec host $GCOV $gcov_args]
+diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp
+index b7aca17..d5dfeae 100644
+--- a/gcc/testsuite/lib/target-supports.exp
++++ b/gcc/testsuite/lib/target-supports.exp
+@@ -427,9 +427,7 @@ proc check_gc_sections_available { } {
+ }
+
+ # Check if the ld used by gcc supports --gc-sections.
+- set gcc_spec [${tool}_target_compile "-dumpspecs" "" "none" ""]
+- regsub ".*\n\\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
+- set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=$linker" "" "none" ""] 0]
++ set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=ld" "" "none" ""] 0]
+ set ld_output [remote_exec host "$gcc_ld" "--help"]
+ if { [ string first "--gc-sections" $ld_output ] >= 0 } {
+ set gc_sections_available_saved 1
+diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c
+index 4991219..4be8668 100644
+--- a/gcc/tree-nested.c
++++ b/gcc/tree-nested.c
+@@ -1344,7 +1344,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
+ {
+ wi->val_only = true;
+ wi->is_lhs = false;
+- *handled_ops_p = true;
++ *handled_ops_p = false;
+ return NULL_TREE;
+ }
+ break;
+diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
+index 03a38b4..8f6a75e 100644
+--- a/gcc/tree-predcom.c
++++ b/gcc/tree-predcom.c
+@@ -252,6 +252,7 @@ along with GCC; see the file COPYING3. If not see
+ #include "tree-affine.h"
+ #include "tree-inline.h"
+ #include "wide-int-print.h"
++#include "builtins.h"
+
+ /* The maximum number of iterations between the considered memory
+ references. */
+@@ -1424,6 +1425,8 @@ ref_at_iteration (data_reference_p dr, int iter, gimple_seq *stmts)
+ addr = force_gimple_operand_1 (unshare_expr (addr), stmts,
+ is_gimple_mem_ref_addr, NULL_TREE);
+ tree alias_ptr = fold_convert (reference_alias_ptr_type (DR_REF (dr)), coff);
++ tree type = build_aligned_type (TREE_TYPE (DR_REF (dr)),
++ get_object_alignment (DR_REF (dr)));
+ /* While data-ref analysis punts on bit offsets it still handles
+ bitfield accesses at byte boundaries. Cope with that. Note that
+ we cannot simply re-apply the outer COMPONENT_REF because the
+@@ -1435,12 +1438,11 @@ ref_at_iteration (data_reference_p dr, int iter, gimple_seq *stmts)
+ {
+ tree field = TREE_OPERAND (DR_REF (dr), 1);
+ return build3 (BIT_FIELD_REF, TREE_TYPE (DR_REF (dr)),
+- build2 (MEM_REF, DECL_BIT_FIELD_TYPE (field),
+- addr, alias_ptr),
++ build2 (MEM_REF, type, addr, alias_ptr),
+ DECL_SIZE (field), bitsize_zero_node);
+ }
+ else
+- return fold_build2 (MEM_REF, TREE_TYPE (DR_REF (dr)), addr, alias_ptr);
++ return fold_build2 (MEM_REF, type, addr, alias_ptr);
+ }
+
+ /* Get the initialization expression for the INDEX-th temporary variable
+diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
+index 61b65bb..84c6fc8 100644
+--- a/gcc/tree-ssa-math-opts.c
++++ b/gcc/tree-ssa-math-opts.c
+@@ -1619,25 +1619,32 @@ make_pass_cse_sincos (gcc::context *ctxt)
+ return new pass_cse_sincos (ctxt);
+ }
+
+-/* A symbolic number is used to detect byte permutation and selection
+- patterns. Therefore the field N contains an artificial number
+- consisting of octet sized markers:
++/* A symbolic number structure is used to detect byte permutation and selection
++ patterns of a source. To achieve that, its field N contains an artificial
++ number consisting of BITS_PER_MARKER sized markers tracking where does each
++ byte come from in the source:
+
+- 0 - target byte has the value 0
+- FF - target byte has an unknown value (eg. due to sign extension)
+- 1..size - marker value is the target byte index minus one.
++ 0 - target byte has the value 0
++ FF - target byte has an unknown value (eg. due to sign extension)
++ 1..size - marker value is the byte index in the source (0 for lsb).
+
+ To detect permutations on memory sources (arrays and structures), a symbolic
+- number is also associated a base address (the array or structure the load is
+- made from), an offset from the base address and a range which gives the
+- difference between the highest and lowest accessed memory location to make
+- such a symbolic number. The range is thus different from size which reflects
+- the size of the type of current expression. Note that for non memory source,
+- range holds the same value as size.
++ number is also associated:
++ - a base address BASE_ADDR and an OFFSET giving the address of the source;
++ - a range which gives the difference between the highest and lowest accessed
++ memory location to make such a symbolic number;
++ - the address SRC of the source element of lowest address as a convenience
++ to easily get BASE_ADDR + offset + lowest bytepos.
+
+- For instance, for an array char a[], (short) a[0] | (short) a[3] would have
+- a size of 2 but a range of 4 while (short) a[0] | ((short) a[0] << 1) would
+- still have a size of 2 but this time a range of 1. */
++ Note 1: the range is different from size as size reflects the size of the
++ type of the current expression. For instance, for an array char a[],
++ (short) a[0] | (short) a[3] would have a size of 2 but a range of 4 while
++ (short) a[0] | ((short) a[0] << 1) would still have a size of 2 but this
++ time a range of 1.
++
++ Note 2: for non-memory sources, range holds the same value as size.
++
++ Note 3: SRC points to the SSA_NAME in case of non-memory source. */
+
+ struct symbolic_number {
+ uint64_t n;
+@@ -1645,6 +1652,7 @@ struct symbolic_number {
+ tree base_addr;
+ tree offset;
+ HOST_WIDE_INT bytepos;
++ tree src;
+ tree alias_set;
+ tree vuse;
+ unsigned HOST_WIDE_INT range;
+@@ -1746,6 +1754,7 @@ init_symbolic_number (struct symbolic_number *n, tree src)
+ int size;
+
+ n->base_addr = n->offset = n->alias_set = n->vuse = NULL_TREE;
++ n->src = src;
+
+ /* Set up the symbolic number N by setting each byte to a value between 1 and
+ the byte size of rhs1. The highest order byte is set to n->size and the
+@@ -1859,6 +1868,7 @@ perform_symbolic_merge (gimple source_stmt1, struct symbolic_number *n1,
+ uint64_t inc;
+ HOST_WIDE_INT start_sub, end_sub, end1, end2, end;
+ struct symbolic_number *toinc_n_ptr, *n_end;
++ basic_block bb1, bb2;
+
+ if (!n1->base_addr || !n2->base_addr
+ || !operand_equal_p (n1->base_addr, n2->base_addr, 0))
+@@ -1872,15 +1882,20 @@ perform_symbolic_merge (gimple source_stmt1, struct symbolic_number *n1,
+ {
+ n_start = n1;
+ start_sub = n2->bytepos - n1->bytepos;
+- source_stmt = source_stmt1;
+ }
+ else
+ {
+ n_start = n2;
+ start_sub = n1->bytepos - n2->bytepos;
+- source_stmt = source_stmt2;
+ }
+
++ bb1 = gimple_bb (source_stmt1);
++ bb2 = gimple_bb (source_stmt2);
++ if (dominated_by_p (CDI_DOMINATORS, bb1, bb2))
++ source_stmt = source_stmt1;
++ else
++ source_stmt = source_stmt2;
++
+ /* Find the highest address at which a load is performed and
+ compute related info. */
+ end1 = n1->bytepos + (n1->range - 1);
+@@ -1937,6 +1952,7 @@ perform_symbolic_merge (gimple source_stmt1, struct symbolic_number *n1,
+ n->vuse = n_start->vuse;
+ n->base_addr = n_start->base_addr;
+ n->offset = n_start->offset;
++ n->src = n_start->src;
+ n->bytepos = n_start->bytepos;
+ n->type = n_start->type;
+ size = TYPE_PRECISION (n->type) / BITS_PER_UNIT;
+@@ -2147,7 +2163,7 @@ find_bswap_or_nop (gimple stmt, struct symbolic_number *n, bool *bswap)
+ uint64_t cmpxchg = CMPXCHG;
+ uint64_t cmpnop = CMPNOP;
+
+- gimple source_stmt;
++ gimple ins_stmt;
+ int limit;
+
+ /* The last parameter determines the depth search limit. It usually
+@@ -2157,9 +2173,9 @@ find_bswap_or_nop (gimple stmt, struct symbolic_number *n, bool *bswap)
+ in libgcc, and for initial shift/and operation of the src operand. */
+ limit = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (gimple_expr_type (stmt)));
+ limit += 1 + (int) ceil_log2 ((unsigned HOST_WIDE_INT) limit);
+- source_stmt = find_bswap_or_nop_1 (stmt, n, limit);
++ ins_stmt = find_bswap_or_nop_1 (stmt, n, limit);
+
+- if (!source_stmt)
++ if (!ins_stmt)
+ return NULL;
+
+ /* Find real size of result (highest non-zero byte). */
+@@ -2201,7 +2217,7 @@ find_bswap_or_nop (gimple stmt, struct symbolic_number *n, bool *bswap)
+ return NULL;
+
+ n->range *= BITS_PER_UNIT;
+- return source_stmt;
++ return ins_stmt;
+ }
+
+ namespace {
+@@ -2250,7 +2266,7 @@ public:
+ changing of basic block. */
+
+ static bool
+-bswap_replace (gimple cur_stmt, gimple src_stmt, tree fndecl, tree bswap_type,
++bswap_replace (gimple cur_stmt, gimple ins_stmt, tree fndecl, tree bswap_type,
+ tree load_type, struct symbolic_number *n, bool bswap)
+ {
+ gimple_stmt_iterator gsi;
+@@ -2258,18 +2274,24 @@ bswap_replace (gimple cur_stmt, gimple src_stmt, tree fndecl, tree bswap_type,
+ gimple bswap_stmt;
+
+ gsi = gsi_for_stmt (cur_stmt);
+- src = gimple_assign_rhs1 (src_stmt);
++ src = n->src;
+ tgt = gimple_assign_lhs (cur_stmt);
+
+ /* Need to load the value from memory first. */
+ if (n->base_addr)
+ {
+- gimple_stmt_iterator gsi_ins = gsi_for_stmt (src_stmt);
++ gimple_stmt_iterator gsi_ins = gsi_for_stmt (ins_stmt);
+ tree addr_expr, addr_tmp, val_expr, val_tmp;
+ tree load_offset_ptr, aligned_load_type;
+ gimple addr_stmt, load_stmt;
+ unsigned align;
+ HOST_WIDE_INT load_offset = 0;
++ basic_block ins_bb, cur_bb;
++
++ ins_bb = gimple_bb (ins_stmt);
++ cur_bb = gimple_bb (cur_stmt);
++ if (!dominated_by_p (CDI_DOMINATORS, cur_bb, ins_bb))
++ return false;
+
+ align = get_object_alignment (src);
+ /* If the new access is smaller than the original one, we need
+@@ -2301,7 +2323,7 @@ bswap_replace (gimple cur_stmt, gimple src_stmt, tree fndecl, tree bswap_type,
+ /* Move cur_stmt just before one of the load of the original
+ to ensure it has the same VUSE. See PR61517 for what could
+ go wrong. */
+- if (gimple_bb (cur_stmt) != gimple_bb (src_stmt))
++ if (gimple_bb (cur_stmt) != gimple_bb (ins_stmt))
+ reset_flow_sensitive_info (gimple_assign_lhs (cur_stmt));
+ gsi_move_before (&gsi, &gsi_ins);
+ gsi = gsi_for_stmt (cur_stmt);
+@@ -2474,6 +2496,7 @@ pass_optimize_bswap::execute (function *fun)
+
+ memset (&nop_stats, 0, sizeof (nop_stats));
+ memset (&bswap_stats, 0, sizeof (bswap_stats));
++ calculate_dominance_info (CDI_DOMINATORS);
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+@@ -2485,7 +2508,7 @@ pass_optimize_bswap::execute (function *fun)
+ variant wouldn't be detected. */
+ for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi);)
+ {
+- gimple src_stmt, cur_stmt = gsi_stmt (gsi);
++ gimple ins_stmt, cur_stmt = gsi_stmt (gsi);
+ tree fndecl = NULL_TREE, bswap_type = NULL_TREE, load_type;
+ enum tree_code code;
+ struct symbolic_number n;
+@@ -2518,9 +2541,9 @@ pass_optimize_bswap::execute (function *fun)
+ continue;
+ }
+
+- src_stmt = find_bswap_or_nop (cur_stmt, &n, &bswap);
++ ins_stmt = find_bswap_or_nop (cur_stmt, &n, &bswap);
+
+- if (!src_stmt)
++ if (!ins_stmt)
+ continue;
+
+ switch (n.range)
+@@ -2554,7 +2577,7 @@ pass_optimize_bswap::execute (function *fun)
+ if (bswap && !fndecl && n.range != 16)
+ continue;
+
+- if (bswap_replace (cur_stmt, src_stmt, fndecl, bswap_type, load_type,
++ if (bswap_replace (cur_stmt, ins_stmt, fndecl, bswap_type, load_type,
+ &n, bswap))
+ changed = true;
+ }
+diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
+index 34776a3..e6eaad4 100644
+--- a/gcc/tree-ssa-strlen.c
++++ b/gcc/tree-ssa-strlen.c
+@@ -916,6 +916,65 @@ find_equal_ptrs (tree ptr, int idx)
+ }
+ }
+
++/* Return true if STMT is a call to a builtin function with the right
++ arguments and attributes that should be considered for optimization
++ by this pass. */
++
++static bool
++valid_builtin_call (gimple stmt)
++{
++ if (!gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
++ return false;
++
++ tree callee = gimple_call_fndecl (stmt);
++ switch (DECL_FUNCTION_CODE (callee))
++ {
++ case BUILT_IN_MEMCMP:
++ case BUILT_IN_STRCHR:
++ case BUILT_IN_STRCHR_CHKP:
++ case BUILT_IN_STRLEN:
++ case BUILT_IN_STRLEN_CHKP:
++ /* The above functions should be pure. Punt if they aren't. */
++ if (gimple_vdef (stmt) || gimple_vuse (stmt) == NULL_TREE)
++ return false;
++ break;
++
++ case BUILT_IN_CALLOC:
++ case BUILT_IN_MALLOC:
++ case BUILT_IN_MEMCPY:
++ case BUILT_IN_MEMCPY_CHK:
++ case BUILT_IN_MEMCPY_CHKP:
++ case BUILT_IN_MEMCPY_CHK_CHKP:
++ case BUILT_IN_MEMPCPY:
++ case BUILT_IN_MEMPCPY_CHK:
++ case BUILT_IN_MEMPCPY_CHKP:
++ case BUILT_IN_MEMPCPY_CHK_CHKP:
++ case BUILT_IN_MEMSET:
++ case BUILT_IN_STPCPY:
++ case BUILT_IN_STPCPY_CHK:
++ case BUILT_IN_STPCPY_CHKP:
++ case BUILT_IN_STPCPY_CHK_CHKP:
++ case BUILT_IN_STRCAT:
++ case BUILT_IN_STRCAT_CHK:
++ case BUILT_IN_STRCAT_CHKP:
++ case BUILT_IN_STRCAT_CHK_CHKP:
++ case BUILT_IN_STRCPY:
++ case BUILT_IN_STRCPY_CHK:
++ case BUILT_IN_STRCPY_CHKP:
++ case BUILT_IN_STRCPY_CHK_CHKP:
++ /* The above functions should be neither const nor pure. Punt if they
++ aren't. */
++ if (gimple_vdef (stmt) == NULL_TREE || gimple_vuse (stmt) == NULL_TREE)
++ return false;
++ break;
++
++ default:
++ break;
++ }
++
++ return true;
++}
++
+ /* If the last .MEM setter statement before STMT is
+ memcpy (x, y, strlen (y) + 1), the only .MEM use of it is STMT
+ and STMT is known to overwrite x[strlen (x)], adjust the last memcpy to
+@@ -991,7 +1050,7 @@ adjust_last_stmt (strinfo si, gimple stmt, bool is_strcat)
+ return;
+ }
+
+- if (!gimple_call_builtin_p (last.stmt, BUILT_IN_NORMAL))
++ if (!valid_builtin_call (last.stmt))
+ return;
+
+ callee = gimple_call_fndecl (last.stmt);
+@@ -1867,7 +1926,7 @@ handle_builtin_memset (gimple_stmt_iterator *gsi)
+ if (!stmt1 || !is_gimple_call (stmt1))
+ return true;
+ tree callee1 = gimple_call_fndecl (stmt1);
+- if (!gimple_call_builtin_p (stmt1, BUILT_IN_NORMAL))
++ if (!valid_builtin_call (stmt1))
+ return true;
+ enum built_in_function code1 = DECL_FUNCTION_CODE (callee1);
+ tree size = gimple_call_arg (stmt2, 2);
+@@ -2112,7 +2171,7 @@ strlen_optimize_stmt (gimple_stmt_iterator *gsi)
+ if (is_gimple_call (stmt))
+ {
+ tree callee = gimple_call_fndecl (stmt);
+- if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
++ if (valid_builtin_call (stmt))
+ switch (DECL_FUNCTION_CODE (callee))
+ {
+ case BUILT_IN_STRLEN:
+diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
+index 6b4b589..adcd9d4 100644
+--- a/gcc/tree-ssa-tail-merge.c
++++ b/gcc/tree-ssa-tail-merge.c
+@@ -237,6 +237,7 @@ along with GCC; see the file COPYING3. If not see
+ #include "trans-mem.h"
+ #include "stringpool.h"
+ #include "tree-ssanames.h"
++#include "tree-eh.h"
+
+ /* Describes a group of bbs with the same successors. The successor bbs are
+ cached in succs, and the successor edge flags are cached in succ_flags.
+@@ -1273,6 +1274,11 @@ find_duplicate (same_succ same_succ, basic_block bb1, basic_block bb2)
+ || is_tm_ending (stmt2))
+ return;
+
++ /* Verify EH landing pads. */
++ if (lookup_stmt_eh_lp_fn (cfun, stmt1)
++ != lookup_stmt_eh_lp_fn (cfun, stmt2))
++ return;
++
+ if (!gimple_equal_p (same_succ, stmt1, stmt2))
+ return;
+
+diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
+index 90c1e2a..97e0875 100644
+--- a/gcc/tree-ssa-threadedge.c
++++ b/gcc/tree-ssa-threadedge.c
+@@ -574,7 +574,8 @@ simplify_control_stmt_condition (edge e,
+ gimple stmt,
+ gcond *dummy_cond,
+ tree (*simplify) (gimple, gimple),
+- bool handle_dominating_asserts)
++ bool handle_dominating_asserts,
++ bool backedge_seen)
+ {
+ tree cond, cached_lhs;
+ enum gimple_code code = gimple_code (stmt);
+@@ -593,7 +594,7 @@ simplify_control_stmt_condition (edge e,
+ /* Get the current value of both operands. */
+ if (TREE_CODE (op0) == SSA_NAME)
+ {
+- for (int i = 0; i < 2; i++)
++ for (int i = 0; i < (backedge_seen ? 1 : 2); i++)
+ {
+ if (TREE_CODE (op0) == SSA_NAME
+ && SSA_NAME_VALUE (op0))
+@@ -605,7 +606,7 @@ simplify_control_stmt_condition (edge e,
+
+ if (TREE_CODE (op1) == SSA_NAME)
+ {
+- for (int i = 0; i < 2; i++)
++ for (int i = 0; i < (backedge_seen ? 1 : 2); i++)
+ {
+ if (TREE_CODE (op1) == SSA_NAME
+ && SSA_NAME_VALUE (op1))
+@@ -689,7 +690,7 @@ simplify_control_stmt_condition (edge e,
+ a loop invariant SSA_NAME used in the condition. */
+ if (cached_lhs)
+ {
+- for (int i = 0; i < 2; i++)
++ for (int i = 0; i < (backedge_seen ? 1 : 2); i++)
+ {
+ if (TREE_CODE (cached_lhs) == SSA_NAME
+ && SSA_NAME_VALUE (cached_lhs))
+@@ -940,7 +941,8 @@ thread_around_empty_blocks (edge taken_edge,
+
+ /* Extract and simplify the condition. */
+ cond = simplify_control_stmt_condition (taken_edge, stmt, dummy_cond,
+- simplify, handle_dominating_asserts);
++ simplify, handle_dominating_asserts,
++ *backedge_seen_p);
+
+ /* If the condition can be statically computed and we have not already
+ visited the destination edge, then add the taken edge to our thread
+@@ -1326,7 +1328,8 @@ thread_through_normal_block (edge e,
+
+ /* Extract and simplify the condition. */
+ cond = simplify_control_stmt_condition (e, stmt, dummy_cond, simplify,
+- handle_dominating_asserts);
++ handle_dominating_asserts,
++ *backedge_seen_p);
+
+ if (!cond)
+ return 0;
+diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
+index 96f1aaf..2d9ac29 100644
+--- a/gcc/tree-ssa-uninit.c
++++ b/gcc/tree-ssa-uninit.c
+@@ -159,6 +159,31 @@ warn_uninit (enum opt_code wc, tree t, tree expr, tree var,
+ if (!has_undefined_value_p (t))
+ return;
+
++ /* Anonymous SSA_NAMEs shouldn't be uninitialized, but ssa_undefined_value_p
++ can return true if the def stmt of anonymous SSA_NAME is COMPLEX_EXPR
++ created for conversion from scalar to complex. Use the underlying var of
++ the COMPLEX_EXPRs real part in that case. See PR71581. */
++ if (expr == NULL_TREE
++ && var == NULL_TREE
++ && SSA_NAME_VAR (t) == NULL_TREE
++ && is_gimple_assign (SSA_NAME_DEF_STMT (t))
++ && gimple_assign_rhs_code (SSA_NAME_DEF_STMT (t)) == COMPLEX_EXPR)
++ {
++ tree v = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (t));
++ if (TREE_CODE (v) == SSA_NAME
++ && has_undefined_value_p (v)
++ && (integer_zerop (gimple_assign_rhs2 (SSA_NAME_DEF_STMT (t)))
++ || real_zerop (gimple_assign_rhs2 (SSA_NAME_DEF_STMT (t)))
++ || fixed_zerop (gimple_assign_rhs2 (SSA_NAME_DEF_STMT (t)))))
++ {
++ expr = SSA_NAME_VAR (v);
++ var = expr;
++ }
++ }
++
++ if (expr == NULL_TREE)
++ return;
++
+ /* TREE_NO_WARNING either means we already warned, or the front end
+ wishes to suppress the warning. */
+ if ((context
+diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
+index 68ce43a..a3c0c0d 100644
+--- a/gcc/tree-ssa.c
++++ b/gcc/tree-ssa.c
+@@ -1354,6 +1354,18 @@ non_rewritable_lvalue_p (tree lhs)
+ tree decl = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0);
+ if (DECL_P (decl)
+ && DECL_SIZE (decl) == TYPE_SIZE (TREE_TYPE (lhs))
++ /* If the dynamic type of the decl has larger precision than
++ the decl itself we can't use the decls type for SSA rewriting. */
++ && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl))
++ || compare_tree_int (DECL_SIZE (decl),
++ TYPE_PRECISION (TREE_TYPE (decl))) == 0)
++ || (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
++ && (TYPE_PRECISION (TREE_TYPE (decl))
++ >= TYPE_PRECISION (TREE_TYPE (lhs)))))
++ /* Make sure we are not re-writing non-float copying into float
++ copying as that can incur normalization. */
++ && (! FLOAT_TYPE_P (TREE_TYPE (decl))
++ || types_compatible_p (TREE_TYPE (lhs), TREE_TYPE (decl)))
+ && (TREE_THIS_VOLATILE (decl) == TREE_THIS_VOLATILE (lhs)))
+ return false;
+ }
+diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
+index e912f07..76a9fd7 100644
+--- a/gcc/tree-vect-data-refs.c
++++ b/gcc/tree-vect-data-refs.c
+@@ -2593,7 +2593,7 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
+ /* Sorting has ensured that DR_INIT (dra) <= DR_INIT (drb). */
+ HOST_WIDE_INT init_a = TREE_INT_CST_LOW (DR_INIT (dra));
+ HOST_WIDE_INT init_b = TREE_INT_CST_LOW (DR_INIT (drb));
+- gcc_assert (init_a < init_b);
++ gcc_assert (init_a <= init_b);
+
+ /* If init_b == init_a + the size of the type * k, we have an
+ interleaving, and DRA is accessed before DRB. */
+diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
+index a344a49..6b02951 100644
+--- a/gcc/tree-vect-loop-manip.c
++++ b/gcc/tree-vect-loop-manip.c
+@@ -1886,7 +1886,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loop_vinfo, tree loop_niters, int
+ gimple_seq new_stmts = NULL;
+ bool negative = tree_int_cst_compare (DR_STEP (dr), size_zero_node) < 0;
+ tree offset = negative
+- ? size_int (-TYPE_VECTOR_SUBPARTS (vectype) + 1) : NULL_TREE;
++ ? size_int (-TYPE_VECTOR_SUBPARTS (vectype) + 1) : size_zero_node;
+ tree start_addr = vect_create_addr_base_for_vector_ref (dr_stmt,
+ &new_stmts, offset, loop);
+ tree type = unsigned_type_for (TREE_TYPE (start_addr));
+diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
+index 4c13283..e8a87c4 100644
+--- a/gcc/tree-vrp.c
++++ b/gcc/tree-vrp.c
+@@ -8634,7 +8634,10 @@ vrp_intersect_ranges_1 (value_range_t *vr0, value_range_t *vr1)
+ if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
+ bitmap_ior_into (vr0->equiv, vr1->equiv);
+ else if (vr1->equiv && !vr0->equiv)
+- bitmap_copy (vr0->equiv, vr1->equiv);
++ {
++ vr0->equiv = BITMAP_ALLOC (NULL);
++ bitmap_copy (vr0->equiv, vr1->equiv);
++ }
+ }
+
+ static void
+diff --git a/libcpp/line-map.c b/libcpp/line-map.c
+index f9260d0..340eaba 100644
+--- a/libcpp/line-map.c
++++ b/libcpp/line-map.c
+@@ -218,7 +218,7 @@ new_linemap (struct line_maps *set,
+ if (LINEMAPS_USED (set, macro_map_p) == LINEMAPS_ALLOCATED (set, macro_map_p))
+ {
+ /* We ran out of allocated line maps. Let's allocate more. */
+- unsigned alloc_size;
++ size_t alloc_size;
+
+ /* Cast away extern "C" from the type of xrealloc. */
+ line_map_realloc reallocator = (set->reallocator
+diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog
+index 6cded6d..71a8114 100644
+--- a/libgcc/ChangeLog
++++ b/libgcc/ChangeLog
+@@ -1,3 +1,23 @@
++2016-11-07 Florian Weimer <fweimer@redhat.com>
++
++ Backport from mainline
++ 2016-10-24 Florian Weimer <fweimer@redhat.com>
++
++ PR libgcc/78064
++ * unwind-c.c: Include auto-target.h.
++
++2016-09-28 Joseph Myers <joseph@codesourcery.com>
++
++ Backport from mainline
++ 2016-09-07 Joseph Myers <joseph@codesourcery.com>
++
++ PR libgcc/77519
++ * libgcc2.c (NOTRUNC): Invert settings.
++
++2016-08-31 Jakub Sejdak <jakub.sejdak@phoesys.com>
++
++ * config.host: Add support for arm*-*-phoenix* targets.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/libgcc/config.host b/libgcc/config.host
+index b4b0665..9770242 100644
+--- a/libgcc/config.host
++++ b/libgcc/config.host
+@@ -396,6 +396,13 @@ arm*-*-uclinux*) # ARM ucLinux
+ unwind_header=config/arm/unwind-arm.h
+ extra_parts="$extra_parts crti.o crtn.o"
+ ;;
++arm*-*-phoenix*)
++ tmake_file="t-hardfp t-softfp arm/t-arm arm/t-elf arm/t-softfp arm/t-phoenix"
++ tmake_file="${tmake_file} arm/t-bpabi"
++ tm_file="$tm_file arm/bpabi-lib.h"
++ extra_parts="crtbegin.o crtend.o crti.o crtn.o"
++ unwind_header=config/arm/unwind-arm.h
++ ;;
+ arm*-*-eabi* | arm*-*-symbianelf* | arm*-*-rtems*)
+ tmake_file="${tmake_file} arm/t-arm arm/t-elf t-fixedpoint-gnu-prefix"
+ tm_file="$tm_file arm/bpabi-lib.h"
+diff --git a/libgcc/libgcc2.c b/libgcc/libgcc2.c
+index 0ef8823..bd90783 100644
+--- a/libgcc/libgcc2.c
++++ b/libgcc/libgcc2.c
+@@ -1866,25 +1866,25 @@ NAME (TYPE x, int m)
+ # define CTYPE SCtype
+ # define MODE sc
+ # define CEXT __LIBGCC_SF_FUNC_EXT__
+-# define NOTRUNC __LIBGCC_SF_EXCESS_PRECISION__
++# define NOTRUNC (!__LIBGCC_SF_EXCESS_PRECISION__)
+ #elif defined(L_muldc3) || defined(L_divdc3)
+ # define MTYPE DFtype
+ # define CTYPE DCtype
+ # define MODE dc
+ # define CEXT __LIBGCC_DF_FUNC_EXT__
+-# define NOTRUNC __LIBGCC_DF_EXCESS_PRECISION__
++# define NOTRUNC (!__LIBGCC_DF_EXCESS_PRECISION__)
+ #elif defined(L_mulxc3) || defined(L_divxc3)
+ # define MTYPE XFtype
+ # define CTYPE XCtype
+ # define MODE xc
+ # define CEXT __LIBGCC_XF_FUNC_EXT__
+-# define NOTRUNC __LIBGCC_XF_EXCESS_PRECISION__
++# define NOTRUNC (!__LIBGCC_XF_EXCESS_PRECISION__)
+ #elif defined(L_multc3) || defined(L_divtc3)
+ # define MTYPE TFtype
+ # define CTYPE TCtype
+ # define MODE tc
+ # define CEXT __LIBGCC_TF_FUNC_EXT__
+-# define NOTRUNC __LIBGCC_TF_EXCESS_PRECISION__
++# define NOTRUNC (!__LIBGCC_TF_EXCESS_PRECISION__)
+ #else
+ # error
+ #endif
+diff --git a/libgcc/unwind-c.c b/libgcc/unwind-c.c
+index d62afbb..a10a303 100644
+--- a/libgcc/unwind-c.c
++++ b/libgcc/unwind-c.c
+@@ -26,6 +26,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+
+ #include "tconfig.h"
+ #include "tsystem.h"
++#include "auto-target.h"
+ #include "unwind.h"
+ #define NO_SIZE_OF_ENCODED_VALUE
+ #include "unwind-pe.h"
+diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
+index b8ce7e7..0789100 100644
+--- a/libgfortran/ChangeLog
++++ b/libgfortran/ChangeLog
+@@ -1,3 +1,31 @@
++2016-10-31 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk
++ PR libgfortran/78123
++ * io/transfer.c (formatted_transfer_scalar_read): Clear seen_eor
++ only if we have tabbed to left of current position.
++
++2016-09-29 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk
++ PR libgfortran/77707
++ io/transfer.c (next_record): Flush before calculating next_record.
++ Correctly calculate.
++
++2016-09-29 Steven G. Kargl <kargl@gcc.gnu.org>
++
++ Backport from trunk
++ PR fortran/77507
++ * ieee/ieee_arithmetic.F90 (IEEE_VALUE_4,IEEE_VALUE_8,IEEE_VALULE_10,
++ IEEE_VALUE_16): Use correct keyword.
++
++2016-08-11 Jerry DeLisle <jvdelisle@gcc.gnu.org>
++
++ Backport from trunk
++ PR libgfortran/71123
++ PR libgfortran/73142
++ * io/list_read (eat_spaces): Eat '\r' as part of spaces.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/libgfortran/ieee/ieee_arithmetic.F90 b/libgfortran/ieee/ieee_arithmetic.F90
+index f81a4f8..ee89058 100644
+--- a/libgfortran/ieee/ieee_arithmetic.F90
++++ b/libgfortran/ieee/ieee_arithmetic.F90
+@@ -500,12 +500,12 @@ contains
+
+ ! IEEE_VALUE
+
+- elemental real(kind=4) function IEEE_VALUE_4(X, C) result(res)
+- implicit none
++ elemental real(kind=4) function IEEE_VALUE_4(X, CLASS) result(res)
++
+ real(kind=4), intent(in) :: X
+- type(IEEE_CLASS_TYPE), intent(in) :: C
++ type(IEEE_CLASS_TYPE), intent(in) :: CLASS
+
+- select case (C%hidden)
++ select case (CLASS%hidden)
+ case (1) ! IEEE_SIGNALING_NAN
+ res = -1
+ res = sqrt(res)
+@@ -538,12 +538,12 @@ contains
+ end select
+ end function
+
+- elemental real(kind=8) function IEEE_VALUE_8(X, C) result(res)
+- implicit none
++ elemental real(kind=8) function IEEE_VALUE_8(X, CLASS) result(res)
++
+ real(kind=8), intent(in) :: X
+- type(IEEE_CLASS_TYPE), intent(in) :: C
++ type(IEEE_CLASS_TYPE), intent(in) :: CLASS
+
+- select case (C%hidden)
++ select case (CLASS%hidden)
+ case (1) ! IEEE_SIGNALING_NAN
+ res = -1
+ res = sqrt(res)
+diff --git a/libgfortran/io/list_read.c b/libgfortran/io/list_read.c
+index 6b42ecf..b682b11 100644
+--- a/libgfortran/io/list_read.c
++++ b/libgfortran/io/list_read.c
+@@ -418,7 +418,7 @@ eat_spaces (st_parameter_dt *dtp)
+ /* Now skip spaces, EOF and EOL are handled in next_char. */
+ do
+ c = next_char (dtp);
+- while (c != EOF && (c == ' ' || c == '\t'));
++ while (c != EOF && (c == ' ' || c == '\r' || c == '\t'));
+
+ unget_char (dtp, c);
+ return c;
+diff --git a/libgfortran/io/transfer.c b/libgfortran/io/transfer.c
+index 746bb6d..7f02e45 100644
+--- a/libgfortran/io/transfer.c
++++ b/libgfortran/io/transfer.c
+@@ -1434,7 +1434,8 @@ formatted_transfer_scalar_read (st_parameter_dt *dtp, bt type, void *p, int kind
+ dtp->u.p.current_unit->bytes_left -= dtp->u.p.sf_seen_eor;
+ dtp->u.p.skips -= dtp->u.p.sf_seen_eor;
+ bytes_used = pos;
+- dtp->u.p.sf_seen_eor = 0;
++ if (dtp->u.p.pending_spaces == 0)
++ dtp->u.p.sf_seen_eor = 0;
+ }
+ if (dtp->u.p.skips < 0)
+ {
+@@ -3502,6 +3503,8 @@ next_record (st_parameter_dt *dtp, int done)
+ else
+ next_record_w (dtp, done);
+
++ fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
++
+ if (!is_stream_io (dtp))
+ {
+ /* Since we have changed the position, set it to unspecified so
+@@ -3515,8 +3518,8 @@ next_record (st_parameter_dt *dtp, int done)
+ fp = stell (dtp->u.p.current_unit->s);
+ /* Calculate next record, rounding up partial records. */
+ dtp->u.p.current_unit->last_record =
+- (fp + dtp->u.p.current_unit->recl - 1) /
+- dtp->u.p.current_unit->recl;
++ (fp + dtp->u.p.current_unit->recl) /
++ dtp->u.p.current_unit->recl - 1;
+ }
+ else
+ dtp->u.p.current_unit->last_record++;
+@@ -3525,7 +3528,6 @@ next_record (st_parameter_dt *dtp, int done)
+ if (!done)
+ pre_position (dtp);
+
+- fbuf_flush (dtp->u.p.current_unit, dtp->u.p.mode);
+ smarkeor (dtp->u.p.current_unit->s);
+ }
+
+diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog
+index ee0fbf5..a511c0c 100644
+--- a/libgomp/ChangeLog
++++ b/libgomp/ChangeLog
+@@ -1,3 +1,11 @@
++2016-07-07 Jakub Jelinek <jakub@redhat.com>
++
++ Backported from mainline
++ 2016-07-01 Jakub Jelinek <jakub@redhat.com>
++
++ PR fortran/71717
++ * testsuite/libgomp.fortran/associate3.f90: New test.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/libgomp/testsuite/libgomp.fortran/associate3.f90 b/libgomp/testsuite/libgomp.fortran/associate3.f90
+new file mode 100644
+index 0000000..ec3d8dc
+--- /dev/null
++++ b/libgomp/testsuite/libgomp.fortran/associate3.f90
+@@ -0,0 +1,20 @@
++! PR fortran/71717
++! { dg-do run }
++
++ type t
++ real, allocatable :: f(:)
++ end type
++ type (t) :: v
++ integer :: i, j
++ allocate (v%f(4))
++ v%f = 19.
++ i = 5
++ associate (u => v, k => i)
++ !$omp parallel do
++ do j = 1, 4
++ u%f(j) = 21.
++ if (j.eq.1) k = 7
++ end do
++ end associate
++ if (any (v%f(:).ne.21.) .or. i.ne.7) call abort
++end
+diff --git a/libsanitizer/ChangeLog b/libsanitizer/ChangeLog
+index 0094417..13d1949 100644
+--- a/libsanitizer/ChangeLog
++++ b/libsanitizer/ChangeLog
+@@ -1,3 +1,8 @@
++2016-11-16 Markus Trippelsdorf <markus@trippelsdorf.de>
++
++ PR sanitizer/78294
++ * tsan/tsan_rtl.cc: Add missing attribute.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/libsanitizer/tsan/tsan_rtl.cc b/libsanitizer/tsan/tsan_rtl.cc
+index bf971b6..864d2ee 100644
+--- a/libsanitizer/tsan/tsan_rtl.cc
++++ b/libsanitizer/tsan/tsan_rtl.cc
+@@ -42,6 +42,7 @@ extern "C" void __tsan_resume() {
+ namespace __tsan {
+
+ #ifndef TSAN_GO
++__attribute__((tls_model("initial-exec")))
+ THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
+ #endif
+ static char ctx_placeholder[sizeof(Context)] ALIGNED(64);
+diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
+index 58373fd..c56ff11 100644
+--- a/libstdc++-v3/ChangeLog
++++ b/libstdc++-v3/ChangeLog
+@@ -1,3 +1,612 @@
++2016-12-19 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ Backport from mainline
++ 2016-12-19 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ Make the perfect-forwarding constructor of a two-element tuple
++ sfinae away when the first argument is an allocator_arg.
++ * include/std/tuple (tuple(_U1&&, _U2&&)): Constrain.
++ * testsuite/20_util/tuple/cons/allocator_with_any.cc: New.
++
++2016-12-13 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2016-10-26 Uros Bizjak <ubizjak@gmail.com>
++
++ * acinclude.m4 (GLIBCXX_CHECK_FILESYSTEM_DEPS): Include <limits.h>
++ for PATH_MAX in realpath test.
++ * configure: Regenerate.
++
++ Backport from mainline
++ 2016-05-25 Jonathan Wakely <jwakely@redhat.com>
++
++ * acinclude.m4 (GLIBCXX_CHECK_FILESYSTEM_DEPS): Fix test for sendfile.
++ * configure: Regenerate.
++ * config.h.in: Regenerate.
++
++2016-12-12 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2016-12-07 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/18_support/headers/new/synopsis.cc: Add C++14 declarations.
++ * testsuite/18_support/headers/new/synopsis_cxx98.cc: New test.
++
++2016-12-12 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2016-11-22 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/78465
++ * testsuite/29_atomics/headers/atomic/macros.cc: Replace runtime tests
++ with preprocessor conditions.
++
++2016-12-12 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ PR libstdc++/70975
++ PR libstdc++/71337
++ PR libstdc++/78111
++ * include/experimental/bits/fs_dir.h (recursive_directory_iterator):
++ Overload pop (LWG 2706).
++ * include/experimental/bits/fs_fwd.h (perms::resolve_symlinks):
++ Replace with symlink_nofollow (LWG 2720).
++ * include/experimental/bits/fs_ops.h
++ (exists(const path&, error_code&)): Clear error if status is known
++ (LWG 2725).
++ * include/experimental/bits/fs_path.h (__is_path_src)
++ (_S_range_begin, _S_range_end): Overload to treat string_view as a
++ Source object.
++ (path::operator+=, path::compare): Overload for basic_string_view.
++ (path::path(string_type&&))
++ (path::operator=(string&&), path::assign(string_type&&)): Define
++ construction and assignment from string_type rvalues (LWG 2707).
++ (path::_S_convert<_Iter>(_Iter, _Iter)): Remove cv-qualifiers from
++ iterator's value_type.
++ (path::_S_convert<_Iter>(_Iter __first, __null_terminated)): Likewise.
++ Do not use operation not supported by input iterators.
++ (path::__is_path_iter_src): Add partial specialization for const
++ encoded character types.
++ * src/filesystem/dir.cc (open_dir): Return same value for errors
++ whether ignored or not.
++ (_Dir::advance(error_code*, directory_options)): Return false on
++ error.
++ (directory_iterator(const path&, directory_options, error_code*)):
++ Create end iterator on error (LWG 2723).
++ (recursive_directory_iterator(const path&, directory_options,
++ error_code*)): Likewise.
++ (recursive_directory_iterator::increment): Reset state on error.
++ (recursive_directory_iterator::pop): Define new overload.
++ * src/filesystem/ops.cc (canonical): Set error for non-existent path.
++ (file_time): Take error_code parameter and check for overflow.
++ (close_fd): Remove.
++ (do_copy_file): Report an error if source or destination is not a
++ regular file (LWG 2712). Pass error_code in file_time calls. Just
++ use close(3) instead of close_fd, to prevent retrying on error.
++ Check if _GLIBCXX_USE_FCHMODAT is defined.
++ [_GLIBCXX_USE_SENDFILE]: Fallback to read/write operations in case
++ sendfile fails with ENOSYS or EINVAL. Pass non-null pointer to
++ sendfile for offset argument.
++ (copy): Update comment to refer to LWG 2681. Implement 2682 and 2683
++ resolutions.
++ (equivalent): Fix error handling and result when only one file exists.
++ (is_empty): Fix error handling.
++ (last_write_time(const path&, error_code&)): Pass error_code in
++ file_time calls.
++ (last_write_time(const path&, file_time_type, error_code&)): Handle
++ negative times correctly.
++ (permissions(const path&, perms, error_code&)): Handle
++ symlink_nofollow.
++ (read_symlink): Add missing ec.clear().
++ (status(const path&, error_code&)): Handle EOVERFLOW.
++ (temp_directory_path): Pass error_code argument to other filesystem
++ operations.
++ * testsuite/experimental/filesystem/iterators/directory_iterator.cc:
++ Update expected behaviour on error.
++ * testsuite/experimental/filesystem/iterators/pop.cc: New.
++ * testsuite/experimental/filesystem/iterators/
++ recursive_directory_iterator.cc: Update expected behaviour on error.
++ * testsuite/experimental/filesystem/operations/copy.cc: Update
++ expected behaviour for copying directories with create_symlinks.
++ Verify that error_code arguments are cleared if there's no error.
++ Remove files created by tests. Test copying directories.
++ * testsuite/experimental/filesystem/operations/copy_file.cc: Remove
++ files created by tests.
++ * testsuite/experimental/filesystem/operations/create_symlink.cc: New.
++ * testsuite/experimental/filesystem/operations/equivalent.cc: New.
++ * testsuite/experimental/filesystem/operations/exists.cc: Test
++ overload taking an error_code.
++ * testsuite/experimental/filesystem/operations/is_empty.cc: New.
++ * testsuite/experimental/filesystem/operations/last_write_time.cc:
++ New.
++ * testsuite/experimental/filesystem/operations/permissions.cc: Test
++ overload taking error_code. Test symlink_nofollow on non-symlinks.
++ * testsuite/experimental/filesystem/operations/read_symlink.cc: New.
++ * testsuite/experimental/filesystem/operations/remove_all.cc: New.
++ * testsuite/experimental/filesystem/operations/temp_directory_path.cc:
++ Add testcase for inaccessible directory.
++ * testsuite/experimental/filesystem/path/construct/range.cc: Test
++ construction from input iterators with const value types.
++ * testsuite/experimental/filesystem/path/construct/string_view.cc:
++ New.
++ * testsuite/util/testsuite_fs.h (scoped_file): Define RAII helper.
++
++2016-12-07 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ Backport from mainline
++ 2016-12-06 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ Constrain optional's __constexpr_addressof in its return type
++ and use a constexpr addressof for optional, if available.
++ * include/experimental/optional (__constexpr_addressof):
++ Constrain in the return type instead of in a template parameter.
++ (_Has_addressof_mem)
++ (_Has_addressof_free, _Has_addressof, __constexpr_addressof):
++ Guard with #ifndef __cpp_lib_addressof_constexpr.
++ (operator->()): Use std::__addressof if it's constexpr.
++
++2016-12-06 Aditya Kumar <hiraditya@msn.com>
++
++ * src/c++11/shared_ptr.cc (_Sp_locker::_Sp_locker(const void* p)): Add
++ noexcept on constructor.
++ (_Sp_locker::_Sp_locker(const void* p1, const void* p2)): Same.
++
++2016-12-01 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ Backport from mainline
++ 2016-11-21 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE>
++
++ * acinclude.m4 (GLIBCXX_CHECK_MATH11_PROTO): Update comments.
++ (__CORRECT_ISO_CPP11_MATH_H_PROTO): Rename to ...
++ (__CORRECT_ISO_CPP11_MATH_H_PROTO_FP): ... this.
++ Add test for C++11 <math.h> integral overloads.
++ * configure: Regenerate.
++ * config.h.in: Regenerate.
++
++ * include/c_global/cmath [__cplusplus >= 201103L]: Reflect
++ __CORRECT_ISO_CPP11_MATH_H_PROTO to
++ __CORRECT_ISO_CPP11_MATH_H_PROTO_FP rename.
++ * include/c_global/cmath [_GLIBCXX_USE_C99_MATH &&
++ !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC && __cplusplus >= 201103L]
++ (std::fpclassify): Wrap in !__CORRECT_ISO_CPP11_MATH_H_PROTO_INT.
++ (std::isfinite): Likewise.
++ (std::isinf): Likewise.
++ (std::isnan): Likewise.
++ (std::isnormal): Likewise.
++ (std::signbit): Likewise.
++ (std::isgreater): Likewise.
++ (std::isgreaterequal): Likewise.
++ (std::isless): Likewise.
++ (std::islessequal): Likewise.
++ (std::islessgreater): Likewise.
++ (std::isunordered): Likewise.
++ [__cplusplus >= 201103L && _GLIBCXX_USE_C99_MATH_TR1]
++ (std::acosh): Likewise.
++ (std::asinh): Likewise.
++ (std::atanh): Likewise.
++ (std::cbrt): Likewise.
++ (std::copysign): Likewise.
++ (std::erf): Likewise.
++ (std::erfc): Likewise.
++ (std::exp2): Likewise.
++ (std::expm1): Likewise.
++ (std::fdim): Likewise.
++ (std::fma): Likewise.
++ (std::fmax): Likewise.
++ (std::fmin): Likewise.
++ (std::hypot): Likewise.
++ (std::ilogb): Likewise.
++ (std::lgamma): Likewise.
++ (std::llrint): Likewise.
++ (std::llround): Likewise.
++ (std::log1p): Likewise.
++ (std::log2): Likewise.
++ (std::logb): Likewise.
++ (std::lrint): Likewise.
++ (std::lround): Likewise.
++ (std::nearbyint): Likewise.
++ (std::nextafter): Likewise.
++ (std::nexttoward): Likewise.
++ (std::remainder): Likewise.
++ (std::remquo): Likewise.
++ (std::rint): Likewise.
++ (std::round): Likewise.
++ (std::scalbln): Likewise.
++ (std::scalbn): Likewise.
++ (std::tgamma): Likewise.
++ (std::trunc): Likewise.
++ * include/tr1/cmath [_GLIBCXX_USE_C99_MATH_TR1 && __cplusplus >=
++ 201103L]: Reflect __CORRECT_ISO_CPP11_MATH_H_PROTO to
++ __CORRECT_ISO_CPP11_MATH_H_PROTO_FP rename.
++
++2016-11-23 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/24_iterators/reverse_iterator/71771.cc: Replace calls to
++ C++14 std::rbegin and std::rend. Use dg-options instead of
++ effective-target.
++
++2016-11-22 Uros Bizjak <ubizjak@gmail.com>
++
++ * testsuite/Makefile.am
++ (check-DEJAGNU $(check_DEJAGNU_normal_targets)): Fix detection
++ of -j argument.
++ * testsuite/Makefile.in: Regenereate.
++
++2016-11-15 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/experimental/any/typedefs.cc: Fix license text.
++ * testsuite/experimental/chrono/value.cc: Likewise.
++ * testsuite/experimental/optional/assignment/1.cc: Likewise.
++ * testsuite/experimental/optional/assignment/2.cc: Likewise.
++ * testsuite/experimental/optional/assignment/3.cc: Likewise.
++ * testsuite/experimental/optional/assignment/4.cc: Likewise.
++ * testsuite/experimental/optional/assignment/5.cc: Likewise.
++ * testsuite/experimental/optional/assignment/6.cc: Likewise.
++ * testsuite/experimental/optional/cons/move.cc: Likewise.
++ * testsuite/experimental/optional/cons/value.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/cons/value.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/make_optional.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/observers/1.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/observers/2.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/observers/3.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/observers/4.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/observers/5.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/1.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/2.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/3.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/4.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/5.cc: Likewise.
++ * testsuite/experimental/optional/constexpr/relops/6.cc: Likewise.
++ * testsuite/experimental/optional/make_optional.cc: Likewise.
++ * testsuite/experimental/optional/observers/1.cc: Likewise.
++ * testsuite/experimental/optional/observers/2.cc: Likewise.
++ * testsuite/experimental/optional/observers/3.cc: Likewise.
++ * testsuite/experimental/optional/observers/4.cc: Likewise.
++ * testsuite/experimental/optional/observers/5.cc: Likewise.
++ * testsuite/experimental/optional/relops/1.cc: Likewise.
++ * testsuite/experimental/optional/relops/2.cc: Likewise.
++ * testsuite/experimental/optional/relops/3.cc: Likewise.
++ * testsuite/experimental/optional/relops/4.cc: Likewise.
++ * testsuite/experimental/optional/relops/5.cc: Likewise.
++ * testsuite/experimental/optional/relops/6.cc: Likewise.
++ * testsuite/experimental/optional/requirements.cc: Likewise.
++ * testsuite/experimental/optional/swap/1.cc: Likewise.
++ * testsuite/experimental/optional/typedefs.cc: Likewise.
++ * testsuite/experimental/ratio/value.cc: Likewise.
++ * testsuite/experimental/string_view/typedefs.cc: Likewise.
++ * testsuite/experimental/system_error/value.cc: Likewise.
++ * testsuite/experimental/tuple/tuple_size.cc: Likewise.
++ * testsuite/experimental/type_traits/value.cc: Likewise.
++
++2016-10-20 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/78052
++ * include/bits/allocator.h (allocator<void>::construct)
++ (allocator<void>::destroy): Define.
++ * testsuite/20_util/allocator/void.cc: New test.
++
++2016-10-19 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/77990
++ * include/bits/unique_ptr.h (unique_ptr::unique_ptr(pointer)): Set
++ pointer member after value-initialization of tuple.
++ * testsuite/20_util/unique_ptr/assign/48635_neg.cc: Adjust dg-errors.
++ * testsuite/20_util/unique_ptr/cons/77990.cc: New test.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-10-10 Jonathan Wakely <jwakely@redhat.com>
++
++ * doc/xml/manual/appendix_contributing.xml (contrib.organization):
++ Replace <literallayout> with nested <variablelist> elements. Update
++ some more outdated text.
++ * doc/html/*: Regenerate.
++
++ Backport from mainline:
++ 2016-10-10 Jonathan Wakely <jwakely@redhat.com>
++
++ * doc/xml/manual/appendix_contributing.xml (contrib.organization):
++ Describe other subdirectories and add markup. Remove outdated
++ reference to check-script target.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-10-13 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/26_numerics/random/default_random_engine.cc: Use VERIFY
++ instead of assert.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-10-11 Jonathan Wakely <jwakely@redhat.com>
++
++ * include/experimental/string_view (basic_string_view::_S_compare):
++ Remove redundant const from return type.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-10-13 Jonathan Wakely <jwakely@redhat.com>
++
++ * include/experimental/functional (boyer_moore_searcher)
++ (__boyer_moore_map_base, __boyer_moore_array_base): Qualify containers
++ with _GLIBCXX_STD_C.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-08-22 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/77322
++ * doc/xml/manual/intro.xml: Document DR 2062 change.
++ * include/std/functional (function::swap): Add noexcept.
++ (swap(function<Res(Args...)&, function<Res(Args...)&)): Likewise.
++ * testsuite/20_util/function/77322.cc: New test.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-08-17 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/20_util/reference_wrapper/invoke-2.cc: Fix invalid dg-do
++ directive and use effective target instead of dg-options.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline:
++ 2016-08-06 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/72820
++ * include/std/functional (_Function_base::_Base_manager::_M_clone):
++ Qualify new operator.
++ * testsuite/20_util/function/cons/72820.cc: New test.
++
++2016-10-17 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/77994
++ * include/experimental/algorithm (experimental::sample): Convert size
++ argument to iterator difference type. Fix invalid use of input
++ iterator. Defend against overloaded comma operator.
++
++2016-10-05 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/70564
++ * include/experimental/functional (_Not_fn): Add second parameter to
++ disambiguate copying from initialization by not_fn.
++ (not_fn): Add second argument to initialization.
++ * testsuite/experimental/functional/not_fn.cc: Copy call wrapper using
++ direct-initialization. Test abstract class.
++
++ PR libstdc++/77864
++ * include/bits/stl_map.h (map::map()): Use nothrow constructibility
++ of comparison function in conditional noexcept.
++ * include/bits/stl_multimap.h (multimap::multimap()): Likewise.
++ * include/bits/stl_multiset.h (multiset::multiset()): Likewise.
++ * include/bits/stl_set.h (set::set()): Likewise.
++ * testsuite/23_containers/map/cons/noexcept_default_construct.cc:
++ New test.
++ * testsuite/23_containers/multimap/cons/noexcept_default_construct.cc:
++ Likewise.
++ * testsuite/23_containers/multiset/cons/noexcept_default_construct.cc:
++ Likewise.
++ * testsuite/23_containers/set/cons/noexcept_default_construct.cc:
++ Likewise.
++
++2016-10-03 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/68323
++ PR libstdc++/77794
++ * config/abi/pre/gnu-versioned-namespace.ver: Add export for
++ __cxa_thread_atexit.
++ * include/Makefile.am: Add <experimental/lfts_config.h>
++ * include/Makefile.in: Regenerate.
++ * src/filesystem/Makefile.in: Likewise.
++ * include.bits/basic_string.h: Fix nesting of versioned namespaces.
++ * include/bits/c++config: Declare versioned namespaces for literals.
++ * include/bits/regex.h (basic_regex, match_results): Add workarounds
++ for PR c++/59256.
++ * include/bits/uniform_int_dist.h: Fix nesting of versioned namespace.
++ * include/std/chrono: Likewise.
++ * include/std/complex: Likewise.
++ * include/experimental/fs_fwd.h: Declare versioned namespace.
++ * include/experimental/lfts_config.h: Declare versioned namespaces.
++ * include/experimental/algorithm: Include
++ <experimental/lfts_config.h>.
++ * include/experimental/any: Likewise.
++ * include/experimental/chrono: Likewise.
++ * include/experimental/functional: Likewise.
++ * include/experimental/optional: Likewise.
++ * include/experimental/ratio: Likewise.
++ * include/experimental/system_error: Likewise.
++ * include/experimental/tuple: Likewise.
++ * include/experimental/type_traits: Likewise.
++ * include/experimental/string_view: Likewise. Fix nesting of
++ versioned namespaces.
++ * include/experimental/string_view.tcc: Reopen inline namespace for
++ non-inline function definitions.
++ * testsuite/17_intro/using_namespace_std_exp_neg.cc: New test.
++ * testsuite/20_util/duration/literals/range.cc: Adjust dg-error line.
++ * testsuite/experimental/any/misc/any_cast_neg.cc: Likewise.
++ * testsuite/ext/profile/mutex_extensions_neg.cc: Likewise.
++
++2016-09-28 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/77686
++ * include/std/functional (_Any_data): Add may_alias attribute.
++
++2016-09-27 Jonathan Wakely <jwakely@redhat.com>
++
++ * include/debug/safe_iterator.h (_Safe_iterator::operator++()): Fix
++ lifetime of lock.
++
++2016-09-20 Jonathan Wakely <jwakely@redhat.com>
++
++ * python/libstdcxx/v6/xmethods.py (DequeWorkerBase.__init__)
++ (DequeWorkerBase.index, VectorWorkerBase.get): Use // for division.
++
++2016-09-19 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/77645
++ * python/libstdcxx/v6/xmethods.py (DequeWorkerBase.__init__)
++ (DequeWorkerBase.index, VectorWorkerBase.get): Cast results of
++ division to int to work with Python 3.
++
++2016-08-23 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/23_containers/map/77334.cc: Use dg-options for C++11.
++
++ PR libstdc++/77334
++ * include/bits/stl_tree.h (_Rb_tree::_M_move_assign): New functions.
++ (_Rb_tree::operator=(_Rb_tree&&)): Dispatch to _M_move_assign.
++ Include _Compare in noexcept.
++ * testsuite/23_containers/map/77334.cc: New test.
++
++2016-08-23 Jonathan Wakely <jwakely@redhat.com>
++
++ * doc/xml/api.xml: Replace hardcoded links for specific versions with
++ link to docs for all releases.
++ * doc/html/*: Regenerate.
++
++ * include/bits/stl_iterator.h
++ (operator-(reverse_iterator<Iter>, reverse_iterator<Iter>): Constrain
++ for C++11 and later.
++ * testsuite/24_iterators/reverse_iterator/71771.cc: New test.
++
++2016-08-06 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2016-08-05 Jonathan Wakely <jwakely@redhat.com>
++
++ * include/std/functional (function::_Callable): Use lvalue in
++ result_of expression.
++ * testsuite/20_util/function/cons/refqual.cc: New test.
++
++ Backport from mainline
++ 2016-07-22 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/71964
++ * include/bits/stl_tree.h (_Rb_tree(_Rb_tree&&)): Move allocator.
++ * testsuite/23_containers/set/allocator/71964.cc: New test.
++
++ Backport from mainline
++ 2016-08-02 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/21_strings/basic_string/allocator/wchar_t/copy.cc:
++ Remove reundant check for _GLIBCXX_USE_WCHAR_T and fix char type.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/copy_assign.cc:
++ Likewise.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc:
++ Likewise.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/move.cc:
++ Likewise.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/move_assign.cc:
++ Likewise.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/noexcept.cc:
++ Likewise.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/swap.cc:
++ Likewise.
++
++ Backport from mainline
++ 2016-01-18 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/69243
++ * include/std/functional (_Function_base::_M_not_empty_function):
++ Change overloads for pointers to take arguments by value.
++ * testsuite/20_util/function/cons/57465.cc: Add tests for
++ pointer-to-member cases.
++
++ * doc/xml/manual/status_cxx2011.xml: Change "mainline GCC SVN" to
++ refer to the release series.
++ * doc/xml/manual/status_cxx2014.xml: Likewise.
++ * doc/html/manual/status.xml: Regenerate.
++
++ * testsuite/lib/libstdc++.exp (check_v3_target_filesystem_ts): Improve
++ comments.
++
++2016-08-02 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/lib/libstdc++.exp (v3-build_support): Add
++ -fno-lto to additional flags for compiling libtestc++.a objects.
++
++2016-07-19 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2016-06-06 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/71320
++ * src/filesystem/ops.cc (permissions(const path&, perms, error_code&)):
++ Add or remove permissions according to perms argument.
++ * testsuite/experimental/filesystem/operations/permissions.cc: New
++ test.
++
++2016-07-12 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2015-10-02 Jonathan Wakely <jwakely@redhat.com>
++
++ * testsuite/21_strings/basic_string/allocator/char/minimal.cc: Guard
++ explicit instantiation with check for new ABI.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc:
++ Likewise. Use wchar_t as char_type.
++
++ Backport from mainline
++ 2015-09-11 Jonathan Wakely <jwakely@redhat.com>
++
++ PR libstdc++/58265
++ * doc/xml/manual/intro.xml: Document LWG 2063 and 2064 resolutions.
++ * doc/html/manual/bugs.html: Regenerate.
++ * include/bits/basic_string.h (basic_string): Implement N4258. Add
++ correct exception-specifications and propagate allocators correctly.
++ * include/bits/basic_string.tcc (basic_string::swap): Propagate
++ allocators correctly.
++ * include/debug/string (__gnu_debug::basic_string): Add correct
++ exceptions-specifications and allcoator-extended constructors.
++ * testsuite/21_strings/basic_string/allocator/char/copy.cc: New.
++ * testsuite/21_strings/basic_string/allocator/char/copy_assign.cc:
++ New.
++ * testsuite/21_strings/basic_string/allocator/char/minimal.cc: New.
++ * testsuite/21_strings/basic_string/allocator/char/move.cc: New.
++ * testsuite/21_strings/basic_string/allocator/char/move_assign.cc:
++ New.
++ * testsuite/21_strings/basic_string/allocator/char/noexcept.cc: New.
++ * testsuite/21_strings/basic_string/allocator/char/swap.cc: New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/copy.cc: New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/copy_assign.cc:
++ New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc: New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/move.cc: New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/move_assign.cc:
++ New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/noexcept.cc: New.
++ * testsuite/21_strings/basic_string/allocator/wchar_t/swap.cc: New.
++ * testsuite/util/testsuite_allocator.h (tracker_allocator): Define
++ defaulted assignment operators.
++
++2016-07-08 Jonathan Wakely <jwakely@redhat.com>
++
++ Backport from mainline
++ 2015-06-02 Jonathan Wakely <jwakely@redhat.com>
++
++ * doc/html/ext/lwg-active.html: Update to R93.
++ * doc/html/ext/lwg-closed.html: Likewise.
++ * doc/html/ext/lwg-defects.html: Likewise.
++ * doc/html/manual/*: Regenerate.
++ * doc/xml/manual/intro.xml: Document status of several DRs.
++
++2016-07-04 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ Backport from mainline
++ 2016-07-04 Ville Voutilainen <ville.voutilainen@gmail.com>
++
++ PR libstdc++/71313
++ * src/filesystem/ops.cc (remove_all(const path&, error_code&)):
++ Call remove_all for children of a directory.
++ * testsuite/experimental/filesystem/operations/create_directories.cc:
++ Adjust.
++
+ 2016-06-03 Release Manager
+
+ * GCC 5.4.0 released.
+diff --git a/libstdc++-v3/acinclude.m4 b/libstdc++-v3/acinclude.m4
+index 826ef86..18b7b66 100644
+--- a/libstdc++-v3/acinclude.m4
++++ b/libstdc++-v3/acinclude.m4
+@@ -1897,7 +1897,8 @@ AC_DEFUN([GLIBCXX_CHECK_STDIO_PROTO], [
+ ])
+
+ dnl
+-dnl Check whether required C++11 overloads are present in <math.h>.
++dnl Check whether required C++11 overloads for floating point and integral
++dnl types are present in <math.h>.
+ dnl
+ AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
+
+@@ -1908,10 +1909,10 @@ AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
+
+ case "$host" in
+ *-*-solaris2.*)
+- # Solaris 12 introduced the C++11 <math.h> overloads. A backport to
+- # a Solaris 11.3 SRU is likely, maybe even a Solaris 10 patch.
+- AC_MSG_CHECKING([for C++11 <math.h> overloads])
+- AC_CACHE_VAL(glibcxx_cv_math11_overload, [
++ # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
++ # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
++ AC_MSG_CHECKING([for C++11 <math.h> floating point overloads])
++ AC_CACHE_VAL(glibcxx_cv_math11_fp_overload, [
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+ [#include <math.h>
+ #undef isfinite
+@@ -1920,21 +1921,73 @@ AC_DEFUN([GLIBCXX_CHECK_MATH11_PROTO], [
+ { return __builtin_isfinite(__x); }
+ }
+ ])],
+- [glibcxx_cv_math11_overload=no],
+- [glibcxx_cv_math11_overload=yes]
++ [glibcxx_cv_math11_fp_overload=no],
++ [glibcxx_cv_math11_fp_overload=yes]
+ )])
+
+ # autoheader cannot handle indented templates.
+- AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO],
+- [/* Define if all C++11 overloads are available in <math.h>. */
++ AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_FP],
++ [/* Define if all C++11 floating point overloads are available in <math.h>. */
+ #if __cplusplus >= 201103L
+-#undef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ #endif])
+
+- if test $glibcxx_cv_math11_overload = yes; then
+- AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO)
++ if test $glibcxx_cv_math11_fp_overload = yes; then
++ AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_FP)
+ fi
+- AC_MSG_RESULT([$glibcxx_cv_math11_overload])
++ AC_MSG_RESULT([$glibcxx_cv_math11_fp_overload])
++
++ # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
++ # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
++ AC_MSG_CHECKING([for C++11 <math.h> integral type overloads])
++ AC_CACHE_VAL(glibcxx_cv_math11_int_overload, [
++ AC_COMPILE_IFELSE([AC_LANG_SOURCE(
++ [#include <math.h>
++ namespace std {
++ template<typename _Tp>
++ struct __is_integer;
++ template<>
++ struct __is_integer<int>
++ {
++ enum { __value = 1 };
++ };
++ }
++ namespace __gnu_cxx {
++ template<bool, typename>
++ struct __enable_if;
++ template<typename _Tp>
++ struct __enable_if<true, _Tp>
++ { typedef _Tp __type; };
++ }
++ namespace std {
++ template<typename _Tp>
++ constexpr typename __gnu_cxx::__enable_if
++ <__is_integer<_Tp>::__value, double>::__type
++ log2(_Tp __x)
++ { return __builtin_log2(__x); }
++ }
++ int
++ main (void)
++ {
++ int i = 1000;
++ return std::log2(i);
++ }
++ ])],
++ [glibcxx_cv_math11_int_overload=no],
++ [glibcxx_cv_math11_int_overload=yes]
++ )])
++
++ # autoheader cannot handle indented templates.
++ AH_VERBATIM([__CORRECT_ISO_CPP11_MATH_H_PROTO_INT],
++ [/* Define if all C++11 integral type overloads are available in <math.h>. */
++#if __cplusplus >= 201103L
++#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
++#endif])
++
++ if test $glibcxx_cv_math11_int_overload = yes; then
++ AC_DEFINE(__CORRECT_ISO_CPP11_MATH_H_PROTO_INT)
++ fi
++ AC_MSG_RESULT([$glibcxx_cv_math11_int_overload])
+ ;;
+ esac
+
+@@ -4016,6 +4069,7 @@ dnl
+ AC_CACHE_VAL(glibcxx_cv_realpath, [dnl
+ GCC_TRY_COMPILE_OR_LINK(
+ [
++ #include <limits.h>
+ #include <stdlib.h>
+ #include <unistd.h>
+ ],
+@@ -4106,7 +4160,7 @@ dnl
+ gnu* | linux* | solaris*)
+ GCC_TRY_COMPILE_OR_LINK(
+ [#include <sys/sendfile.h>],
+- [sendfile(1, 2, (off_t*)NULL, sizeof 1);],
++ [sendfile(1, 2, (off_t*)0, sizeof 1);],
+ [glibcxx_cv_sendfile=yes],
+ [glibcxx_cv_sendfile=no])
+ ;;
+@@ -4116,7 +4170,7 @@ dnl
+ esac
+ ])
+ if test $glibcxx_cv_sendfile = yes; then
+- AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/stat.h>.])
++ AC_DEFINE(_GLIBCXX_USE_SENDFILE, 1, [Define if sendfile is available in <sys/sendfile.h>.])
+ fi
+ AC_MSG_RESULT($glibcxx_cv_sendfile)
+ dnl
+diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in
+index d605593..8039504 100644
+--- a/libstdc++-v3/config.h.in
++++ b/libstdc++-v3/config.h.in
+@@ -891,7 +891,7 @@
+ /* Define if _SC_NPROC_ONLN is available in <unistd.h>. */
+ #undef _GLIBCXX_USE_SC_NPROC_ONLN
+
+-/* Define if sendfile is available in <sys/stat.h>. */
++/* Define if sendfile is available in <sys/sendfile.h>. */
+ #undef _GLIBCXX_USE_SENDFILE
+
+ /* Define if struct stat has timespec members. */
+@@ -919,9 +919,14 @@
+ /* Define to 1 if mutex_timedlock is available. */
+ #undef _GTHREAD_USE_MUTEX_TIMEDLOCK
+
+-/* Define if all C++11 overloads are available in <math.h>. */
++/* Define if all C++11 floating point overloads are available in <math.h>. */
+ #if __cplusplus >= 201103L
+-#undef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
++#endif
++
++/* Define if all C++11 integral type overloads are available in <math.h>. */
++#if __cplusplus >= 201103L
++#undef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ #endif
+
+ #if defined (HAVE__ACOSF) && ! defined (HAVE_ACOSF)
+diff --git a/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver b/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver
+index 6bf8e9b..9666678 100644
+--- a/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver
++++ b/libstdc++-v3/config/abi/pre/gnu-versioned-namespace.ver
+@@ -186,6 +186,7 @@ CXXABI_2.0 {
+ __cxa_guard_release;
+ __cxa_pure_virtual;
+ __cxa_rethrow;
++ __cxa_thread_atexit;
+ __cxa_throw;
+ __cxa_type_match;
+ __cxa_vec_cctor;
+diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure
+index 8cd4c76..a51dfe6 100755
+--- a/libstdc++-v3/configure
++++ b/libstdc++-v3/configure
+@@ -17616,11 +17616,11 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+ case "$host" in
+ *-*-solaris2.*)
+- # Solaris 12 introduced the C++11 <math.h> overloads. A backport to
+- # a Solaris 11.3 SRU is likely, maybe even a Solaris 10 patch.
+- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++11 <math.h> overloads" >&5
+-$as_echo_n "checking for C++11 <math.h> overloads... " >&6; }
+- if test "${glibcxx_cv_math11_overload+set}" = set; then :
++ # Solaris 12 Build 86, Solaris 11.3 SRU 3.6, and Solaris 10 Patch
++ # 11996[67]-02 introduced the C++11 <math.h> floating point overloads.
++ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++11 <math.h> floating point overloads" >&5
++$as_echo_n "checking for C++11 <math.h> floating point overloads... " >&6; }
++ if test "${glibcxx_cv_math11_fp_overload+set}" = set; then :
+ $as_echo_n "(cached) " >&6
+ else
+
+@@ -17635,9 +17635,9 @@ else
+
+ _ACEOF
+ if ac_fn_cxx_try_compile "$LINENO"; then :
+- glibcxx_cv_math11_overload=no
++ glibcxx_cv_math11_fp_overload=no
+ else
+- glibcxx_cv_math11_overload=yes
++ glibcxx_cv_math11_fp_overload=yes
+
+ fi
+ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+@@ -17647,12 +17647,74 @@ fi
+ # autoheader cannot handle indented templates.
+
+
+- if test $glibcxx_cv_math11_overload = yes; then
+- $as_echo "#define __CORRECT_ISO_CPP11_MATH_H_PROTO 1" >>confdefs.h
++ if test $glibcxx_cv_math11_fp_overload = yes; then
++ $as_echo "#define __CORRECT_ISO_CPP11_MATH_H_PROTO_FP 1" >>confdefs.h
+
+ fi
+- { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_math11_overload" >&5
+-$as_echo "$glibcxx_cv_math11_overload" >&6; }
++ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_math11_fp_overload" >&5
++$as_echo "$glibcxx_cv_math11_fp_overload" >&6; }
++
++ # Solaris 12 Build 90, Solaris 11.3 SRU 5.6, and Solaris 10 Patch
++ # 11996[67]-02 introduced the C++11 <math.h> integral type overloads.
++ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++11 <math.h> integral type overloads" >&5
++$as_echo_n "checking for C++11 <math.h> integral type overloads... " >&6; }
++ if test "${glibcxx_cv_math11_int_overload+set}" = set; then :
++ $as_echo_n "(cached) " >&6
++else
++
++ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h. */
++#include <math.h>
++ namespace std {
++ template<typename _Tp>
++ struct __is_integer;
++ template<>
++ struct __is_integer<int>
++ {
++ enum { __value = 1 };
++ };
++ }
++ namespace __gnu_cxx {
++ template<bool, typename>
++ struct __enable_if;
++ template<typename _Tp>
++ struct __enable_if<true, _Tp>
++ { typedef _Tp __type; };
++ }
++ namespace std {
++ template<typename _Tp>
++ constexpr typename __gnu_cxx::__enable_if
++ <__is_integer<_Tp>::__value, double>::__type
++ log2(_Tp __x)
++ { return __builtin_log2(__x); }
++ }
++ int
++ main (void)
++ {
++ int i = 1000;
++ return std::log2(i);
++ }
++
++_ACEOF
++if ac_fn_cxx_try_compile "$LINENO"; then :
++ glibcxx_cv_math11_int_overload=no
++else
++ glibcxx_cv_math11_int_overload=yes
++
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++fi
++
++
++ # autoheader cannot handle indented templates.
++
++
++ if test $glibcxx_cv_math11_int_overload = yes; then
++ $as_echo "#define __CORRECT_ISO_CPP11_MATH_H_PROTO_INT 1" >>confdefs.h
++
++ fi
++ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_math11_int_overload" >&5
++$as_echo "$glibcxx_cv_math11_int_overload" >&6; }
+ ;;
+ esac
+
+@@ -79069,6 +79131,7 @@ else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h. */
+
++ #include <limits.h>
+ #include <stdlib.h>
+ #include <unistd.h>
+
+@@ -79101,6 +79164,7 @@ fi
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h. */
+
++ #include <limits.h>
+ #include <stdlib.h>
+ #include <unistd.h>
+
+@@ -79400,7 +79464,7 @@ else
+ int
+ main ()
+ {
+-sendfile(1, 2, (off_t*)NULL, sizeof 1);
++sendfile(1, 2, (off_t*)0, sizeof 1);
+ ;
+ return 0;
+ }
+@@ -79421,7 +79485,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ int
+ main ()
+ {
+-sendfile(1, 2, (off_t*)NULL, sizeof 1);
++sendfile(1, 2, (off_t*)0, sizeof 1);
+ ;
+ return 0;
+ }
+diff --git a/libstdc++-v3/doc/html/api.html b/libstdc++-v3/doc/html/api.html
+index 2960f0c..9b5fedf 100644
+--- a/libstdc++-v3/doc/html/api.html
++++ b/libstdc++-v3/doc/html/api.html
+@@ -20,42 +20,14 @@
+ member functions for the library classes, finding out what is in a
+ particular include file, looking at inheritance diagrams, etc.
+ </p><p>
+- The API documentation, rendered into HTML, can be viewed online:
+-</p><div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-3.4/index.html" target="_top">for the 3.4 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.1/index.html" target="_top">for the 4.1 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.2/index.html" target="_top">for the 4.2 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.3/index.html" target="_top">for the 4.3 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.4/index.html" target="_top">for the 4.4 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.5/index.html" target="_top">for the 4.5 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.6/index.html" target="_top">for the 4.6 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/gcc-4.7.4/libstdc++/api/" target="_top">for the 4.7.4 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/" target="_top">for the 4.8.3 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/" target="_top">for the 4.9.0 release
+- </a>
+- </p></li><li class="listitem"><p>
+- <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/index.html" target="_top">"the latest collection"
+- </a>
+- (For the main development tree; see the date on the first page.)
+- </p></li></ul></div><p>
++ The API documentation, rendered into HTML, can be viewed online
++ <a class="link" href="http://gcc.gnu.org/onlinedocs/" target="_top">for each GCC release</a>
++ and
++ <a class="link" href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/index.html" target="_top">
++ for the main development tree
++ </a>
++ (see the date on the first page).
++</p><p>
+ The rendered HTML, as above, is also available for download on the
+ gcc.gnu.org site in a directory located at
+ <code class="literal">&lt;URL:ftp://gcc.gnu.org/pub/gcc/libstdc++/doxygen/&gt;</code>.
+diff --git a/libstdc++-v3/doc/html/ext/lwg-active.html b/libstdc++-v3/doc/html/ext/lwg-active.html
+index 3608408..7da07e6 100644
+--- a/libstdc++-v3/doc/html/ext/lwg-active.html
++++ b/libstdc++-v3/doc/html/ext/lwg-active.html
+@@ -1,6 +1,7 @@
+-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+-<!-- saved from url=(0059)http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html -->
+-<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
++<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
++ "http://www.w3.org/TR/html4/strict.dtd">
++<html>
++<head>
+ <title>C++ Standard Library Active Issues List</title>
+ <style type="text/css">
+ p {text-align:justify}
+@@ -19,13 +20,13 @@
+ </head>
+ <body>
+ <table>
+-<tbody><tr>
++<tr>
+ <td align="left">Doc. no.</td>
+- <td align="left">D3181=10-0171</td>
++ <td align="left">N4484</td>
+ </tr>
+ <tr>
+ <td align="left">Date:</td>
+- <td align="left">2010-11-29</td>
++ <td align="left">2015-05-23</td>
+ </tr>
+ <tr>
+ <td align="left">Project:</td>
+@@ -33,38 +34,38 @@
+ </tr>
+ <tr>
+ <td align="left">Reply to:</td>
+- <td align="left">Alisdair Meredith &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
++ <td align="left">Marshall Clow &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
+ </tr>
+-</tbody></table>
+-<h1>C++ Standard Library Active Issues List (Revision D73)</h1>
+-<p>Revised 2010-11-29 at 10:11:56 UTC</p>
+-
+- <p>Reference ISO/IEC IS 14882:2003(E)</p>
++</table>
++<h1>C++ Standard Library Active Issues List (Revision R93)</h1>
++<p><p>Revised 2015-05-23 at 15:05:40 UTC</p>
++</p>
++ <p>Reference ISO/IEC IS 14882:2014(E)</p>
+ <p>Also see:</p>
+ <ul>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-toc.html">Table of Contents</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html">Index by Section</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html">Index by Status</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html">Library Defect Reports List</a></li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html">Library Closed Issues List</a></li>
++ <li><a href="lwg-toc.html">Table of Contents</a> for all library issues.</li>
++ <li><a href="lwg-index.html">Index by Section</a> for all library issues.</li>
++ <li><a href="lwg-status.html">Index by Status</a> for all library issues.</li>
++ <li><a href="lwg-defects.html">Library Defect Reports List</a></li>
++ <li><a href="lwg-closed.html">Library Closed Issues List</a></li>
+ </ul>
+ <p>The purpose of this document is to record the status of issues
+ which have come before the Library Working Group (LWG) of the INCITS PL22.16
+ and ISO WG21 C++ Standards Committee. Issues represent
+- potential defects in the ISO/IEC IS 14882:2003(E) document.
++ potential defects in the ISO/IEC IS 14882:2014(E) document.
+ </p>
+
+ <p>This document contains only library issues which are actively being
+ considered by the Library Working Group, i.e., issues which have a
+- status of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>,
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>, or <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Review">Review</a>. See
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html">Library Defect Reports List</a> for issues considered defects and
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html">Library Closed Issues List</a> for issues considered closed.</p>
++ status of <a href="lwg-active.html#New">New</a>, <a href="lwg-active.html#Open">Open</a>,
++ <a href="lwg-active.html#Ready">Ready</a>, or <a href="lwg-active.html#Review">Review</a>.
++ See <a href="lwg-defects.html">Library Defect Reports List</a> for issues considered defects
++ and <a href="lwg-closed.html">Library Closed Issues List</a> for issues considered closed.</p>
+
+ <p>The issues in these lists are not necessarily formal ISO Defect
+ Reports (DR's). While some issues will eventually be elevated to
+ official Defect Report status, other issues will be disposed of in
+- other ways. See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Status">Issue Status</a>.</p>
++ other ways. See <a href="#Status">Issue Status</a>.</p>
+
+ <p>Prior to Revision 14, library issues lists existed in two slightly
+ different versions; a Committee Version and a Public
+@@ -81,7 +82,7 @@
+ <p>For the most current official version of this document see
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/">http://www.open-std.org/jtc1/sc22/wg21/</a>.
+ Requests for further information about this document should include
+- the document number above, reference ISO/IEC 14882:2003(E), and be
++ the document number above, reference ISO/IEC 14882:2014(E), and be
+ submitted to Information Technology Industry Council (ITI), 1250 Eye
+ Street NW, Washington, DC 20005.</p>
+
+@@ -92,53 +93,53 @@
+
+ <p><a name="submit_issue"></a><b>How to submit an issue</b></p>
+
+-<ol type="A">
+-<a name="submit_issue_A"></a><li>
++<ol style="list-style-type:upper-alpha">
++<li><a name="submit_issue_A"></a>
+ Mail your issue to the author of this list.
+ </li>
+-<a name="submit_issue_B"></a><li>
++<li><a name="submit_issue_B"></a>
+ Specify a short descriptive title. If you fail to do so, the subject line of your
+ mail will be used as the issue title.
+ </li>
+-<a name="submit_issue_C"></a><li>
++<li><a name="submit_issue_C"></a>
+ If the "From" on your email is not the name you wish to appear as issue submitter,
+ then specify issue submitter.
+ </li>
+-<a name="submit_issue_D"></a><li>
++<li><a name="submit_issue_D"></a>
+ Provide a brief discussion of the problem you wish to correct. Refer to the latest
+ working draft or standard using [section.tag] and paragraph numbers where appropriate.
+ </li>
+-<a name="submit_issue_E"></a><li>
++<li><a name="submit_issue_E"></a>
+ Provide proposed wording. This should indicate exactly how you want the standard
+ to be changed. General solution statements belong in the discussion area. This
+ area contains very clear and specific directions on how to modify the current
+ draft. If you are not sure how to word a solution, you may omit this part.
+ But your chances of a successful issue greatly increase if you attempt wording.
+ </li>
+-<a name="submit_issue_F"></a><li>
++<li><a name="submit_issue_F"></a>
+ It is not necessary for you to use html markup. However, if you want to, you can
+ &lt;ins&gt;<ins>insert text like this</ins>&lt;/ins&gt; and &lt;del&gt;<del>delete text like
+ this</del>&lt;/del&gt;. The only strict requirement is to communicate clearly to
+ the list maintainer exactly how you want your issue to look.
+ </li>
+-<a name="submit_issue_G"></a><li>
++<li><a name="submit_issue_G"></a>
+ It is not necessary for you to specify other html font/formatting
+ mark-up, but if you do the list maintainer will attempt to respect your
+ formatting wishes (as described by html markup, or other common idioms).
+ </li>
+-<a name="submit_issue_H"></a><li>
++<li><a name="submit_issue_H"></a>
+ It is not necessary for you to specify open date or last modified date (the date
+ of your mail will be used).
+ </li>
+-<a name="submit_issue_I"></a><li>
++<li><a name="submit_issue_I"></a>
+ It is not necessary for you to cross reference other issues, but you can if you
+ like. You do not need to form the hyperlinks when you do, the list maintainer will
+ take care of that.
+ </li>
+-<a name="submit_issue_J"></a><li>
++<li><a name="submit_issue_J"></a>
+ One issue per email is best.
+ </li>
+-<a name="submit_issue_K"></a><li>
++<li><a name="submit_issue_K"></a>
+ Between the time you submit the issue, and the next mailing deadline
+ (date at the top of the Revision History), you <em>own</em> this issue.
+ You control the content, the stuff that is right, the stuff that is
+@@ -153,1048 +154,159 @@ ownership of it.
+
+ <h2>Revision History</h2>
+ <ul>
+-<li>D73: Batavia meeting preview<ul>
+-<li><b>Summary:</b><ul>
+-<li>80 open issues, down by 126.</li>
+-<li>1459 closed issues, up by 145.</li>
+-<li>1539 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following 11 New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1521">1521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1523">1523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2012">2012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2013">2013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2014">2014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2015">2015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2016">2016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2017">2017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2018">2018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2019">2019</a>.</li>
+-<li>Added the following 5 Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2001">2001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2003">2003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2005">2005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Added the following Resolved issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2002">2002</a>.</li>
+-<li>Added the following Review issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>.</li>
+-<li>Added the following Tentatively NAD issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2006">2006</a>.</li>
+-<li>Added the following 3 Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2000">2000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2004">2004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2007">2007</a>.</li>
+-<li>Added the following WP issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1522">1522</a>.</li>
+-<li>Changed the following 3 issues from New to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>.</li>
+-<li>Changed the following issue from Open to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>.</li>
+-<li>Changed the following 14 issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>.</li>
+-<li>Changed the following issue from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>.</li>
+-<li>Changed the following 8 issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issue from WP to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following 11 issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>.</li>
+-<li>Changed the following issue from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issue from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>.</li>
+-<li>Changed the following 6 issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following 2 issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>.</li>
+-<li>Changed the following 3 issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>.</li>
+-<li>Changed the following 6 issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>.</li>
+-<li>Changed the following 42 issues from NAD Editorial to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>.</li>
+-<li>Changed the following 5 issues from New to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>.</li>
+-<li>Changed the following 46 issues from Open to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>.</li>
+-<li>Changed the following issue from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>.</li>
+-<li>Changed the following 2 issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>.</li>
+-<li>Changed the following issue from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>.</li>
+-<li>Changed the following 3 issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>.</li>
+-<li>Changed the following issue from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>.</li>
+-<li>Changed the following 24 issues from NAD Editorial to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>.</li>
+-<li>Changed the following issue from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>.</li>
+-<li>Changed the following 10 issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>.</li>
+-<li>Changed the following 2 issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following 33 issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R72:
+-2010-10-18 pre-Batavia mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>206 open issues, up by 141.</li>
+-<li>1314 closed issues, up by 36.</li>
+-<li>1520 issues total, up by 177.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1433">1433</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1444">1444</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1415">1415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1419">1419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1434">1434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1483">1483</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1500">1500</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1506">1506</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1345">1345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1348">1348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1349">1349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1353">1353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1358">1358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1364">1364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1369">1369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1374">1374</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1396">1396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1421">1421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1448">1448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1452">1452</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1456">1456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1457">1457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1459">1459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1460">1460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1461">1461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1478">1478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1479">1479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1485">1485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1486">1486</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1487">1487</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1494">1494</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1502">1502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1503">1503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1504">1504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1505">1505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1507">1507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1514">1514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1515">1515</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R71:
+-2010-08-25 post-Rapperswil mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>65 open issues, up by 2.</li>
+-<li>1278 closed issues, up by 7.</li>
+-<li>1343 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R70:
+-2010-03-26 post-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>63 open issues, down by 203.</li>
+-<li>1271 closed issues, up by 219.</li>
+-<li>1334 issues total, up by 16.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1329">1329</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>.</li>
+-<li>Changed the following issues from Tentatively Dup to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Concepts to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#446">446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>.</li>
+-<li>Changed the following issues from Ready to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#427">427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R69:
+-2010-02-12 pre-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>266 open issues, up by 61.</li>
+-<li>1052 closed issues, down by 3.</li>
+-<li>1318 issues total, up by 58.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>.</li>
+-<li>Added the following Tentatively NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#101">101</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from New to Tentatively Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>.</li>
+-<li>Changed the following issues from NAD to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R68:
+-2009-11-06 post-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>205 open issues, down by 77.</li>
+-<li>1055 closed issues, up by 120.</li>
+-<li>1260 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1230">1230</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1229">1229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1236">1236</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1243">1243</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1232">1232</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1235">1235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1242">1242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from NAD Concepts to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R67:
+-2009-09-25 pre-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>282 open issues, up by 32.</li>
+-<li>935 closed issues, down by 1.</li>
+-<li>1217 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>.</li>
+-<li>Changed the following issues from WP to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R66:
+-2009-07-31 post-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>250 open issues, down by 128.</li>
+-<li>936 closed issues, up by 171.</li>
+-<li>1186 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1164">1164</a>.</li>
+-<li>Added the following NAD Concepts issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1149">1149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1167">1167</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1168">1168</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#290">290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#343">343</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#394">394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#398">398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#417">417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#421">421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#459">459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#492">492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>.</li>
+-<li>Changed the following issues from New to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>.</li>
+-<li>Changed the following issues from Review to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#423">423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from CD1 to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>.</li>
+-<li>Changed the following issues from NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R65:
+-2009-06-19 pre-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>378 open issues, up by 32.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1143 issues total, up by 32.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R64:
+-2009-05-01 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>346 open issues, up by 19.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1111 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from DR to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#386">386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#406">406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#409">409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#413">413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#434">434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#438">438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#444">444</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#445">445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#455">455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#469">469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>.</li>
+-<li>Changed the following issues from Review to New: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R63:
+-2009-03-20 post-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>327 open issues, up by 96.</li>
+-<li>765 closed issues, up by 14.</li>
+-<li>1092 issues total, up by 110.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1022">1022</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1025">1025</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R62:
+-2009-02-06 pre-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>231 open issues, up by 44.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>982 issues total, up by 44.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R61:
+-2008-12-05 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>187 open issues, up by 20.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>938 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R60:
+-2008-10-03 post-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>167 open issues, down by 25.</li>
+-<li>751 closed issues, up by 65.</li>
+-<li>918 issues total, up by 40.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following CD1 issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#882">882</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from New to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>.</li>
+-<li>Changed the following issues from Ready to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Changed the following issues from Review to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from WP to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#44">44</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#98">98</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#123">123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#167">167</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#200">200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#231">231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#239">239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#240">240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#274">274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#282">282</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#291">291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#300">300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#305">305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#310">310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#315">315</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#316">316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#318">318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#319">319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#320">320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#321">321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#322">322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#324">324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#325">325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#327">327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#328">328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#329">329</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#331">331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#333">333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#334">334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#337">337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#338">338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#339">339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#340">340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#341">341</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#345">345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#346">346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#349">349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#352">352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#354">354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#355">355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#358">358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#359">359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#360">360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#363">363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#364">364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#365">365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#370">370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#373">373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#375">375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#379">379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#380">380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#381">381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#391">391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#395">395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#400">400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#403">403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#405">405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#407">407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#410">410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#411">411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#412">412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#414">414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#415">415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#420">420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#425">425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#426">426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#428">428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#435">435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#436">436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#442">442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#443">443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#448">448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#449">449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-<li>Changed the following issues from TC to TC1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1">1</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#5">5</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#7">7</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#11">11</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#13">13</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#14">14</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#15">15</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#16">16</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#18">18</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#20">20</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#21">21</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#22">22</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#24">24</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#25">25</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#27">27</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#28">28</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#30">30</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#32">32</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#33">33</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#34">34</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#35">35</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#36">36</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#37">37</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#39">39</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#40">40</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#41">41</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#42">42</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#46">46</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#47">47</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#48">48</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#50">50</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#51">51</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#52">52</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#53">53</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#54">54</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#56">56</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#57">57</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#59">59</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#62">62</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#66">66</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#68">68</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69">69</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#71">71</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#74">74</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#75">75</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#78">78</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#79">79</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#80">80</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#90">90</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#106">106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#119">119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#124">124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#125">125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#141">141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#148">148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#150">150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#151">151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#152">152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#154">154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#155">155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#156">156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#158">158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#161">161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#168">168</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#169">169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#172">172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#173">173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#174">174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#175">175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#176">176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#193">193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R59:
+-2008-08-22 pre-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>192 open issues, up by 9.</li>
+-<li>686 closed issues, up by 0.</li>
+-<li>878 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R58:
+-2008-07-28 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>183 open issues, up by 12.</li>
+-<li>686 closed issues, down by 4.</li>
+-<li>869 issues total, up by 8.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from WP to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R57:
+-2008-06-27 post-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>171 open issues, down by 20.</li>
+-<li>690 closed issues, up by 43.</li>
+-<li>861 issues total, up by 23.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#840">840</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R56:
+-2008-05-16 pre-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>191 open issues, up by 24.</li>
+-<li>647 closed issues, up by 1.</li>
+-<li>838 issues total, up by 25.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R55:
+-2008-03-14 post-Bellevue mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>167 open issues, down by 39.</li>
+-<li>646 closed issues, up by 65.</li>
+-<li>813 issues total, up by 26.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#795">795</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#790">790</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#791">791</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#796">796</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#797">797</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#799">799</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Open to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R54:
+-2008-02-01 pre-Bellevue mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>206 open issues, up by 23.</li>
+-<li>581 closed issues, up by 0.</li>
+-<li>787 issues total, up by 23.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R53:
+-2007-12-09 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>183 open issues, up by 11.</li>
+-<li>581 closed issues, down by 1.</li>
+-<li>764 issues total, up by 10.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R52:
+-2007-10-19 post-Kona mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>172 open issues, up by 4.</li>
+-<li>582 closed issues, up by 27.</li>
+-<li>754 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
+-<li>Changed the following issues from New to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R51:
+-2007-09-09 pre-Kona mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>168 open issues, up by 15.</li>
+-<li>555 closed issues, up by 0.</li>
+-<li>723 issues total, up by 15.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R50:
+-2007-08-05 post-Toronto mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>153 open issues, down by 5.</li>
+-<li>555 closed issues, up by 17.</li>
+-<li>708 issues total, up by 12.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from DR to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R49:
+-2007-06-23 pre-Toronto mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>158 open issues, up by 13.</li>
+-<li>538 closed issues, up by 7.</li>
+-<li>696 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R48:
+-2007-05-06 post-Oxford mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>145 open issues, down by 33.</li>
+-<li>531 closed issues, up by 53.</li>
+-<li>676 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#357">357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#368">368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>.</li>
+-<li>Changed the following issues from NAD_Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R47:
+-2007-03-09 pre-Oxford mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>178 open issues, up by 37.</li>
+-<li>478 closed issues, up by 0.</li>
+-<li>656 issues total, up by 37.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R46:
+-2007-01-12 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>141 open issues, up by 11.</li>
+-<li>478 closed issues, down by 1.</li>
+-<li>619 issues total, up by 10.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R45:
+-2006-11-03 post-Portland mailing.
+-<ul>
++<li>R93: 2014-05-22 2015 post-Lenexa mailing<ul>
+ <li><b>Summary:</b><ul>
+-<li>130 open issues, up by 0.</li>
+-<li>479 closed issues, up by 17.</li>
+-<li>609 issues total, up by 17.</li>
++<li>256 open issues, down by 36.</li>
++<li>1770 closed issues, up by 48.</li>
++<li>2026 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a> to WP.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a> to NAD.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Dup.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a> to Open.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a> - <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a> to Review.</li>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>.</li>
++<li>Added the following 2 Ready issues: <a href="lwg-active.html#2492">2492</a>, <a href="lwg-active.html#2494">2494</a>.</li>
++<li>Added the following 10 New issues: <a href="lwg-active.html#2493">2493</a>, <a href="lwg-active.html#2495">2495</a>, <a href="lwg-active.html#2496">2496</a>, <a href="lwg-active.html#2497">2497</a>, <a href="lwg-active.html#2498">2498</a>, <a href="lwg-active.html#2499">2499</a>, <a href="lwg-active.html#2500">2500</a>, <a href="lwg-active.html#2501">2501</a>, <a href="lwg-active.html#2502">2502</a>, <a href="lwg-active.html#2503">2503</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-active.html#2111">2111</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 20 issues to Ready (from New): <a href="lwg-active.html#2244">2244</a>, <a href="lwg-active.html#2250">2250</a>, <a href="lwg-active.html#2259">2259</a>, <a href="lwg-active.html#2336">2336</a>, <a href="lwg-active.html#2353">2353</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2489">2489</a>.</li>
++<li>Changed the following 12 issues to Ready (from Open): <a href="lwg-active.html#1169">1169</a>, <a href="lwg-active.html#2072">2072</a>, <a href="lwg-active.html#2101">2101</a>, <a href="lwg-active.html#2119">2119</a>, <a href="lwg-active.html#2127">2127</a>, <a href="lwg-active.html#2133">2133</a>, <a href="lwg-active.html#2156">2156</a>, <a href="lwg-active.html#2181">2181</a>, <a href="lwg-active.html#2218">2218</a>, <a href="lwg-active.html#2219">2219</a>, <a href="lwg-active.html#2447">2447</a>, <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2224">2224</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2296">2296</a>.</li>
++<li>Changed the following issue to Review (from Open): <a href="lwg-active.html#2328">2328</a>.</li>
++<li>Changed the following 11 issues to Open (from New): <a href="lwg-active.html#2262">2262</a>, <a href="lwg-active.html#2289">2289</a>, <a href="lwg-active.html#2338">2338</a>, <a href="lwg-active.html#2348">2348</a>, <a href="lwg-active.html#2349">2349</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2456">2456</a>.</li>
++<li>Changed the following 8 issues to Open (from SG1): <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following issue to LEWG (from New): <a href="lwg-active.html#2372">2372</a>.</li>
++<li>Changed the following issue to EWG (from New): <a href="lwg-active.html#2432">2432</a>.</li>
++<li>Changed the following issue to Deferred (from Open): <a href="lwg-active.html#2202">2202</a>.</li>
++<li>Changed the following 14 issues to WP (from Ready): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following 18 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2059">2059</a>, <a href="lwg-defects.html#2076">2076</a>, <a href="lwg-defects.html#2239">2239</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2415">2415</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-defects.html#2458">2458</a>, <a href="lwg-defects.html#2459">2459</a>, <a href="lwg-defects.html#2463">2463</a>, <a href="lwg-defects.html#2467">2467</a>, <a href="lwg-defects.html#2470">2470</a>, <a href="lwg-defects.html#2482">2482</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-defects.html#2464">2464</a>, <a href="lwg-defects.html#2488">2488</a>.</li>
++<li>Changed the following issue to WP (from Open): <a href="lwg-defects.html#2063">2063</a>.</li>
++<li>Changed the following 2 issues to WP (from SG1): <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2442">2442</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2228">2228</a>.</li>
++<li>Changed the following 3 issues to Resolved (from Open): <a href="lwg-defects.html#1526">1526</a>, <a href="lwg-defects.html#2274">2274</a>, <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Changed the following 5 issues to NAD (from New): <a href="lwg-closed.html#2079">2079</a>, <a href="lwg-closed.html#2251">2251</a>, <a href="lwg-closed.html#2351">2351</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-closed.html#2386">2386</a>.</li>
++<li>Changed the following issue to NAD (from Open): <a href="lwg-closed.html#2388">2388</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R44:
+-2006-09-08 pre-Portland mailing.
++<li>R92:
++2015-04-09 pre-Lenexa mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>130 open issues, up by 6.</li>
+-<li>462 closed issues, down by 1.</li>
+-<li>592 issues total, up by 5.</li>
++<li>292 open issues, up by 33.</li>
++<li>1722 closed issues, up by 0.</li>
++<li>2014 issues total, up by 33.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
++<li>Added the following 5 Tentatively Ready issues: <a href="lwg-active.html#2459">2459</a>, <a href="lwg-active.html#2463">2463</a>, <a href="lwg-active.html#2467">2467</a>, <a href="lwg-active.html#2470">2470</a>, <a href="lwg-active.html#2482">2482</a>.</li>
++<li>Added the following 27 New issues: <a href="lwg-active.html#2460">2460</a>, <a href="lwg-active.html#2461">2461</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2464">2464</a>, <a href="lwg-active.html#2465">2465</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2468">2468</a>, <a href="lwg-active.html#2471">2471</a>, <a href="lwg-active.html#2472">2472</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2474">2474</a>, <a href="lwg-active.html#2475">2475</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2478">2478</a>, <a href="lwg-active.html#2479">2479</a>, <a href="lwg-active.html#2480">2480</a>, <a href="lwg-active.html#2481">2481</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2488">2488</a>, <a href="lwg-active.html#2489">2489</a>, <a href="lwg-active.html#2490">2490</a>, <a href="lwg-active.html#2491">2491</a>.</li>
++<li>Added the following Open issue: <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Review): <a href="lwg-active.html#2378">2378</a>.</li>
++<li>Changed the following 11 issues to Tentatively Ready (from New): <a href="lwg-active.html#2076">2076</a>, <a href="lwg-active.html#2239">2239</a>, <a href="lwg-active.html#2369">2369</a>, <a href="lwg-active.html#2410">2410</a>, <a href="lwg-active.html#2415">2415</a>, <a href="lwg-active.html#2418">2418</a>, <a href="lwg-active.html#2437">2437</a>, <a href="lwg-active.html#2448">2448</a>, <a href="lwg-active.html#2454">2454</a>, <a href="lwg-active.html#2455">2455</a>, <a href="lwg-active.html#2458">2458</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2059">2059</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-active.html#2337">2337</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from Open): <a href="lwg-active.html#760">760</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2312">2312</a>, <a href="lwg-active.html#2388">2388</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2447">2447</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-active.html#2451">2451</a>.</li>
++<li>Changed the following issue to EWG (from Open): <a href="lwg-active.html#2089">2089</a>.</li>
++<li>Changed the following issue to Core (from New): <a href="lwg-active.html#2452">2452</a>.</li>
++<li>Changed the following 13 issues to SG1 (from New): <a href="lwg-active.html#2236">2236</a>, <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2334">2334</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2407">2407</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2442">2442</a>, <a href="lwg-active.html#2445">2445</a>.</li>
++<li>Changed the following issue to SG1 (from Open): <a href="lwg-active.html#2441">2441</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R43:
+-2006-06-23 mid-term mailing.
++<li>R91:
++2014-11-23 post-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>124 open issues, up by 14.</li>
+-<li>463 closed issues, down by 1.</li>
+-<li>587 issues total, up by 13.</li>
++<li>259 open issues, up by 32.</li>
++<li>1722 closed issues, down by 20.</li>
++<li>1981 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Tentatively Ready.</li>
++<li>Added the following 12 New issues: <a href="lwg-active.html#2447">2447</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-active.html#2449">2449</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2451">2451</a>, <a href="lwg-active.html#2452">2452</a>, <a href="lwg-active.html#2453">2453</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-active.html#2456">2456</a>, <a href="lwg-active.html#2457">2457</a>, <a href="lwg-defects.html#2458">2458</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2364">2364</a>.</li>
++<li>Changed the following 11 issues to Ready (from New): <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following issue to Ready (from Open): <a href="lwg-defects.html#2168">2168</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2424">2424</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2307">2307</a>, <a href="lwg-active.html#2310">2310</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following 2 issues to Open (from NAD Future): <a href="lwg-active.html#760">760</a>, <a href="lwg-active.html#1173">1173</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2419">2419</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>Changed the following 48 issues to LEWG (from NAD Future): <a href="lwg-active.html#255">255</a>, <a href="lwg-active.html#423">423</a>, <a href="lwg-active.html#484">484</a>, <a href="lwg-active.html#523">523</a>, <a href="lwg-active.html#532">532</a>, <a href="lwg-active.html#708">708</a>, <a href="lwg-active.html#839">839</a>, <a href="lwg-active.html#851">851</a>, <a href="lwg-active.html#877">877</a>, <a href="lwg-active.html#933">933</a>, <a href="lwg-active.html#935">935</a>, <a href="lwg-active.html#936">936</a>, <a href="lwg-active.html#961">961</a>, <a href="lwg-active.html#1025">1025</a>, <a href="lwg-active.html#1031">1031</a>, <a href="lwg-active.html#1041">1041</a>, <a href="lwg-active.html#1052">1052</a>, <a href="lwg-active.html#1053">1053</a>, <a href="lwg-active.html#1112">1112</a>, <a href="lwg-active.html#1120">1120</a>, <a href="lwg-active.html#1121">1121</a>, <a href="lwg-active.html#1150">1150</a>, <a href="lwg-active.html#1154">1154</a>, <a href="lwg-active.html#1184">1184</a>, <a href="lwg-active.html#1188">1188</a>, <a href="lwg-active.html#1201">1201</a>, <a href="lwg-active.html#1203">1203</a>, <a href="lwg-active.html#1217">1217</a>, <a href="lwg-active.html#1235">1235</a>, <a href="lwg-active.html#1238">1238</a>, <a href="lwg-active.html#1242">1242</a>, <a href="lwg-active.html#1282">1282</a>, <a href="lwg-active.html#1289">1289</a>, <a href="lwg-active.html#1317">1317</a>, <a href="lwg-active.html#1320">1320</a>, <a href="lwg-active.html#1396">1396</a>, <a href="lwg-active.html#1406">1406</a>, <a href="lwg-active.html#1422">1422</a>, <a href="lwg-active.html#1459">1459</a>, <a href="lwg-active.html#1484">1484</a>, <a href="lwg-active.html#1488">1488</a>, <a href="lwg-active.html#1493">1493</a>, <a href="lwg-active.html#1499">1499</a>, <a href="lwg-active.html#1521">1521</a>, <a href="lwg-active.html#2040">2040</a>, <a href="lwg-active.html#2055">2055</a>, <a href="lwg-active.html#2226">2226</a>, <a href="lwg-active.html#2232">2232</a>.</li>
++<li>Changed the following 2 issues to Pending NAD (from Tentatively NAD): <a href="lwg-closed.html#2302">2302</a>, <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 11 issues to WP (from Ready): <a href="lwg-defects.html#2016">2016</a>, <a href="lwg-defects.html#2170">2170</a>, <a href="lwg-defects.html#2340">2340</a>, <a href="lwg-defects.html#2354">2354</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Changed the following 12 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2217">2217</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>, <a href="lwg-defects.html#2266">2266</a>, <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Resolved (from Ready): <a href="lwg-defects.html#2319">2319</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2118">2118</a>.</li>
++<li>Changed the following issue to Resolved (from New): <a href="lwg-defects.html#2416">2416</a>.</li>
++<li>Changed the following issue to Resolved (from Open): <a href="lwg-defects.html#2108">2108</a>.</li>
++<li>Changed the following issue to NAD (from New): <a href="lwg-closed.html#2429">2429</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R42:
+-2006-04-21 post-Berlin mailing.
++<li>R90:
++2014-10-13 pre-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>110 open issues, down by 16.</li>
+-<li>464 closed issues, up by 24.</li>
+-<li>574 issues total, up by 8.</li>
++<li>227 open issues, up by 31.</li>
++<li>1742 closed issues, up by 0.</li>
++<li>1969 issues total, up by 31.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#501">501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#517">517</a> to NAD.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a> to Open.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> to WP.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a> to Review.</li>
++<li>Added the following 31 New issues: <a href="lwg-defects.html#2416">2416</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-active.html#2419">2419</a>, <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-active.html#2421">2421</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2423">2423</a>, <a href="lwg-active.html#2424">2424</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-closed.html#2429">2429</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2431">2431</a>, <a href="lwg-active.html#2432">2432</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>, <a href="lwg-active.html#2441">2441</a>, <a href="lwg-defects.html#2442">2442</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2445">2445</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>No issues changed.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R41:
+-2006-02-24 pre-Berlin mailing.
++<li>R89:
++2014-07-08 post-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>126 open issues, up by 31.</li>
+-<li>440 closed issues, up by 0.</li>
+-<li>566 issues total, up by 31.</li>
++<li>196 open issues, up by 14.</li>
++<li>1742 closed issues, up by 12.</li>
++<li>1938 issues total, up by 26.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a> ,<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>.</li>
+-<li>Moved <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a> from Ready to Open.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>.</li>
++<li>Added the following 6 Ready issues: <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Added the following 15 New issues: <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2392">2392</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2394">2394</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2413">2413</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-defects.html#2415">2415</a>.</li>
++<li>Added the following Open issue: <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Added the following 3 WP issues: <a href="lwg-defects.html#2390">2390</a>, <a href="lwg-defects.html#2395">2395</a>, <a href="lwg-defects.html#2409">2409</a>.</li>
++<li>Added the following NAD issue: <a href="lwg-closed.html#2405">2405</a>.</li>
++<li>Changed the following issue to Ready (from New): <a href="lwg-defects.html#2377">2377</a>.</li>
++<li>Changed the following 2 issues to Ready (from Deferred): <a href="lwg-active.html#2253">2253</a>, <a href="lwg-active.html#2255">2255</a>.</li>
++<li>Changed the following 2 issues to Tentatively Ready (from New): <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 3 issues to Review (from New): <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 2 issues to Review (from Open): <a href="lwg-defects.html#2118">2118</a>, <a href="lwg-defects.html#2160">2160</a>.</li>
++<li>Changed the following 3 issues to Open (from New): <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-active.html#2238">2238</a>, <a href="lwg-active.html#2273">2273</a>.</li>
++<li>Changed the following 3 issues to Open (from Deferred): <a href="lwg-active.html#2254">2254</a>, <a href="lwg-active.html#2264">2264</a>, <a href="lwg-active.html#2277">2277</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 4 issues to Resolved (from Deferred): <a href="lwg-defects.html#2282">2282</a>, <a href="lwg-defects.html#2283">2283</a>, <a href="lwg-defects.html#2287">2287</a>, <a href="lwg-defects.html#2333">2333</a>.</li>
++<li>Changed the following issue to NAD (from Deferred): <a href="lwg-closed.html#2305">2305</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R40:
+-2005-12-16 mid-term mailing.
++<li>R88:
++2014-05-24 pre-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>95 open issues.</li>
+-<li>440 closed issues.</li>
+-<li>535 issues total.</li>
++<li>182 open issues, up by 29.</li>
++<li>1730 closed issues, up by 0.</li>
++<li>1912 issues total, up by 29.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>.</li>
++<li>Added the following 3 Tentatively Ready issues: <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>.</li>
++<li>Added the following 26 New issues: <a href="lwg-active.html#2362">2362</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-active.html#2366">2366</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2368">2368</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-active.html#2372">2372</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-active.html#2375">2375</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2380">2380</a>, <a href="lwg-active.html#2381">2381</a>, <a href="lwg-closed.html#2382">2382</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-closed.html#2386">2386</a>, <a href="lwg-defects.html#2387">2387</a>, <a href="lwg-closed.html#2388">2388</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 5 issues to Tentatively Ready (from Open): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R39:
+-2005-10-14 post-Mont Tremblant mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a> from Ready to WP as per the vote from Mont Tremblant.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a> from Review to Ready.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a> from New to Open.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> from New to Ready.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#500">500</a> from New to NAD.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a> from New to Review.
+-</li>
+-<li>R38:
+-2005-07-03 pre-Mont Tremblant mailing.
+-Merged open TR1 issues in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>
+-</li>
+-<li>R37:
+-2005-06 mid-term mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>.
+-</li>
+-<li>R36:
+-2005-04 post-Lillehammer mailing. All issues in "ready" status except
+-for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a> were moved to "DR" status, and all issues
+-previously in "DR" status were moved to "WP".
+-</li>
+-<li>R35:
+-2005-03 pre-Lillehammer mailing.
+-</li>
+-<li>R34:
+-2005-01 mid-term mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#494">494</a>.
+-</li>
+-<li>R33:
+-2004-11 post-Redmond mailing. Reflects actions taken in Redmond.
+-</li>
+-<li>R32:
+-2004-09 pre-Redmond mailing: reflects new proposed resolutions and
+-new issues received after the 2004-07 mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#481">481</a>.
+-</li>
+-<li>R31:
+-2004-07 mid-term mailing: reflects new proposed resolutions and
+-new issues received after the post-Sydney mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>.
+-</li>
+-<li>R30:
+-Post-Sydney mailing: reflects decisions made at the Sydney meeting.
+-Voted all "Ready" issues from R29 into the working paper.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>.
+-</li>
+-<li>R29:
+-Pre-Sydney mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>.
+-</li>
+-<li>R28:
+-Post-Kona mailing: reflects decisions made at the Kona meeting.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#440">440</a>.
+-</li>
+-<li>R27:
+-Pre-Kona mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>.
+-</li>
+-<li>R26:
+-Post-Oxford mailing: reflects decisions made at the Oxford meeting.
+-All issues in Ready status were voted into DR status. All issues in
+-DR status were voted into WP status.
+-</li>
+-<li>R25:
+-Pre-Oxford mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>.
+-</li>
+-<li>R24:
+-Post-Santa Cruz mailing: reflects decisions made at the Santa Cruz
+-meeting. All Ready issues from R23 with the exception of <iref ref="253">, which has been given a new proposed resolution, were
+-moved to DR status. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>-<iref ref="389">. (Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a> were discussed
+-at the meeting.) Made progress on issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <iref ref="226">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a> and <iref ref="229"> have been moved to Ready status, and the only remaining
+-concerns with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a> involve wording.
+-</iref></iref></iref></iref></li>
+-<li>R23:
+-Pre-Santa Cruz mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#367">367</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>.
+-Moved issues in the TC to TC status.
+-</li>
+-<li>R22:
+-Post-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>-<iref ref="366">.
+-</iref></li>
+-<li>R21:
+-Pre-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>-<iref ref="361">.
+-</iref></li>
+-<li>R20:
+-Post-Redmond mailing; reflects actions taken in Redmond. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, of which issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a> were added since Redmond, hence
+-not discussed at the meeting.
+-
+-All Ready issues were moved to DR status, with the exception of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-
+-Noteworthy issues discussed at Redmond include
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.
+-</li>
+-<li>R19:
+-Pre-Redmond mailing. Added new issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>.
+-</li>
+-<li>R18:
+-Post-Copenhagen mailing; reflects actions taken in Copenhagen.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, and discussed
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>
+-to DR.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>
+-to Ready.
+-
+-Closed issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#279">279</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#287">287</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#289">289</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#293">293</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#302">302</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#313">313</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>
+-as NAD.
+-
+-</li>
+-<li>R17:
+-Pre-Copenhagen mailing. Converted issues list to XML. Added proposed
+-resolutions for issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <iref ref="91">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>.
+-</iref></li>
+-<li>R16:
+-post-Toronto mailing; reflects actions taken in Toronto. Added new
+-issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a>. Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a> to "DR". Reopened issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>. Reopened
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>. Changed issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#2">2</a> and
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD. Fixed a typo in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>. Fixed
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>: signature should be changed both places it
+-appears. Fixed issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>: previous version didn't fix
+-the bug in enough places.
+-</li>
+-<li>R15:
+-pre-Toronto mailing. Added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>. Some small HTML formatting
+-changes so that we pass Weblint tests.
+-</li>
+-<li>R14:
+-post-Tokyo II mailing; reflects committee actions taken in
+-Tokyo. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>. (00-0019R1/N1242)
+-</li>
+-<li>R13:
+-pre-Tokyo II updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.
+-</li>
+-<li>R12:
+-pre-Tokyo II mailing: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>. Added "and paragraph 5" to the proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>. Add further rationale to issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#178">178</a>.
+-</li>
+-<li>R11:
+-post-Kona mailing: Updated to reflect LWG and full committee actions
+-in Kona (99-0048/N1224). Note changed resolution of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#196">196</a>
+-to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>. Closed issues list split into "defects" and
+-"closed" documents. Changed the proposed resolution of issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD, and changed the wording of proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>.
+-</li>
+-<li>R10:
+-pre-Kona updated. Added proposed resolutions <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>. (99-0033/D1209, 14 Oct 99)
+-</li>
+-<li>R9:
+-pre-Kona mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>. Issues list split into separate "active" and
+-"closed" documents. (99-0030/N1206, 25 Aug 99)
+-</li>
+-<li>R8:
+-post-Dublin mailing. Updated to reflect LWG and full committee actions
+-in Dublin. (99-0016/N1193, 21 Apr 99)
+-</li>
+-<li>R7:
+-pre-Dublin updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#131">131</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#135">135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a> (31 Mar 99)
+-</li>
+-<li>R6:
+-pre-Dublin mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>,
+-and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>. (99-0007/N1194, 22 Feb 99)
+-</li>
+-<li>R5:
+-update issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>; added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>. Format revisions to prepare
+-for making list public. (30 Dec 98)
+-</li>
+-<li>R4:
+-post-Santa Cruz II updated: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#113">113</a> added, several
+-issues corrected. (22 Oct 98)
+-</li>
+-<li>R3:
+-post-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#94">94</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>
+-added, many issues updated to reflect LWG consensus (12 Oct 98)
+-</li>
+-<li>R2:
+-pre-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#73">73</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#93">93</a> added,
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a> updated. (29 Sep 98)
+-</li>
+-<li>R1:
+-Correction to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a> resolution, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a> code
+-format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a> title. (17 Sep 98)
+-</li>
+ </ul>
+
+ <h2><a name="Status"></a>Issue Status</h2>
+
++ <p>Issues reported to the LWG transition through a variety of statuses,
++ indicating their progress towards a resolution. Typically, most issues
++ will flow through the following stages.
++ </p>
++
+ <p><b><a name="New">New</a></b> - The issue has not yet been
+ reviewed by the LWG. Any <b>Proposed Resolution</b> is purely a
+ suggestion from the issue submitter, and should not be construed as
+@@ -1219,6 +331,46 @@ format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64
+ font. Such comments are for information only and should not be given
+ undue importance.</p>
+
++ <p><b><a name="Review">Review</a></b> - Exact wording of a
++ <b>Proposed Resolution</b> is now available for review on an issue
++ for which the LWG previously reached informal consensus.</p>
++
++ <p><b><a name="Ready">Ready</a></b> - The LWG has reached consensus
++ that the issue is a defect in the Standard, the <b>Proposed
++ Resolution</b> is correct, and the issue is ready to forward to the
++ full committee for further action as a Defect Report (DR).</p>
++
++ <p>Typically, an issue must have a proposed resolution in the currently
++ published issues list, whose wording does not change during LWG review, to
++ move to the Ready status.</p>
++
++ <p><b><a name="Voting">Voting</a></b> - This status should not be seen
++ in a published issues list, but is a marker for use during meetings to
++ indicate an issues was Ready in the pre-meeting mailing, the <b>Proposed
++ Resolution</b> is correct, and the issue will be offered to the working
++ group at the end of the current meeting to apply to the current working
++ paper (WP) or to close in some other appropriate manner. This easily
++ distinguishes such issues from those moving to Ready status during the
++ meeting itself, that should not be forwarded until the next meeting. If
++ the issue does not move forward, it should fall back to one of the other
++ open states before the next list is published.</p>
++
++ <p><b><a name="Immediate">Immediate</a></b> - This status should not be
++ seen in a published issues list, but is a marker for use during meetings
++ to indicate an issues was not Ready in the pre-meeting mailing, but the
++ <b>Proposed Resolution</b> is correct, and the issue will be offered to
++ the working group at the end of the current meeting to apply to the
++ current working paper (WP) or to close in some other appropriate manner.
++ This status is used only rarely, typically for fixes that are both small
++ and obvious, and usually within a meeting of the expected publication of
++ a revised standard. If the issue does not move forward, it should fall
++ back to one of the other open states before the next list is published.</p>
++
++ <p>In addition, there are a few ways to categorise and issue that remains
++ open to a resolution within the library, but is not actively being worked
++ on.
++ </p>
++
+ <p><b><a name="Deferred">Deferred</a></b> - The LWG has discussed the issue,
+ is not yet ready to move the issue forward, but neither does it deem the
+ issue significant enough to delay publishing a standard or Technical Report.
+@@ -1231,40 +383,32 @@ format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64
+ font. Such comments are for information only and should not be given
+ undue importance.</p>
+
+- <p><b><a name="Dup">Dup</a></b> - The LWG has reached consensus that
+- the issue is a duplicate of another issue, and will not be further
+- dealt with. A <b>Rationale</b> identifies the duplicated issue's
+- issue number. </p>
+-
+- <p><b><a name="NAD">NAD</a></b> - The LWG has reached consensus that
+- the issue is not a defect in the Standard.</p>
+-
+- <p><b><a name="NAD Editorial">NAD Editorial</a></b> - The LWG has reached consensus that
+- the issue can either be handled editorially, or is handled by a paper (usually
+- linked to in the rationale).</p>
+-
+- <p><b><a name="NAD Concepts">NAD Concepts</a></b> - The LWG has reached consensus that
+- the issue is NAD for now, but represents a real issue when the library is
+- done with language-supported concepts.</p>
+-
+- <p><b><a name="NAD Future">NAD Future</a></b> - In addition to the regular
+- status, the LWG believes that this issue should be revisited at the
+- next revision of the standard.</p>
++ <p><b><a name="Core">Core</a></b> - The LWG has discussed the issue, and feels
++ that some key part of resolving the issue is better handled by a cleanup of
++ the language in the Core part of the standard. The issue is passed to the Core
++ Working Group, which should ideally open a corresponding issue that can be
++ linked from the library issue. Such issues will be revisitted after Core have
++ made (or declined to make) any changes.
++ </p>
+
+- <p><b><a name="Review">Review</a></b> - Exact wording of a
+- <b>Proposed Resolution</b> is now available for review on an issue
+- for which the LWG previously reached informal consensus.</p>
++ <p><b><a name="EWG">EWG</a></b> - The LWG has discussed the issue, and wonder
++ that some key part of resolving the issue is better handled by some (hopefully
++ small) extension to the language. The issue is passed to the Evolution Working
++ Group, which should ideally open a corresponding issue that can be linked from
++ the library issue. Such issues will be revisitted after Evoltion have made (or
++ declined to make) any recommendations. Positive recommendations from EWG will
++ often mean the issue transition to <i>Core</i> status while we wait for some
++ proposed new feature to land in the working paper.
++ </p>
+
+- <p><b><a name="Ready">Ready</a></b> - The LWG has reached consensus
+- that the issue is a defect in the Standard, the <b>Proposed
+- Resolution</b> is correct, and the issue is ready to forward to the
+- full committee for further action as a Defect Report (DR).</p>
++ <p><b><a name="LEWG">LEWG</a></b> - The LWG has discussed the issue, and deemd
++ the issue is either an extension, however small, or changes the library design
++ in some fundamental way, and so has delegated the initial work to the Library
++ Evolution Working Group.
++ </p>
+
+- <p><b><a name="Resolved">Resolved</a></b> - The LWG has reached consensus
+- that the issue is a defect in the Standard, but the resolution adopted to
+- resolve the issue came via some other mechanism than this issue in the
+- list - typically by applying a formal paper, occasionally as a side effect
+- of consolidating several interacting issue resolutions into a single issue.</p>
++ <p>Ultimately, all issues should reach closure with one of the following statuses.
++ </p>
+
+ <p><b><a name="DR">DR</a></b> - (Defect Report) - The full WG21/PL22.16
+ committee has voted to forward the issue to the Project Editor to be
+@@ -1274,632 +418,762 @@ format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64
+ accords the status of DR to all these Defect Reports regardless of
+ where they are in that process.</p>
+
++ <p><b><a name="WP">WP</a></b> - (Working Paper) - The proposed resolution has not been
++ accepted as a Technical Corrigendum, but the full WG21/PL22.16 committee has voted to
++ apply the Defect Report's Proposed Resolution to the working paper.</p>
++
++ <p><b><a name="C++11">C++14</a></b> - (C++ Standard, as revised for 2014) - The full
++ WG21/PL22.16 committee has voted to accept the Defect Report's Proposed Resolution into
++ the published 2011 revision to the C++ standard, ISO/IEC IS 14882:2014(E).</p>
++
++ <p><b><a name="C++11">C++11</a></b> - (C++ Standard, as revised for 2011) - The full
++ WG21/PL22.16 committee has voted to accept the Defect Report's Proposed Resolution into
++ the published 2011 revision to the C++ standard, ISO/IEC IS 14882:2011(E).</p>
++
++ <p><b><a name="CD1">CD1</a></b> - (Committee Draft 2008) - The full
++ WG21/PL22.16 committee has voted to accept the Defect Report's Proposed
++ Resolution into the Fall 2008 Committee Draft.</p>
++
+ <p><b><a name="TC1">TC1</a></b> - (Technical Corrigenda 1) - The full
+ WG21/PL22.16 committee has voted to accept the Defect Report's Proposed
+ Resolution as a Technical Corrigenda. Action on this issue is thus
+ complete and no further action is possible under ISO rules.</p>
+
+- <p><b><a name="CD1">CD1</a></b> - (Committee Draft 2008) - The full
+- WG21/PL22.16 committee has voted to accept the Defect Report's Proposed
+- Resolution into the Fall 2008 Committee Draft.</p>
++ <p><b><a name="TRDec">TRDec</a></b> - (Decimal TR defect) - The LWG has voted to
++ accept the Defect Report's Proposed Resolution into the Decimal TR. Action on this
++ issue is thus complete and no further action is expected.</p>
+
+- <p><b><a name="TRDec">TRDec</a></b> - (Decimal TR defect) - The
+- LWG has voted to accept the Defect Report's Proposed
+- Resolution into the Decimal TR. Action on this issue is thus
+- complete and no further action is expected.</p>
+-
+- <p><b><a name="WP">WP</a></b> - (Working Paper) - The proposed
+- resolution has not been accepted as a Technical Corrigendum, but
+- the full WG21/PL22.16 committee has voted to apply the Defect Report's Proposed
+- Resolution to the working paper.</p>
++ <p><b><a name="Resolved">Resolved</a></b> - The LWG has reached consensus
++ that the issue is a defect in the Standard, but the resolution adopted to
++ resolve the issue came via some other mechanism than this issue in the
++ list - typically by applying a formal paper, occasionally as a side effect
++ of consolidating several interacting issue resolutions into a single issue.</p>
++
++ <p><b><a name="Dup">Dup</a></b> - The LWG has reached consensus that
++ the issue is a duplicate of another issue, and will not be further
++ dealt with. A <b>Rationale</b> identifies the duplicated issue's
++ issue number.</p>
++
++ <p><b><a name="NAD">NAD</a></b> - The LWG has reached consensus that
++ the issue is not a defect in the Standard.</p>
++
++ <p><b><a name="NAD Editorial">NAD Editorial</a></b> - The LWG has reached consensus that
++ the issue can either be handled editorially, or is handled by a paper (usually
++ linked to in the rationale).</p>
+
+ <p><b>Tentatively</b> - This is a <i>status qualifier</i>. The issue has
+- been reviewed online, or at an unofficial meeting, but not in an official meeting, and some support has been formed
+- for the qualified status. Tentatively qualified issues may be moved to the unqualified status
+- and forwarded to full committee (if Ready) within the same meeting. Unlike Ready issues, Tentatively Ready issues
+- will be reviewed in subcommittee prior to forwarding to full committee. When a status is
+- qualified with Tentatively, the issue is still considered active.</p>
+-
+- <p><b>Pending</b> - This is a <i>status qualifier</i>. When prepended to
+- a status this indicates the issue has been
+- processed by the committee, and a decision has been made to move the issue to
+- the associated unqualified status. However for logistical reasons the indicated
+- outcome of the issue has not yet appeared in the latest working paper.
+-
+- </p><p>Issues are always given the status of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a> when
++ been reviewed online, or at an unofficial meeting, but not in an official meeting, and
++ some support has been formed for the qualified status. Tentatively qualified issues may
++ be moved to the unqualified status and forwarded to full committee (if Ready) within the
++ same meeting. Unlike Ready issues, Tentatively Ready issues will be reviewed in
++ subcommittee prior to forwarding to full committee. When a status is qualified with
++ Tentatively, the issue is still considered active.</p>
++
++ <p><b>Pending</b> - This is a <i>status qualifier</i>. When prepended to a status this
++ indicates the issue has been processed by the committee, and a decision has been made to
++ move the issue to the associated unqualified status. However for logistical reasons the
++ indicated outcome of the issue has not yet appeared in the latest working paper.</p>
++
++ <p>The following statuses have been retired, but may show up on older issues lists.</p>
++
++ <p><b><a name="NAD Future">NAD Future</a></b> - In addition to the regular status, the
++ LWG believes that this issue should be revisited at the next revision of the standard.
++ That is now an ongoing task managed by the Library Evolution Working Group, and most
++ issues in this status were reopended with the status <a href="#NAD Editorial">LEWG</a>.
++ </p>
++
++ <p><b><a name="NAD Concepts">NAD Concepts</a></b> - This status reflects an evolution
++ of the language during the development of C++11, where a new feature entered the
++ language, called <i>concepts</i>, that fundamentally changed the way templates would
++ be specified and written. While this language feature was removed towards the end of
++ the C++11 project, there is a clear intent to revisit this part of the language design.
++ During that development, a number of issues were opened against the updated library
++ related to use of that feature, or requesting fixes that would require exlicit use of
++ the concepts feature. All such issues have been closed with this status, and may be
++ revisitted should this or a similar language feature return for a future standard.</p>
++
++ <p>Issues are always given the status of <a href="lwg-active.html#New">New</a> when
+ they first appear on the issues list. They may progress to
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a> or <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Review">Review</a> while the LWG
+- is actively working on them. When the LWG has reached consensus on
++ <a href="lwg-active.html#Open">Open</a> or <a href="lwg-active.html#Review">Review</a>
++ while the LWG is actively working on them. When the LWG has reached consensus on
+ the disposition of an issue, the status will then change to
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>, or
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a> as appropriate. Once the full J16 committee votes to
+- forward Ready issues to the Project Editor, they are given the
+- status of Defect Report ( <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#DR">DR</a>). These in turn may
+- become the basis for Technical Corrigenda (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC">TC</a>),
++ <a href="lwg-active.html#Dup">Dup</a>, <a href="lwg-active.html#NAD">NAD</a>, or
++ <a href="lwg-active.html#Ready">Ready</a> as appropriate. Once the full PL22.16 committee
++ votes to forward Ready issues to the Project Editor, they are given the status of Defect
++ Report (<a href="lwg-active.html#DR">DR</a>). These in turn may become the basis for
++ Technical Corrigenda (<a href="lwg-active.html#TC1">TC1</a>), an updated standard
++ (<a href="lwg-defects.html#C++11">C++11</a>, <a href="lwg-defects.html#C++14">C++14</a>),
+ or are closed without action other than a Record of Response
+- (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#RR">RR</a> ). The intent of this LWG process is that
+- only issues which are truly defects in the Standard move to the
+- formal ISO DR status.
++ (<a href="lwg-active.html#Resolved">Resolved</a>) where the desired effect has already
++ been achieved by some other process. The intent of this LWG process is that only issues
++ which are truly defects in the Standard move to the formal ISO DR status.
+ </p>
+
+
+ <h2>Active Issues</h2>
+ <hr>
+-<h3><a name="964"></a>964. Various threading bugs #14</h3>
+-<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="255"></a>255. Why do <tt>basic_streambuf&lt;&gt;::pbump()</tt> and <tt>gbump()</tt> take an int?</h3>
++<p><b>Section:</b> 27.6.3 [streambuf] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf">issues</a> in [streambuf].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The requirements for the constructor for <tt>condition_variable</tt> has several
+-error conditions, but the requirements for the constructor for
+-<tt>condition_variable_any</tt> has none. Is this difference intentional?
++The basic_streambuf members gbump() and pbump() are specified to take an
++int argument. This requirement prevents the functions from effectively
++manipulating buffers larger than std::numeric_limits&lt;int&gt;::max()
++characters. It also makes the common use case for these functions
++somewhat difficult as many compilers will issue a warning when an
++argument of type larger than int (such as ptrdiff_t on LLP64
++architectures) is passed to either of the function. Since it's often the
++result of the subtraction of two pointers that is passed to the
++functions, a cast is necessary to silence such warnings. Finally, the
++usage of a native type in the functions signatures is inconsistent with
++other member functions (such as sgetn() and sputn()) that manipulate the
++underlying character buffer. Those functions take a streamsize argument.
+ </p>
+
+ <p><i>[
+-Summit:
++2009-07 Frankfurt
+ ]</i></p>
+
+
+ <blockquote>
+-Move to open, pass to Howard. If this is intentional, a note may be
+-helpful. If the error conditions are to be copied from
+-<tt>condition_variable</tt>, this depends on LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>.
++<p>
++This is part of a bigger problem. If anyone cares enough, they should
++write a paper solving the bigger problem of offset types in iostreams.
++</p>
++<p>
++This is related to the paper about large file sizes. Beman has already
++agreed to drop the section of that paper that deals with this.
++</p>
++<p>
++int is big enough for reasonable buffers.
++</p>
++<p>
++Move to NAD Future.
++</p>
++<p>
++This is related to LWG <a href="lwg-active.html#423">423</a>.
++</p>
+ </blockquote>
+
+-<p><i>[
+-Post Summit Howard adds:
+-]</i></p>
+
+
+-<blockquote>
+-The original intention
+-(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2447.htm#ConditionVariablesWording">N2447</a>)
+-was to let the OS return whatever errors it was going to return, and for
+-those to be translated into exceptions, for both
+-<tt>condition_variable</tt> and <tt>condition_variable_any</tt>. I have not
+-received any complaints about specific error conditions from vendors on
+-non-POSIX platforms, but such complaints would not surprise me if they surfaced.
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the signatures of these functions in the synopsis of template
++class basic_streambuf (27.5.2) and in their descriptions (27.5.2.3.1, p4
++and 27.5.2.3.2, p4) to take a streamsize argument.
++</p>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
++<p>
++Although this change has the potential of changing the ABI of the
++library, the change will affect only platforms where int is different
++than the definition of streamsize. However, since both functions are
++typically inline (they are on all known implementations), even on such
++platforms the change will not affect any user code unless it explicitly
++relies on the existing type of the functions (e.g., by taking their
++address). Such a possibility is IMO quite remote.
++</p>
+
++<p>
++Alternate Suggestion from Howard Hinnant, c++std-lib-7780:
++</p>
++
++<p>
++This is something of a nit, but I'm wondering if streamoff wouldn't be a
++better choice than streamsize. The argument to pbump and gbump MUST be
++signed. But the standard has this to say about streamsize
++(27.4.1/2/Footnote):
++</p>
++
++<blockquote><p>
++ [Footnote: streamsize is used in most places where ISO C would use
++ size_t. Most of the uses of streamsize could use size_t, except for
++ the strstreambuf constructors, which require negative values. It
++ should probably be the signed type corresponding to size_t (which is
++ what Posix.2 calls ssize_t). --- end footnote]
++</p></blockquote>
++
++<p>
++This seems a little weak for the argument to pbump and gbump. Should we
++ever really get rid of strstream, this footnote might go with it, along
++with the reason to make streamsize signed.
++</p>
+
+-<blockquote>
+-Leave open. Benjamin to provide wording.
+-</blockquote>
+
++<p><b>Rationale:</b></p>
++<p>The LWG believes this change is too big for now. We may wish to
++reconsider this for a future revision of the standard. One
++possibility is overloading pbump, rather than changing the
++signature.</p>
+ <p><i>[
+-2010 Pittsburgh:
++[2006-05-04: Reopened at the request of Chris (Krzysztof ?elechowski)]
+ ]</i></p>
+
+
+-<blockquote>
++
++
++
++<hr>
++<h3><a name="423"></a>423. effects of negative streamsize in iostreams</h3>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
+ <p>
+-We don't have throw clauses for condition variables.
++A third party test suite tries to exercise istream::ignore(N) with
++a negative value of N and expects that the implementation will treat
++N as if it were 0. Our implementation asserts that (N >= 0) holds and
++aborts the test.
+ </p>
++
+ <p>
+-This issue may be dependent on LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.
++I can't find anything in section 27 that prohibits such values but I don't
++see what the effects of such calls should be, either (this applies to
++a number of unformatted input functions as well as some member functions
++of the basic_streambuf template).
+ </p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote>
+ <p>
+-Leave open. Detlef will coordinate with Benjamin.
++This is related to LWG <a href="lwg-active.html#255">255</a>.
+ </p>
+ <p>
+-Consider merging LWG 964, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a> into a
+-single paper.
++Move to NAD Future.
+ </p>
+ </blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++I propose that we add to each function in clause 27 that takes an argument,
++say N, of type streamsize a Requires clause saying that "N >= 0." The intent
++is to allow negative streamsize values in calls to precision() and width()
++but disallow it in calls to streambuf::sgetn(), istream::ignore(), or
++ostream::write().
++</p>
++
++<p><i>[Kona: The LWG agreed that this is probably what we want. However, we
++ need a review to find all places where functions in clause 27 take
++ arguments of type streamsize that shouldn't be allowed to go
++ negative. Martin will do that review.]</i></p>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="966"></a>966. Various threading bugs #16</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="484"></a>484. Convertible to <tt>T</tt></h3>
++<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-09-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>From comp.std.c++:</p>
++
+ <p>
+-30.5.1 [thread.condition.condvar]:
+-<tt>condition_variable::wait</tt> and
+-<tt>condition_variable::wait_until</tt> both have a postcondition that
+-<tt>lock</tt> is locked by the calling thread, and a throws clause that
+-requires throwing an exception if this postcondition cannot be achieved.
+-How can the implementation detect that this <tt>lock</tt> can never be
+-obtained?
++I note that given an input iterator a for type <tt>T</tt>,
++then <tt>*a</tt> only has to be "convertable to <tt>T</tt>",
++not actually of type <tt>T</tt>.
+ </p>
+
+-<p><i>[
+-Summit:
+-]</i></p>
++<p>Firstly, I can't seem to find an exact definition of "convertable to <tt>T</tt>".
++While I assume it is the obvious definition (an implicit conversion), I
++can't find an exact definition. Is there one?</p>
+
++<p>Slightly more worryingly, there doesn't seem to be any restriction on
++the this type, other than it is "convertable to <tt>T</tt>". Consider two input
++iterators <tt>a</tt> and <tt>b</tt>. I would personally assume that most people would
++expect <tt>*a==*b</tt> would perform <tt>T(*a)==T(*b)</tt>, however it doesn't seem that
++the standard requires that, and that whatever type <tt>*a</tt> is (call it <tt>U</tt>)
++could have == defined on it with totally different symantics and still
++be a valid inputer iterator.</p>
+
+-<blockquote>
+-Move to open. Requires wording. Agreed this is an issue, and the
+-specification should not require detecting deadlocks.
+-</blockquote>
++<p>Is this a correct reading? When using input iterators should I write
++<tt>T(*a)</tt> all over the place to be sure that the object I'm using is the
++class I expect?</p>
+
+-<p><i>[
+-2009-08-01 Howard provides wording.
+-]</i></p>
++<p>This is especially a nuisance for operations that are defined to be
++ "convertible to <tt>bool</tt>". (This is probably allowed so that
++ implementations could return say an <tt>int</tt> and avoid an unnessary
++ conversion. However all implementations I have seen simply return a
++ <tt>bool</tt> anyway. Typical implemtations of STL algorithms just write
++ things like <tt>while(a!=b &amp;&amp; *a!=0)</tt>. But strictly
++ speaking, there are lots of types that are convertible to <tt>T</tt> but
++ that also overload the appropriate operators so this doesn't behave
++ as expected.</p>
+
++<p>If we want to make code like this legal (which most people seem to
++ expect), then we'll need to tighten up what we mean by "convertible
++ to <tt>T</tt>".</p>
+
+-<blockquote>
+-<p>
+-The proposed wording is inspired by the POSIX spec which says:
+-</p>
++<p><i>[Lillehammer: The first part is NAD, since "convertible" is
++ well-defined in core. The second part is basically about pathological
++ overloads. It's a minor problem but a real one. So leave open for
++ now, hope we solve it as part of iterator redesign.]</i></p>
+
+-<blockquote>
+-<dl>
+-<dt>[EINVAL]</dt>
+-<dd>The value specified by cond or mutex is invalid.</dd>
+-<dt>[EPERM]</dt>
+-<dd>The mutex was not owned by the current thread at the time of the call.</dd>
+-</dl>
+-</blockquote>
+
+-<p>
+-I do not believe [EINVAL] is possible without memory corruption (which we don't
+-specify). [EPERM] is possible if this thread doesn't own the mutex, which is
+-listed as a precondition. "May" is used instead of "Shall" because not all
+-OS's are POSIX.
+-</p>
+-</blockquote>
++<p><i>[
++2009-07-28 Reopened by Alisdair. No longer solved by concepts.
++]</i></p>
++
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Leave open, Detlef to provide improved wording.
+-</blockquote>
++<blockquote><p>
++Mark as NAD Future. We agree there's an issue, but there is no
++proposed solution at this time and this will be solved by concepts in
++the future.
++</p></blockquote>
+
+-<p><i>[
+-2009-10-23 Detlef Provided wording.
+-]</i></p>
+
+
+-<blockquote>
+-<p>
+-Detlef's wording put in Proposed resolution. Original wording here:
+-</p>
+-<blockquote>
+-<p>
+-Change 30.5.1 [thread.condition.condvar] p12, p19 and
+-30.5.2 [thread.condition.condvarany] p10, p16:
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-<i>Throws:</i> <ins>May throw</ins> <tt>std::system_error</tt>
+-<ins>
+-if a precondition is not met.
+-</ins>
+-<del>when the effects or postcondition
+-cannot be achieved.</del>
+-</blockquote>
+-</blockquote>
+-</blockquote>
+
++<p><b>Rationale:</b></p>
+ <p><i>[
+-2009-10 Santa Cruz:
++San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
+-Leave open, Detlef to provide improved wording.
+-</blockquote>
++<blockquote><p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2758.pdf">N2758</a>.
++</p></blockquote>
+
+-<p><i>[
+-2009-11-18 Anthony adds:
+-]</i></p>
+
+
+-<blockquote>
++
++
++<hr>
++<h3><a name="523"></a>523. regex case-insensitive character ranges are unimplementable as specified</h3>
++<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2005-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re">active issues</a> in [re].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re">issues</a> in [re].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-<tt>condition_variable::wait</tt> takes a <tt>unique_lock&lt;mutex&gt;</tt>. We
+-know whether or not a <tt>unique_lock</tt> owns a lock, through use of its
+-<tt>owns_lock()</tt> member.
++A problem with TR1 regex is currently being discussed on the Boost
++developers list. It involves the handling of case-insensitive matching
++of character ranges such as [Z-a]. The proper behavior (according to the
++ECMAScript standard) is unimplementable given the current specification
++of the TR1 regex_traits&lt;&gt; class template. John Maddock, the author of
++the TR1 regex proposal, agrees there is a problem. The full discussion
++can be found at http://lists.boost.org/boost/2005/06/28850.php (first
++message copied below). We don't have any recommendations as yet.
+ </p>
+-
+ <p>
+-I would like to propose the following resolution:
++-- Begin original message --
++</p>
++<p>
++The situation of interest is described in the ECMAScript specification
++(ECMA-262), section 15.10.2.15:
++</p>
++<p>
++"Even if the pattern ignores case, the case of the two ends of a range
++is significant in determining which characters belong to the range.
++Thus, for example, the pattern /[E-F]/i matches only the letters E, F,
++e, and f, while the pattern /[E-f]/i matches all upper and lower-case
++ASCII letters as well as the symbols [, \, ], ^, _, and `."
++</p>
++<p>
++A more interesting case is what should happen when doing a
++case-insentitive match on a range such as [Z-a]. It should match z, Z,
++a, A and the symbols [, \, ], ^, _, and `. This is not what happens with
++Boost.Regex (it throws an exception from the regex constructor).
++</p>
++<p>
++The tough pill to swallow is that, given the specification in TR1, I
++don't think there is any effective way to handle this situation.
++According to the spec, case-insensitivity is handled with
++regex_traits&lt;&gt;::translate_nocase(CharT) -- two characters are equivalent
++if they compare equal after both are sent through the translate_nocase
++function. But I don't see any way of using this translation function to
++make character ranges case-insensitive. Consider the difficulty of
++detecting whether "z" is in the range [Z-a]. Applying the transformation
++to "z" has no effect (it is essentially std::tolower). And we're not
++allowed to apply the transformation to the ends of the range, because as
++ECMA-262 says, "the case of the two ends of a range is significant."
++</p>
++<p>
++So AFAICT, TR1 regex is just broken, as is Boost.Regex. One possible fix
++is to redefine translate_nocase to return a string_type containing all
++the characters that should compare equal to the specified character. But
++this function is hard to implement for Unicode, and it doesn't play nice
++with the existing ctype facet. What a mess!
+ </p>
+-
+-<blockquote>
+ <p>
+-Modify the first sentence of 30.5.1 [thread.condition.condvar] p9:
++-- End original message --
+ </p>
+
+-<blockquote><pre>void wait(unique_lock&lt;mutex&gt;&amp; lock);
+-</pre>
+-<blockquote>
+-9 <i>Precondition:</i> <del><tt>lock</tt> is locked by the calling thread</del>
+-<ins><tt>lock.owns_lock()</tt> is <tt>true</tt></ins>, and either
+-<p>...</p>
+-</blockquote>
+-</blockquote>
++<p><i>[
++John Maddock adds:
++]</i></p>
++
+
+ <p>
+-Replace 30.5.1 [thread.condition.condvar] p11-13 with:
++One small correction, I have since found that ICU's regex package does
++implement this correctly, using a similar mechanism to the current
++TR1.Regex.
+ </p>
+-
+-<blockquote><pre>void wait(unique_lock&lt;mutex&gt;&amp; lock);
+-</pre>
+-<blockquote>
+-<p>...</p>
+ <p>
+-11 <i>Postcondition:</i> <del><tt>lock</tt> is locked by the calling
+-thread</del> <ins><tt>lock.owns_lock()</tt> is <tt>true</tt></ins>.
++Given an expression [c1-c2] that is compiled as case insensitive it:
+ </p>
+-
+ <p>
+-12 <i>Throws:</i> <tt>std::system_error</tt> <del>when the effects or
+-postcondition cannot be achieved</del> <ins>if the implementation detects that
+-the preconditions are not met or the effects cannot be achieved. Any exception
+-thrown by <tt>lock.lock()</tt> or <tt>lock.unlock()</tt></ins>.
++Enumerates every character in the range c1 to c2 and converts it to it's
++case folded equivalent. That case folded character is then used a key to a
++table of equivalence classes, and each member of the class is added to the
++list of possible matches supported by the character-class. This second step
++isn't possible with our current traits class design, but isn't necessary if
++the input text is also converted to a case-folded equivalent on the fly.
++</p>
++<p>
++ICU applies similar brute force mechanisms to character classes such as
++[[:lower:]] and [[:word:]], however these are at least cached, so the impact
++is less noticeable in this case.
+ </p>
+-
+ <p>
+-13 <i>Error Conditions:</i> <ins>The error conditions are implementation
+-defined.</ins>
++Quick and dirty performance comparisons show that expressions such as
++"[X-\\x{fff0}]+" are indeed very slow to compile with ICU (about 200 times
++slower than a "normal" expression). For an application that uses a lot of
++regexes this could have a noticeable performance impact. ICU also has an
++advantage in that it knows the range of valid characters codes: code points
++outside that range are assumed not to require enumeration, as they can not
++be part of any equivalence class. I presume that if we want the TR1.Regex
++to work with arbitrarily large character sets enumeration really does become
++impractical.
++</p>
++<p>
++Finally note that Unicode has:
++</p>
++<p>
++Three cases (upper, lower and title).
++One to many, and many to one case transformations.
++Character that have context sensitive case translations - for example an
++uppercase sigma has two different lowercase forms - the form chosen depends
++on context(is it end of a word or not), a caseless match for an upper case
++sigma should match either of the lower case forms, which is why case folding
++is often approximated by tolower(toupper(c)).
++</p>
++<p>
++Probably we need some way to enumerate character equivalence classes,
++including digraphs (either as a result or an input), and some way to tell
++whether the next character pair is a valid digraph in the current locale.
++</p>
++<p>
++Hoping this doesn't make this even more complex that it was already,
+ </p>
+
+-<ul>
+-<li><del>
+-equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</del></li>
+-</ul>
++<p><i>[
++Portland: Alisdair: Detect as invalid, throw an exception.
++Pete: Possible general problem with case insensitive ranges.
++]</i></p>
+
+-</blockquote>
+-</blockquote>
+-</blockquote>
+-</blockquote>
+
+ <p><i>[
+-2010 Pittsburgh:
++2009-07 Frankfurt
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-There are heavy conflicts with adopted papers.
++We agree that this is a problem, but we do not know the answer.
+ </p>
+ <p>
+-This issue is dependent on LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.
++We are going to declare this NAD until existing practice leads us in some direction.
+ </p>
+ <p>
+-Leave open pending outstanding edits to the working draft. Detlef will provide
+-wording.
++No objection to NAD Future.
+ </p>
+ <p>
+-Possibly related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>.
++Move to NAD Future.
+ </p>
+-
+ </blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Replace 30.5.1 [thread.condition.condvar] p12, p19 and
+-30.5.2 [thread.condition.condvarany] p10, p16:
+-</p>
+-
+-<blockquote>
+-<p><del>
+-<i>Throws:</i> <tt>std::system_error</tt> when the effects or
+-postcondition cannot be achieved.
+-</del></p>
+-<p><del>
+-Error conditions:
+-</del></p>
+-<ul>
+-<li><del>
+-equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</del></li>
+-</ul>
+-
+-<p><ins>
+-<i>Throws:</i> It is implementation-defined whether a <tt>std::system_error</tt>
+-with implementation-defined error condition is thrown if the
+-precondition is not met.
+-</ins></p>
+-</blockquote>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="985"></a>985. Allowing throwing move</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Rani Sharoni <b>Opened:</b> 2009-02-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="532"></a>532. Tuple comparison</h3>
++<p><b>Section:</b> 20.4.2.7 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2005-11-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.rel">active issues</a> in [tuple.rel].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#348">348</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+-<b>Introduction</b>
++Where possible, <tt>tuple</tt> comparison operators &lt;,&lt;=,=&gt;, and &gt; ought to be
++defined in terms of <tt>std::less</tt> rather than <tt>operator&lt;</tt>, in order to
++support comparison of tuples of pointers.
+ </p>
+
+-<p>This proposal is meant to resolve potential regression of the
+-<a href="" ref="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2800.pdf">N2800</a>
+-draft, see
+-next section, and to relax the requirements for containers of types with
+-throwing move constructors.</p>
++<p><i>[
++2009-07-28 Reopened by Alisdair. No longer solved by concepts.
++]</i></p>
+
+-<p>The basic problem is that some containers operations, like <tt>push_back</tt>,
+-have a strong exception safety
+-guarantee (i.e. no side effects upon exception) that are not achievable when
+-throwing move constructors are used since there is no way to guarantee revert
+-after partial move. For such operations the implementation can at most provide
+-the basic guarantee (i.e. valid but unpredictable) as it does with multi
+-copying operations (e.g. range insert).</p>
+
+-<p>For example, <tt>vector&lt;T&gt;::push_back()</tt> (where <tt>T</tt> has a move
+-constructor) might resize the <tt>vector</tt> and move the objects to the new underlying
+-buffer. If move constructor throws it might
+-not be possible to recover the throwing object or to move the old objects back to
+-the original buffer.</p>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+-<p>The current draft is explicit by disallowing throwing move
+-for some operations (e.g. <tt>vector&lt;&gt;::reserve</tt>) and not clear about other
+-operations mentioned in 23.2.1 [container.requirements.general]/10
+-(e.g. single element <tt>insert</tt>): it guarantees strong exception
+-safety without explicitly disallowing a throwing move constructor.
+-</p>
+
++<blockquote>
+ <p>
+-<b>Regression</b>
++If we solve this for <tt>tuple</tt> we would have to solve it for <tt>pair</tt>
++algorithms, etc. It is too late to do that at this time. Move to NAD Future.
+ </p>
++</blockquote>
+
+-<p>This section only refers to cases in which the contained object
+-is by itself a standard container.</p>
+-
+-<p>Move constructors of standard containers are allowed to throw and therefore
+-existing operations are broken, compared with C++03, due to move optimization.
+-(In fact existing implementations like Dinkumware are actually throwing).</p>
+
+-<p>For example, <tt>vector&lt; list&lt;int&gt; &gt;::reserve</tt> yields
+-undefined behavior since <tt>list&lt;int&gt;</tt>'s move constructor is allowed to throw.
+-On the other hand, the same operation has strong exception safety guarantee in
+-C++03.</p>
+
+-<p>There are few options to solve this regression:</p>
++<p><b>Proposed resolution:</b></p>
++<p>
++change 6.1.3.5/5 from:
++</p>
+
+-<ol>
+-<li>
+-Disallow throwing move and throwing default constructor
+-</li>
++<blockquote><p>
++ Returns: The result of a lexicographical comparison between t and
++ u. The result is defined as: (bool)(get&lt;0&gt;(t) &lt; get&lt;0&gt;(u)) ||
++ (!(bool)(get&lt;0&gt;(u) &lt; get&lt;0&gt;(t)) &amp;&amp; ttail &lt; utail), where rtail for
++ some tuple r is a tuple containing all but the first element of
++ r. For any two zero-length tuples e and f, e &lt; f returns false.
++</p></blockquote>
+
+-<li>
+-Disallow throwing move but disallowing usage after move
+-</li>
++<p>
++to:
++</p>
+
+-<li>
+-Special casing
+-</li>
++<blockquote>
++<p>
++ Returns: The result of a lexicographical comparison between t and
++ u. For any two zero-length tuples e and f, e &lt; f returns false.
++ Otherwise, the result is defined as: cmp( get&lt;0&gt;(t), get&lt;0&gt;(u)) ||
++ (!cmp(get&lt;0&gt;(u), get&lt;0&gt;(t)) &amp;&amp; ttail &lt; utail), where rtail for some
++ tuple r is a tuple containing all but the first element of r, and
++ cmp(x,y) is an unspecified function template defined as follows.
++</p>
++<p>
++ Where T is the type of x and U is the type of y:
++</p>
+
+-<li>
+-Disallow throwing move and making it optional
+-</li>
++<p>
++ if T and U are pointer types and T is convertible to U, returns
++ less&lt;U&gt;()(x,y)
++</p>
+
+-</ol>
++<p>
++ otherwise, if T and U are pointer types, returns less&lt;T&gt;()(x,y)
++</p>
+
+-<p>Option 1 is suggested by proposal
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2815.html">N2815</a>
+-but it might not be applicable for existing implementations for which
+-containers default constructors are throwing.</p>
++<p>
++ otherwise, returns (bool)(x &lt; y)
++</p>
++</blockquote>
+
+-<p>Option 2 limits the usage significantly and it's error prone
+-by allowing zombie objects that are nothing but destructible (e.g. no <tt>clear()</tt>
+-is allowed after move). It also potentially complicates the implementation by
+-introducing special state.</p>
++<p><i>[
++Berlin: This issue is much bigger than just tuple (pair, containers,
++algorithms). Dietmar will survey and work up proposed wording.
++]</i></p>
+
+-<p>Option 3 is possible, for example, using default
+-construction and <tt>swap</tt> instead of move for standard containers case. The
+-implementation is also free to provide special hidden operation for non
+-throwing move without forcing the user the cope with the limitation of option-2
+-when using the public move.</p>
+
+-<p>Option 4 impact the efficiency in all use cases due to rare throwing move.</p>
+
+-<p>The proposed wording will imply option 1 or 3 though option 2 is also
+-achievable using more wording. I personally oppose to option 2 that has impact
+-on usability.</p>
+
++<p><b>Rationale:</b></p>
+ <p>
+-<b>Relaxation for user types</b>
++Recommend NAD. This will be fixed with the next revision of concepts.
+ </p>
+
+-<p>Disallowing throwing move constructors in general seems very restrictive
+-since, for example, common implementation of move will be default construction
+-+ <tt>swap</tt> so move will throw if the
+-default constructor will throw. This is currently the case with the Dinkumware
+-implementation of node based containers (e.g. <tt>std::list</tt>)
+-though this section doesn't refer to standard types.</p>
++<p><i>[
++San Francisco:
++]</i></p>
+
+-<p>For throwing move constructors it seem that the implementation should have
+-no problems to provide the basic guarantee instead of the strong one. It's
+-better to allow throwing move constructors with basic guarantee than to
+-disallow it silently (compile and run), via undefined behavior.</p>
+
+-<p>There might still be cases in which the relaxation will break existing generic
+-code that assumes the strong guarantee but it's broken either way given a
+-throwing move constructor since this is not a preserving optimization. </p>
++<blockquote><p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2770.pdf">N2770</a>.
++</p></blockquote>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+
+-<blockquote>
++
++
++
++<hr>
++<h3><a name="708"></a>708. Locales need to be per thread and updated for POSIX changes</h3>
++<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#localization">issues</a> in [localization].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Bjarne comments (referring to his draft paper):
+-"I believe that my suggestion simply solves that.
+-Thus, we don't need a throwing move."
++The POSIX "Extended API Set Part 4,"
+ </p>
++<blockquote><p>
++<a href="http://www.opengroup.org/sib/details.tpl?id=C065">http://www.opengroup.org/sib/details.tpl?id=C065</a>
++</p></blockquote>
+ <p>
+-Move to Open and recommend it be deferred until after the next
+-Committee Draft is issued.
++introduces extensions to the C locale mechanism that
++allow multiple concurrent locales to be used in the same application
++by introducing a type <tt>locale_t</tt> that is very similar to
++<tt>std::locale</tt>, and a number of <tt>_l</tt> functions that make use of it.
++</p>
++<p>
++The global locale (set by setlocale) is now specified to be per-
++process. If a thread does not call <tt>uselocale</tt>, the global locale is
++in effect for that thread. It can install a per-thread locale by
++using <tt>uselocale</tt>.
++</p>
++<p>
++There is also a nice <tt>querylocale</tt> mechanism by which one can obtain
++the name (such as "de_DE") for a specific <tt>facet</tt>, even for combined
++locales, with no <tt>std::locale</tt> equivalent.
++</p>
++<p>
++<tt>std::locale</tt> should be harmonized with the new POSIX <tt>locale_t</tt>
++mechanism and provide equivalents for <tt>uselocale</tt> and <tt>querylocale</tt>.
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++Kona (2007): Bill and Nick to provide wording.
+ ]</i></p>
+
+
+-<blockquote>
+-Should wait to get direction from Dave/Rani
+-(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2983.html">N2983</a>).
+-</blockquote>
++<p><i>[
++San Francisco: Bill and Nick still intend to provide wording, but this
++is a part of the task to be addressed by the group that will look into
++issue <a href="lwg-defects.html#860">860</a>.
++]</i></p>
++
+
+ <p><i>[
+-2010-03-28 Daniel updated wording to sync with N3092.
++2009-07 Frankfurt:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-The suggested change of 23.3.2.3 [deque.modifiers]/2 should be removed,
+-because the current wording does say more general things:
++It's our intention to stay in sync with WG14. If WG14 makes a decision
++that requires a change in WG21 the issue will be reopened.
+ </p>
+-
+-<blockquote>
+-2 <i>Remarks:</i> If an exception is thrown other than by the copy constructor,
+-move constructor, assignment operator, or move assignment operator of <tt>T</tt>
+-there are no effects. If an exception is thrown by the move constructor of a
+-non-CopyConstructible <tt>T</tt>, the effects are unspecified.
+-</blockquote>
+-
+ <p>
+-The suggested change of 23.4.1.2 [vector.capacity]/2 should be removed,
+-because the current wording does say more general things:
++Move to NAD Future.
+ </p>
+-
+-<blockquote>
+-2 <i>Effects:</i> A directive that informs a <tt>vector</tt> of a planned change
+-in size, so that it can manage the storage allocation accordingly. After
+-<tt>reserve()</tt>, <tt>capacity()</tt> is greater or equal to the argument of
+-<tt>reserve</tt> if reallocation happens; and equal to the previous value of
+-<tt>capacity()</tt> otherwise. Reallocation happens at this point if and only if
+-the current capacity is less than the argument of <tt>reserve()</tt>. If an
+-exception is thrown other than by the move constructor of a
+-non-<tt>CopyConstructible</tt> type, there are no effects.
+-</blockquote>
+-
+ </blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-
+ <p>
+-23.2.1 [container.requirements.general] paragraph 11 add footnote:
+ </p>
+
+-<blockquote>
+-<p>
+--11- Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and
+-23.2.6.4) all container types defined in this Clause meet the following
+-additional requirements:
+-</p>
+-<ul>
+-<li>...</li>
+-</ul>
+
+-<p>
+-<ins>[<i>Note</i>: for compatibility with C++
+-2003, when "no effect" is required, standard containers should not use the
+-value_type's throwing move constructor when the contained object is by itself a
+-standard container. -- <i>end note</i>]</ins>
+-</p>
+
+-</blockquote>
+
+-<p>23.2.5.1 [unord.req.except] change paragraph 2 to say: </p>
+
+-<blockquote>
++<hr>
++<h3><a name="760"></a>760. The emplace issue</h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">Tentatively NAD</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-11-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Tentatively NAD">Tentatively NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+--2- For unordered associative containers, if an exception is
+-thrown by any operation other than the container's hash function from within an
+-<tt>insert()</tt> function inserting a single element, the <tt>insert()</tt>
+-function has no effect<ins> unless the exception is thrown by the contained
+-object move constructor</ins>.
++In an <tt>emplace</tt> member function the function parameter pack may be bound
++to a priori unlimited number of objects: some or all of them can be
++elements of the container itself. Apparently, in order to conform to the
++blanket statement 23.2 [container.requirements]/11, the
++implementation must check all of them for that possibility. A possible
++solution can involve extending the exception in 23.2 [container.requirements]/12 also to the emplace member. As a
++side note, the <tt>push_back</tt> and <tt>push_front</tt> member
++functions are luckily not affected by this problem, can be efficiently
++implemented anyway.
+ </p>
+
+-<p>
+--4- For unordered associative containers, if an exception is
+-thrown from within a <tt>rehash()</tt> function other than by the container's hash
+-function or comparison function, the <tt>rehash()</tt> function has no effect
+-<ins>unless the exception is thrown by the contained
+-object move constructor</ins>.</p>
++<p><i>[
++Related to <a href="lwg-defects.html#767">767</a> and to <a href="lwg-active.html#2164">2164</a>
++]</i></p>
++
++
++<p><i>[
++Bellevue:
++]</i></p>
+
+-</blockquote>
+
++<blockquote>
++<p>
++The proposed addition (13) is partially redundant with the existing
++paragraph 12. Why was the qualifier "rvalues" added to paragraph 12? Why
++does it not cover subelements and pointers?
++</p>
+ <p>
+-23.3.2.3 [deque.modifiers] change paragraph 2 to say:
++Resolution: Alan Talbot to rework language, then set state to Review.
+ </p>
++</blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
+
+ <blockquote>
+--2- <i>Remarks:</i> If an exception is thrown other than by
+-the copy constructor<ins>, move constructor</ins>
+-or assignment operator of <tt>T</tt>
+-there are no effects.
+-<ins>If an exception is thrown by <tt>push_back()</tt> or <tt>emplace_back()</tt>
+-function, that function has no effects unless the exception is thrown by
+-the move constructor of <tt>T</tt>.</ins>
++<p>
++The problem is broader than <tt>emplace</tt>. The LWG doesn't
++feel that it knows how to write wording that prohibits all of the
++problematic use cases at this time.
++</p>
++<p>
++NAD Future.
++</p>
+ </blockquote>
+
++<p><i>[2015-02 Cologne]</i></p>
++
+ <p>
+-23.4.1.2 [vector.capacity] paragraph 2 change to say:
++LWG believes that <a href="lwg-active.html#2164">2164</a> addresses this issue and therefore considers <a href="lwg-active.html#760">760</a> as NAD.
+ </p>
+
+-<blockquote>
+--2- <i>Effects:</i> A directive that informs a <tt>vector</tt>
+-of a planned change in size, so
+-that it can manage the storage allocation accordingly. After <tt>reserve()</tt>,
+-<tt>capacity()</tt> is greater or equal to the argument of <tt>reserve</tt>
+-if reallocation happens; and equal
+-to the previous value of <tt>capacity()</tt>
+-otherwise. Reallocation happens at this point if and only if the current
+-capacity is less than the argument of <tt>reserve()</tt>.
+-If an exception is thrown, there are no effects<ins>
+-unless the exception is thrown by the contained object move constructor</ins>.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-23.4.1.2 [vector.capacity] paragraph 12 change to say:
++Add after 23.2 [container.requirements]/12:
+ </p>
+
+ <blockquote>
+--12- <i>Requires:</i> <del>If <tt>value_type</tt> has a move constructor,
+-that constructor shall not throw any exceptions.</del>
+-<ins>If an exception is thrown, there are no effects unless the exception is thrown by
+-the contained object move constructor.</ins>
+-</blockquote>
+-
+ <p>
+-23.4.1.4 [vector.modifiers] change paragraph 1 to say:
++-12- Objects passed to member functions of a container as rvalue
++references shall not be elements of that container. No diagnostic
++required.
++</p>
++<p>
++<ins>
++-13- Objects bound to the function parameter pack of the
++<tt>emplace</tt> member function shall not be elements or sub-objects of
++elements of the container. No diagnostic required.
++</ins>
+ </p>
+
+-<blockquote>
+--1- <del><i>Requires:</i> If <tt>value_type</tt> has a move constructor,
+-that constructor shall not throw any exceptions.</del>
+-<ins><i>Remarks:</i> If an exception is thrown by <tt>push_back()</tt>
+-or <tt>emplace_back()</tt> function, that function has no effect unless the
+-exception is thrown by the move constructor of <tt>T</tt>.</ins>
+ </blockquote>
+
+
+@@ -1908,3067 +1182,24271 @@ exception is thrown by the move constructor of <tt>T</tt>.</ins>
+
+
+ <hr>
+-<h3><a name="1169"></a>1169. <tt>num_get</tt> not fully compatible with <tt>strto*</tt></h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Cosmin Truta <b>Opened:</b> 2009-07-04 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="839"></a>839. Maps and sets missing splice operation</h3>
++<p><b>Section:</b> 23.4 [associative], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alan Talbot <b>Opened:</b> 2008-05-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative">active issues</a> in [associative].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative">issues</a> in [associative].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-As specified in the latest draft,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>,
+-<code>num_get</code> is still not fully compatible with the following C
+-functions: <code>strtoul</code>, <code>strtoull</code>,
+-<code>strtof</code> and
+-<code>strtod</code>.
++Splice is a very useful feature of <tt>list</tt>. This functionality is also very
++useful for any other node based container, and I frequently wish it were
++available for maps and sets. It seems like an omission that these
++containers lack this capability. Although the complexity for a splice is
++the same as for an insert, the actual time can be much less since the
++objects need not be reallocated and copied. When the element objects are
++heavy and the compare operations are fast (say a <tt>map&lt;int, huge_thingy&gt;</tt>)
++this can be a big win.
+ </p>
++
+ <p>
+-In C, when conversion of a string to an unsigned integer type falls
+-outside the
+-representable range, <code>strtoul</code> and <code>strtoull</code> return
+-<code>ULONG_MAX</code> and <code>ULLONG_MAX</code>, respectively,
+-regardless
+-whether the input field represents a positive or a negative value.
+-On the other hand, the result of <code>num_get</code> conversion of
+-negative
+-values to unsigned integer types is zero. This raises a compatibility
+-issue.
++<b>Suggested resolution:</b>
+ </p>
++
+ <p>
+-Moreover, in C, when conversion of a string to a floating-point type falls
+-outside the representable range, <code>strtof</code>, <code>strtod</code>
+-and
+-<code>strtold</code> return <code>±HUGE_VALF</code>,
+-<code>±HUGE_VAL</code> and <code>±HUGE_VALL</code>, respectively.
+-On the other hand, the result of <code>num_get</code> conversion of such
+-out-of-range floating-point values results in the most positive/negative
+-representable value.
+-Although many C library implementations do implement <code>HUGE_VAL</code>
+-(etc.) as the highest representable (which is, usually, the infinity),
+-this
+-isn't required by the C standard. The C library specification makes no
+-statement regarding the value of <code>HUGE_VAL</code> and friends, which
+-potentially raises the same compatibility issue as in the above case of
+-unsigned integers.
+-In addition, neither C nor C++ define symbolic constants for the maximum
+-representable floating-point values (they only do so only for the maximum
+-representable <i>finite</i> floating-point values), which raises a
+-usability
+-issue (it would be hard for the programmer to check the result of
+-<code>num_get</code> against overflow).
++Add the following signatures to map, set, multimap, multiset, and the unordered associative containers:
+ </p>
++<blockquote><pre>
++void splice(list&lt;T,Allocator&gt;&amp;&amp; x);
++void splice(list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
++void splice(list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator first, const_iterator last);
++</pre></blockquote>
++
+ <p>
+-As such, we propose to adjust the specification of <code>num_get</code> to
+-closely follow the behavior of all of its underlying C functions.
++Hint versions of these are also useful to the extent hint is useful.
++(I'm looking for guidance about whether hints are in fact useful.)
+ </p>
+-
+-
++
++<blockquote><pre>
++void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
++void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
++void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator first, const_iterator last);
++</pre></blockquote>
+
+ <p><i>[
+-2010 Rapperswil:
++Sophia Antipolis:
+ ]</i></p>
+
+
+ <blockquote>
+-Some concern that this is changing the specification for an existing C++03 function, but it was pointed out that this was underspecified as resolved by issue 23. This is clean-up for that issue in turn.
++<p>
++Don't try to <tt>splice "list"</tt> into the other containers, it should be container-type.
++</p>
++<p>
++<tt>forward_list</tt> already has <tt>splice_after</tt>.
++</p>
++<p>
++Would "<tt>splice</tt>" make sense for an <tt>unordered_map</tt>?
++</p>
++<p>
++Jens, Robert: "<tt>splice</tt>" is not the right term, it implies maintaining ordering in <tt>list</tt>s.
++</p>
++<p>
++Howard: <tt>adopt</tt>?
++</p>
++<p>
++Jens: <tt>absorb</tt>?
++</p>
++<p>
++Alan: <tt>subsume</tt>?
++</p>
++<p>
++Robert: <tt>recycle</tt>?
++</p>
++<p>
++Howard: <tt>transfer</tt>? (but no direction)
++</p>
++<p>
++Jens: <tt>transfer_from</tt>. No.
++</p>
++<p>
++Alisdair: Can we give a nothrow guarantee? If your <tt>compare()</tt> and <tt>hash()</tt> doesn't throw, yes.
++</p>
++<p>
++Daniel: For <tt>unordered_map</tt>, we can't guarantee nothrow.
++</p>
++</blockquote>
+
+-Some concern that we are trying to solve the same problem in both clause 22 and 27.
++<p><i>[
++San Francisco:
++]</i></p>
+
+-Bill: There's a change here as to whether val is stored to in an error case.
+
+-Pablo: Don't think this changes whether val is stored to or not, but changes the value that is stored.
++<blockquote>
++<p>
++Martin: this would possibly outlaw an implementation technique that is
++currently in use; caching nodes in containers.
++</p>
++<p>
++Alan: if you cache in the allocator, rather than the individual
++container, this proposal doesn't interfere with that.
++</p>
++<p>
++Martin: I'm not opposed to this, but I'd like to see an implementation
++that demonstrates that it works.
++</p>
++</blockquote>
+
+-Bill: Remembers having skirmishes with customers and testers as to whether val is stored to, and the resolution was not to store in error cases.
++<p><i>[
++2009-07 Frankfurt:
++]</i></p>
+
+-Howard: Believes since C++03 we made a change to always store in overflow.
+
+-Everyone took some time to review the issue.
++<blockquote><p>
++NAD Future.
++</p></blockquote>
+
+-Pablo: C++98 definitely did not store any value during an error condition.
++<p><i>[
++2009-09-19 Howard adds:
++]</i></p>
+
+-Dietmar: Depends on the question of what is considered an error, and whether overflow is an error or not, which was the crux of LWG 23.
+
+-Pablo: Yes, but given the "zero, if the conversion function fails to convert the entire field", we are requiring every error condition to store.
++<blockquote>
++<p>
++I'm not disagreeing with the NAD Future resolution. But when the future gets
++here, here is a possibility worth exploring:
++</p>
+
+-Bill: When did this happen?
++<blockquote>
++<p>
++Add to the "unique" associative containers:
++</p>
+
+-Alisdair: One of the last two or three meetings.
++<blockquote><pre>
++typedef <i>details</i> node_ptr;
+
+-Dietmar: To store a value in case of failure is a very bad idea.
++node_ptr remove(const_iterator p);
++pair&lt;iterator, bool&gt; insert(node_ptr&amp;&amp; nd);
++iterator insert(const_iterator p, node_ptr&amp;&amp; nd);
++</pre></blockquote>
+
+-Move to Open, needs more study.
+-</blockquote>
++<p>
++And add to the "multi" associative containers:
++</p>
+
++<blockquote><pre>
++typedef <i>details</i> node_ptr;
+
++node_ptr remove(const_iterator p);
++iterator insert(node_ptr&amp;&amp; nd);
++iterator insert(const_iterator p, node_ptr&amp;&amp; nd);
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
++<p>
++<tt>Container::node_ptr</tt> is a smart pointer much like <tt>unique_ptr</tt>.
++It owns a node obtained from the container it was removed from. It maintains a
++reference to the allocator in the container so that it can properly deallocate
++the node if asked to, even if the allocator is stateful. This being said, the
++<tt>node_ptr</tt> can not outlive the container for this reason.
++</p>
+
+ <p>
+-Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:
++The <tt>node_ptr</tt> offers "<tt>const</tt>-free" access to the node's
++<tt>value_type</tt>.
+ </p>
+-<blockquote>
++
+ <p>
+-<b>Stage 3:</b>
+-The sequence of <code>char</code>s accumulated in stage 2 (the field) is
+-converted to a numeric value by the rules of one of the functions declared in
+-the header <code>&lt;cstdlib&gt;</code>:
++With this interface, clients have a great deal of flexibility:
+ </p>
++
+ <ul>
+-<li>For a signed integer value, the function <code>strtoll</code>.</li>
+-<li>For an unsigned integer value, the function <code>strtoull</code>.</li>
+-<li><ins>For a <code>float</code> value, the function
+- <code>strtof</code>.</ins></li>
+-<li><ins>For a <code>double</code> value, the function
+- <code>strtod</code>.</ins></li>
+-<li>For a <del>floating-point</del> <ins><code>long double</code></ins>
+- value, the function <code>strtold</code>.</li>
++<li>
++A client can remove a node from one container, and insert it into another
++(without any heap allocation). This is the splice functionality this issue
++asks for.
++</li>
++<li>
++A client can remove a node from a container, change its key or value, and insert
++it back into the same container, or another container, all without the cost of
++allocating a node.
++</li>
++<li>
++If the Compare function is nothrow (which is very common), then this functionality
++is nothrow unless modifying the value throws. And if this does throw, it does
++so outside of the containers involved.
++</li>
++<li>
++If the Compare function does throw, the <tt>insert</tt> function will have the
++argument <tt>nd</tt> retain ownership of the node.
++</li>
++<li>
++The <tt>node_ptr</tt> should be independent of the <tt>Compare</tt> parameter
++so that a node can be transferred from <tt>set&lt;T, C1, A&gt;</tt>
++to <tt>set&lt;T, C2, A&gt;</tt> (for example).
++</li>
+ </ul>
++
+ <p>
+-The numeric value to be stored can be one of:
++Here is how the customer might use this functionality:
+ </p>
++
+ <ul>
+-<li>zero, if the conversion function fails to convert the entire field.
+- <del><code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
+-<li>the most positive <ins>(or negative)</ins> representable value, if
+- the field <ins>to be converted to a signed integer type</ins> represents a
+- value too large positive <ins>(or negative)</ins> to be represented in
+- <code>val</code>.
+- <del><code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
+-<li><del>the most negative representable value or zero for an unsigned integer
+- type, if the field represents a value too large negative to be represented
+- in <code>val</code>.
+- <code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
+-<li><ins>the most positive representable value, if the field to be converted to
+- an unsigned integer type represents a value that cannot be represented in
+- <code>val</code>.</ins></li>
+-<li>the converted value, otherwise.</li>
+-</ul>
++<li>
+ <p>
+-The resultant numeric value is stored in <code>val</code>.
+-<ins>If the conversion function fails to convert the entire field, or if the
+-field represents a value outside the range of representable values,
+-<code>ios_base::failbit</code> is assigned to <code>err</code>.</ins>
++Splice a node from one container to another:
+ </p>
+-</blockquote>
+-
++<blockquote><pre>
++m2.insert(m1.remove(i));
++</pre></blockquote>
++</li>
+
++<li>
++<p>
++Change the "key" in a <tt>std::map</tt> without the cost of node reallocation:
++</p>
++<blockquote><pre>
++auto p = m.remove(i);
++p->first = new_key;
++m.insert(std::move(p));
++</pre></blockquote>
++</li>
+
++<li>
++<p>
++Change the "value" in a <tt>std::set</tt> without the cost of node reallocation:
++</p>
++<blockquote><pre>
++auto p = s.remove(i);
++*p = new_value;
++s.insert(std::move(p));
++</pre></blockquote>
++</li>
+
++<li>
++<p>
++Move a move-only or heavy object out of an associative container (as opposed to
++the proposal in <a href="lwg-active.html#1041">1041</a>):
++</p>
++<blockquote><pre>
++MoveOnly x = std::move(*s.remove(i));
++</pre></blockquote>
++<ol>
++<li>
++<tt>remove(i)</tt> transfers ownership of the node from the set to a temporary
++<tt>node_ptr</tt>.
++</li>
++<li>
++The <tt>node_ptr</tt> is dereferenced, and that non-const reference is sent to
++<tt>move</tt> to cast it to an rvalue.
++</li>
++<li>
++The rvalue <tt>MoveOnly</tt> is move constructed into <tt>x</tt> from
++the <tt>node_ptr</tt>.
++</li>
++<li>
++<tt>~node_ptr()</tt> destructs the moved-from <tt>MoveOnly</tt> and deallocates
++the node.
++</li>
++</ol>
+
++<p>
++Contrast this with the <a href="lwg-active.html#1041">1041</a> solution:
++</p>
++<blockquote><pre>
++MoveOnly x = std::move(s.extract(i).first);
++</pre></blockquote>
+
+-<hr>
+-<h3><a name="1175"></a>1175. <tt>unordered</tt> complexity</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-07-17 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-When I look at the <tt>unordered_*</tt> constructors, I think the complexity is poorly
+-described and does not follow the style of the rest of the standard.
++The former requires one move construction for <tt>x</tt> while the latter
++requires two (one into the <tt>pair</tt> and then one into <tt>x</tt>). Either
++of these constructions can throw (say if there is only a copy constructor for
++<tt>x</tt>). With the former, the point of throw is outside of the container
++<tt>s</tt>, after the element has been removed from the container. With the latter,
++one throwing construction takes place prior to the removal of the element, and
++the second takes place after the element is removed.
+ </p>
+
++</li>
++</ul>
++
+ <p>
+-The complexity for the default constructor is specified as constant.
+- Actually, it is proportional to <tt>n</tt>, but there are no invocations of
+-<tt>value_type</tt> constructors or other <tt>value_type</tt> operations.
++The "node insertion" API maintains the API associated with inserting <tt>value_type</tt>s
++so the customer can use familiar techniques for getting an iterator to the
++inserted node, or finding out whether it was inserted or not for the "unique"
++containers.
+ </p>
+
+ <p>
+-For the iterator-based constructor the complexity should be:
++Lightly prototyped. No implementation problems. Appears to work great
++for the client.
+ </p>
+
+-<blockquote>
+-<i>Complexity:</i> exactly <tt>n</tt> calls to construct <tt>value_type</tt>
+-from <tt>InputIterator::value_type</tt> (where <tt>n = distance(f,l)</tt>).
+-The number of calls to <tt>key_equal::operator()</tt> is proportional to
+-<tt>n</tt> in the average case and <tt>n*n</tt> in the worst case.
++</blockquote>
+ </blockquote>
+
+
+
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-Concern that the current wording may require O(1) where that cannot be delivered. We need to look at both the clause 23 requirements tables and the constructor description of each unodered container to be sure.
+
+-Howard suggests NAD Editorial as we updated the container requirement tables since this issue was written.
+
+-Daniel offers to look deeper, and hopefully produce wording addressing any outstanding concerns at the next meeting.
+
+-Move to Open.
+-</blockquote>
+
++<hr>
++<h3><a name="851"></a>851. simplified array construction</h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Benjamin Kosnik <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++This is an issue that came up on the libstdc++ list, where a
++discrepancy between "C" arrays and C++0x's <tt>std::array</tt> was pointed
++out.
++</p>
+
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
++In "C," this array usage is possible:
+ </p>
+
++<blockquote><pre>
++int ar[] = {1, 4, 6};
++</pre></blockquote>
+
+-
+-
+-
+-<hr>
+-<h3><a name="1213"></a>1213. Meaning of valid and singular iterator underspecified</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Deferred">Deferred</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-09-19 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Deferred">Deferred</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-The terms <em>valid</em> iterator and <em>singular</em> aren't
+-properly defined. The fuzziness of those terms became even worse
+-after the resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a> (including further updates by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>). In
+-24.2 [iterator.requirements] as of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+-the standard says now:
++But for C++,
+ </p>
+
+-<blockquote>
+-<p>
+-5 - These values are called past-the-end values. Values of an iterator <tt>i</tt> for
+-which the expression <tt>*i</tt> is defined are called dereferenceable. The library
+-never assumes that past-the-end values are dereferenceable. Iterators
+-can also have singular values that are not associated with any
+-container. [...] Results of most expressions are undefined for singular
+-values; the only exceptions are destroying an iterator that holds a
+-singular value and the assignment of a non-singular value to an iterator
+-that holds a singular value. [...] Dereferenceable values are always
+-non-singular.
+-</p>
++<blockquote><pre>
++std::array&lt;int&gt; a = { 1, 4, 6 }; // error
++</pre></blockquote>
+
+ <p>
+-10 - An invalid iterator is an iterator that may be singular.
++Instead, the second parameter of the <tt>array</tt> template must be
++explicit, like so:
+ </p>
+-</blockquote>
++
++<blockquote><pre>
++std::array&lt;int, 3&gt; a = { 1, 4, 6 };
++</pre></blockquote>
+
+ <p>
+-First, issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a> intentionally removed the earlier constraint that past-the-end
+-values are always non-singular. The reason for this was to support null
+-pointers as past-the-end iterators of e.g. empty sequences. But there
+-seem to exist different views on what a singular (iterator) value is. E.g.
+-according to the <a href="http://www.sgi.com/tech/stl/trivial.html">SGI definition</a>
+-a null pointer is <em>not</em> a singular value:
++Doug Gregor proposes the following solution, that assumes
++generalized initializer lists.
+ </p>
+
+-<blockquote>
+-Dereferenceable iterators are always nonsingular, but the converse is
+-not true.
+-For example, a null pointer is nonsingular (there are well defined operations
+-involving null pointers) even thought it is not dereferenceable.
+-</blockquote>
++<blockquote><pre>
++template&lt;typename T, typename... Args&gt;
++inline array&lt;T, sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args)
++{ return { std::forward&lt;Args&gt;(args)... }; }
++</pre></blockquote>
+
+ <p>
+-and <a href="http://www.sgi.com/tech/stl/InputIterator.html">proceeds</a>:
++Then, the way to build an <tt>array</tt> from a list of unknown size is:
+ </p>
+
+-<blockquote>
+-An iterator is valid if it is dereferenceable or past-the-end.
+-</blockquote>
++<blockquote><pre>
++auto a = make_array&lt;T&gt;(1, 4, 6);
++</pre></blockquote>
+
++<p><i>[
++San Francisco:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-Even if the standard prefers a different meaning of singular here, the
+-change was
+-incomplete, because by restricting feasible expressions of singular
+-iterators to
+-destruction and assignment isn't sufficient for a past-the-end
+-iterator: Of-course
+-it must still be equality-comparable and in general be a readable value.
++Benjamin: Move to Ready?
+ </p>
+-
+ <p>
+-Second, the standard doesn't clearly say whether a past-the-end value is
+-a valid iterator or not. E.g. 20.9.8 [specialized.algorithms]/1 says:
++Bjarne: I'm not convinced this is useful enough to add, so I'd like us
++to have time to reflect on it.
+ </p>
+-
+-<blockquote>
+-In all of the following algorithms, the formal template parameter
+-<tt>ForwardIterator</tt>
+-is required to satisfy the requirements of a forward iterator (24.1.3)
+-[..], and is
+-required to have the property that no exceptions are thrown from [..], or
+-dereference of valid iterators.
+-</blockquote>
+-
+ <p>
+-The standard should make better clear what "singular pointer" and "valid
+-iterator" means. The fact that the meaning of a valid <em>value</em>
+-has a core language meaning doesn't imply that for an iterator concept
+-the term "valid iterator" has the same meaning.
++Alisdair: the constraints are wrong, they should be
+ </p>
+-
++<blockquote><pre>
++template&lt;ValueType T, ValueType... Args&gt;
++requires Convertible&lt;Args, T&gt;...
++array&lt;T, sizeof...(Args)&gt; make_array(Args&amp;&amp;... args);
++</pre></blockquote>
+ <p>
+-Let me add a final example: In X [allocator.concepts.members] of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>
+-we find:
++Alidair: this would be useful if we had a constexpr version.
+ </p>
+-
+-<blockquote><pre>pointer X::allocate(size_type n);
+-</pre>
+-
+-<blockquote>
+-11 <i>Returns:</i> a pointer to the allocated memory. [<i>Note:</i> if <tt>n == 0</tt>, the return
+-value is unspecified. —<i>end note</i>]
+-</blockquote>
+-
+ <p>
+-[..]
++Bjarne: this is probably useful for arrays with a small number of
++elements, but it's not clearly useful otherwise.
+ </p>
+-
+-<pre>void X::deallocate(pointer p, size_type n);
+-</pre>
+-
+-<blockquote>
+-<i>Preconditions:</i> <tt>p</tt> shall be a non-singular pointer value obtained from a call
+-to <tt>allocate()</tt> on this allocator or one that compares equal to it.
+-</blockquote>
+-</blockquote>
+-
+ <p>
+-If singular pointer value would include null pointers this make the
+-preconditions
+-unclear if the pointer value is a result of <tt>allocate(0)</tt>: Since the return value
+-is unspecified, it could be a null pointer. Does that mean that programmers
+-need to check the pointer value for a null value before calling deallocate?
++Consensus is to move to Open.
+ </p>
++</blockquote>
+
+ <p><i>[
+-2010-11-09 Daniel comments:
++2009-06-07 Daniel adds:
+ ]</i></p>
+
+
++<blockquote>
+ <p>
+-A later paper is in preparation.
++I suggest a fix and a simplification of the current proposal: Recent
++prototyping by
++Howard showed, that a fix is required because narrowing conversion
++8.5.4 [dcl.init.list]/6 b.3
++would severely limit the possible distribution of argument types, e.g.
++the expression
++<tt>make_array&lt;double&gt;(1, 2.0)</tt> is ill-formed, because the narrowing
++happens <em>inside</em> the
++function body where no constant expressions exist anymore. Furthermore
++given e.g.
++</p>
++<blockquote><pre>
++int f();
++double g();
++</pre></blockquote>
++<p>
++we probably want to support
+ </p>
++<blockquote><pre>
++make_array&lt;double&gt;(f(), g());
++</pre></blockquote>
+
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
++<p>
++as well. To make this feasible, the currently suggested expansion
++</p>
+
++<blockquote><pre>
++{ std::forward&lt;Args&gt;(args)... }
++</pre></blockquote>
+
+ <p>
+-Doesn't need to be resolved for Ox
++needs to be replaced by
+ </p>
+
++<blockquote><pre>
++{ static_cast&lt;T&gt;(std::forward&lt;Args&gt;(args))... }
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-Consider to await the paper.
++<p>
++which is safe, because we already ensure convertibility via the
++element-wise <tt>Convertible&lt;Args, T&gt;</tt> requirement. Some other fixes are
++necessary: The <tt>ValueType</tt> requirement for the function <em>parameters</em>
++is invalid, because all lvalue arguments will deduce to an lvalue-reference,
++thereby no longer satisfying this requirement.
++</p>
+
++<p>
++The suggested simplification is to provide a default-computed effective
++type for the result array based on common_type and decay, in
++unconstrained form:
++</p>
++
++<blockquote><pre>
++template&lt;typename... Args&gt;
++array&lt;typename decay&lt;typename common_type&lt;Args...&gt;::type&gt;::type,
++sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args);
++</pre></blockquote>
+
++<p>
++The approach used below is similar to that of <tt>make_pair</tt> and <tt>make_tuple</tt>
++using a symbol <tt>C</tt> to represent the decayed common type [Note: Special
++handling of <tt>reference_wrapper</tt> types is intentionally <em>not</em> provided, because
++our target has so satisfy <tt>ValueType</tt>, thus under the revised proposal only
++an all-<tt>reference_wrapper</tt>-arguments would be well-formed and an array of
++<tt>reference_wrapper</tt> will be constructed]. I do currently not suggest to
++add new concepts reflecting <tt>decay</tt> and <tt>common_type</tt>, but an implementor will
++need something like this to succeed. Note that we use a similar fuzziness for
++<tt>make_pair</tt> and <tt>make_tuple</tt> currently. This fuzziness is not related to
++the currently
++missing <tt>Constructible&lt;Vi, Ti&amp;&amp;&gt;</tt> requirement for those functions. The following
++proposal fixes that miss for <tt>make_array</tt>. If the corresponding <tt>C</tt> type
++deduction is
++explicitly wanted for standardization, here the implementation
++</p>
++
++<blockquote><pre>
++auto concept DC&lt;typename... T&gt; {
++ typename type = typename decay&lt;typename common_type&lt;T...&gt;::type&gt;::type;
++}
++</pre></blockquote>
+
++<p>
++where <tt>C</tt> is identical to <tt>DC&lt;Args...&gt;::type</tt> in the proposed resolution below.
++</p>
++<p>
++I intentionally added no further type relation between type and the concept
++template parameters, but instead added this requirement below to make
++the specification as transparent as possible. As written this concept is
++satisfied, if the corresponding associated type exists.
++</p>
+
++<p><b>Suggested Resolution:</b></p>
+
+-<hr>
+-<h3><a name="1214"></a>1214. Insufficient/inconsistent key immutability requirements for associative containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Deferred">Deferred</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-09-20 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Deferred">Deferred</a> status.</p>
+-<p><b>Discussion:</b></p>
++<ol>
++<li>
+ <p>
+-Scott Meyers' mentions on a recent posting on <a href="http://groups.google.de/group/comp.std.c++/msg/6f9160fc428bcbea">c.s.c++</a>
+-some arguments that point to an incomplete resolution
+-of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> and to an inconsistency of requirements on keys in ordered and
+-unordered associative
+-containers:
++Add to the array synopsis in 23.3 [sequences]:
+ </p>
++<blockquote><pre>
++<ins>
++template&lt;ReferentType... Args&gt;
++requires ValueType&lt;C&gt; &amp;&amp; IdentityOf&lt;Args&gt; &amp;&amp; Constructible&lt;C, Args&amp;&amp;&gt;...
++array&lt;C, sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args);
++</ins>
++</pre></blockquote>
++</li>
+
++<li>
++<p>
++Append after 23.3.2.9 [array.tuple] Tuple interface to class template array
++the following new section:
++</p>
+ <blockquote>
+ <p>
+-1) <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> introduced the term immutable without defining it in a unique manner in
+-23.2.4 [associative.reqmts]/5:
++23.4.1.7 Array creation functions [array.creation]
+ </p>
+
++<pre>
++<ins>
++template&lt;ReferentType... Args&gt;
++requires ValueType&lt;C&gt; &amp;&amp; IdentityOf&lt;Args&gt; &amp;&amp; Constructible&lt;C, Args&amp;&amp;&gt;...
++array&lt;C, sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args);</ins>
++</pre>
++
+ <blockquote>
+-[..] Keys in an associative container are immutable.
++<p><ins>
++Let <tt>C</tt> be <tt>decay&lt;common_type&lt;Args...&gt;::type&gt;::type</tt>.
++</ins></p>
++<p>
++<ins><i>Returns:</i> an <tt>array&lt;C, sizeof...(Args)&gt;</tt> initialized with
++<tt>{ static_cast&lt;C&gt;(std::forward&lt;Args&gt;(args))... }</tt>.
++</ins></p>
++</blockquote>
++</blockquote>
++
++</li>
++
++</ol>
++
+ </blockquote>
+
++<p><i>[
++2009-07 Frankfurt:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-According to conventional dictionaries immutable is an unconditional way of
+-saying that something cannot be changed. So without any further explicit
+-allowance a user <em>always</em> runs into undefined behavior if (s)he attempts
+-to modify such a key. IMO this was not the intend of the committee to resolve
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> in that way because the comments suggest an interpretation that
+-should give any user the freedom to modify the key in an <em>explicit</em> way
+-<em>provided</em> it would not affect the sort order in that container.
++The proposed resolution uses concepts.
+ </p>
+-
+ <p>
+-2) Another observation was that surprisingly no similar 'safety guards'
+-exists against unintentional key changes for the unordered associative
+-containers, specifically there is no such requirement as in
+-23.2.4 [associative.reqmts]/6 that "both <tt>iterator</tt> and <tt>const_iterator</tt> are constant
+-iterators". But the need for such protection against unintentional
+-changes as well as the constraints in which manner any explicit
+-changes may be performed are both missing and necessary, because
+-such changes could potentially change the <em>equivalence</em> of keys that
+-is measured by the <tt>hasher</tt> and <tt>key_equal</tt>.
++Daniel to rewrite the proposed resolution.
+ </p>
+-
+ <p>
+-I suggest to fix the unconditional wording involved with "immutable keys"
+-by at least adding a hint for the reader that users <em>may</em> perform such
+-changes in an explicit manner <em>and</em> to perform similar wording changes
+-as <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> did for the ordered associative containers also for the unordered
+-containers.
++Leave Open.
+ </p>
+ </blockquote>
+
+ <p><i>[
+-2010-03-27 Daniel provides wording.
++2009-07-25 Daniel provides rewritten proposed resolution.
+ ]</i></p>
+
+
+-<blockquote>
+-This update attempts to provide normative wording that harmonizes the key and
+-function object constraints of associative and unordered containers.
+-</blockquote>
+-
+ <p><i>[
+-2010 Batavia:
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<p>
+-We're uncomfortable with the first agenda item, and we can live with the second agenda
+-item being applied before or after Madrid.
+-</p>
++<blockquote><p>
++Argument for NAD future: everything about this could be added on. This
++does not require changes to the existing text.
++</p></blockquote>
++
+
+
+ <p><b>Proposed resolution:</b></p>
++
+ <ol>
+ <li>
+ <p>
+-Change 23.2.4 [associative.reqmts]/2 as indicated: <i>[This ensures that
+-associative containers make better clear what this "arbitrary" type is, as the
+-unordered containers do in 23.2.5 [unord.req]/3]</i>
++Add to the array synopsis in 23.3 [sequences]:
+ </p>
+
+-<blockquote>
+-2 Each associative container is parameterized on <tt>Key</tt> and an ordering
+-relation <tt>Compare</tt> that induces a strict weak ordering (25.4) on elements
+-of <tt>Key</tt>. In addition, <tt>map</tt> and <tt>multimap</tt> associate an
+-arbitrary <ins><em>mapped type</em></ins><del>type</del> <tt>T</tt> with the
+-<tt>Key</tt>. The object of type <tt>Compare</tt> is called the <em>comparison
+-object</em> of a container.
+-</blockquote>
++<blockquote><pre>
++<ins>template&lt;class... Args&gt;
++ array&lt;<i>CT</i>, sizeof...(Args)&gt;
++ make_array(Args&amp;&amp;... args);</ins>
++</pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.2.4 [associative.reqmts]/5 as indicated: <i>[This removes the
+-too strong requirement that keys must not be changed at all and brings this line
+-in sync with 23.2.5 [unord.req]/7. We take care about the real
+-constraints by the remaining suggested changes. The rationale provided by LWG
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> didn't really argue why that addition is necessary, and I
+-believe the remaining additions make it clear that any user changes have strong
+-restrictions]</i>:
++Append after 23.3.2.9 [array.tuple] "Tuple interface to class template array" the
++following new section:
+ </p>
+
+ <blockquote>
+-5 For <tt>set</tt> and <tt>multiset</tt> the value type is the same as the key
+-type. For <tt>map</tt> and <tt>multimap</tt> it is equal to <tt>pair&lt;const
+-Key, T&gt;</tt>. <del>Keys in an associative container are immutable.</del>
+-</blockquote>
+-</li>
+-
+-<li>
+ <p>
+-Change 23.2.5 [unord.req]/3+4 as indicated: <i>[The current sentence of
+-p.4 has doesn't say something really new and this whole subclause misses to
+-define the concepts of the container-specific hasher <i>object</i> and predicate
+-<i>object</i>. We introduce the term <em>key equality predicate</em> which is
+-already used in the requirements table. This change does not really correct part
+-of this issue, but is recommended to better clarify the nomenclature and the
+-difference between the function objects and the function object <em>types</em>,
+-which is important, because both can potentially be stateful.]</i>
++<ins>XX.X.X.X Array creation functions [array.creation]</ins>
+ </p>
+
++<pre><ins>
++template&lt;class... Args&gt;
++array&lt;<i>CT</i>, sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args)
++</ins></pre>
++
+ <blockquote>
+ <p>
+-3 Each unordered associative container is parameterized by <tt>Key</tt>, by a
+-function object type <tt>Hash</tt> that meets the <tt>Hash</tt> requirements
+-(20.2.4) and acts as a hash function for argument values of type <tt>Key</tt>,
+-and by a binary predicate <tt>Pred</tt> that induces an equivalence relation on
+-values of type <tt>Key</tt>. Additionally, <tt>unordered_map</tt> and
+-<tt>unordered_multimap</tt> associate an arbitrary <em>mapped type</em>
+-<tt>T</tt> with the <tt>Key</tt>.
++<ins>Let <i>CT</i> be <tt>decay&lt;common_type&lt;Args...&gt;::type&gt;::type</tt>.</ins>
+ </p>
+-
+ <p>
+-4 <ins>The container's object of type <tt>Hash</tt> - denoted by
+-<tt>hash</tt> - is called the <em>hash function</em> of the container.
+-The container's object of type <tt>Pred</tt> - denoted by
+-<tt>pred</tt> - is called the <em>key equality predicate</em> of the
+-container.</ins><del>A hash function is a function object that takes a single
+-argument of type <tt>Key</tt> and returns a value of type
+-<tt>std::size_t</tt></del>.
++<ins><i>Returns:</i> An <tt>array&lt;<i>CT</i>, sizeof...(Args)&gt;</tt> initialized with <tt>{
++static_cast&lt;<i>CT</i>&gt;(std::forward&lt;Args&gt;(args))... }</tt>.</ins>
+ </p>
+-</blockquote>
+-</li>
+
+-<li>
+-<p>
+-Change 23.2.5 [unord.req]/5 as indicated: <i>[This adds a similar
+-safe-guard as the last sentence of 23.2.4 [associative.reqmts]/3]</i>
+-</p>
++<p><ins>
++[<i>Example:</i>
++</ins></p>
++<blockquote><pre><ins>
++int i = 0; int&amp; ri = i;
++make_array(42u, i, 2.78, ri);
++</ins></pre></blockquote>
++<p><ins>
++returns an array of type
++</ins></p>
++<blockquote><pre><ins>
++array&lt;double, 4&gt;
++</ins></pre></blockquote>
+
+-<blockquote>
+-5 Two values <tt>k1</tt> and <tt>k2</tt> of type <tt>Key</tt> are considered
+-equivalent if the container's <ins>key equality
+-predicate</ins><del><tt>key_equal</tt> function object</del> returns
+-<tt>true</tt> when passed those values. If <tt>k1</tt> and <tt>k2</tt> are
+-equivalent, the <ins>container's</ins> hash function shall return the same value
+-for both. [<i>Note:</i> thus, when an unordered associative container is
+-instantiated with a non-default <tt>Pred</tt> parameter it usually needs a
+-non-default <tt>Hash</tt> parameter as well. — <i>end note</i>] <ins>For
+-any two keys <tt>k1</tt> and <tt>k2</tt> in the same container, calling
+-<tt>pred(k1, k2)</tt> shall always return the same value. For any key <tt>k</tt>
+-in a container, calling <tt>hash(k)</tt> shall always return the same
+-value.</ins>
++<p><ins>
++&mdash;<i>end example</i>]</ins>
++</p>
++</blockquote>
+ </blockquote>
+ </li>
+
+-<li>
+-<p>
+-After 23.2.5 [unord.req]/7 add the following new paragraph: <i>[This
+-ensures the same level of compile-time protection that we already require for
+-associative containers. It is necessary for similar reasons, because any change
+-in the stored key which would change it's equality relation to others or would
+-change it's hash value such that it would no longer fall in the same bucket,
+-would break the container invariants]</i>
+-</p>
++</ol>
++
++
++
++
++
++
++
++
++<hr>
++<h3><a name="877"></a>877. to <tt>throw()</tt> or to <i>Throw:</i> Nothing.</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-08-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++ <p>
++
++Recent changes to
++the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">working
++draft</a> have introduced a gratuitous inconsistency with the C++ 2003
++version of the specification with respect to exception guarantees
++provided by standard functions. While the C++ 2003 standard
++consistenly uses the empty exception specification, <tt>throw()</tt>,
++to declare functions that are guaranteed not to throw exceptions, the
++current working draft contains a number of "<i>Throws:</i> Nothing."
++clause to specify essentially the same requirement. The difference
++between the two approaches is that the former specifies the behavior
++of programs that violate the requirement (<tt>std::unexpected()</tt>
++is called) while the latter leaves the behavior undefined.
++
++ </p>
++ <p>
++
++A survey of the working draft reveals that there are a total of 209
++occurrences of <tt>throw()</tt> in the library portion of the spec,
++the majority in clause 18, a couple (literally) in 19, a handful in
++20, a bunch in 22, four in 24, one in 27, and about a dozen in D.9.
++
++ </p>
++ <p>
++
++There are also 203 occurrences of "<i>Throws:</i> Nothing." scattered
++throughout the spec.
++
++ </p>
++ <p>
++
++While sometimes there are good reasons to use the "<i>Throws:</i>
++Nothing." approach rather than making use of <tt>throw()</tt>, these
++reasons do not apply in most of the cases where this new clause has
++been introduced and the empty exception specification would be a
++better approach.
++
++ </p>
++ <p>
++
++First, functions declared with the empty exception specification
++permit compilers to generate better code for calls to such
++functions. In some cases, the compiler might even be able to eliminate
++whole chunks of user-written code when instantiating a generic
++template on a type whose operations invoked from the template
++specialization are known not to throw. The prototypical example are
++the <tt>std::uninitialized_copy()</tt>
++and <tt>std::uninitialized_fill()</tt> algorithms where the
++entire <tt>catch(...)</tt> block can be optimized away.
++
++ </p>
++ <p>
++
++For example, given the following definition of
++the <tt>std::uninitialized_copy</tt> function template and a
++user-defined type <tt>SomeType</tt>:
++
++ </p>
++ <blockquote>
++ <pre>
++template &lt;class InputIterator, class ForwardIterator&gt;
++ForwardIterator
++uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator res)
++{
++ typedef iterator_traits&lt;ForwardIterator&gt;::value_type ValueType;
++
++ ForwardIterator start = res;
++
++ try {
++ for (; first != last; ++first, ++res)
++ ::new (&amp;*res) ValueType (*first);
++ }
++ catch (...) {
++ for (; start != res; --start)
++ (&amp;*start)->~ValueType ();
++ throw;
++ }
++ return res;
++}
++
++struct SomeType {
++ SomeType (const SomeType&amp;) <ins>throw ()</ins>;
++}</pre>
++ </blockquote>
++ <p>
++
++compilers are able to emit the following efficient specialization
++of <tt>std::uninitialized_copy&lt;const SomeType*, SomeType*&gt;</tt>
++(note that the <tt>catch</tt> block has been optimized away):
++
++ </p>
++ <blockquote>
++ <pre>
++template &lt;&gt; SomeType*
++uninitialized_copy (const SomeType *first, const SomeType *last, SomeType *res)
++{
++ for (; first != last; ++first, ++res)
++ ::new (res) SomeType (*first);
++
++ return res;
++}</pre>
++ </blockquote>
++ <p>
++
++Another general example is default constructors which, when decorated
++with <tt>throw()</tt>, allow the compiler to eliminate the
++implicit <tt>try</tt> and <tt>catch</tt> blocks that it otherwise must
++emit around each the invocation of the constructor
++in <i>new-expressions</i>.
++
++ </p>
++ <p>
++
++For example, given the following definitions of
++class <tt>MayThrow</tt> and <tt>WontThrow</tt> and the two
++statements below:
++
++ </p>
++ <blockquote>
++ <pre>
++struct MayThrow {
++ MayThrow ();
++};
++
++struct WontThrow {
++ WontThrow () <ins>throw ()</ins>;
++};
++
++MayThrow *a = new MayThrow [N];
++WontThrow *b = new WontThrow [N];</pre>
++
++ </blockquote>
++ <p>
++
++the compiler generates the following code for the first statement:
++
++ </p>
++ <blockquote>
++ <pre>
++MayThrow *a;
++{
++ MayThrow *first = operator new[] (N * sizeof (*a));
++ MayThrow *last = first + N;
++ MayThrow *next = first;
++ try {
++ for ( ; next != last; ++next)
++ new (next) MayThrow;
++ }
++ catch (...) {
++ for ( ; first != first; --next)
++ next->~MayThrow ();
++ operator delete[] (first);
++ throw;
++ }
++ a = first;
++}</pre>
++ </blockquote>
++ <p>
++
++but it is can generate much more compact code for the second statement:
++
++ </p>
++ <blockquote>
++ <pre>
++WontThrow *b = operator new[] (N * sizeof (*b));
++WontThrow *last = b + N;
++for (WontThrow *next = b; next != last; ++next)
++ new (next) WontThrow;
++</pre>
++ </blockquote>
++ <p>
++
++Second, in order for users to get the maximum benefit out of the new
++<tt>std::has_nothrow_xxx</tt> traits when using standard library types
++it will be important for implementations to decorate all non throwing
++copy constructors and assignment operators with <tt>throw()</tt>. Note
++that while an optimizer may be able to tell whether a function without
++an explicit exception specification can throw or not based on its
++definition, it can only do so when it can see the source code of the
++definition. When it can't it must assume that the function may
++throw. To prevent violating the One Definition Rule,
++the <tt>std::has_nothrow_xxx</tt> trait must return the most
++pessimistic guess across all translation units in the program, meaning
++that <tt>std::has_nothrow_xxx&lt;T&gt;::value</tt> must evaluate to
++<tt>false</tt> for any <tt>T</tt> whose <tt>xxx</tt>
++(where <tt>xxx</tt> is default or copy ctor, or assignment operator)
++is defined out-of-line.
++
++ </p>
++ <p>
++
++<b>Counterarguments:</b>
++
++ </p>
++ <p>
++
++During the discussion of this issue
++on <a href="mailto:c++std-lib@accu.org">c++std-lib@accu.org</a>
++(starting with post <tt>c++std-lib-21950</tt>) the following arguments
++in favor of the "<i>Throws:</i> Nothing." style have been made.
++
++ </p>
++ <ol>
++ <li>
++
++Decorating functions that cannot throw with the empty exception
++specification can cause the compiler to generate suboptimal code for
++the implementation of the function when it calls other functions that
++aren't known to the compiler not to throw (i.e., that aren't decorated
++with <tt>throw()</tt> even if they don't actually throw). This is a
++common situation when the called function is a C or POSIX function.
++
++ </li>
++ <li>
++
++Alternate, proprietary mechanisms exist (such as
++GCC <a href="http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Function-Attributes.html#index-g_t_0040code_007bnothrow_007d-function-attribute-2160"><tt>__attribute__((nothrow))</tt></a>
++or Visual
++C++ <a href="http://msdn.microsoft.com/en-us/library/49147z04(VS.80).aspx"><tt>__declspec(nothrow)</tt></a>)
++that let implementers mark up non-throwing functions, often without
++the penalty mentioned in (1) above. The C++ standard shouldn't
++preclude the use of these potentially more efficient mechanisms.
++
++ </li>
++ <li>
++
++There are functions, especially function templates, that invoke
++user-defined functions that may or may not be
++declared <tt>throw()</tt>. Declaring such functions with the empty
++exception specification will cause compilers to generate suboptimal
++code when the user-defined function isn't also declared not to throw.
++
++ </li>
++ </ol>
++ <p>
++
++The answer to point (1) above is that implementers can (and some have)
++declare functions with <tt>throw()</tt> to indicate to the compiler
++that calls to the function can safely be assumed not to throw in order
++to allow it to generate efficient code at the call site without also
++having to define the functions the same way and causing the compiler
++to generate suboptimal code for the function definition. That is, the
++function is declared with <tt>throw()</tt> in a header but it's
++defined without it in the source file. The <tt>throw()</tt>
++declaration is suppressed when compiling the definition to avoid
++compiler errors. This technique, while strictly speaking no permitted
++by the language, is safe and has been employed in practice. For
++example, the GNU C library takes this approach. Microsoft Visual C++
++takes a similar approach by simply assuming that no function with C
++language linkage can throw an exception unless it's explicitly
++declared to do so using the language extension <tt>throw(...)</tt>.
++
++ </p>
++ <p>
++
++Our answer to point (2) above is that there is no existing practice
++where C++ Standard Library implementers have opted to make use of the
++proprietary mechanisms to declare functions that don't throw. The
++language provides a mechanism specifically designed for this
++purpose. Avoiding its use in the specification itself in favor of
++proprietary mechanisms defeats the purpose of the feature. In
++addition, making use of the empty exception specification
++inconsistently, in some areas of the standard, while conspicuously
++avoiding it and making use of the "<i>Throws:</i> Nothing." form in
++others is confusing to users.
++
++ </p>
++ <p>
++
++The answer to point (3) is simply to exercise caution when declaring
++functions and especially function templates with the empty exception
++specification. Functions that required not to throw but that may call
++back into user code are poor candidates for the empty exception
++specification and should instead be specified using "<i>Throws:</i>
++Nothing." clause.
++
++ </p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
+
+ <blockquote>
+ <p>
+-7 For <tt>unordered_set</tt> and <tt>unordered_multiset</tt> the value type is
+-the same as the key type. For <tt>unordered_map</tt> and
+-<tt>unordered_multimap</tt> it is <tt>std::pair&lt;const Key, T&gt;</tt>.
++We need someone to do an extensive review.
+ </p>
+ <p>
+-<ins>For unordered containers where the value type is the same as the key type,
+-both <tt>iterator</tt> and <tt>const_iterator</tt> are constant iterators. It is
+-unspecified whether or not <tt>iterator</tt> and <tt>const_iterator</tt> are the
+-same type. [<i>Note:</i> <tt>iterator</tt> and <tt>const_iterator</tt> have
+-identical semantics in this case, and <tt>iterator</tt> is convertible to
+-<tt>const_iterator</tt>. Users can avoid violating the One Definition Rule by
+-always using <tt>const_iterator</tt> in their function parameter lists. —
+-<i>end note</i>]</ins>
++NAD Future.
+ </p>
+ </blockquote>
+-</li>
+
+-</ol>
++
++ <p><b>Proposed resolution:</b></p>
++ <p>
++
++We propose two possible solutions. Our recommendation is to adopt
++Option 1 below.
+
++ </p>
++ <p>
+
++<b>Option 1:</b>
+
++ </p>
++ <p>
++
++Except for functions or function templates that make calls back to
++user-defined functions that may not be declared <tt>throw()</tt>
++replace all occurrences of the "<i>Throws:</i> Nothing." clause with
++the empty exception specification. Functions that are required not to
++throw but that make calls back to user code should be specified to
++"<i>Throw:</i> Nothing."
++
++ </p>
++ <p>
++
++<b>Option 2:</b>
++
++ </p>
++ <p>
++
++For consistency, replace all occurrences of the empty exception
++specification with a "<i>Throws:</i> Nothing." clause.
++
++ </p>
++
+
+
+
+ <hr>
+-<h3><a name="1215"></a>1215. <tt>list::merge</tt> with unequal allocators</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-09-24 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
++<h3><a name="933"></a>933. Unique_ptr defect</h3>
++<p><b>Section:</b> 20.8.1.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-11-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Bellevue (I think), we passed
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a>,
+-which, among other things, specifies that the behavior of
+-<tt>list::splice</tt> is undefined if the allocators of the two lists
+-being spliced do not compare equal. The same rationale should apply to
+-<tt>list::merge</tt>. The intent of <tt>list::merge</tt> (AFAIK) is to
+-move nodes from one sorted <tt>list</tt> into another sorted
+-<tt>list</tt> without copying the elements. This is possible only if the
+-allocators compare equal.
++If we are supporting stateful deleters, we need an overload for
++<tt>reset</tt> that
++takes a deleter as well.
+ </p>
+
++<blockquote><pre>
++void reset( pointer p, deleter_type d);
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Relative to the August 2009 WP,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>,
+-change 23.3.4.4 [list.ops],
+-paragraphs 22-25 as follows:
++We probably need two overloads to support move-only deleters, and
++this
++sounds uncomfortably like the two constructors I have been ignoring
++for
++now...
+ </p>
+
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
+ <blockquote>
+-<pre>void merge(list&amp;&amp; x);
+-template &lt;class Compare&gt; void merge(list&amp;&amp; x, Compare comp);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Requires</i>: both the list and the argument list shall be sorted
+-according to operator&lt; or comp.
+-</p>
+ <p>
+-<i>Effects</i>: If <tt>(&amp;x == this)</tt> does nothing; otherwise, merges the
+-two sorted ranges <tt>[begin(), end())</tt> and <tt>[x.begin(),
+-x.end())</tt>. The result is a range in which the elements will be
+-sorted in non-decreasing order according to the ordering defined by
+-<tt>comp</tt>; that is, for every iterator <tt>i</tt>, in the range other than the
+-<tt>first</tt>, the condition <tt>comp(*i, *(i - 1)<ins>)</ins></tt> will be
+-<tt>false</tt>.
++Howard comments that we have the functionality via move-assigment.
+ </p>
+ <p>
+-<i>Remarks</i>: Stable. If <tt>(&amp;x != this)</tt> the range <tt>[x.begin(), x.end())</tt> is
+-empty after the merge. <ins>No elements are copied by this operation.
+-The behavior is undefined if <tt>this-&gt;get_allocator() !=
+-x.get_allocator()</tt>.</ins>
++Move to Open.
+ </p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark as NAD Future.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-<i>Complexity</i>: At most <tt>size() + x.size() - 1</tt> applications of <tt>comp</tt>
+-if <tt>(&amp;x != this)</tt>; otherwise, no applications of <tt>comp</tt> are performed. If an
+-exception is thrown other than by a comparison there are no effects.
+ </p>
+-</blockquote>
+-</blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1252"></a>1252. <tt>wbuffer_convert::state_type</tt> inconsistency</h3>
+-<p><b>Section:</b> 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-10-21 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="935"></a>935. clock error handling needs to be specified</h3>
++<p><b>Section:</b> 20.12.7 [time.clock] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-11-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The synopisis for <tt>wbuffer_convert</tt> 22.3.3.2.3 [conversions.buffer]/2 contains
++Each of the three clocks specified in Clocks 20.12.7 [time.clock]
++provides the member function:
+ </p>
+
+-<blockquote><pre>typedef typename Tr::state_type state_type;
++<blockquote><pre>
++static time_point now();
+ </pre></blockquote>
+
+ <p>
+-making <tt>state_type</tt> a synonym for (possibly) some
+-<tt>char_traits&lt;x&gt;::state_type</tt>.
++The semantics specified by Clock requirements 20.12.3 [time.clock.req]
++make no mention of error handling. Thus the function may throw <tt>bad_alloc</tt>
++or an implementation-defined exception (17.6.5.12 [res.on.exception.handling]
++paragraph 4).
+ </p>
+
+ <p>
+-However, in paragraph 9 of the same section, we have
++Some implementations of these functions on POSIX, Windows, and
++presumably on other operating systems, may fail in ways only detectable
++at runtime. Some failures on Windows are due to supporting chipset
++errata and can even occur after successful calls to a clock's <tt>now()</tt>
++function.
+ </p>
+
+-<blockquote><pre>typedef typename Codecvt::state_type state_type;
+-</pre>
+-
+-<blockquote>
+-The type shall be a synonym for <tt>Codecvt::state_type</tt>.
+-</blockquote>
+-</blockquote>
++<p>
++These functions are used in cases where exceptions are not appropriate
++or where the specifics of the exception or cause of error need to be
++available to the user. See
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2828.html">N2828</a>,
++<i>Library Support for hybrid error
++handling (Rev 1)</i>, for more specific discussion of use cases. Thus some change in
++the interface of now is required.
++</p>
+
+ <p>
+-From what I can see, it might be hard to implement
+-<tt>wbuffer_convert</tt> if the types were not both
+-<tt>std::mbstate_t</tt>, but I cannot find a requirement that they must
+-be the same type.
++The proposed resolution has been implemented in the Boost version of the
++chrono library. No problems were encountered.
+ </p>
+
+ <p><i>[
+-Batavia 2010:
++Batavia (2009-05):
+ ]</i></p>
+
+-
++<blockquote>
+ <p>
+-Howard to draft wording, move to Review. Run it by Bill. Need to move this in Madrid.
++We recommend this issue be deferred until the next Committee Draft
++has been issued and the prerequisite paper has been accepted.
+ </p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1253"></a>1253. invalidation of iterators and <tt>emplace</tt> vs. <tt>insert</tt> inconsistence in assoc. containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Boris Dušek <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-In the latest published draft
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>,
+-section 23.2.4 [associative.reqmts], paragraph 8, it is specifies
+-that that <tt>insert</tt> does not invalidate any iterators. As per
+-23.2.1 [container.requirements.general], paragraph 12, this holds
+-true not only for <tt>insert</tt>, but <tt>emplace</tt> as well. This
+-gives the <tt>insert</tt> member a special treatment w.r.t.
+-<tt>emplace</tt> member in 23.2.4 [associative.reqmts], par. 8,
+-since both modify the container. For the sake of consistency, in 23.2.4 [associative.reqmts], par. 8: either reference to
+-<tt>insert</tt> should be removed (i.e. count on 23.2.1 [container.requirements.general], par. 12), or reference to
+-<tt>emplace</tt> be added (i.e. mention all members of assoc. containers
+-that modify it).
++Move to Open.
+ </p>
+-
+-<p><i>[
+-2009-11-18 Chris provided wording.
+-]</i></p>
+-
+-
+-<blockquote>
+-This suggested wording covers both the issue discussed, and a number of other
+-identical issues (namely insert being discussed without emplace). I'm happy to
+-go back and split and introduce a new issue if appropriate, but I think the
+-changes are fairly mechanical and obvious.
+ </blockquote>
+
+ <p><i>[
+-2010-01-23 Daniel Krügler and J. Daniel García updated wording to
+-make the use of <tt>hint</tt> consistent with <tt>insert</tt>.
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
++<blockquote><p>
++Mark as NAD future. Too late to make this change without having already
++accepted the hybrid error handling proposal.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Modify bullet 1 of 23.2.1 [container.requirements.general], p10:
+-</p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-10 Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4)
+-all container types defined in this Clause meet the following additional
+-requirements:
++Accept the proposed wording of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2828.html">N2828</a>,
++<i>Library Support for hybrid error handling (Rev 1)</i>.
+ </p>
+
+-<ul>
+-<li>
+-if an exception is thrown by an <tt>insert()</tt> <ins>or
+-<tt>emplace()</tt></ins> function while inserting a single element, that
+-function has no effects.
+-</li>
+-<li>...</li>
+-</ul>
+-
+ <p>
+-Modify 23.2.4 [associative.reqmts], p4:
++Change <tt>Clock</tt> requirements 20.12.3 [time.clock.req] as indicated:
+ </p>
+
+ <blockquote>
+-4 An associative container supports <i>unique keys</i> if it may contain at most
+-one element for each key. Otherwise, it supports <i>equivalent keys</i>. The
+-<tt>set</tt> and <tt>map</tt> classes support unique keys; the <tt>multiset</tt>
+-and <tt>multimap</tt> classes support equivalent keys. For <tt>multiset</tt> and
+-<tt>multimap</tt>, <tt>insert</tt><ins>, <tt>emplace</tt>,</ins> and
+-<tt>erase</tt> preserve the relative ordering of equivalent elements.
+-</blockquote>
+-
+ <p>
+-Modify Table 96 — Associative container requirements in 23.2.4 [associative.reqmts]:
++-2- In Table 55 <tt>C1</tt> and <tt>C2</tt> denote clock types. <tt>t1</tt> and
++<tt>t2</tt> are values returned by <tt>C1::now()</tt> where the call
++returning <tt>t1</tt> happens before (1.10) the call returning <tt>t2</tt> and
++both of these calls happen before <tt>C1::time_point::max()</tt>.
++<ins><tt>ec</tt> denotes an object of type <tt>error_code</tt>
++(19.5.2.1 [syserr.errcode.overview]).</ins>
+ </p>
+
+-<blockquote>
+ <table border="1">
+-<caption>Table 96 — Associative container requirements (in addition to container)</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
+-<th>Complexity</th>
+-</tr>
+-
++<caption>Table 55 &mdash; Clock requirements</caption>
+ <tr>
+-<td colspan="4"><center>...</center></td>
++<th>Expression</th><th>Return type</th><th>Operational semantics</th>
+ </tr>
+
+ <tr>
+-<td><tt>a_eq.emplace(args)</tt></td>
+-<td><tt>iterator</tt></td>
+-<td>inserts a <tt>T</tt> object <tt>t</tt> constructed with
+-<tt>std::forward&lt;Args&gt;(args)...</tt> and returns the iterator pointing to
+-the newly inserted element. <ins>If a range containing elements equivalent to
+-<tt>t</tt> exists in <tt>a_eq</tt>, <tt>t</tt> is inserted at the end of that
+-range.</ins></td>
+-<td>logarithmic</td>
++<td>...</td>
++<td>...</td>
++<td>...</td>
+ </tr>
+
+ <tr>
+-<td><tt>a.emplace_hint(p, args)</tt></td>
+-<td><tt>iterator</tt></td>
+-<td>equivalent to <tt>a.emplace(std::forward&lt;Args&gt;(args)...)</tt>. Return
+-value is an iterator pointing to the element with the key equivalent to the
+-newly inserted element. <del>The <tt>const_iterator p</tt> is a hint pointing to
+-where the search should start.</del> <ins>The element is inserted as close as
+-possible to the position just prior to <tt>p</tt>.</ins> <del>Implementations
+-are permitted to ignore the hint.</del></td>
+-<td>logarithmic in general, but amortized constant if the element is inserted
+-right <del>after</del> <ins>before</ins> <tt>p</tt></td>
++<td><tt>C1::now()</tt></td>
++<td><tt>C1::time_point</tt></td>
++<td>Returns a <tt>time_point</tt> object representing the current point in time.
++</td>
+ </tr>
+
+ <tr>
+-<td colspan="4"><center>...</center></td>
++<td><tt><ins>C1::now(ec)</ins></tt></td>
++<td><tt><ins>C1::time_point</ins></tt></td>
++<td><ins>Returns a <tt>time_point</tt> object representing the current point in time.</ins>
++</td>
+ </tr>
+-
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Modify 23.2.4 [associative.reqmts], p8:
++Change class <tt>system_clock</tt> 20.12.7.1 [time.clock.system] as indicated:
+ </p>
+
+-<blockquote>
+-8 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
+-the validity of iterators and references to the container, and the
+-<tt>erase</tt> members shall invalidate only iterators and references to the
+-erased elements.
+-</blockquote>
++<blockquote><pre>
++static time_point now(<ins>error_code&amp; ec=throws()</ins>);
++</pre></blockquote>
+
+ <p>
+-Modify 23.2.4.1 [associative.reqmts.except], p2:
++Change class <tt>monotonic_clock</tt> X [time.clock.monotonic] as indicated:
+ </p>
+
+-<blockquote>
+-2 For associative containers, if an exception is thrown by any operation from
+-within an <tt>insert()</tt> <ins> or <tt>emplace()</tt></ins> function inserting
+-a single element, the <del><tt>insert()</tt> function</del> <ins>insertion</ins>
+-has no effect.
+-</blockquote>
++<blockquote><pre>
++static time_point now(<ins>error_code&amp; ec=throws()</ins>);
++</pre></blockquote>
+
+ <p>
+-Modify 23.2.5 [unord.req], p6, p12 and p13:
++Change class <tt>high_resolution_clock</tt> 20.12.7.3 [time.clock.hires] as indicated:
+ </p>
+
+-<blockquote>
+-<p>
+-6 An unordered associative container supports <i>unique keys</i> if it may
+-contain at most one element for each key. Otherwise, it supports <i>equivalent
+-keys</i>. <tt>unordered_set</tt> and <tt>unordered_map</tt> support unique keys.
+-<tt>unordered_multiset</tt> and <tt>unordered_multimap</tt> support equivalent
+-keys. In containers that support equivalent keys, elements with equivalent keys
+-are adjacent to each other. For <tt>unordered_multiset</tt> and
+-<tt>unordered_multimap</tt>, <tt>insert</tt><ins>, <tt>emplace</tt>,</ins> and
+-<tt>erase</tt> preserve the relative ordering of equivalent elements.
+-</p>
++<blockquote><pre>
++static time_point now(<ins>error_code&amp; ec=throws()</ins>);
++</pre></blockquote>
+
+-<p>
+-12 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
+-the validity of references to container elements, but may invalidate all
+-iterators to the container. The erase members shall invalidate only iterators
+-and references to the erased elements.
+-</p>
+
+-<p>
+-13 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
+-the validity of iterators if <tt>(N+n) &lt; z * B</tt>, where <tt>N</tt> is the
+-number of elements in the container prior to the insert operation, <tt>n</tt> is
+-the number of elements inserted, <tt>B</tt> is the container's bucket count, and
+-<tt>z</tt> is the container's maximum load factor.
+-</p>
+-</blockquote>
+
+-<p>
+-Modify 23.2.5.1 [unord.req.except], p2:
+-</p>
+
+-<blockquote>
+-2 For unordered associative containers, if an exception is thrown by any
+-operation other than the container's hash function from within an
+-<tt>insert()</tt> <ins>or <tt>emplace()</tt></ins> function inserting a single
+-element, the <del><tt>insert()</tt></del> <ins>insertion</ins>
+-<del>function</del> has no effect.
+-</blockquote>
+
+
++<hr>
++<h3><a name="936"></a>936. Mutex type overspecified</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-active.html#961">961</a></p>
++<p><b>Discussion:</b></p>
+
+
+
+-<hr>
+-<h3><a name="1279"></a>1279. forbid <tt>[u|bi]nary_function</tt> specialization</h3>
+-<p><b>Section:</b> X [base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-11-30 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#base">issues</a> in [base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-A program should not be allowed to add specialization of class templates
+-<tt>unary_function</tt> and <tt>binary_function</tt>, in force of 17.6.3.2.1 [namespace.std]/1.
+-If a program were allowed to specialize these templates, the library could no
+-longer rely on them to provide the intended typedefs or there might be other
+-undesired interactions.
++30.4.1 [thread.mutex.requirements] describes the requirements for a type to be
++a "Mutex type". A Mutex type can be used as the template argument for
++the <tt>Lock</tt> type that's passed to <tt>condition_variable_any::wait</tt> (although
++<tt>Lock</tt> seems like the wrong name here, since <tt>Lock</tt> is given a different
++formal meaning in 30.4.2 [thread.lock]) and, although the WD doesn't quite say
++so, as the template argument for <tt>lock_guard</tt> and <tt>unique_lock</tt>.
+ </p>
+
+-<p><i>[
+-2010-03-27 Daniel adds:
+-]</i></p>
++<p>
++The requirements for a Mutex type include:
++</p>
++
++<ul>
++<li>
++<tt>m.lock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>void</tt>.
++</li>
++<li>
++<tt>m.try_lock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>bool</tt>.
++</li>
++<li>
++<tt>m.unlock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>void</tt>.
++</li>
++</ul>
+
++<p>
++Also, a Mutex type "shall not be copyable nor movable".
++</p>
+
+-<blockquote>
+-Accepting issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a> would resolve this issue as NAD editorial.
+-</blockquote>
++<p>
++The latter requirement seems completely irrelevant, and the three
++requirements on return types are tighter than they need to be. For
++example, there's no reason that <tt>lock_guard</tt> can't be instantiated with a
++type that's copyable. The rule is, in fact, that <tt>lock_guard</tt>, etc. won't
++try to copy objects of that type. That's a constraint on locks, not on
++mutexes. Similarly, the requirements for <tt>void</tt> return types are
++unnecessary; the rule is, in fact, that <tt>lock_guard</tt>, etc. won't use any
++returned value. And with the return type of <tt>bool</tt>, the requirement should
++be that the return type is convertible to <tt>bool</tt>.
++</p>
+
+ <p><i>[
+-2010-10-24 Daniel adds:
++Summit:
+ ]</i></p>
+
+
+ <blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145.html">n3145</a> would resolve this issue as NAD editorial.
++<p>
++Move to open. Related to conceptualization and should probably be tackled as part of that.
++</p>
++<ul>
++<li>
++The intention is not only to place a constraint on what types such as
++<tt>lock_guard</tt> may do with mutex types, but on what any code, including user
++code, may do with mutex types. Thus the constraints as they are apply to
++the mutex types themselves, not the current users of mutex types in the
++standard.
++</li>
++<li>
++This is a low priority issue; the wording as it is may be overly
++restrictive but this may not be a real issue.
++</li>
++</ul>
+ </blockquote>
+
+ <p><i>[
+-2010 Batavia: Solved by N3198
++Post Summit Anthony adds:
+ ]</i></p>
+
+
++<blockquote>
+ <p>
+-Previous proposed resolution:
+-</p><p>
+-Change paragraph X [base]/1 as follows:
++Section 30.4.1 [thread.mutex.requirements] conflates the
++requirements on a generic Mutex type (including user-supplied mutexes)
++with the requirements placed on the standard-supplied mutex types in an
++attempt to group everything together and save space.
++</p>
++<p>
++When applying concepts to chapter 30, I suggest that the concepts
++<tt>Lockable</tt> and <tt>TimedLockable</tt> embody the requirements for
++*use* of a mutex type as required by
++<tt>unique_lock/lock_guard/condition_variable_any</tt>. These should be
++relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of
++<tt>std::mutex</tt>, <tt>std::timed_mutex</tt>,
++<tt>std::recursive_mutex</tt> and <tt>std::recursive_timed_mutex</tt>,
++and should be rephrased as such.
+ </p>
+-
+-<blockquote>
+-1 The following <del>classes</del> <ins>class templates</ins> are provided to
+-simplify the typedefs of the argument and result types<del>:</del><ins>. A
+-program shall not declare specializations of these templates.</ins>
+ </blockquote>
+
+-<p></p>
+-
+
+
+ <p><b>Proposed resolution:</b></p>
+-Addressed by paper <a href="http://wiki.dinkumware.com/twiki/pub/Wg21batavia/LibraryWorkingGroup/D3198.html">D3198</a>.
++<p>
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1297"></a>1297. <tt>unique_ptr</tt>'s relational operator functions should induce a total order</h3>
+-<p><b>Section:</b> 20.9.9.4 [unique.ptr.special] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-23 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="961"></a>961. Various threading bugs #11</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-active.html#936">936</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The comparison functions of <tt>unique_ptr</tt> currently directly delegate to
+-the underlying comparison functions of <tt>unique_ptr&lt;T, D&gt;::pointer</tt>.
+-This is disadvantageous, because this would not guarantee to induce a total
+-ordering for native pointers and it is hard to define a total order for mixed
+-types anyway.
+-</p>
+-<p>
+-The currently suggested resolution for <tt>shared_ptr</tt> comparison as of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a> uses a normalization strategy: They perform the comparison on
+-the <em>composite pointer type</em> (5.9 [expr.rel]). This is not
+-exactly possible for <tt>unique_ptr</tt> in the presence of user-defined
+-pointer-like types but the existing definition of <tt>std::duration</tt>
+-comparison as of 20.11.3.6 [time.duration.comparisons] via
+-<tt>common_type</tt> of both argument types demonstrates a solution of this
+-problem. The approach can be seen as the general way to define a <em>composite
+-pointer type</em> and this is the approach which is used for here suggested
+-wording change.
+-</p>
+-<p>
+-For consistency reasons I would have preferred the same normalization strategy
+-for <tt>==</tt> and <tt>!=</tt>, but Howard convinced me not to do so (now).
++30.4.1 [thread.mutex.requirements] describes required member
++functions of mutex types, and requires that they throw exceptions under
++certain circumstances. This is overspecified. User-defined types can
++abort on such errors without affecting the operation of templates
++supplied by standard-library.
+ </p>
+
+ <p><i>[
+-2010-11-03 Daniel comments and adjustes the currently proposed wording changes:
++Summit:
+ ]</i></p>
+
++<blockquote><p>
++Move to open. Related to conceptualization and should probably be
++tackled as part of that.
++</p></blockquote>
+
+-<p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a> is remotely related. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401_extra_bullet">Bullet A</a> of its proposed resolution
+-provides an alternative solution for issue discussed here and addresses NB comment GB-99.
+-Additionally I updated the below suggested wording in regard to the following:
+-It is an unncessary requirement that the below defined effective composite pointer-like
+-type <tt>CT</tt> satisfies the <tt>LessThanComparable</tt> requirements. All what is
+-needed is, that the function object type <tt>less&lt;CT&gt;</tt> induces a strict
+-weak ordering on the pointer values.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p>
+-Change 20.9.9.4 [unique.ptr.special]/4-7 as indicated: <i>[The implicit
+-requirements and remarks imposed on the last three operators are the same as for
+-the first one due to the normative "equivalent to" usage within a Requires
+-element, see 17.5.1.4 [structure.specifications]/4. The effects of this
+-change are that all real pointers wrapped in a <tt>unique_ptr</tt> will order
+-like <tt>shared_ptr</tt> does.]</i>
+-</p>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+-<blockquote><pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
+ <blockquote>
+ <p>
+-<ins>? <i>Requires:</i> Let <tt>CT</tt> be <tt>common_type&lt;unique_ptr&lt;T1,
+-D1&gt;::pointer, unique_ptr&lt;T2, D2&gt;::pointer&gt;::type</tt>. Then
+-the specialization <tt>less&lt;CT&gt;</tt> shall be a function object type ([function.objects])
+-that induces a strict weak ordering ([alg.sorting]) on the pointer values.</ins>
++Would be OK to leave it as is for time constraints, could loosen later.
+ </p>
+
+ <p>
+-4 <i>Returns:</i> <tt><ins>less&lt;CT&gt;()(x.get(), y.get())</ins><del>x.get()
+-&lt; y.get()</del></tt>.
++Mark as NAD Future.
+ </p>
++</blockquote>
+
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-<ins>? <i>Remarks:</i> If <tt>unique_ptr&lt;T1, D1&gt;::pointer</tt> is not
+-implicitly convertible to <tt>CT</tt> or <tt>unique_ptr&lt;T2,
+-D2&gt;::pointer</tt> is not implicitly convertible to <tt>CT</tt>, the program
+-is ill-formed.</ins>
+ </p>
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
+-<blockquote>
+-5 <ins><i>Effects:</i> Equivalent to <tt>return !(y &lt; x)</tt></ins>
+-<del><i>Returns:</i> <tt>x.get() &lt;= y.get()</tt></del>.
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
+-<blockquote>
+-6 <ins><i>Effects:</i> Equivalent to <tt>return (y &lt; x)</tt></ins>
+-<del><i>Returns:</i> <tt>x.get() &gt; y.get()</tt></del>.
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
++<hr>
++<h3><a name="1025"></a>1025. The library should provide more specializations for <tt>std::hash</tt></h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 208 [CD1]</b></p>
++
++<p>
++<tt>std::hash</tt> should be implemented for much more of the standard
++library. In particular for <tt>pair</tt>, <tt>tuple</tt> and all the
++standard containers.
++</p>
+
+-<blockquote>
+-7 <ins><i>Effects:</i> Equivalent to <tt>return !(x &lt; y)</tt></ins>
+-<del><i>Returns:</i> <tt>x.get() &gt;= y.get()</tt></del>.
+-</blockquote>
+-</blockquote>
+
+
++<p><b>Proposed resolution:</b></p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1310"></a>1310. <tt>forward_list splice_after</tt> from lvalues</h3>
+-<p><b>Section:</b> 23.3.3.5 [forwardlist.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-02-05 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
++<h3><a name="1031"></a>1031. Need <tt>shared_ptr</tt> conversion to a <tt>unique_ptr</tt></h3>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
++
++<p><b>Addresses US 78 [CD1]</b></p>
++
+ <p>
+-We've moved <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a> to Tentatively Ready and I'm fine with that.
++There is presently no way to convert directly from a <tt>shared_ptr</tt> to a
++<tt>unique_ptr</tt>. Add an interface that performs the conversion.
+ </p>
+
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++We look forward to a paper on this topic. We recommend no action until a
++paper is available. We believe that the shared pointer must use the default
++deleter for the conversion to succeed.
++</p></blockquote>
++
++<p><i>[
++Peter Dimov adds:
++]</i></p>
++
++
++<blockquote><p>
++This is basically a request for <tt>shared_ptr&lt;&gt;::release</tt> in
++disguise, with all the associated problems. Not a good idea.
++</p></blockquote>
++
++<p><i>[
++2009-07 post-Frankfurt:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a> adds lvalue-references to the <tt>splice</tt> signatures for <tt>list</tt>. So now
+-<tt>list</tt> can <tt>splice</tt> from lvalue and rvalue lists (which was the intent of the
+-original move papers btw). During the discussion of this issue it was mentioned
+-that if we want to give the same treatment to <tt>forward_list</tt>, that should be a
+-separate issue.
++The rationale for the omission of a release() member function from shared_ptr is given in:
++<a href="http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm">http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm</a>
+ </p>
+-
+ <p>
+-This is that separate issue.
++The implementation of such a member is non-trivial (and maybe
++impossible), because it would need to account for the deleter.
+ </p>
++</blockquote>
++
++<p><i>[
++2009-07-26 Howard sets to Tentatively NAD Future.
++]</i></p>
++
+
++<blockquote>
+ <p>
+-Consider the following case where you want to splice elements from one place in
+-a <tt>forward_list</tt> to another. Currently this must be coded like so:
++I took an online poll and got 3 votes for NAD and 3 for NAD Future. Personally
++I prefer NAD Future as this does refer to an extension that could conceivably be
++considered beyond C++0X.
+ </p>
+
+-<blockquote><pre>fl.splice_after(to_here, std::move(fl), from1, from2);
+-</pre></blockquote>
+-
+ <p>
+-This looks pretty shocking to me. I would expect to be able to code instead:
++However such an extension would need to solve a couple of problems:
+ </p>
+
+-<blockquote><pre>fl.splice_after(to_here, fl, from1, from2);
+-</pre></blockquote>
++<ol>
++<li>What is the interface for such a conversion when the <tt>shared_ptr</tt> does
++not have unique ownership? Throw an exception? Create a null <tt>unique_ptr</tt>?
++Undefined behavior?
++</li>
+
++<li>
+ <p>
+-but we currently don't allow it.
++How does one handle custom deleters given to the <tt>shared_ptr</tt> constructor?
+ </p>
+-
+ <p>
+-When I say <tt>move(fl)</tt>, I consider that as saying that I don't care about
+-the value of <tt>fl</tt> any more (until I assign it a new value). But in the
+-above example, this simply isn't true. I do care about the value of <tt>fl</tt>
+-after the move, and I'm not assigning it a new value. I'm merely permuting its
+-current value.
++I do not believe it is possible to implement a general answer to this question.
++The <tt>shared_ptr</tt> deleter is a run time (or construction time) characteristic.
++The <tt>unique_ptr</tt> deleter is a compile time characteristic. In general one
++can not know to what type of <tt>unqiue_ptr</tt> you are converting to.
+ </p>
+-
+ <p>
+-I propose adding <tt>forward_list&amp;</tt> overloads to the 3
+-<tt>splice_after</tt> members. For consistency's sake (principal of least
+-surprise) I'm also proposing to overload <tt>merge</tt> this way as well.
++One answer is for the user of the conversion to specify the deleter type and perhaps
++throw an exception if the specification turns out to be incorrect.
+ </p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Add to the synopsis of 23.3.3 [forwardlist]:
++Another answer is for the conversion to only be valid when the underlying deleter
++is <tt>default_delete</tt>. We would probalby need to specify that this is indeed the
++underlying deleter of a <tt>shared_ptr</tt> when a custom deleter is not given in
++the constructor.
+ </p>
+-
+-<blockquote><pre>template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
+-class forward_list {
+-public:
+- ...
+- <ins>void splice_after(const_iterator p, forward_list&amp; x);</ins>
+- void splice_after(const_iterator p, forward_list&amp;&amp; x);
+- <ins>void splice_after(const_iterator p, forward_list&amp; x, const_iterator i);</ins>
+- void splice_after(const_iterator p, forward_list&amp;&amp; x, const_iterator i);
+- <ins>void splice_after(const_iterator p, forward_list&amp; x,
+- const_iterator first, const_iterator last);</ins>
+- void splice_after(const_iterator p, forward_list&amp;&amp; x,
+- const_iterator first, const_iterator last);
+- ...
+- <ins>void merge(forward_list&amp; x);</ins>
+- void merge(forward_list&amp;&amp; x);
+- <ins>template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp);</ins>
+- template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp);
+- ...
+-};
+-</pre></blockquote>
++</li>
++</ol>
+
+ <p>
+-Add to the signatures of 23.3.3.5 [forwardlist.ops]:
++At any rate, there are non-trivial design issues which would need to be implemented
++and tested in the field for usability prior to standardization.
+ </p>
+-
+-<blockquote>
+-<pre><ins>void splice_after(const_iterator p, forward_list&amp; x);</ins>
+-void splice_after(const_iterator p, forward_list&amp;&amp; x);
+-</pre>
+-<blockquote>
+-<p>1 ...</p>
+ </blockquote>
+
+-<pre><ins>void splice_after(const_iterator p, forward_list&amp; x, const_iterator i);</ins>
+-void splice_after(const_iterator p, forward_list&amp;&amp; x, const_iterator i);
+-</pre>
+-<blockquote>
+-<p>5 ...</p>
+-</blockquote>
++<p><i>[
++2009 Santa Cruz:
++]</i></p>
+
+-<pre><ins>void splice_after(const_iterator p, forward_list&amp; x,
+- const_iterator first, const_iterator last);</ins>
+-void splice_after(const_iterator p, forward_list&amp;&amp; x,
+- const_iterator first, const_iterator last);
+-</pre>
+-<blockquote>
+-<p>9 ...</p>
+-</blockquote>
+
+-<pre><ins>void merge(forward_list&amp; x);</ins>
+-void merge(forward_list&amp;&amp; x);
+-<ins>template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp);</ins>
+-template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp);
+-</pre>
+-<blockquote>
+-<p>18 ...</p>
+-</blockquote>
++<blockquote><p>
++Moved to NAD Future.
++</p></blockquote>
+
+-</blockquote>
+
+
++<p><b>Proposed resolution:</b></p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1318"></a>1318. N2982 removes previous allocator capabilities</h3>
+-<p><b>Section:</b> 20.9.4.1 [allocator.traits.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2010-02-11 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a></p>
++<h3><a name="1041"></a>1041. Add associative/unordered container functions that allow to extract elements</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-87</b></p>
+-<p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
+-says that containers should have a nested typedef that defines their
+-<tt>reference_type</tt> as <tt>value_type&amp;</tt>; the previous
+-standard deferred to the allocator to define its
+-<tt>reference_type</tt>, and containers simply passed the allocator's
+-typedef on. This change is a mistake. Allocators should define both a
+-<tt>pointer</tt> type and a <tt>reference</tt> type. That's essential
+-for their original purpose, which was to make different memory models
+-transparent. If an allocator defines a <tt>pointer</tt> type that isn't
+-compatible with a normal pointer it also has to define a corresponding
+-<tt>reference</tt> type. For example (and please forgive a Windows-ism),
+-if an allocator's pointer is <tt>T __far*</tt>, then it's
+-<tt>reference</tt> has to be <tt>T __far&amp;</tt>. Otherwise everything
+-crashes (under the hood, references are pointers and have to have the
+-same memory access mechanics). Extensions such as this for more general
+-memory models were explicitly encouraged by C++03, and the allocator's
+-<tt>pointer</tt> and <tt>reference</tt> typedefs were the hooks for such
+-extensions. Removing the allocator's <tt>reference</tt> and
+-<tt>const_reference</tt> typedefs makes those extensions unimplementable
+-and breaks existing implementations that rely on those hooks.
+-</p>
+-
+-<p><i>[
+-2010-02-25 Alisdair adds:
+-]</i></p>
+-
+
+-<blockquote>
+-<p>
+-<tt>vector&lt;bool&gt;::reference</tt> is a nested class, and not a typedef. It
+-should be removed from the list of containers when this change is made.
+-</p>
++<p><b>Addresses UK 239 [CD1]</b></p>
+
+ <p>
+-In general, I am unfcomfortable placing this reference requirement on each
+-container, as I would prefer to require:
++It is not possible to take a move-only key out of an unordered
++container, such as (<tt>multi</tt>)<tt>set</tt> or
++(<tt>multi</tt>)<tt>map</tt>, or the new unordered containers.
+ </p>
+
+-<blockquote><pre>is_same&lt;Container::reference, Container::iterator::reference&gt;
+-</pre></blockquote>
+-
+ <p>
+-This distinction is important, if we intend to support proxy iterators. The
+-iterator paper in the pre-Pittsburgh mailing
+-(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3046.html">N3046</a>)
+-does <em>not</em> make this proposal, but organises clause 24 in such a way this
+-will be much easier to specify.
++Add below <tt>a.erase(q)</tt>, <tt>a.extract(q)</tt>, with the following notation:
+ </p>
+-
+ <p>
+-The changes to clause 20 remain important for all the reasons Pete highlights.
++<tt>a.extract(q)></tt>, Return type <tt>pair&lt;key, iterator&gt;</tt>
++Extracts the element pointed to by <tt>q</tt> and erases it from the
++<tt>set</tt>. Returns a <tt>pair</tt> containing the value pointed to by
++<tt>q</tt> and an <tt>iterator</tt> pointing to the element immediately
++following <tt>q</tt> prior to the element being erased. If no such
++element exists,returns <tt>a.end()</tt>.
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2010 Batavia
++Summit:
+ ]</i></p>
+
+
+-<p>
+-Removed <tt>vector</tt> from list of templates that should be adjusted.
+-</p>
++<blockquote><p>
++We look forward to a paper on this topic. We recommend no action until a
++paper is available. The paper would need to address exception safety.
++</p></blockquote>
+
++<p><i>[
++Post Summit Alisdair adds:
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Add the following two rows to Table 40, Allocator requirements:
+-</p>
+
+-<blockquote>
+-<table border="1">
+-<caption>Table 40 — Allocator requirements</caption>
+-<tbody><tr>
+-<th>
+-Expression
+-</th>
++<blockquote><p>
++Would <tt>value_type</tt> be a better return type than <tt>key_type</tt>?
++</p></blockquote>
+
+-<th>
+-Return type
+-</th>
++<p><i>[
++2009-07 post-Frankfurt:
++]</i></p>
+
+-<th>
+-Assertion/note<br>pre-/post-condition
+-</th>
+
+-<th>
+-Default
+-</th>
++<blockquote><p>
++Leave Open. Alisdair to contact Chris Jefferson about this.
++</p></blockquote>
+
+-</tr>
++<p><i>[
++2009-09-20 Howard adds:
++]</i></p>
+
+-<tr>
+-<td><ins><tt>X::reference</tt></ins></td>
+
+-<td><tt></tt></td>
++<blockquote><p>
++See the 2009-09-19 comment of <a href="lwg-active.html#839">839</a> for an API which
++accomplishes this functionality and also addresses several other use
++cases which this proposal does not.
++</p></blockquote>
+
+-<td><tt></tt></td>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+-<td><ins><tt>T&amp;</tt></ins></td>
+-</tr>
+
+-<tr>
+-<td><ins><tt>X::const_reference</tt></ins></td>
++<blockquote><p>
++Mark as NAD Future. No consensus to make the change at this time.
++</p></blockquote>
+
+-<td><tt></tt></td>
+
+-<td><tt></tt></td>
+
+-<td><ins><tt>const T&amp;</tt></ins></td>
+-</tr>
++<p><b>Proposed resolution:</b></p>
++<p>
++In 23.2.4 [associative.reqmts] Table 85, add:
++</p>
+
+-</tbody></table>
++<blockquote>
++<table border="1">
++<caption>Table 85 -- Associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++<tr>
++<td><tt>a.erase(q)</tt></td>
++<td>...</td>
++<td>...</td>
++<td>...</td>
++</tr>
++<tr>
++<td><ins><tt>a.extract(q)</tt></ins></td>
++<td><ins><tt>pair&lt;key_type, iterator&gt;</tt></ins></td>
++<td><ins>Extracts the element pointed to by <tt>q</tt> and erases it from the <tt>set</tt>.
++Returns a <tt>pair</tt> containing the value pointed to by <tt>q</tt> and an <tt>iterator</tt>
++pointing to the element immediately following <tt>q</tt> prior to the element being
++erased. If no such element
++exists, returns <tt>a.end()</tt>.</ins></td>
++<td><ins>amortized constant</ins></td>
++</tr>
++</table>
+ </blockquote>
+
+-</li>
+-
+-<li>
+ <p>
+-2. Change the following two rows in Table 40:
++In 23.2.5 [unord.req] Table 87, add:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 40 — Allocator requirements</caption>
+-<tbody><tr>
+-<th>
+-Expression
+-</th>
++<caption>Table 87 -- Unordered associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++<tr>
++<td><tt>a.erase(q)</tt></td>
++<td>...</td>
++<td>...</td>
++<td>...</td>
++</tr>
++<tr>
++<td><ins><tt>a.extract(q)</tt></ins></td>
++<td><ins><tt>pair&lt;key_type, iterator&gt;</tt></ins></td>
++<td><ins>Extracts the element pointed to by <tt>q</tt> and erases it from the <tt>set</tt>.
++Returns a <tt>pair</tt> containing the value pointed to by <tt>q</tt> and an <tt>iterator</tt>
++pointing to the element immediately following <tt>q</tt> prior to the element being
++erased. If no such element
++exists, returns <tt>a.end()</tt>.</ins></td>
++<td><ins>amortized constant</ins></td>
++</tr>
++</table>
++</blockquote>
+
+-<th>
+-Return type
+-</th>
+
+-<th>
+-Assertion/note<br>pre-/post-condition
+-</th>
+
+-<th>
+-Default
+-</th>
+
+-</tr>
+
+-<tr>
+-<td><ins><tt>*p</tt></ins></td>
++<hr>
++<h3><a name="1052"></a>1052. <tt>reverse_iterator::operator-&gt;</tt> should also support smart pointers</h3>
++<p><b>Section:</b> 24.5.1.3.5 [reverse.iter.opref] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iter.opref">issues</a> in [reverse.iter.opref].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<td><tt><del>T&amp;</del> <ins>X::reference</ins></tt></td>
++<p><b>Addresses UK 281 [CD1]</b></p>
+
+-<td><tt></tt></td>
++<p>
++The current specification for return value for <tt>reverse_iterator::operator-&gt;</tt>
++will always be a true pointer type, but <tt>reverse_iterator</tt> supports proxy
++iterators where the pointer type may be some kind of 'smart pointer'.
++</p>
+
+-<td></td>
+-</tr>
++<p><i>[
++Summit:
++]</i></p>
+
+-<tr>
+-<td><ins><tt>*q</tt></ins></td>
+
+-<td><tt><del>const T&amp;</del> <ins>X::const_reference</ins></tt></td>
++<blockquote>
++<p>
++<tt>move_iterator</tt> avoids this problem by returning a value of the wrapped
++Iterator type.
++study group formed to come up with a suggested resolution.
++</p>
++<p>
++<tt>move_iterator</tt> solution shown in proposed wording.
++</p>
++</blockquote>
++
++<p><i>[
++2009-07 post-Frankfurt:
++]</i></p>
+
+-<td><tt></tt></td>
+
+-<td></td>
+-</tr>
++<blockquote><p>
++Howard to deconceptize. Move to Review after that happens.
++</p></blockquote>
+
+-</tbody></table>
+-</blockquote>
++<p><i>[
++2009-08-01 Howard deconceptized:
++]</i></p>
+
+-</li>
+
+-<li>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-Add the following typedef declarations to allocator_traits 20.9.4 [allocator.traits]:
++We can't think of any reason we can't just define reverse
++iterator's pointer types to be the same as the underlying iterator's
++pointer type, and get it by calling the right arrow directly.
+ </p>
+-
+-<blockquote><pre>template &lt;class Alloc&gt; struct allocator_traits {
+- ...
+- <ins>typedef <i>see below</i> reference;</ins>
+- <ins>typedef <i>see below</i> const_reference;</ins>
++<p>
++Here is the proposed wording that was replaced:
++</p>
++<blockquote><pre>
++template &lt;class Iterator&gt;
++class reverse_iterator {
+ ...
++ typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
+ </pre></blockquote>
+-</li>
+
+-<li>
+ <p>
+-Add the following descriptions to 20.9.4.1 [allocator.traits.types]:
++Change 24.5.1.3.5 [reverse.iter.opref]:
+ </p>
+
+-<blockquote>
+-<pre>typedef see below reference;</pre>
+-<blockquote>
+-<i>Type:</i> <tt>Alloc::reference</tt> if such a type exists; otherwise,
+-<tt>value_type&amp;</tt>.
++<blockquote><pre>
++pointer operator-&gt;() const;
++</pre>
++<blockquote><p>
++<i>Returns:</i>
++</p><blockquote><pre>
++<del>&amp;(operator*());</del>
++<ins>this-&gt;tmp = current;</ins>
++<ins>--this-&gt;tmp;</ins>
++<ins>return this-&gt;tmp;</ins>
++</pre></blockquote>
+ </blockquote>
+-
+-<pre>typedef see below const reference;</pre>
+-<blockquote>
+-<i>Type:</i> <tt>Alloc::const_reference</tt> if such a type exists; otherwise,
+-<tt>const value_type&amp;</tt>.
+ </blockquote>
++
+ </blockquote>
++
++<p><i>[
++2010-03-03 Daniel opens:
++]</i></p>
++
++
++<blockquote>
++<ol>
++
++<li>
++There is a minor problem with the exposition-only declaration of the private
++member <tt>deref_tmp</tt> which is modified in a const member function (and the
++same problem occurs in the specification of <tt>operator*</tt>). The fix is to
++make it a mutable member.
+ </li>
+
+ <li>
+ <p>
+-Add the following typdef declarations to scoped_allocator_adaptor 20.10 [allocator.adaptor]:
++The more severe problem is that the resolution for some reasons
++does not explain in the rationale why it was decided to differ from
++the suggested fix (using <tt>deref_tmp</tt> instead of <tt>tmp</tt>) in the
++[ 2009-10 Santa Cruz] comment:
+ </p>
+
+-<blockquote><pre>template &lt;class OuterAlloc, class... InnerAllocs&gt;
+-class scoped_allocator_adaptor : public OuterAlloc {
+- ...
+- <ins>typedef typename OuterTraits::reference reference;</ins>
+- <ins>typedef typename OuterTraits::const_reference const_reference;</ins>
+- ...
++<blockquote><pre>
++this-&gt;deref_tmp = current;
++--this-&gt;deref_tmp;
++return this-&gt;deref_tmp;
+ </pre></blockquote>
+-</li>
+
+-<li>
+ <p>
+-Change the nested typedefs reference and
+-const_reference to:
++combined with the change of
+ </p>
+
+-<blockquote><pre>typedef typename allocator_traits&lt;Allocator&gt;::reference reference;
+-typedef typename allocator_traits&lt;Allocator&gt;::const_reference const_reference;
++<blockquote><pre>
++typedef typename iterator_traits&lt;Iterator&gt;::pointer pointer;
+ </pre></blockquote>
+
+ <p>
+-for each of the following class templates:
++to
+ </p>
+
+-<blockquote>
+-<tt>deque</tt> 23.3.2 [deque]<br>
+-<tt>forward_list</tt> 23.3.3 [forwardlist]<br>
+-<tt>list</tt> 23.3.4 [list]<br>
+-<tt>queue</tt> 23.5.1.1 [queue.defn]<br>
+-<tt>priority_queue</tt> 23.5.2 [priority.queue]<br>
+-<tt>stack</tt> 23.5.3.1 [stack.defn]<br>
+-<tt>vector&lt;bool&gt;</tt> 23.4.2 [vector.bool]<br>
+-<tt>map</tt> 23.6.1 [map]<br>
+-<tt>multimap</tt> 23.6.2 [multimap]<br>
+-<tt>set</tt> 23.6.3 [set]<br>
+-<tt>multiset</tt> 23.6.4 [multiset]<br>
+-<tt>unordered_map</tt> 23.7.1 [unord.map]<br>
+-<tt>unordered_multimap</tt> 23.7.2 [unord.multimap]<br>
+-<tt>unordered_set</tt> 23.7.3 [unord.set]<br>
+-<tt>unordered_multiset</tt> 23.7.4 [unord.multiset]<br>
+-<tt>basic_string</tt> 21.4 [basic.string]<br>
+-<tt>match_results</tt> 28.10 [re.results]
+-</blockquote>
+-</li>
+-
+-</ol>
+-
++<blockquote><pre>
++typedef Iterator pointer;
++</pre></blockquote>
+
++<p>
++The problem of the agreed on wording is that the following rather
++typical example, that compiled with the wording before 1052 had
++been applied, won't compile anymore:
++</p>
+
++<blockquote><pre>
++#include &lt;iterator&gt;
++#include &lt;utility&gt;
+
++int main() {
++ typedef std::pair&lt;int, double&gt; P;
++ P op;
++ std::reverse_iterator&lt;P*&gt; ri(&amp;op + 1);
++ ri-&gt;first; // Error
++}
++</pre></blockquote>
+
+-<hr>
+-<h3><a name="1320"></a>1320. Header for <tt>iter_swap</tt></h3>
+-<p><b>Section:</b> 24.3 [iterator.synopsis] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">Tentatively NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-The <tt>iter_swap</tt> function template appears in the
+-<tt>&lt;algorithm&gt;</tt> header, yet its main use is in building further
+-algorithms, not calling existing ones. The main clients are implementers of data
+-structures and their iterators, so it seems most appropriate to place the
+-template in the <tt>&lt;iterator&gt;</tt> header instead.
++Comeau online returns (if a correspondingly changed
++<tt>reverse_iterator</tt> is used):
+ </p>
+
+-<p>
+-Note that this is not an issue for implementers of the standard library, as they
+-rarely use the standard headers directly, designing a more fine-grained set of
+-headers for their own internal use. This option is not available to customers
+-of the standard library.
+-</p>
++<blockquote><pre>
++"error: expression must have class type
++ return deref_tmp.operator-&gt;();
++ ^
++ detected during instantiation of "Iterator
++ reverse_iterator&lt;Iterator&gt;::operator-&gt;() const [with
++ Iterator=std::pair&lt;int, double&gt; *]""
++</pre></blockquote>
+
+ <p>
+-Note that we cannot remove <tt>iter_swap</tt> from <tt>&lt;algorithm&gt;</tt>
+-without breaking code, but there is no reason we cannot offer the same
+-declaration via two standard headers. Alternatively, require
+-<tt>&lt;algorithm&gt;</tt> to <tt>#include &lt;iterator&gt;</tt>, but
+-introducing the dependency on the iterator adaptors seems un-necessary.
++Thus the change will break valid, existing code based
++on <tt>std::reverse_iterator</tt>.
+ </p>
+
+-<p><i>[
+-]</i></p>
++</li>
+
++</ol>
+
+ <p>
+-Discussed possibly moving to <tt>&lt;utility&gt;</tt> but don't like that. Some not seeing this
+-as a defect, and want to keep it in <tt>&lt;algorithm&gt;</tt>. No one seems to feel strongly
+-about moving to <tt>&lt;iterator&gt;</tt>.
++IMO the suggestion proposed in the comment is a necessary fix, which harmonizes
++with the similar specification of <tt>std::move_iterator</tt> and properly
++reflects the recursive nature of the evaluation of <tt>operator-&gt;</tt>
++overloads.
+ </p>
+
++<p>
++Suggested resolution:
++</p>
+
+-<p><b>Proposed resolution:</b></p>
++<ol>
+
++<li>
+ <p>
+-Add the declaration of <tt>iter_swap</tt> to the <tt>&lt;iterator&gt;</tt>
+-header synopsis (24.3 [iterator.synopsis]), with a note that it is
+-documented in clause 25 [algorithms].
++In the class template <tt>reverse_iterator</tt> synopsis of 24.5.1.1 [reverse.iterator]
++change as indicated:
+ </p>
+
+-<blockquote><pre>...
+-template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
++<blockquote><pre>
++namespace std {
++template &lt;class Iterator&gt;
++class reverse_iterator : public
++ iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
++ typename iterator_traits&lt;Iterator&gt;::value_type,
++ typename iterator_traits&lt;Iterator&gt;::difference_type,
++ <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del>,
++ typename iterator_traits&lt;Iterator&gt;::reference&gt; {
++public:
++ [..]
++ typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
++ [..]
++protected:
++ Iterator current;
++private:
++ <ins>mutable</ins> Iterator deref_tmp; // exposition only
++};
++</pre></blockquote>
++</li>
+
+-<ins><i>// documented in 25 [algorithms]</i>
+-template&lt;class ForwardIterator1, class ForwardIterator2&gt;
+- void iter_swap(ForwardIterator1 a, ForwardIterator2 b);</ins>
++<li>
++Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated:
++
++<blockquote><pre>
++pointer operator-&gt;() const;
++</pre>
++
++<blockquote><p>
++1 <i><del>Returns</del> <ins>Effects</ins>:</i> <del><tt>&amp;(operator*())</tt>.</del>
++</p><blockquote><pre>
++<ins>deref_tmp = current;</ins>
++<ins>--deref_tmp;</ins>
++<ins>return deref_tmp;</ins>
+ </pre></blockquote>
++</blockquote>
++</blockquote>
+
++</li>
+
++</ol>
+
++</blockquote>
+
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
+
+
+-<hr>
+-<h3><a name="1330"></a>1330. Move container requirements into requirements tables</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Deferred">Deferred</a>
+- <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-03-10 <b>Last modified:</b> 2010-11-15</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Deferred">Deferred</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Abstract:
+-</p>
++<blockquote>
+ <p>
+-In general, it seems that in a couple of places container behavior is
+-not described in requirement tables although it is a general behavior.
++We prefer to make to use a local variable instead of <tt>deref_tmp</tt> within
++<tt>operator-&gt;()</tt>. And although this means that the <tt>mutable</tt>
++change is no longer needed, we prefer to keep it because it is needed for
++<tt>operator*()</tt> anyway.
+ </p>
+
+ <p>
+-History:
++Here is the proposed wording that was replaced:
+ </p>
+
++<blockquote class="note">
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a> added move semantics to unordered containers.
+-For the added insert functions the Editor requested to put their
+-semantic description into a requirements table rather than describing
+-them for each container individually. The text however was taken from
+-the associative containers, where we also have the semantics for each
+-container described. Also, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a> is to some extend
+-requesting a clarification of the requirement tables and it turned out
+-that in other places we have the same problem (e.g. we have no general
+-requirement for type pointer and const_pointer although each container
+-has them with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>).
++Change 24.5.1.3.5 [reverse.iter.opref]:
+ </p>
+
+-<p>
+-From my personal list of functions in requirement tables
+-and containers, the following types/functions are missing in
+-requirement tables:
+-</p>
++<blockquote><pre>
++pointer operator-&gt;() const;
++</pre>
+
+-<ul>
+-<li>
+-<tt>pointer</tt>, <tt>const_pointer</tt> in Table 91 (container requirements)
+-</li>
+-<li>
+-<p>
+-all copy constructors, copy constructors with allocator,
+- assignment operators, and insert operators
+- with move semantics for associative and unordered containers
+-</p>
+-<blockquote><pre>ContType c1(c2&amp;&amp;)
+-ContType c1(c2&amp;&amp;,alloc)
+-c1 = c2&amp;&amp;
+-c.insert(val&amp;&amp;)
+-c.insert(pos,val&amp;&amp;)
++<blockquote><p>
++<i>Returns:</i>
++</p><blockquote><pre>
++<del>&amp;(operator*());</del>
++<ins>deref_tmp = current;
++--deref_tmp;
++return deref_tmp::operator-&gt;();</ins>
+ </pre></blockquote>
+-</li>
+-</ul>
+
+-<p>
+-As a special case, we lack the following requirements for all sequence
+-containers BUT array (so special wording or a new container category is
+-required):
+-</p>
++</blockquote>
++</blockquote>
+
+-<ul>
+-<li>
++
++</blockquote>
++</blockquote>
++
++<p><i>[
++2010-03-10 Howard adds:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-constructor with only a size argument
++Here are three tests that the current proposed wording passes, and no
++other solution I've seen passes all three:
+ </p>
+-<blockquote><pre>ContType c(num)
+-</pre></blockquote>
+-</li>
++
++<ol>
+ <li>
+ <p>
+-copy constructor with allocator and move semantics
++Proxy pointer support:
+ </p>
+-<blockquote><pre>ContType c1(c2&amp;&amp;,alloc)
++<blockquote><pre>
++#include &lt;iterator&gt;
++#include &lt;cassert&gt;
++
++struct X { int m; };
++
++X x;
++
++struct IterX {
++ typedef std::bidirectional_iterator_tag iterator_category;
++ typedef X&amp; reference;
++ struct pointer
++ {
++ pointer(X&amp; v) : value(v) {}
++ X&amp; value;
++ X* operator-&gt;() const {return &amp;value;}
++ };
++ typedef std::ptrdiff_t difference_type;
++ typedef X value_type;
++ // additional iterator requirements not important for this issue
++
++ reference operator*() const { return x; }
++ pointer operator-&gt;() const { return pointer(x); }
++ IterX&amp; operator--() {return *this;}
++
++};
++
++int main()
++{
++ std::reverse_iterator&lt;IterX&gt; ix;
++ assert(&amp;ix-&gt;m == &amp;(*ix).m);
++}
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+-all constructors that insert multiple elements with additional allocator
++Raw pointer support:
+ </p>
+-<blockquote><pre>ContType c(num, val,alloc)
+-ContType c(beg, end,alloc)
+-ContType c(initlist,alloc)
++<blockquote><pre>
++#include &lt;iterator&gt;
++#include &lt;utility&gt;
++
++int main() {
++ typedef std::pair&lt;int, double&gt; P;
++ P op;
++ std::reverse_iterator&lt;P*&gt; ri(&amp;op + 1);
++ ri-&gt;first; // Error
++}
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+-all resize functiuons:
+-</p>
+-<blockquote><pre>c.resize(num)
+-c.resize(num,val)
+-</pre></blockquote>
+-</li>
+-</ul>
+-
+-<p>
+-Note that we also might have to add additional requirements on other
+-places for sequence containers because having an allocator requires
+-additional statements for the treatment of the allocators. E.g. swap for
+-containers with allocators is not specified in any requirement table.
++Caching iterator support:
+ </p>
++<blockquote><pre>
++#include &lt;iterator&gt;
++#include &lt;cassert&gt;
+
+-<p>
+-And finally, if we have the requirements in the requirements tables, we
+-can remove the corresponding descriptions for the individual container.
+-However, note that sequence container requirements have NO complexity
+-column, so that we still need container specific descriptions for the
+-functions listed there.
+-</p>
+-
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++struct X { int m; };
+
+-<p>
+-While there is consensus that further cleaning up the container requirement
+-tables would be a good thing, there is no feeling that this <em>must</em>
+-be done in time for 0x. The issue remains open, but Deferred.
+-</p>
++struct IterX {
++ typedef std::bidirectional_iterator_tag iterator_category;
++ typedef X&amp; reference;
++ typedef X* pointer;
++ typedef std::ptrdiff_t difference_type;
++ typedef X value_type;
++ // additional iterator requirements not important for this issue
++
++ reference operator*() const { return value; }
++ pointer operator-&gt;() const { return &amp;value; }
++ IterX&amp; operator--() {return *this;}
+
++private:
++ mutable X value;
++};
+
++int main()
++{
++ std::reverse_iterator&lt;IterX&gt; ix;
++ assert(&amp;ix-&gt;m == &amp;(*ix).m);
++}
++</pre></blockquote>
++</li>
++</ol>
++</blockquote>
+
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+
++<blockquote><p>
++Moved to NAD Future, rationale added.
++</p></blockquote>
+
+
+
+
+-<hr>
+-<h3><a name="1332"></a>1332. Let Hash objects throw!</h3>
+-<p><b>Section:</b> 20.2.4 [hash.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-03-26 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
++<p><b>Rationale:</b></p>
+ <p>
+-The currently added Hash requirements demand in Table 40 — Hash
+-requirements [hash]:
++The LWG did not reach a consensus for a change to the WP.
+ </p>
+
+-<blockquote>
+-<table border="1">
+-
+-<caption>Table 40 — Hash requirements [hash]</caption>
+-
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Requirement</th>
+-</tr>
+
+-<tr>
+-<td><tt>h(k)</tt></td>
+-<td><tt>size_t</tt></td>
+-<td>Shall not throw exceptions. [..]</td>
+-</tr>
++<p><b>Proposed resolution:</b></p>
+
+-</tbody></table>
+-</blockquote>
++<ol>
+
++<li>
+ <p>
+-While it surely is a generally accepted idea that hash function objects
+-<i>should</i> not throw exceptions, this basic constraint for such a fundamental
+-requirement set does neither match the current library policy nor real world
+-cases:
++In the class template <tt>reverse_iterator</tt> synopsis of 24.5.1.1 [reverse.iterator] change as indicated:
+ </p>
+
+-<ol>
+-<li>
+-There are little known situations where a swap or move operation may throw an
+-exception and in some popular domains such functions are <em>required</em> not
+-to throw. But the library invested already efforts for good reasons to require
+-"working" container implementations in the presence of throwing move or swap
+-operations, see e.g. 23.2.4.1 [associative.reqmts.except], 23.2.5.1 [unord.req.except].
++<blockquote><pre>
++namespace std {
++template &lt;class Iterator&gt;
++class reverse_iterator : public
++ iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
++ typename iterator_traits&lt;Iterator&gt;::value_type,
++ typename iterator_traits&lt;Iterator&gt;::difference_type,
++ <del>typename iterator_traits&lt;</del>Iterator<ins>&amp;</ins><del>&gt;::pointer</del>,
++ typename iterator_traits&lt;Iterator&gt;::reference&gt; {
++public:
++ [..]
++ typedef <del>typename iterator_traits&lt;</del>Iterator<ins>&amp;</ins><del>&gt;::pointer</del> pointer;
++ [..]
++protected:
++ Iterator current;
++private:
++ <ins>mutable</ins> Iterator deref_tmp; // exposition only
++};
++</pre></blockquote>
+ </li>
+
+ <li>
+-The container library is already specified to cope with potentially throwing
+-comparers, predicates, <i>and</i> hash function objects, see above.
+-</li>
++Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated:
+
+-<li>
+-<p>
+-The new definition goes beyond the original hash requirements as specified
+-by SGI library in regard to the exception requirement:
+-</p>
+-<blockquote>
+-<a href="http://www.sgi.com/tech/stl/HashFunction.html">http://www.sgi.com/tech/stl/HashFunction.html</a>
++<blockquote><pre>
++pointer operator-&gt;() const;
++</pre>
++
++<blockquote><p>
++1 <i><del>Returns</del> <ins>Effects</ins>:</i> <del><tt>&amp;(operator*())</tt>.</del>
++</p><blockquote><pre>
++<ins>deref_tmp = current;</ins>
++<ins>--deref_tmp;</ins>
++<ins>return deref_tmp;</ins>
++</pre></blockquote>
++</blockquote>
+ </blockquote>
+-</li>
+
+-<li>
+-There are indeed real-world examples of potentially throwing hash functions,
+-typically when the proxy pattern is used and when the to-be hashed proxied
+-instance is some <i>volatile</i> object, e.g. a file or internet resource, that
+-might suddenly be unavailable at the time of hashing.
+ </li>
+
+-<li>
+-With the new <tt>noexcept</tt> language facility libraries can still take
+-advantage of no-throw guarantees of hasher functions with stricter guarantees.
+-</li>
+ </ol>
+
++
++
++
++
++
++
++
++
++
++<hr>
++<h3><a name="1053"></a>1053. Unify algorithms with operator and function object variants</h3>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 295 [CD1]</b></p>
++
++<p>
++There is a level of redundancy in the library specification for many
++algorithms that can be eliminated with the combination of concepts and
++default parameters for function templates. Eliminating redundancy simplified
++specification and reduces the risk of introducing accidental
++inconsistencies.
++</p>
+ <p>
+-Even though the majority of all known move, swap, and hash functions won't throw
+-and in some cases <em>must</em> not throw, it seems like unnecessary
+-over-constraining the definition of a Hash functor not to propagate exceptions
+-in any case and it contradicts the general principle of C++ to impose such a
+-requirement for this kind of fundamental requirement.
++Proposed resolution: Adopt
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2743.pdf">N2743</a>.
+ </p>
+
+ <p><i>[
+-2010-11-11 Daniel asks the working group whether they would prefer a replacement
+-for the second bullet of the proposed resolution (a result of discussing this
+-with Alberto) of the form:
++Summit:
+ ]</i></p>
+
+
++<blockquote>
+ <p>
+-Add to 20.8.15 [unord.hash]/1 a new bullet:
++NAD, this change would break code that takes the address of an algorithm.
+ </p>
++</blockquote>
++
++<p><i>[
++Post Summit Alisdair adds:
++]</i></p>
++
+
+ <blockquote>
+ <p>
+-1 The unordered associative containers defined in Clause 23.5 use
+-specializations of the class template <tt>hash</tt>
+-as the default hash function. For all object types <tt>Key</tt> for which there
+-exists a specialization <tt>hash&lt;Key&gt;</tt>, the
+-instantiation <tt>hash&lt;Key&gt;</tt> shall:
++Request 'Open'. The issues in the paper go beyond just reducing
++the number of signatures, but cover unifying the idea of the ordering
++operation used by algorithms, containers and other library components. At
++least, it takes a first pass at the problem.
++</p>
++
++<p>
++For me (personally) that was the more important part of the paper, and not
++clearly addressed by the Summit resolution.
+ </p>
+-<ul>
+-<li>
+-satisfy the <tt>Hash</tt> requirements (20.2.4), with <tt>Key</tt> as the
+-function call argument type, the <tt>DefaultConstructible</tt> requirements
+-(33), the <tt>CopyAssignable</tt> requirements (37),
+-</li>
+-<li>
+-be swappable (20.2.2) for lvalues,
+-</li>
+-<li>
+-provide two nested types <tt>result_type</tt> and <tt>argument_type</tt> which
+-shall be synonyms for <tt>size_t</tt> and <tt>Key</tt>, respectively,
+-</li>
+-<li>
+-satisfy the requirement that if <tt>k1 == k2</tt> is true, <tt>h(k1) ==
+-h(k2)</tt> is also true, where <tt>h</tt> is an object of type
+-<tt>hash&lt;Key&gt;</tt> and <tt>k1</tt> and <tt>k2</tt> are objects of type
+-<tt>Key</tt><ins>,</ins><del>.</del>
+-</li>
+-<li>
+-<ins>satisfy the requirement <tt>noexcept(h(k)) == true</tt>, where <tt>h</tt> is an object
+-of type <tt>hash&lt;Key&gt;</tt> and <tt>k</tt> is an object of type <tt>Key</tt>, unless
+-<tt>hash&lt;Key&gt;</tt> is a user-defined specialization that depends on at least one user-defined type.</ins>
+-</li>
+-</ul>
+ </blockquote>
+
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+
+-<p><i>[Batavia: Closed as NAD Future, then reopened. See the wiki for Tuesday.]</i></p>
++<blockquote><p>
++Too inventive, too late, would really need a paper. Moved to NAD Future.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Change Table 40 — Hash requirements [hash] as indicated:
+-</p>
+
+-<blockquote>
+-<table border="1">
++<p><b>Proposed resolution:</b></p>
+
+-<caption>Table 40 — Hash requirements [hash]</caption>
+
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Requirement</th>
+-</tr>
+
+-<tr>
+-<td><tt>h(k)</tt></td>
+-<td><tt>size_t</tt></td>
+-<td><del>Shall not throw exceptions.</del> [..]</td>
+-</tr>
+
+-</tbody></table>
+-</blockquote>
+-</li>
+
+-<li>
++<hr>
++<h3><a name="1112"></a>1112. bitsets and new style for loop</h3>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Add to 20.8.15 [unord.hash]/1 a new bullet:
++<tt>std::bitset</tt> is a homogeneous container-like sequence of bits, yet it does
++not model the Range concept so cannot be used with the new for-loop syntax.
++It is the only such type in the library that does NOT support the new for
++loop.
+ </p>
+-
+-<blockquote>
+ <p>
+-1 The unordered associative containers defined in Clause 23.5 use
+-specializations of the class template <tt>hash</tt>
+-as the default hash function. For all object types <tt>Key</tt> for which there
+-exists a specialization <tt>hash&lt;Key&gt;</tt>, the
+-instantiation <tt>hash&lt;Key&gt;</tt> shall:
++The obvious reason is that bitset does not support iterators.
+ </p>
+-<ul>
+-<li>
+-satisfy the <tt>Hash</tt> requirements (20.2.4), with <tt>Key</tt> as the
+-function call argument type, the <tt>DefaultConstructible</tt> requirements
+-(33), the <tt>CopyAssignable</tt> requirements (37),
+-</li>
+-<li>
+-be swappable (20.2.2) for lvalues,
+-</li>
+-<li>
+-provide two nested types <tt>result_type</tt> and <tt>argument_type</tt> which
+-shall be synonyms for <tt>size_t</tt> and <tt>Key</tt>, respectively,
+-</li>
++<p>
++At least two reasonable solutions are available:
++</p>
++<ol style="list-style-type:lower-roman">
+ <li>
+-satisfy the requirement that if <tt>k1 == k2</tt> is true, <tt>h(k1) ==
+-h(k2)</tt> is also true, where <tt>h</tt> is an object of type
+-<tt>hash&lt;Key&gt;</tt> and <tt>k1</tt> and <tt>k2</tt> are objects of type
+-<tt>Key</tt><ins>,</ins><del>.</del>
++Add an iterator interface to <tt>bitset</tt>, bringing its interface close to that
++of <tt>std::array</tt>
+ </li>
+ <li>
+-<ins>satisfy the requirement that the expression <tt>h(k)</tt>, where <tt>h</tt>
+-is an object of type <tt>hash&lt;Key&gt;</tt> and <tt>k</tt> is an object of
+-type <tt>Key</tt>, shall not throw an exception, unless
+-<tt>hash&lt;Key&gt;</tt> is a user-defined specialization that depends on at
+-least one user-defined type.</ins>
+-</li>
+-</ul>
+-</blockquote>
++Provide an unspecified concept_map for <tt>Range&lt;bitset&gt;</tt>.
+ </li>
+ </ol>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1345"></a>1345. [FCD] Library classes should have <tt>noexcept</tt> move operations</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-31</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-61</b></p>
+ <p>
+-All library types should have non-throwing move
+-constructors and move-assignment operators unless
+-wrapping a type with a potentially throwing move operation.
+-When such a type is a class-template, these
+-operations should have a conditional <tt>noexcept</tt>
+-specification.
++The latter will still need some kind of iterator-like adapter for <tt>bitset</tt>,
++but gives implementers greater freedom on the details. E.g. begin/end return
++some type that simply invokes <tt>operator[]</tt> on the object it wraps, and
++increments its index on <tt>operator++</tt>. A vendor can settle for <tt>InputIterator</tt>
++support, rather than wrapping up a full <tt>RandomAccessIterator</tt>.
++</p>
++<p>
++I have a mild preference for option (ii) as I think it is less work to
++specify at this stage of the process, although (i) is probably more useful
++in the long run.
++</p>
++<p>
++Hmm, my wording looks a little woolly, as it does not say what the element
++type of the range is. Do I get a range of <tt>bool</tt>, <tt>bitset&lt;N&gt;::reference</tt>, or
++something else entirely?
+ </p>
+ <p>
+-There are many other places where a <tt>noexcept</tt>
+-specification may be considered, but the move operations
+-are a special case that must be called out, to effectively
+-support the <tt>move_if_noexcept</tt> function template.
++I guess most users will assume the behaviour of reference, but expect to
++work with <tt>bool</tt>. <tt>Bool</tt> is OK for read-only traversal, but you really need to
++take a reference to a <tt>bitset::reference</tt> if you want to write back.
+ </p>
+
+ <p><i>[
+-Resolution proposed by ballot comment:
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++Move to Open.
++We further recommend this be deferred until after the next Committee Draft.
++</p></blockquote>
++
++<p><i>[
++2009-05-25 Alisdair adds:
+ ]</i></p>
+
++
++<blockquote>
+ <p>
+-Review every class and class template in the
+-library. If noexcept move constructor/assignment
+-operators can be implicitly declared, then they
+-should be implicitly declared, or explicitly
+-defaulted. Otherwise, a move constructor/moveassingment
+-operator with a <tt>noexcept</tt> exception
+-specification should be provided.
++I just stumbled over the <tt>Range concept_map</tt> for <tt>valarray</tt> and this should
++probably set the precedent on how to write the wording.
+ </p>
+
+ <p><i>[
+-2010-10-31 Daniel comments:
++Howard: I've replaced the proposed wording with Alisdair's suggestion.
+ ]</i></p>
+
+
+-<blockquote>
+-The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>
+-would satisfy this request.
+ </blockquote>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>
++<p><i>[
++2009-07-24 Daniel modifies the proposed wording for non-concepts.
++]</i></p>
+
+
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
+
+
++<blockquote><p>
++Mark as Tentatively NAD Future due to the loss of concepts.
++</p></blockquote>
+
+-<hr>
+-<h3><a name="1348"></a>1348. [FCD] Exception safety of unspecified types</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-25</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-64</b></p>
+-<p>
+-There are a number of unspecified types used throughout
+-the library, such as the container iterators. Many of these
+-unspecified types have restrictions or expectations on
+-their behaviour in terms of exceptions. Are they permitted
+-or required to use exception specifications, more
+-specifically the new <tt>noexcept</tt> specification? For example,
+-if <tt>vector&lt;T&gt;::iterator</tt> is implemented as a native pointer,
+-all its operations will have an (effective) <tt>noexcept</tt>
+-specification. If the implementation uses a class type to
+-implement this iterator, is it permitted or required to
+-support that same guarantee?
+-</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
+
++<p><b>Rationale:</b></p>
+ <p>
+-Clearly state the requirements for exception
+-specifications on all unspecified library types. For
+-example, all container iterator operations should
+-be conditionally <tt>noexcept</tt>, with the condition
+-matching the same operation applied to the
+-allocator's <tt>pointer_type</tt>, a certain subset of which
+-are already required not to throw.
++All concepts-related text has been removed from the draft.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Modify the section 20.6 [template.bitset] <tt>&lt;bitset&gt;</tt> synopsis by adding
++the following at the end of the synopsis:
++</p>
++<blockquote><pre>
++<ins>
++// XX.X.X bitset range access [bitset.range]
++template&lt;size_t N&gt; <i>unspecified-1</i> begin(bitset&lt;N&gt;&amp;);
++template&lt;size_t N&gt; <i>unspecified-2</i> begin(const bitset&lt;N&gt;&amp;);
++template&lt;size_t N&gt; <i>unspecified-1</i> end(bitset&lt;N&gt;&amp;);
++template&lt;size_t N&gt; <i>unspecified-2</i> end(const bitset&lt;N&gt;&amp;);
++</ins>
++</pre></blockquote>
++</li>
++<li>
++<p>
++Add a new section <ins>"bitset range access" [bitset.range]</ins>
++after the current section 20.6.4 [bitset.operators] with the following series of
++paragraphs:
++</p>
++<blockquote>
++<p>
++<ins>
++1. In the <tt>begin</tt> and <tt>end</tt> function templates that follow, <i>unspecified-1</i>
++is a type that meets the requirements of a mutable random access
++iterator (24.2.7 [random.access.iterators]) whose <tt>value_type</tt> is <tt>bool</tt> and
++whose reference type is <tt>bitset&lt;N&gt;::reference</tt>.
++<i>unspecified-2</i> is a type that meets the requirements of a constant
++random access iterator (24.2.7 [random.access.iterators]) whose <tt>value_type</tt>
++is <tt>bool</tt> and whose reference type is <tt>bool</tt>.
++</ins>
++</p>
++<pre>
++<ins>
++template&lt;size_t N&gt; <i>unspecified-1</i> begin(bitset&lt;N&gt;&amp;);
++template&lt;size_t N&gt; <i>unspecified-2</i> begin(const bitset&lt;N&gt;&amp;);
++</ins>
++</pre>
++<blockquote><p>
++<ins>2. Returns: an iterator referencing the first bit in the bitset.</ins>
++</p></blockquote>
+
++<pre><ins>
++template&lt;size_t N&gt; <i>unspecified-1</i> end(bitset&lt;N&gt;&amp;);
++template&lt;size_t N&gt; <i>unspecified-2</i> end(const bitset&lt;N&gt;&amp;);
++</ins></pre>
+
++<blockquote><p>
++<ins>3. Returns: an iterator referencing one past the last bit in the
++bitset.</ins>
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
+
+
+
+-<hr>
+-<h3><a name="1349"></a>1349. [FCD] <tt>swap</tt> should not throw</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-25</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-65</b></p>
+-<p>
+-Nothrowing <tt>swap</tt> operations are key to many C++ idioms,
+-notably the common copy/swap idiom to provide the
+-strong exception safety guarantee.
+-</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
+
+-<p>
+-Where possible, all library types should provide a
+-<tt>swap</tt> operation with an exception specification
+-guaranteeing no exception shall propagate.
+-Where <tt>noexcept(true)</tt> cannot be guaranteed to
+-not terminate the program, and the <tt>swap</tt> in
+-questions is a template, an exception specification
+-with the appropriate conditional expression could
+-be specified.
+-</p>
+
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1353"></a>1353. [FCD] Clarify the state of a <i>moved-from</i> object</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="1120"></a>1120. New type trait - remove_all</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-18</b></p>
+ <p>
+-The general approach on moving is that a library object
+-after moving out is in a "valid but unspecified state". But
+-this is stated at the single object specifications, which is
+-error prone (especially if the move operations are implicit)
+-and unnecessary duplication.
++Sometimes it is necessary to remove all qualifiers from a type before
++passing on to a further API. A good example would be calling the
++<tt>tuple</tt> query APIs <tt>tuple_size</tt> or <tt>tuple_element</tt>
++with a deduced type inside a function template. If the deduced type is
++cv-qualified or a reference then the call will fail. The solution is to
++chain calls to
++<tt>remove_cv&lt;remove_reference&lt;T&gt;::type&gt;::type</tt>, and
++note that the order matters.
++</p>
++<p>
++Suggest it would be helpful to add a new type trait,
++<tt>remove_all</tt>, that removes all top-level qualifiers from a type
++i.e. cv-qualification and any references. Define the term in such a way
++that if additional qualifiers are added to the language, then
++<tt>remove_all</tt> is defined as stripping those as well.
+ </p>
+
+ <p><i>[
+-Resolution propsed by ballot comment
++2009-10-14 Daniel adds:
+ ]</i></p>
+
+-<p>
+-Consider putting a general statement to the same
+-effect into clause 17.
+-</p>
+
+-<p><i>[2010-11-05 Beman provides exact wording.
+-The wording was inspired by Dave Abrahams'
+-message c++std-lib-28958, and refined with help from Alisdair, Daniel, and Howard.
++<blockquote><p>
++<tt>remove_all</tt> seems too generic, a possible alternative matching
++the current naming style could be <tt>remove_cv_reference</tt> or
++<tt>remove_reference_cv</tt>. It should also be considered whether this
++trait should also remove 'extents', or pointer 'decorations'. Especially
++if the latter situations are considered as well, it might be easier to
++chose the name not in terms of what it <em>removes</em> (which might be
++a lot), but in terms of it <em>creates</em>. In this case I could think
++of e.g. <tt>extract_value_type</tt>.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
++<blockquote><p>
++NAD Future.
++</p></blockquote>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+- <p><i>Add a new definition to 17.3 Definitions [definitions]:</i></p>
+-
+- <blockquote>
+- <p>17.3.24 [defns.valid.unspecified]<br>
+- <b>valid but unspecified state</b><br>
+- an object state that is not specified except that the object's invariants are met, and operations
+- on the object perform as specified,
+- subject only to the operation's normal preconditions.</p>
+- <p>
+- [<i>Example:</i> If an object <tt>x</tt> of type <tt>std::vector&lt;int&gt;</tt> is in a valid but
+- unspecified state, <tt>x.empty()</tt> can be called unconditionally, and
+- <tt>x.front()</tt> can be called provided <tt>x.empty()</tt> returns
+- <tt>false</tt>. <i>--end example</i>]</p>
+- </blockquote>
+-
+- <p><i>Change Table 34 - MoveConstructible requirements [moveconstructible] as
+- indicated:</i></p>
+- <blockquote>
+- <p><del>[ <i>Note:</i> <tt>rv</tt> remains a valid object. Its state is
+- unspecified&nbsp; <i>--end note</i> ]</del><br>
+- <ins><i>Postcondition:</i><tt> rv</tt> is in a valid but
+- unspecified state ([defns.valid.unspecified]).</ins></p>
+- </blockquote>
+-
+- <p><i>Change Table 36 - MoveAssignable requirements [moveassignable] as
+- indicated:</i></p>
+- <blockquote>
+- <p><del>[ <i>Note:</i> <tt>rv</tt> remains a valid object. Its state is
+- unspecified&nbsp; <i>--end note</i> ]</del><br>
+- <ins><i>Postcondition:</i><tt> rv</tt> is in a valid but
+- unspecified state ([defns.valid.unspecified]).</ins></p>
+- </blockquote>
+-
+- <p><i>No change in the half-dozen or so places in the standard library that
+- use "valid but unspecified state" directly, and no change in the many places
+- that require <tt>MoveCostructible</tt> or <tt>MoveAssignable</tt>,
+- since <tt>MoveCostructible</tt> and <tt>MoveAssignable</tt> will now
+- normatively require "valid but unspecified state".</i></p>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="1358"></a>1358. [FCD] Add <tt>&lt;chrono&gt;</tt> and <tt>&lt;ratio&gt;</tt> to
+-freestanding implementations</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="1121"></a>1121. Support for multiple arguments</h3>
++<p><b>Section:</b> 20.11.4 [ratio.arithmetic] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-55</b></p>
+-<p>
+-The <tt>&lt;thread&gt;</tt> header uses <tt>duration</tt> types, found in the
+-<tt>&lt;chrono&gt;</tt> header, and which rely on the <tt>ratio</tt> types
+-declared in the <tt>&lt;ratio&gt;</tt> header.
+-</p>
+-
+-<p><i>[
+-Extracts from lengthy Rapperswil discussion:
+-]</i></p>
+-
+ <p>
+-There is a concern that this issue is a misunderstanding of the actual
+-requirements of a free-standing implementation to support the <tt>&lt;thread&gt;</tt>
+-header. In general, a free-standanding implementation will provide an <em>empty</em>
+-header, specifically so that a user can test for the absence of the
+-<tt>_ _ STDCPP_THREADS _ _</tt> macro. This idiom as used as there is no portable way to test for the lack of a header.
++Both add and multiply could sensibly be called with more than two arguments.
++The variadic template facility makes such declarations simple, and is likely
++to be frequently wrapped by end users if we do not supply the variant
++ourselves.
+ </p>
+ <p>
+-At this point, it was suggested the NB comment is trying to solve the wrong problem, and that <tt>_ _ STDCPP_THREADS _ _</tt> should be a pre-defined macro in clause 16 that can be tested before including <tt>&lt;thread&gt;</tt>. That would remove the need to add additional headers to the free-standanding requirements.
++We deliberately ignore divide at this point as it is not transitive.
++Likewise, subtract places special meaning on the first argument so I do not
++suggest extending that immediately. Both could be supported with analogous
++wording to that for add/multiply below.
+ </p>
+ <p>
+-It is worth noting that Japan requested <tt>&lt;ratio&gt;</tt> as a free-standing header in their CD1 comments. No-one seemed keen to require clocks of a free-standing implementation though.
++Note that the proposed resolution is potentially incompatible with that
++proposed for <a href="lwg-defects.html#921">921</a>, although the addition of the typedef to ratio would be
++equally useful.
+ </p>
+
+-<p>Detlef volunteers to look at a way to redraft 17.6.1.3 p3.</p>
+-
+ <p><i>[
+-Original resolution proposed by NB comment:
++2009-10-30 Alisdair adds:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-Add the <tt>&lt;chrono&gt;</tt> and <tt>&lt;ratio&gt;</tt> headers to the
+-freestanding requirements.
++The consensus of the group when we reviewed this in Santa Cruz was that
++<a href="lwg-defects.html#921">921</a> would proceed to Ready as planned, and the
++multi-paramater add/multiply templates should be renamed as
++<tt>ratio_sum</tt> and <tt>ratio_product</tt> to avoid the problem
++mixing template aliases with partial specializations.
+ </p>
++
+ <p>
+-It might be necessary to address scaled-down
+-expectations of clock support in a freestanding
+-environment, much like <tt>&lt;thread&gt;</tt>.
++It was also suggested to close this issue as NAD Future as it does not
++correspond directly to any NB comment. NBs are free to submit a
++specific comment (and re-open) in CD2 though.
+ </p>
+-</blockquote>
+
++<p>
++Walter Brown also had concerns on better directing the order of
++evaluation to avoid overflows if we do proceed for 0x rather than TR1,
++so wording may not be complete yet.
++</p>
+
++<p><i>[
++Alisdair updates wording.
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+
++</blockquote>
+
++<p><i>[
++2009-10-30 Howard:
++]</i></p>
+
+
++<blockquote><p>
++Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
++</p></blockquote>
+
+-<hr>
+-<h3><a name="1364"></a>1364. [FCD] It is not clear how <tt>exception_ptr</tt> is synchronized</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CH-19</b></p>
+-<p>
+-It is not clear how <tt>exception_ptr</tt> is synchronized.
+-</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
+
++<p><b>Rationale:</b></p>
+ <p>
+-Make clear that accessing in different threads
+-multiple <tt>exception_ptr</tt> objects that all refer to the
+-same exception introduce a race.
++Does not have sufficient support at this time. May wish to reconsider for a
++future standard.
+ </p>
+
+
+-
+ <p><b>Proposed resolution:</b></p>
+
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1369"></a>1369. [FCD] <tt>rethrow_exception</tt> may introduce data races</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-74</b></p>
+ <p>
+-One idea for the <tt>exception_ptr</tt> type was that a reference-counted
+-implementation could simply 'reactivate' the same
+-exception object in the context of a call to
+-<tt>rethrow_exception</tt>. Such an implementation would allow
+-the same exception object to be active in multiple threads
+-(such as when multiple threads join on a <tt>shared_future</tt>)
+-and introduce potential data races in any exception
+-handler that catches exceptions by reference - notably
+-existing library code written before this capability was
+-added. <tt>rethrow_exception</tt> should <em>always</em> make a copy
+-of the target exception object.
++Add the following type traits to p3 20.11 [ratio]
+ </p>
+
++<blockquote><pre>
++// ratio arithmetic
++template &lt;class R1, class R2&gt; struct ratio_add;
++template &lt;class R1, class R2&gt; struct ratio_subtract;
++template &lt;class R1, class R2&gt; struct ratio_multiply;
++template &lt;class R1, class R2&gt; struct ratio_divide;
++<ins>template &lt;class R1, class ... RList&gt; struct ratio_sum;</ins>
++<ins>template &lt;class R1, class ... RList&gt; struct ratio_product;</ins>
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following to 18.8.5, [propogation]
++after 20.11.4 [ratio.arithmetic] p1: add
+ </p>
+-<blockquote><ins>
+-<i>Throws</i>: a copy of the exception object to which <tt>p</tt> refers.
+-</ins></blockquote>
+
++<blockquote><pre>
++template &lt;class R1, class ... RList&gt; struct ratio_sum; // declared, never defined
+
++template &lt;class R1&gt; struct ratio_sum&lt;R1&gt; : R1 {};
++</pre>
+
++<blockquote><p>
++<i>Requires:</i> <tt>R1</tt> is a specialization of class template <tt>ratio</tt>
++</p></blockquote>
+
++<pre>
++template &lt;class R1, class R2, class ... RList&gt;
++ struct ratio_sum&lt;R1, R2, RList...&gt;
++ : ratio_add&lt; R1, ratio_sum&lt;R2, RList...&gt;&gt; {
++};
++</pre>
+
++<blockquote><p>
++<i>Requires:</i> <tt>R1</tt> and each element in parmater pack
++<tt>RList</tt> is a specialization of class template <tt>ratio</tt>
++</p></blockquote>
++</blockquote>
+
+-<hr>
+-<h3><a name="1371"></a>1371. [FCD] standard exceptions require stronger no-throw guarantees</h3>
+-<p><b>Section:</b> 19 [diagnostics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">Tentatively NAD</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively NAD">Tentatively NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-75</b></p>
+ <p>
+-None of the exception types defined in clause 19 are
+-allowed to throw an exception on copy or move
+-operations, but there is no clear specification that the
+-operations have an exception specification to prove it.
+-Note that the implicitly declared constructors, taking the
+-exception specification from their base class (ultimately
+-<tt>std::exception</tt>) will implicitly generate a <tt>noexcept</tt>
+-exception specification if all of their data members
+-similarly declare <tt>noexcept</tt> operations. As the
+-representation is unspecified, we cannot assume nonthrowing
+-operations unless we explicitly state this as a
+-constraint on the implementation.
++after 20.11.4 [ratio.arithmetic] p3: add
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<blockquote><pre>
++template &lt;class R1, class ... RList&gt; struct ratio_product; // declared, never defined
+
+-<p>
+-Add a global guarantee that all exception types
+-defined in clause 19 that rely on implicitly declared
+-operations have a non-throwing exception
+-specification on those operations.
+-</p>
++template &lt;class R1&gt; struct ratio_product&lt;R1&gt; : R1 {};
++</pre>
+
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
++<blockquote><p>
++<i>Requires:</i> <tt>R1</tt> is a specialization of class template <tt>ratio</tt>
++</p></blockquote>
+
+-<p>
+-This is addressed by the current words in 18.8.1 [exception], p2
+-</p>
+-<blockquote>
+-Each standard library class <tt>T</tt> that derives from class <tt>exception</tt>
+-shall have a publicly accessible copy constructor and a publicly accessible copy
+-assignment operator that do not exit with an exception.
++<pre>
++template &lt;class R1, class R2, class ... RList&gt;
++ struct ratio_sum&lt;R1, R2, RList...&gt;
++ : ratio_add&lt; R1, ratio_product&lt;R2, RList...&gt;&gt; {
++};
++</pre>
++
++<blockquote><p>
++<i>Requires:</i> <tt>R1</tt> and each element in parmater pack
++<tt>RList</tt> is a specialization of class template <tt>ratio</tt>
++</p></blockquote>
+ </blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1374"></a>1374. [FCD] Clarify moved-from objects are "toxic"</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="1150"></a>1150. wchar_t, char16_t and char32_t filenames</h3>
++<p><b>Section:</b> 27.9.1.14 [fstream] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-85</b></p>
+-<p>
+-20.2.1 Table 34 "MoveConstructible requirements" says
+-"Note: rv remains a valid object. Its state is unspecified".
+-Some components give stronger guarantees. For
+-example, moved-from <tt>shared_ptr</tt>s are guaranteed <tt>empty</tt>
+-(20.9.11.2.1/25).
+-In general, what the standard really should say (preferably
+-as a global blanket statement) is that moved-from objects
+-can be destroyed and can be the destination of an
+-assignment. Anything else is radioactive. For example,
+-containers can be "emptier than empty". This needs to be
+-explicit and required generally.
+-</p>
+-<p>
+-Note: The last time that one of us mentioned "emptier
+-than empty" (i.e. containers missing sentinel nodes, etc.)
+-the objection was that containers can store sentinel nodes
+-inside themselves in order to avoid dynamically allocating
+-them. This is unacceptable because
+-</p>
+-<p>
+-(a) it forces existing implementations (i.e. Dinkumware's, Microsoft's,
+-IBM's, etc.) to change for no good reason (i.e. permitting more
+-operations on moved-from objects), and
+-</p>
+-<p>
+-(b) it invalidates end-iterators when swapping containers. (The Working
+-Paper currently permits end-iterator invalidation, which we
+-consider to be wrong, but that's a separate argument. In
+-any event, <em>mandating</em> end-iterator invalidation is very
+-different from permitting it.)
+-</p>
++<p><b>Addresses JP 73</b></p>
++
++ <p><b>Description</b></p>
++ <p>It is a problem
++ from C++98, <tt>fstream</tt> cannot appoint a filename of wide
++ character string(<tt>const wchar_t</tt> and <tt>const wstring&amp;</tt>).</p>
++<p><b>Suggestion</b></p>
++ <p>Add
++ interface corresponding to <tt>wchar_t</tt>, <tt>char16_t</tt> and <tt>char32_t</tt>.</p>
+
+ <p><i>[
+-Resolution proposed in ballot comment
++2009-07-01 Alisdair notes that this is a duplicate of <a href="lwg-closed.html#454">454</a> which has more
++in-depth rationale.
+ ]</i></p>
+
+-<p>
+-State as a general requirement that moved-from
+-objects can be destroyed and can be the
+-destination of an assignment. Any other use is
+-undefined behavior.
+-</p>
+
++<p><i>[
++2009-09-21 Daniel adds:
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+
++<blockquote><p>
++I suggest to mark this issue as NAD Future with the intend to
++solve the issue with a single file path c'tor template assuming
++a provision of a TR2 filesystem library.
++</p></blockquote>
+
++<p><i>[
++2009 Santa Cruz:
++]</i></p>
+
+
++<blockquote><p>
++NAD Future. This is a duplicate of <a href="lwg-closed.html#454">454</a>.
++</p></blockquote>
+
+-<hr>
+-<h3><a name="1385"></a>1385. [FCD] <tt>tuple_cat</tt> should be a single variadic signature</h3>
+-<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-88</b></p>
+-<p>
+-The <tt>tuple_cat</tt> template consists of four overloads and that
+-can concatenate only two <tt>tuple</tt>s. A single variadic
+-signature that can concatenate an arbitrary number of
+-<tt>tuple</tt>s would be preferred.
+-</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++
++<p><b>Proposed resolution:</b></p>
+
+
+-<blockquote>
+-Adopt a simplified form of the proposal in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2975.pdf">n2975</a>,
+-restricted to <tt>tuple</tt>s and neither requiring nor outlawing support for other <tt>tuple</tt>-like types.
+-</blockquote>
++
++
++
++<hr>
++<h3><a name="1154"></a>1154. <tt>complex</tt> should accept integral types</h3>
++<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#complex.numbers">active issues</a> in [complex.numbers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses FR 35</b></p>
++
++<p><b>Description</b></p>
++ <p>Instantiations of the class
++ template <tt>complex&lt;&gt;</tt> have to be allowed for integral
++ types, to reflect existing practice and ISO standards
++ (LIA-III).</p>
++
++<p><b>Suggestion</b></p>
+
+ <p><i>[
+-2010 Rapperswil: Alisdair to provide wording.
++2009-10-26 Proposed wording in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3002.pdf">N3002</a>.
+ ]</i></p>
+
+
+ <p><i>[
+-2010-11-06: Daniel comments and proposes some alternative wording:
++2010 Pittsburgh:
+ ]</i></p>
+
+
++<blockquote><p>
++Moved to NAD Future. Rationale added.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
+ <p>
+-There are some problems in the wording: First, even though the result type <tt>tuple&lt;<i>see below</i>&gt;</tt>
+-implies it, the specification of the contained tuple element types is missing. Second, the term "<tt>tuple</tt>
+-protocol" is not defined anywhere and I see no reason why this normative wording should not be a non-normative
+-note. We could at least give a better approximation, maybe "tuple-like protocol" as indicated from header
+-<tt>&lt;utility&gt;</tt> synopsis. Further, it seems to me that the effects need to contain a combination of <tt>std::forward</tt>
+-with the call of <tt>get</tt>. Finally I suggest to replace the requirements <tt>Move/CopyConstructible</tt>
+-by proper usage of <tt>is_constructible</tt>, as indicated by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
++There is no consensus for making this change at this time.
+ </p>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
+
+-<p>
+-Moved to Ready with Daniel's improved wording.
++<p><b>Proposed resolution:</b></p><p>
++Adopt
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3002.pdf">N3002</a>.
+ </p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>Note: This alternate proposed resolution works only if <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a> has been accepted.</p>
+
++
++<hr>
++<h3><a name="1169"></a>1169. <tt>num_get</tt> not fully compatible with <tt>strto*</tt></h3>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Cosmin Truta <b>Opened:</b> 2009-07-04 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As specified in the latest draft,
++<a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>,
++<code>num_get</code> is still not fully compatible with the following C
++functions: <code>strtoul</code>, <code>strtoull</code>,
++<code>strtof</code> and
++<code>strtod</code>.
++</p>
++<p>
++In C, when conversion of a string to an unsigned integer type falls
++outside the
++representable range, <code>strtoul</code> and <code>strtoull</code> return
++<code>ULONG_MAX</code> and <code>ULLONG_MAX</code>, respectively,
++regardless
++whether the input field represents a positive or a negative value.
++On the other hand, the result of <code>num_get</code> conversion of
++negative
++values to unsigned integer types is zero. This raises a compatibility
++issue.
++</p>
++<p>
++Moreover, in C, when conversion of a string to a floating-point type falls
++outside the representable range, <code>strtof</code>, <code>strtod</code>
++and
++<code>strtold</code> return <code>&plusmn;HUGE_VALF</code>,
++<code>&plusmn;HUGE_VAL</code> and <code>&plusmn;HUGE_VALL</code>, respectively.
++On the other hand, the result of <code>num_get</code> conversion of such
++out-of-range floating-point values results in the most positive/negative
++representable value.
++Although many C library implementations do implement <code>HUGE_VAL</code>
++(etc.) as the highest representable (which is, usually, the infinity),
++this isn't required by the C standard. The C library specification makes no
++statement regarding the value of <code>HUGE_VAL</code> and friends, which
++potentially raises the same compatibility issue as in the above case of
++unsigned integers.
++In addition, neither C nor C++ define symbolic constants for the maximum
++representable floating-point values (they only do so only for the maximum
++representable <i>finite</i> floating-point values), which raises a
++usability
++issue (it would be hard for the programmer to check the result of
++<code>num_get</code> against overflow).
++</p>
+ <p>
+-</p><ol>
+-<li>Change 20.4.1 [tuple.general] p. 2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
+-<blockquote><pre>namespace std {
++As such, we propose to adjust the specification of <code>num_get</code> to
++closely follow the behavior of all of its underlying C functions.
++</p>
+
+-...
+
+-// <i>20.4.2.4, tuple creation functions:</i>
+-const unspecified ignore;
+
+-template &lt;class... Types&gt;
+- tuple&lt;<i>VTypes</i>...&gt; make_tuple(Types&amp;&amp;...);
+- template &lt;class... Types&gt;
+- tuple&lt;<i>ATypes</i>...&gt; forward_as_tuple(Types&amp;&amp;...);
+-
+-template&lt;class... Types&gt;
+- tuple&lt;Types&amp;...&gt; tie(Types&amp;...);
+-
+-<del>template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
+-template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, const tuple&lt;UTypes...&gt;&amp;);
+-template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;);
+-template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;);</del>
+-<ins>template &lt;class... Tuples&gt;
+- tuple&lt;<i>CTypes</i>...&gt; tuple_cat(Tuples&amp;&amp;...);</ins>
++<p><i>[
++2010 Rapperswil:
++]</i></p>
+
+-...
+
+-</pre></blockquote>
+-</li>
+-<li>Change 20.4.2.4 [tuple.creation] as indicated:
+-<blockquote>
+-<pre><del>template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</del></pre>
+-<p></p><blockquote><del>
+-8 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35). All the types in
+-<tt>UTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35).
+-</del></blockquote><p></p>
+-<p></p><blockquote><del>
+-9 <i>Returns</i>: A <tt>tuple</tt> object constructed by copy constructing its first <tt>sizeof...(TTypes)</tt> elements
+-from the corresponding elements of <tt>t</tt> and copy constructing its last <tt>sizeof...(UTypes)</tt> elements from the
+-corresponding elements of <tt>u</tt>.
+-</del></blockquote><p></p>
+-<pre><del>template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</del></pre>
+-<p></p><blockquote><del>
+-10 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34). All the types in
+-<tt>UTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35).
+-</del></blockquote><p></p>
+-<p></p><blockquote><del>
+-11 <i>Returns</i>: A <tt>tuple</tt> object constructed by move constructing its first <tt>sizeof...(TTypes)</tt> elements
+-from the corresponding elements of <tt>t</tt> and copy constructing its last <tt>sizeof...(UTypes)</tt> elements from the
+-corresponding elements of <tt>u</tt>.
+-</del></blockquote><p></p>
+-<pre><del>template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);</del></pre>
+-<p></p><blockquote><del>
+-12 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35). All the types in
+-<tt>UTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34).
+-</del></blockquote><p></p>
+-<p></p><blockquote><del>
+-13 <i>Returns</i>: A <tt>tuple</tt> object constructed by copy constructing its first <tt>sizeof...(TTypes)</tt> elements
+-from the corresponding elements of <tt>t</tt> and move constructing its last <tt>sizeof...(UTypes)</tt> elements from the
+-corresponding elements of <tt>u</tt>.
+-</del></blockquote><p></p>
+-<pre><del>template &lt;class... TTypes, class... UTypes&gt;
+- tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);</del></pre>
+-<p></p><blockquote><del>
+-14 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34). All the types in
+-<tt>UTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34).
+-</del></blockquote><p></p>
+-<p></p><blockquote><del>
+-15 <i>Returns</i>: A <tt>tuple</tt> object constructed by move constructing its first <tt>sizeof...(TTypes)</tt> elements
+-from the corresponding elements of <tt>t</tt> and move constructing its last <tt>sizeof...(UTypes)</tt> elements from the
+-corresponding elements of <tt>u</tt>.
+-</del></blockquote><p></p>
+-<pre><ins>template &lt;class... Tuples&gt;
+- tuple&lt;<i>CTypes</i>...&gt; tuple_cat(Tuples&amp;&amp;... tpls);
+-</ins></pre>
+-<p></p><blockquote><ins>
+-8 Let <tt>Ti</tt> be the <tt><i>i</i></tt><sup>th</sup> type in <tt>Tuples</tt>, <tt>Ui</tt> be <tt>remove_reference&lt;Ti&gt;::type</tt>,
+-and <tt>tp<sub><i>i</i></sub></tt> be the <tt><i>i</i></tt><sup>th</sup> parameter in the function parameter pack <tt>tpls</tt>, where all
+-indexing is zero-based in the following paragraphs of this sub-clause [tuple.creation].
+-</ins></blockquote><p></p>
+-<p></p><blockquote><ins>
+-9 <i>Requires</i>: For all <tt><i>i</i></tt>, <tt>Ui</tt> shall be the type <i>cv<sub><tt>i</tt></sub>&nbsp;</i><tt>tuple&lt;Args<sub><i>i</i></sub>...&gt;</tt>,
+-where <i>cv<sub><tt>i</tt></sub></i> is the (possibly empty) <tt><i>i</i></tt><sup>th</sup> <i>cv</i>-qualifier-seq, and
+-<tt>Args<sub><i>i</i></sub></tt> is the parameter pack representing the element types in <tt>Ui</tt>. Let <tt>Aik</tt> be the
+-<tt><i>k<sub>i</sub></i></tt><sup>th</sup> type in <tt>Args<sub><i>i</i></sub></tt>, then for all <tt>Aik</tt> the following
+-requirements shall be satisfied: If <tt>Ti</tt> is deduced as an lvalue reference type, then
+-<tt>is_constructible&lt;Aik, <i>cv<sub>i</sub>&nbsp;</i>Aik&amp;&gt;::value == true</tt>, otherwise
+-<tt>is_constructible&lt;Aik, <i>cv<sub>i</sub>&nbsp;</i>Aik&amp;&amp;&gt;::value == true</tt>.
+-</ins></blockquote><p></p>
+-<p></p><blockquote><ins>
+-10 <i>Remarks</i>: The types in <tt><i>CTypes</i></tt> shall be equal to the ordered sequence of the expanded types
+-<tt>Args<sub>0</sub>..., Args<sub>1</sub>..., Args<sub><i>n</i>-1</sub>...</tt>, where <tt><i>n</i></tt> equals
+-<tt>sizeof...(Tuples)</tt>. Let <tt><i>e<sub>i</sub></i>...</tt> be the <tt><i>i</i></tt><sup>th</sup> ordered
+-sequence of tuple elements of the result <tt>tuple</tt> object corresponding to the type sequence
+-<tt>Args<sub><i>i</i></sub></tt>.
+-</ins></blockquote><p></p>
+-<p></p><blockquote><ins>
+-11 <i>Returns</i>: A <tt>tuple</tt> object constructed by initializing
+-the <tt><i>k<sub>i</sub></i></tt><sup>th</sup> type element <tt>eik</tt> in <tt><i>e<sub>i</sub></i>...</tt>
+-with <tt>get&lt;<i>k<sub>i</sub></i>&gt;(std::forward&lt;Ti&gt;(tp<sub>i</sub>))</tt>
+-for each valid <tt><i>k<sub>i</sub></i></tt> and each element group <tt><i>e<sub>i</sub></i></tt> in order.
+-</ins></blockquote><p></p>
+-<p></p><blockquote><ins>
+-12 [<i>Note</i>: An implementation may support additional types in the parameter pack <tt>Tuples</tt>, such as
+-<tt>pair</tt> and <tt>array</tt> that support the <tt>tuple</tt>-like protocol. -- <i>end note</i>]
+-</ins></blockquote><p></p>
++<blockquote><p>
++Some concern that this is changing the specification for an existing C++03 function, but it was
++pointed out that this was underspecified as resolved by issue 23. This is clean-up for that
++issue in turn. Some concern that we are trying to solve the same problem in both clause 22 and 27.
++</p>
++<p>
++Bill: There's a change here as to whether val is stored to in an error case.
++</p>
++<p>
++Pablo: Don't think this changes whether val is stored to or not, but changes the value that is stored.
++</p>
++<p>
++Bill: Remembers having skirmishes with customers and testers as to whether val is stored to, and the resolution was not to store in error cases.
++</p>
++<p>
++Howard: Believes since C++03 we made a change to always store in overflow.
++</p>
++<p>
++Everyone took some time to review the issue.
++</p>
++<p>
++Pablo: C++98 definitely did not store any value during an error condition.
++</p>
++<p>
++Dietmar: Depends on the question of what is considered an error, and whether overflow is an error or not, which was the crux of LWG 23.
++</p>
++<p>
++Pablo: Yes, but given the "zero, if the conversion function fails to convert the entire field", we are requiring every error condition to store.
++</p>
++<p>
++Bill: When did this happen?
++</p>
++<p>
++Alisdair: One of the last two or three meetings.
++</p>
++<p>
++Dietmar: To store a value in case of failure is a very bad idea.
++</p>
++<p>
++Move to Open, needs more study.
++</p>
+ </blockquote>
+-</li>
+-</ol>
+-<p></p>
+
++<p><i>[2011-03-24 Madrid meeting]</i></p>
+
+
++<p>Move to deferred</p>
+
++<p><i>[
++2011 Bloomington
++]</i></p>
+
+
+-<hr>
+-<h3><a name="1396"></a>1396. [FCD] <tt>regex</tt> should support allocators</h3>
+-<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-07</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex">issues</a> in [re.regex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a></p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-104, US-141</b></p>
+ <p>
+-<tt>std::basic_regex</tt> should have an allocator for all the
+-reasons that a <tt>std::string</tt> does. For example, I can use
+-<tt>boost::interprocess</tt> to put a <tt>string</tt> or <tt>vector</tt>
+-in shared memory, but not a <tt>regex</tt>.
++The proposed wording looks good, no-one sure why this was held back before. Move to Review.
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++
++<p><i>[2012,Kona]</i></p>
+
+ <p>
+-Add allocators to regexes
++Move to Open.
++</p>
++<p>
++THe issues is what to do with <tt>-1</tt>. Should it match 'C' or do the "sane" thing.
++A fix here changes behavior, but is probably what we want.
++</p>
++<p>
++Pablo to provide wording, with help from Howard.
+ </p>
+
+-<p><i>[
+-2010-10-24 Daniel adds:
+-]</i></p>
++<p><i>[2015-05-06 Lenexa: Move to Ready]</i></p>
+
++<p>STL: I like that this uses strtof, which I think is new in C99. that avoids truncation from using atof. I have another issue ...</p>
++<p>MC: yes LWG 2403 (stof should call strtof)</p>
++<p>PJP: the last line is horrible, you don't assign to err, you call setstate(ios_base::failbit). Ah, no, this is inside num_get so the caller does the setstate.</p>
++<p>MC: we need all these words. are they the right words?</p>
++<p>JW: I'd like to take a minute to check my impl. Technically this implies a change in behaviour (from always using strtold and checking the extracted floating point value, to using the right function). Oh, we already do exactly this.</p>
++<p>MC: Move to Ready</p>
++<p>6 in favor, none opposed, 1 abstention</p>
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">n3171</a> would solve this issue.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
++<p>
++Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:
++</p>
++<blockquote>
++<p>
++<b>Stage 3:</b>
++The sequence of <code>char</code>s accumulated in stage 2 (the field) is
++converted to a numeric value by the rules of one of the functions declared in
++the header <code>&lt;cstdlib&gt;</code>:
++</p>
++<ul>
++<li>For a signed integer value, the function <code>strtoll</code>.</li>
++<li>For an unsigned integer value, the function <code>strtoull</code>.</li>
++<li><ins>For a <code>float</code> value, the function
++ <code>strtof</code>.</ins></li>
++<li><ins>For a <code>double</code> value, the function
++ <code>strtod</code>.</ins></li>
++<li>For a <del>floating-point</del> <ins><code>long double</code></ins>
++ value, the function <code>strtold</code>.</li>
++</ul>
++<p>
++The numeric value to be stored can be one of:
++</p>
++<ul>
++<li>zero, if the conversion function fails to convert the entire field.
++ <del><code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
++<li>the most positive <ins>(or negative)</ins> representable value, if
++ the field <ins>to be converted to a signed integer type</ins> represents a
++ value too large positive <ins>(or negative)</ins> to be represented in
++ <code>val</code>.
++ <del><code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
++<li><del>the most negative representable value or zero for an unsigned integer
++ type, if the field represents a value too large negative to be represented
++ in <code>val</code>.
++ <code>ios_base::failbit</code> is assigned to <code>err</code>.</del></li>
++<li><ins>the most positive representable value, if the field to be converted to
++ an unsigned integer type represents a value that cannot be represented in
++ <code>val</code>.</ins></li>
++<li>the converted value, otherwise.</li>
++</ul>
++<p>
++The resultant numeric value is stored in <code>val</code>.
++<ins>If the conversion function fails to convert the entire field, or if the
++field represents a value outside the range of representable values,
++<code>ios_base::failbit</code> is assigned to <code>err</code>.</ins>
++</p>
++</blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">n3171</a>.
+
+
+
+
+
+ <hr>
+-<h3><a name="1401"></a>1401. [FCD] <tt>unique_ptr&lt;T&gt; == nullptr</tt></h3>
+-<p><b>Section:</b> 20.9 [memory] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#memory">issues</a> in [memory].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
++<h3><a name="1173"></a>1173. "Equivalence" wishy-washiness</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-99</b></p>
+ <p>
+-One reason that the <tt>unique_ptr</tt> constructor taking a
+-<tt>nullptr_t</tt> argument is not <tt>explicit</tt> is to allow conversion
+-of <tt>nullptr</tt> to <tt>unique_ptr</tt> in contexts like equality
+-comparison. Unfortunately <tt>operator==</tt> for <tt>unique_ptr</tt> is a
+-little more clever than that, deducing template parameters for both
+-arguments. This means that <tt>nullptr</tt> does not get deduced
+-as <tt>unique_ptr</tt> type, and there are no other comparison
+-functions to match.
++Issue: The <tt>CopyConstructible</tt> requirements are wishy-washy. It requires
++that the copy is "equivalent" to the original, but "equivalent" is never
++defined.
++</p>
++<p>
++I believe this to be an example of a more general lack of rigor around
++copy and assignment, although I haven't done the research to dig up all
++the instances.
++</p>
++<p>
++It's a problem because if you don't know what <tt>CopyConstructible</tt> means,
++you also don't know what it means to copy a pair of <tt>CopyConstructible</tt>
++types. It doesn't prevent us from writing code, but it is a hole in our
++ability to understand the meaning of copy.
++</p>
++<p>
++Furthermore, I'm pretty sure that vector's copy constructor doesn't
++require the elements to be <tt>EqualityComparable</tt>, so that table is actually
++referring to some ill-defined notion of equivalence when it uses ==.
+ </p>
+
+ <p><i>[
+-Resolution proposed by ballot comment:
++2009 Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-Add the following signatures to 20.9 [memory] p.1, <tt>&lt;memory&gt;</tt>
+-header synopsis:
+-<blockquote><pre>template&lt;typename T, typename D&gt;
+-bool operator==(const unique_ptr&lt;T, D&gt; &amp; lhs, nullptr_t);
+-template&lt;typename T, typename D&gt;
+-bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt; &amp; rhs);
+-template&lt;typename T, typename D&gt;
+-bool operator!=(const unique_ptr&lt;T, D&gt; &amp; lhs, nullptr_t);
+-template&lt;typename T, typename D&gt;
+-bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt; &amp; rhs);
+-</pre></blockquote>
+-</blockquote>
++
++<blockquote><p>
++Move to "Open". Dave is right that this is a big issue. Paper D2987
++("Defining Move Special Member Functions", Bjarne Stroustrup and
++Lawrence Crowl) touches on this but does not solve it. This issue is
++discussed in Elements of Programming.
++</p></blockquote>
++
+
+ <p><i>[
+-2010-11-02 Daniel comments and provides a proposed resolution:
++2010 Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
+-The same problem applies to <tt>shared_ptr</tt> as well: In both cases there are no
+-conversions considered because the comparison functions are templates. I agree with
+-the direction of the proposed resolution, but I believe it would be very surprising
+-and inconsistent, if given a smart pointer object <tt>p</tt>, the expression
+-<tt>p == nullptr</tt> would be provided, but not <tt>p &lt; nullptr</tt> and the
+-other relational operators. According to 5.9 [expr.rel] they are defined
+-if null pointer values meet other pointer values, even though the result is unspecified
+-for all except some trivial ones. But null pointer values are nothing special here:
+-The Library already defines the relational operators for both <tt>unique_ptr</tt> and
+-<tt>shared_ptr</tt> and the outcome of comparing non-null pointer values will be equally
+-unspecified. If the idea of supporting <tt>nullptr_t</tt> arguments for relational
+-operators is not what the committee prefers, I suggest at least to consider to remove
+-the existing relational operators for both <tt>unique_ptr</tt> and <tt>shared_ptr</tt>
+-for consistency. But that would not be my preferred resolution of this issue.
+-<p>
+-The number of overloads triple the current number, but I think it is much clearer to
+-provide them explicitly instead of adding wording that attempts to say that "sufficient overloads" are
+-provided. The following proposal makes the declarations explicit.
+-</p><p>
+-Additionally, the proposal adds the missing declarations for some <tt>shared_ptr</tt>
+-comparison functions for consistency.
++<blockquote><p>
++This issue is quite vague, so it is difficult to know if and when it has been resolved.
++John Lakos wrote a paper covering this area a while back, and there is a real interest
++in providing some sort of clean-up in the future. We need a more clearly draughted
++issues with an addressable set of concerns, ideally with a paper proposing a resolution,
++but for a future revision of the standard. Move to Tentatively NAD Future.
+ </p></blockquote>
+
+ <p><i>[
+-2010-11-03 Daniel adds:
++Moved to NAD Future at 2010-11 Batavia
+ ]</i></p>
+
+
+-<p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a> is remotely related. The following proposed resolution splits
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401_extra_bullet">this bullet</a> into sub-bullets A and B. Sub-bullet A would
+-also solve <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>, but sub-bullet B would not.
+-</p><p>
+-A further remark in regard to the proposed semantics of the ordering of <tt>nullptr</tt>
+-against other pointer(-like) values: One might think that the following definition might
+-be superior because of simplicity:
+-
+-</p><blockquote><pre>template&lt;class T&gt;
+-bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t);
+-template&lt;class T&gt;
+-bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a);
+-</pre><blockquote>
+-<i>Returns</i>: <tt>false</tt>.
+-</blockquote></blockquote>
+
+-The underlying idea behind this approach is the assumption that nullptr corresponds
+-to the least ordinal pointer value. But this assertion does not hold for all supported
+-architectures, therefore this approach was not followed because it would lead to
+-the inconsistency, that the following assertion could fire:
+-<p></p>
+-<blockquote><pre>shared_ptr&lt;int&gt; p(new int);
+-shared_ptr&lt;int&gt; null;
+-bool v1 = p &lt; nullptr;
+-bool v2 = p &lt; null;
+-assert(v1 == v2);
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Wording changes are against N3126.
+-<p>
+-</p><ol>
+-<li>Change 20.9 [memory] p. 1, header <tt>&lt;memory&gt;</tt> synopsis as indicated.
+-<tt>noexcept</tt> specifications are only added, where the guarantee exists, that the function
+-shall no throw an exception (as replacement of "<i>Throws</i>: Nothing". This needs
+-to be harmonized with the result of the <tt>noexcept</tt> proposals:
+-<blockquote><pre>namespace std {
+- [..]
+- // <i>20.9.10 Class unique_ptr:</i>
+- template &lt;class T&gt; class default_delete;
+- template &lt;class T&gt; class default_delete&lt;T[]&gt;;
+- template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr;
+- template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;
+-
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-
+- // <i>20.9.11.1, Class bad_weak_ptr:</i>
+- class bad_weak_ptr;
+-
+- // <i>20.9.11.2, Class template shared_ptr:</i>
+- template&lt;class T&gt; class shared_ptr;
+-
+- // <i>20.9.11.2.7, shared_ptr comparisons:</i>
+- template&lt;class T, class U&gt;
+- bool operator==(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator!=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator&lt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator&gt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator&lt;=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator&gt;=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b);
+-
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator==(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator==(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator!=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator!=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
+
+- [..]
+-}
+-</pre></blockquote>
+-</li>
+-<li>Change the synopsis just after 20.9.9 [unique.ptr] p. 6 as indicated:
+-<blockquote><pre>namespace std {
+- [..]
+-
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+- template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+- <ins>template &lt;class T, class D&gt;</ins>
+- <ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+
+-}
+-</pre></blockquote>
+-</li>
+-<li><a name="1401_extra_bullet">This bullet splits into two sub-bullets A and B as mentioned in the discussion comment:</a>
+-<ol style="list-style-type:upper-alpha">
+-<li>Change 20.9.9.4 [unique.ptr.special]/4-7 as indicated and add a series of prototype
+-descriptions:
+-<blockquote><pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
+-<blockquote>
++<hr>
++<h3><a name="1175"></a>1175. <tt>unordered</tt> complexity</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-07-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-<ins>? <i>Requires:</i> Let <tt>CT</tt> be <tt>common_type&lt;unique_ptr&lt;T1,
+-D1&gt;::pointer, unique_ptr&lt;T2, D2&gt;::pointer&gt;::type</tt>. Then
+-the specialization <tt>less&lt;CT&gt;</tt> shall be a function object type ([function.objects])
+-that induces a strict weak ordering ([alg.sorting]) on the pointer values.</ins>
++When I look at the <tt>unordered_*</tt> constructors, I think the complexity is poorly
++described and does not follow the style of the rest of the standard.
+ </p>
+
+ <p>
+-4 <i>Returns:</i> <tt><ins>less&lt;CT&gt;()(x.get(), y.get())</ins><del>x.get()
+-&lt; y.get()</del></tt>.
++The complexity for the default constructor is specified as constant.
++Actually, it is proportional to <tt>n</tt>, but there are no invocations of
++<tt>value_type</tt> constructors or other <tt>value_type</tt> operations.
+ </p>
+
+ <p>
+-<ins>? <i>Remarks:</i> If <tt>unique_ptr&lt;T1, D1&gt;::pointer</tt> is not
+-implicitly convertible to <tt>CT</tt> or <tt>unique_ptr&lt;T2,
+-D2&gt;::pointer</tt> is not implicitly convertible to <tt>CT</tt>, the program
+-is ill-formed.</ins>
++For the iterator-based constructor the complexity should be:
+ </p>
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
++<blockquote><p>
++<i>Complexity:</i> exactly <tt>n</tt> calls to construct <tt>value_type</tt>
++from <tt>InputIterator::value_type</tt> (where <tt>n = distance(f,l)</tt>).
++The number of calls to <tt>key_equal::operator()</tt> is proportional to
++<tt>n</tt> in the average case and <tt>n*n</tt> in the worst case.
++</p></blockquote>
++
++<p><i>[
++2010 Rapperswil:
++]</i></p>
++
++
++<blockquote><p>
++Concern that the current wording may require O(1) where that cannot be delivered. We need to look at
++both the clause 23 requirements tables and the constructor description of each unordered container to be sure.
++</p>
++<p>
++Howard suggests NAD Editorial as we updated the container requirement tables since this issue was written.
++</p>
++<p>
++Daniel offers to look deeper, and hopefully produce wording addressing any outstanding concerns at the next meeting.
++</p>
++<p>
++Move to Open.
++</p>
++</blockquote>
++
++<p><i>[2011-02-26: Daniel provides wording]</i></p>
++
++
++<p>I strongly suggest to clean-up the differences between requirement tables and individual
++specifications. In the usual way, the most specific specifications wins, which is in this
++case the wrong one. In regard to the concern expressed about missing <tt>DefaultConstructible</tt>
++requirements of the value type I disagree: The function argument <tt>n</tt> is no size-control
++parameter, but only some effective capacity parameter: No elements will be value-initialized
++by these constructors. The necessary requirement for the value type, <tt>EmplaceConstructible</tt>
++into <tt>*this</tt>, is already listed in Table 103 &mdash; Unordered associative container requirements.
++Another part of the proposed resolution is the fact that there is an inconsistency of the
++complexity counting when both a range <strong>and</strong> a bucket count is involved compared
++to constructions where only bucket counts are provided: E.g. the construction <tt>X a(n);</tt>
++has a complexity of <tt>n</tt> bucket allocations, but this part of the work is omitted for
++<tt>X a(i, j, n);</tt>, even though it is considerable larger (in the average case) for
++<tt>n &#8811; distance(i, j)</tt>.
++</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>Move to deferred</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++The proposed wording looks good. Move to Review.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Fix up some presentation issues with the wording, combining the big-O expressions into single
++expressions rather than the sum of two separate big-Os.
++</p>
++<p>
++Strike "constant or linear", prefer "linear in the number of buckets".
++This allows for number of buckets being larger than requested <tt>n</tt> as well.
++</p>
++<p>
++Default <tt>n</tt> to "unspecified" rather than "implementation-defined". It seems an un-necessary
++burden asking vendors to document a quantity that is easily determined through the public API of
++these classes.
++</p>
++<p>
++Replace <tt>distance(f,l)</tt> with "number of elements in the range <tt>[f,l)</tt>"
++</p>
++<p>
++Retain in Review with the updated wording
++</p>
++
++<p><i>[2012, Portland: Move to Open]</i></p>
++
++<p>
++The wording still does not call out Pablo's original concern, that the element constructor is called
++no more than <tt>N</tt> times, and that the <tt>N</tt> squared term applies to moves during rehash.
++</p>
++
++<p>
++Inconsistent use of O(n)+O(N) vs. O(n+N), with a preference for the former.
++</p>
++
++<p>
++AJM to update wording with a reference to "no more than <tt>N</tt> element constructor calls".
++</p>
++
++<p>
++Matt concerned that calling out the O(n) requirements is noise, and dangerous noise in suggesting a precision
++we do not mean. The cost of constructing a bucket is very different to constructing an element of user-supplied
++type.
++</p>
++
++<p>
++AJM notes that if there are multiple rehashes, the 'n' complexity is probably not linear.
++</p>
++
++<p>
++Matt suggests back to Open, Pablo suggests potentially NAD if we keep revisitting without achieving a resolution.
++</p>
++
++<p>
++Matt suggests complexity we are concerned with is the number of operations, such as constructing elements, moving
++nodes, and comparing/hashing keys. We are less concerned with constructing buckets, which are generally noise in
++this bigger picture.
++</p>
++
++<p><i>[2015-01-29 Telecon]</i></p>
++
++<p>
++AM: essentially correct, but do we want to complicate the spec?
++<p/>
++HH: Pablo has given us permission to NAD it
++<p/>
++JM: when I look at the first change in the P/R I find it mildly disturbing that the existing wording says you have a
++constant time constructor with a single element even if your <tt>n</tt> is 10^6, so I think adding this change makes people
++aware there might be a large cost in initializing the hash table, even though it doesn't show up in user-visible constructions.
++<p/>
++HH: one way to avoid that problem is make the default ctor <tt>noexcept</tt>. Then the container isn't allowed to create
++an arbitrarily large hash table
++<p/>
++AM: but this is the constructor where the user provides <tt>n</tt>
++<p/>
++MC: happy with the changes, except I agree with the editorial recommendation to keep the two &#x1d4aa;s separate.
++<p/>
++JW: yes, the constant '<tt>k</tt>' is different in &#x1d4aa;(n) and &#x1d4aa;(N)
++<p/>
++GR: do we want to talk about buckets at all
++<p/>
++JM: yes, good to highlight that bucket construction might be a significant cost
++<p/>
++HH: suggest we take the suggestion to split &#x1d4aa;(n+N) to &#x1d4aa;(n)+&#x1d4aa;(N) and move to Tentatively Ready
++<p/>
++GR: 23.2.1p2 says all complexity requirements are stated solely in terms of the number of operations on the contained
++object, so we shouldn't be stating complexity in terms of the hash table initialization
++<p/>
++HH: channeling Pete, there's an implicit "unless otherwise specified" everywhere.
++<p/>
++VV: seem to be requesting modifications that render this not Tentatively Ready
++<p/>
++GR: I think it can't be T/R
++<p/>
++AM: make the editorial recommendation, consider fixing 23.2.1/3 to give us permission to state complexity in terms
++of bucket initialization
++<p/>
++HH: only set it to Review after we get new wording to review
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Update wording, revisit later.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Modify the following rows in Table 103 &mdash; Unordered associative container requirements to
++add the explicit bucket allocation overhead of some constructions. As editorial recommendation it is
++suggested <em>not</em> to shorten the sum <tt>&#x1d4aa;(n) + &#x1d4aa;(<em>N</em>)</tt> to
++<tt>&#x1d4aa;(n + <em>N</em>)</tt>, because two different work units are involved.</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 103 &mdash; Unordered associative container requirements (in addition to container)</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" style="text-align:center;">&hellip;</td>
++</tr>
++
++<tr>
++<td><tt>X(i, j, n, hf, eq)</tt><br/>
++<tt>X a(i, j, n, hf, eq)</tt>
++</td>
++<td><tt>X</tt></td>
++<td>&hellip;<br/>
++<i>Effects</i>: Constructs an empty container with at least <tt>n</tt><br/>
++buckets, using <tt>hf</tt> as the hash function and <tt>eq</tt> as the key<br/>
++equality predicate, and inserts elements from <tt>[i, j)</tt> into it.
++</td>
++<td>Average case &#x1d4aa;(<tt><i><ins>n + </ins>N</i></tt>) (<tt><i>N</i></tt> is <tt>distance(i, j)</tt>),<br/>
++worst case <ins>&#x1d4aa;(<tt>n</tt>) +</ins> &#x1d4aa;(<tt><i>N</i><sup>2</sup></tt>)</td>
++</tr>
++
++<tr>
++<td><tt>X(i, j, n, hf)</tt><br/>
++<tt>X a(i, j, n, hf)</tt>
++</td>
++<td><tt>X</tt></td>
++<td>&hellip;<br/>
++<i>Effects</i>: Constructs an empty container with at least <tt>n</tt><br/>
++buckets, using <tt>hf</tt> as the hash function and <tt>key_equal()</tt> as the key<br/>
++equality predicate, and inserts elements from <tt>[i, j)</tt> into it.
++</td>
++<td>Average case &#x1d4aa;(<tt><i><ins>n + </ins>N</i></tt>) (<tt><i>N</i></tt> is <tt>distance(i, j)</tt>),<br/>
++worst case &#x1d4aa;(<tt><i><ins>n + </ins>N</i><sup>2</sup></tt>)</td>
++</tr>
++
++<tr>
++<td><tt>X(i, j, n)</tt><br/>
++<tt>X a(i, j, n)</tt>
++</td>
++<td><tt>X</tt></td>
++<td>&hellip;<br/>
++<i>Effects</i>: Constructs an empty container with at least <tt>n</tt><br/>
++buckets, using <tt>hasher()</tt> as the hash function and <tt>key_equal()</tt> as the key<br/>
++equality predicate, and inserts elements from <tt>[i, j)</tt> into it.
++</td>
++<td>Average case &#x1d4aa;(<tt><i><ins>n + </ins>N</i></tt>) (<tt><i>N</i></tt> is <tt>distance(i, j)</tt>),<br/>
++worst case &#x1d4aa;(<tt><i><ins>n + </ins>N</i><sup>2</sup></tt>)</td>
++</tr>
++
++<tr>
++<td colspan="4" style="text-align:center;">&hellip;</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Modify 23.5.4.2 [unord.map.cnstr] p. 1-4 as indicated (The edits of p. 1 and p. 3 attempt to fix some
++editorial oversight.):</p>
++
++<blockquote><pre>
++explicit unordered_map(size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++1 <i>Effects</i>: Constructs an empty <tt>unordered_map</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_map</tt></del>.
++<tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++2 <i>Complexity</i>: <del>Constant</del><ins>Linear in the number of buckets</ins>.
++</p></blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_map(InputIterator f, InputIterator l,
++ size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++3 <i>Effects</i>: Constructs an empty <tt>unordered_map</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_map</tt></del>.
++Then inserts elements from the range <tt>[f, l)</tt>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++4 <i>Complexity</i>: <del>Average case linear, worst case quadratic</del><ins>Linear in the number of buckets.
++In the average case linear in <tt><i>N</i></tt> and in the worst case quadratic in <tt><i>N</i></tt> to insert
++the elements, where <tt><i>N</i></tt> is equal to number of elements in the range <tt>[f,l)</tt></ins>.
++</p></blockquote>
++</blockquote>
++</li>
++
++<li><p>Modify 23.5.5.2 [unord.multimap.cnstr] p. 1-4 as indicated (The edits of p. 1 and p. 3 attempt to fix some
++editorial oversight.):</p>
++
++<blockquote><pre>
++explicit unordered_multimap(size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++1 <i>Effects</i>: Constructs an empty <tt>unordered_multimap</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_multimap</tt></del>.
++<tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++2 <i>Complexity</i>: <del>Constant</del><ins>Linear in the number of buckets</ins>.
++</p></blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_multimap(InputIterator f, InputIterator l,
++ size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++3 <i>Effects</i>: Constructs an empty <tt>unordered_multimap</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_multimap</tt></del>.
++Then inserts elements from the range <tt>[f, l)</tt>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++4 <i>Complexity</i>: <del>Average case linear, worst case quadratic</del><ins>Linear in the number of buckets.
++In the average case linear in <tt><i>N</i></tt> and in the worst case quadratic in <tt><i>N</i></tt> to insert
++the elements, where <tt><i>N</i></tt> is equal to number of elements in the range <tt>[f,l)</tt></ins>.
++</p></blockquote>
++</blockquote>
++</li>
++
++<li><p>Modify 23.5.6.2 [unord.set.cnstr] p. 1-4 as indicated (The edits of p. 1 and p. 3 attempt to fix some
++editorial oversight.):</p>
++
++<blockquote><pre>
++explicit unordered_set(size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++1 <i>Effects</i>: Constructs an empty <tt>unordered_set</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_set</tt></del>.
++<tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++2 <i>Complexity</i>: <del>Constant</del><ins>Linear in the number of buckets</ins>.
++</p></blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_set(InputIterator f, InputIterator l,
++ size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++3 <i>Effects</i>: Constructs an empty <tt>unordered_set</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_set</tt></del>.
++Then inserts elements from the range <tt>[f, l)</tt>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++4 <i>Complexity</i>: <del>Average case linear, worst case quadratic</del><ins>Linear in the number of buckets.
++In the average case linear in <tt><i>N</i></tt> and in the worst case quadratic in <tt><i>N</i></tt> to insert
++the elements, where <tt><i>N</i></tt> is equal to number of elements in the range <tt>[f,l)</tt></ins>.
++</p></blockquote>
++</blockquote>
++</li>
++
++<li><p>Modify 23.5.7.2 [unord.multiset.cnstr] p. 1-4 as indicated (The edits of p. 1 and p. 3 attempt to fix some
++editorial oversight.):</p>
++
++<blockquote><pre>
++explicit unordered_multiset(size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++1 <i>Effects</i>: Constructs an empty <tt>unordered_multiset</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_multiset</tt></del>.
++<tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++2 <i>Complexity</i>: <del>Constant</del><ins>Linear in the number of buckets</ins>.
++</p></blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_multiset(InputIterator f, InputIterator l,
++ size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre><blockquote><p>
++3 <i>Effects</i>: Constructs an empty <tt>unordered_multiset</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++<ins>unspecified</ins><del>impldefdefault number of buckets in <tt>unordered_multiset</tt></del>.
++Then inserts elements from the range <tt>[f, l)</tt>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p></blockquote>
++<blockquote><p>
++4 <i>Complexity</i>: <del>Average case linear, worst case quadratic</del><ins>Linear in the number of buckets.
++In the average case linear in <tt><i>N</i></tt> and in the worst case quadratic in <tt><i>N</i></tt> to insert
++the elements, where <tt><i>N</i></tt> is equal to number of elements in the range <tt>[f,l)</tt></ins>.
++</p></blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1184"></a>1184. Feature request: dynamic bitset</h3>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Opened at Alisdair's request, steming from <a href="lwg-closed.html#96">96</a>.
++Alisdair recommends NAD Future.
++</p>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++NAD Future. We want a heap allocated bitset, but we don't have one today and
++don't have time to add one.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1188"></a>1188. Unordered containers should have a minimum load factor as well as a maximum</h3>
++<p><b>Section:</b> 23.2.5 [unord.req], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Unordered associative containers have a notion of a maximum load factor:
++when the number of elements grows large enough, the containers
++automatically perform a rehash so that the number of elements per bucket
++stays below a user-specified bound. This ensures that the hash table's
++performance characteristics don't change dramatically as the size
++increases.
++</p>
++
++<p>
++For similar reasons, Google has found it useful to specify a minimum
++load factor: when the number of elements shrinks by a large enough, the
++containers automatically perform a rehash so that the number of elements
++per bucket stays above a user-specified bound. This is useful for two
++reasons. First, it prevents wasting a lot of memory when an unordered
++associative container grows temporarily. Second, it prevents amortized
++iteration time from being arbitrarily large; consider the case of a hash
++table with a billion buckets and only one element. (This was discussed
++even before TR1 was published; it was TR issue 6.13, which the LWG
++closed as NAD on the grounds that it was a known design feature.
++However, the LWG did not consider the approach of a minimum load
++factor.)
++</p>
++
++<p>
++The only interesting question is when shrinking is allowed. In principle
++the cleanest solution would be shrinking on erase, just as we grow on
++insert. However, that would be a usability problem; it would break a
++number of common idioms involving erase. Instead, Google's hash tables
++only shrink on insert and rehash.
++</p>
++
++<p>
++The proposed resolution allows, but does not require, shrinking in
++rehash, mostly because a postcondition for rehash that involves the
++minimum load factor would be fairly complicated. (It would probably have
++to involve a number of special cases and it would probably have to
++mention yet another parameter, a minimum bucket count.)
++</p>
++
++<p>
++The current behavior is equivalent to a minimum load factor of 0. If we
++specify that 0 is the default, this change will have no impact on
++backward compatibility.
++</p>
++
++
++<p><i>[
++2010 Rapperswil:
++]</i></p>
++
++
++<blockquote><p>
++This seems to a useful extension, but is too late for 0x.
++
++Move to Tentatively NAD Future.
++</p></blockquote>
++
++<p><i>[
++Moved to NAD Future at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add two new rows, and change rehash's postcondition in the unordered
++associative container requirements table in 23.2.5 [unord.req]:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 87 &mdash; Unordered associative container requirements
++(in addition to container)</caption>
++
++<tr>
++<th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++<tr>
++<td><ins>
++<tt>a.min_load_factor()</tt>
++</ins></td>
++<td><ins>
++<tt>float</tt>
++</ins></td>
++<td><ins>
++Returns a non-negative number that the container attempts to keep the
++load factor greater than or equal to. The container automatically
++decreases the number of buckets as necessary to keep the load factor
++above this number.
++</ins></td>
++<td><ins>
++constant
++</ins></td>
++</tr>
++
++<tr>
++<td><ins><tt>a.min_load_factor(z)</tt></ins></td>
++<td><ins><tt>void</tt></ins></td>
++<td><ins>Pre: <tt>z</tt> shall be non-negative. Changes the container's minimum
++load factor, using <tt>z</tt> as a hint. [<i>Footnote:</i> the minimum
++load factor should be significantly smaller than the maximum.
++If <tt>z</tt> is too large, the implementation may reduce it to a more sensible value.]
++</ins></td>
++<td><ins>
++constant
++</ins></td>
++</tr>
++<tr>
++<td><tt>a.rehash(n)</tt></td>
++<td><tt>void</tt></td>
++<td>
++Post: <ins><tt>a.bucket_count() &gt;= n</tt>, and <tt>a.size() &lt;= a.bucket_count()
++* a.max_load_factor()</tt>. [<i>Footnote:</i> It is intentional that the
++postcondition does not mention the minimum load factor.
++This member function is primarily intended for cases where the user knows
++that the container's size will increase soon, in which case the container's
++load factor will temporarily fall below <tt>a.min_load_factor()</tt>.]</ins>
++<del>
++<tt>a.bucket_cout &gt; a.size() / a.max_load_factor()</tt> and <tt>a.bucket_count()
++&gt;= n</tt>.
++</del>
++</td>
++<td>
++Average case linear in <tt>a.size()</tt>, worst case quadratic.
++</td>
++</tr>
++</table>
++</blockquote>
++
++<p>
++Add a footnote to 23.2.5 [unord.req] p12:
++</p>
++
++<blockquote>
++<p>
++The insert members shall not affect the validity of references to
++container elements, but may invalidate all iterators to the container.
++The erase members shall invalidate only iterators and references to the
++erased elements.
++</p>
++
++<blockquote><p>
++[A consequence of these requirements is that while insert may change the
++number of buckets, erase may not. The number of buckets may be reduced
++on calls to insert or rehash.]
++</p></blockquote>
++</blockquote>
++
++<p>
++Change paragraph 13:
++</p>
++
++<blockquote><p>
++The insert members shall not affect the validity of iterators if
++<del><tt>(N+n) &lt; z * B</tt></del> <ins><tt>zmin * B &lt;= (N+n) &lt;= zmax * B</tt></ins>,
++where <tt>N</tt> is the number of elements in
++the container prior to the insert operation, <tt>n</tt> is the number of
++elements inserted, <tt>B</tt> is the container's bucket count,
++<ins><tt>zmin</tt> is the container's minimum load factor,</ins>
++and <tt>z<ins>max</ins></tt> is the container's maximum load factor.
++</p></blockquote>
++
++<p>
++Add to the <tt>unordered_map</tt> class synopsis in section 23.5.4 [unord.map],
++the <tt>unordered_multimap</tt> class synopsis
++in 23.5.5 [unord.multimap], the <tt>unordered_set</tt> class synopsis in
++23.5.6 [unord.set], and the <tt>unordered_multiset</tt> class synopsis
++in 23.5.7 [unord.multiset]:
++</p>
++
++<blockquote><pre><ins>
++float min_load_factor() const;
++void min_load_factor(float z);
++</ins></pre></blockquote>
++
++<p>
++In 23.5.4.2 [unord.map.cnstr], 23.5.5.2 [unord.multimap.cnstr], 23.5.6.2 [unord.set.cnstr], and
++23.5.7.2 [unord.multiset.cnstr], change:
++</p>
++
++<blockquote><p>
++... <tt>max_load_factor()</tt> returns 1.0 <ins>and
++<tt>min_load_factor()</tt> returns 0</ins>.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1201"></a>1201. Do we always want to unwrap <tt>ref</tt>-wrappers in <tt>make_tuple</tt></h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation], 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Spotting a recent thread on the boost lists regarding collapsing
++optional representations in <tt>optional&lt;optional&lt;T&gt;&gt;</tt> instances, I wonder if
++we have some of the same issues with <tt>make_tuple</tt>, and now <tt>make_pair</tt>?
++</p>
++
++<p>
++Essentially, if my generic code in my own library is handed a
++<tt>reference_wrapper</tt> by a user, and my library in turn delegates some logic
++to <tt>make_pair</tt> or <tt>make_tuple</tt>, then I am going to end up with a <tt>pair</tt>/<tt>tuple</tt>
++holding a real reference rather than the intended reference wrapper.
++</p>
++
++<p>
++There are two things as a library author I can do at this point:
++</p>
++
++<ol style="list-style-type:lower-roman">
++<li>
++document my library also has the same reference-wrapper behaviour as
++<tt>std::make_tuple</tt>
++</li>
++<li>
++roll my own <tt>make_tuple</tt> that does not unwrap rereferences, a lost
++opportunity to re-use the standard library.
++</li>
++</ol>
++
++<p>
++(There may be some metaprogramming approaches my library can use to wrap
++the <tt>make_tuple</tt> call, but all will be significantly more complex than
++simply implementing a simplified <tt>make_tuple</tt>.)
++</p>
++
++<p>
++Now I don't propose we lose this library facility, I think unwrapping
++references will be the common behaviour. However, we might want to
++consider adding another overload that does nothing special with
++<tt>ref</tt>-wrappers. Note that we already have a second overload of
++<tt>make_tuple</tt> in the library, called <tt>tie</tt>.
++</p>
++
++<p><i>[
++2009-09-30 Daniel adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++I suggest to change the currently proposed paragraph for
++<tt>make_simple_pair</tt>
++</p>
++
++<blockquote><pre>
++template&lt;typename... Types&gt;
++ pair&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_pair(Types&amp;&amp;... t);
++</pre>
++<blockquote>
++<p>
++<del><i>Type requirements:</i> <tt>sizeof...(Types) == 2</tt>.</del>
++<ins><i>Remarks:</i> The program shall be ill-formed, if
++<tt>sizeof...(Types) != 2</tt>.</ins>
++</p>
++<p>
++...
++</p>
++</blockquote>
++</blockquote>
++
++<p>
++or alternatively (but with a slightly different semantic):
++</p>
++
++<blockquote>
++<blockquote><p>
++<i>Remarks:</i> If <tt>sizeof...(Types) != 2</tt>, this function shall not
++participate in overload resolution.
++</p></blockquote>
++</blockquote>
++
++<p>
++to follow a currently introduced style and because the library does
++not have yet a specific "<i>Type requirements</i>" element. If such thing
++would be considered as useful this should be done as a separate
++issue. Given the increasing complexity of either of these wordings
++it might be preferable to use the normal two-argument-declaration
++style again in either of the following ways:
++</p>
++
++<ol style="list-style-type:upper-alpha">
++<li>
++<pre>template&lt;class T1, class T2&gt;
++pair&lt;typename decay&lt;T1&gt;::type, typename decay&lt;T2&gt;::type&gt;
++make_simple_pair(T1&amp;&amp; t1, T2&amp;&amp; t2);
++</pre>
++</li>
++<li>
++<pre>template&lt;class T1, class T2&gt;
++pair&lt;V1, V2&gt; make_simple_pair(T1&amp;&amp; t1, T2&amp;&amp; t2);
++</pre>
++<blockquote><p>
++Let <tt>V1</tt> be <tt>typename decay&lt;T1&gt;::type</tt> and <tt>V2</tt> be
++<tt>typename decay&lt;T2&gt;::type</tt>.
++</p></blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark as Tentatively NAD Future.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Does not have sufficient support at this time. May wish to reconsider for a
++future standard.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add the following function to 20.3 [pairs] and signature in
++appropriate synopses:
++</p>
++
++<blockquote><pre>
++template&lt;typename... Types&gt;
++ pair&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_pair(Types&amp;&amp;... t);
++</pre>
++<blockquote>
++<p>
++<i>Type requirements:</i> <tt>sizeof...(Types) == 2</tt>.
++</p>
++<p>
++<i>Returns:</i> <tt>pair&lt;typename decay&lt;Types&gt;::type...&gt;(std::forward&lt;Types&gt;(t)...)</tt>.
++</p>
++</blockquote>
++</blockquote>
++
++<p><i>[
++Draughting note: I chose a variadic representation similar to <tt>make_tuple</tt>
++rather than naming both types as it is easier to read through the
++clutter of metaprogramming this way. Given there are exactly two
++elements, the committee may prefer to draught with two explicit template
++type parameters instead
++]</i></p>
++
++
++<p>
++Add the following function to 20.4.2.4 [tuple.creation] and
++signature in appropriate synopses:
++</p>
++
++<blockquote><pre>
++template&lt;typename... Types&gt;
++ tuple&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_tuple(Types&amp;&amp;... t);
++</pre>
++<blockquote>
++<p>
++<i>Returns:</i> <tt>tuple&lt;typename decay&lt;Types&gt;::type...&gt;(std::forward&lt;Types&gt;(t)...)</tt>.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1203"></a>1203. More useful rvalue stream insertion</h3>
++<p><b>Section:</b> 27.7.3.9 [ostream.rvalue], 27.7.2.6 [istream.rvalue] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++27.7.3.9 [ostream.rvalue] was created to preserve the ability to insert
++into (and extract from 27.7.2.6 [istream.rvalue]) rvalue streams:
++</p>
++
++<blockquote><pre>
++template &lt;class charT, class traits, class T&gt;
++ basic_ostream&lt;charT, traits&gt;&amp;
++ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;&amp; os, const T&amp; x);
++</pre>
++<blockquote>
++<p>
++1 <i>Effects:</i> <tt>os &lt;&lt; x</tt>
++</p>
++<p>
++2 <i>Returns:</i> <tt>os</tt>
++</p>
++</blockquote>
++</blockquote>
++
++<p>
++This is good as it allows code that wants to (for example) open, write to, and
++close an <tt>ofstream</tt> all in one statement:
++</p>
++
++<blockquote><pre>
++std::ofstream("log file") &lt;&lt; "Some message\n";
++</pre></blockquote>
++
++<p>
++However, I think we can easily make this "rvalue stream helper" even easier to
++use. Consider trying to quickly create a formatted string. With the current
++spec you have to write:
++</p>
++
++<blockquote><pre>
++std::string s = static_cast&lt;std::ostringstream&amp;&gt;(std::ostringstream() &lt;&lt; "i = " &lt;&lt; i).str();
++</pre></blockquote>
++
++<p>
++This will store "<tt>i = 10</tt>" (for example) in the string <tt>s</tt>. Note
++the need to cast the stream back to <tt>ostringstream&amp;</tt> prior to using
++the member <tt>.str()</tt>. This is necessary because the inserter has cast
++the <tt>ostringstream</tt> down to a more generic <tt>ostream</tt> during the
++insertion process.
++</p>
++
++<p>
++I believe we can re-specify the rvalue-inserter so that this cast is unnecessary.
++Thus our customer now has to only type:
++</p>
++
++<blockquote><pre>
++std::string s = (std::ostringstream() &lt;&lt; "i = " &lt;&lt; i).str();
++</pre></blockquote>
++
++<p>
++This is accomplished by having the rvalue stream inserter return an rvalue of
++the same type, instead of casting it down to the base class. This is done by
++making the stream generic, and constraining it to be an rvalue of a type derived
++from <tt>ios_base</tt>.
++</p>
++
++<p>
++The same argument and solution also applies to the inserter. This code has been
++implemented and tested.
++</p>
++
++<p><i>[
++2009 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++NAD Future. No concensus for change.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 27.7.2.6 [istream.rvalue]:
++</p>
++
++<blockquote><pre>
++template &lt;class <del>charT, class traits</del> <ins>Istream</ins>, class T&gt;
++ <del>basic_istream&lt;charT, traits&gt;&amp;</del> <ins>Istream&amp;&amp;</ins>
++ operator&gt;&gt;(<del>basic_istream&lt;charT, traits&gt;</del> <ins>Istream</ins>&amp;&amp; is, T&amp; x);
++</pre>
++<blockquote>
++<p>
++1 <i>Effects:</i> <tt>is &gt;&gt; x</tt>
++</p>
++<p>
++2 <i>Returns:</i> <tt><ins>std::move(</ins>is<ins>)</ins></tt>
++</p>
++<p><ins>
++3 <i>Remarks:</i> This signature shall participate in overload resolution if
++and only if <tt>Istream</tt> is not an lvalue reference type and is derived from
++<tt>ios_base</tt>.
++</ins></p>
++</blockquote>
++</blockquote>
++
++<p>
++Change 27.7.3.9 [ostream.rvalue]:
++</p>
++
++<blockquote><pre>
++template &lt;class <del>charT, class traits</del> <ins>Ostream</ins>, class T&gt;
++ <del>basic_ostream&lt;charT, traits&gt;&amp;</del> <ins>Ostream&amp;&amp;</ins>
++ operator&lt;&lt;(<del>basic_ostream&lt;charT, traits&gt;</del> <ins>Ostream</ins>&amp;&amp; os, const T&amp; x);
++</pre>
++<blockquote>
++<p>
++1 <i>Effects:</i> <tt>os &lt;&lt; x</tt>
++</p>
++<p>
++2 <i>Returns:</i> <tt><ins>std::move(</ins>os<ins>)</ins></tt>
++</p>
++<p><ins>
++3 <i>Remarks:</i> This signature shall participate in overload resolution if
++and only if <tt>Ostream</tt> is not an lvalue reference type and is derived from
++<tt>ios_base</tt>.
++</ins></p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1213"></a>1213. Meaning of valid and singular iterator underspecified</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-09-19 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The terms <em>valid</em> iterator and <em>singular</em> aren't
++properly defined. The fuzziness of those terms became even worse
++after the resolution of <a href="lwg-defects.html#208">208</a> (including further updates by <a href="lwg-defects.html#278">278</a>). In
++24.2 [iterator.requirements] as of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
++the standard says now:
++</p>
++
++<blockquote>
++<p>
++5 - These values are called past-the-end values. Values of an iterator <tt>i</tt> for
++which the expression <tt>*i</tt> is defined are called dereferenceable. The library
++never assumes that past-the-end values are dereferenceable. Iterators
++can also have singular values that are not associated with any
++container. [...] Results of most expressions are undefined for singular
++values; the only exceptions are destroying an iterator that holds a
++singular value and the assignment of a non-singular value to an iterator
++that holds a singular value. [...] Dereferenceable values are always
++non-singular.
++</p>
++
++<p>
++10 - An invalid iterator is an iterator that may be singular.
++</p>
++</blockquote>
++
++<p>
++First, issue <a href="lwg-defects.html#208">208</a> intentionally removed the earlier constraint that past-the-end
++values are always non-singular. The reason for this was to support null
++pointers as past-the-end iterators of e.g. empty sequences. But there
++seem to exist different views on what a singular (iterator) value is. E.g.
++according to the <a href="http://www.sgi.com/tech/stl/trivial.html">SGI definition</a>
++a null pointer is <em>not</em> a singular value:
++</p>
++
++<blockquote><p>
++Dereferenceable iterators are always nonsingular, but the converse is
++not true.
++For example, a null pointer is nonsingular (there are well defined operations
++involving null pointers) even thought it is not dereferenceable.
++</p></blockquote>
++
++<p>
++and <a href="http://www.sgi.com/tech/stl/InputIterator.html">proceeds</a>:
++</p>
++
++<blockquote><p>
++An iterator is valid if it is dereferenceable or past-the-end.
++</p></blockquote>
++
++<p>
++Even if the standard prefers a different meaning of singular here, the
++change was incomplete, because by restricting feasible expressions of singular
++iterators to destruction and assignment isn't sufficient for a past-the-end
++iterator: Of-course it must still be equality-comparable and in general be a readable value.
++</p>
++
++<p>
++Second, the standard doesn't clearly say whether a past-the-end value is
++a valid iterator or not. E.g. 20.7.12 [specialized.algorithms]/1 says:
++</p>
++
++<blockquote><p>
++In all of the following algorithms, the formal template parameter <tt>ForwardIterator</tt>
++is required to satisfy the requirements of a forward iterator (24.1.3)
++[..], and is required to have the property that no exceptions are thrown from [..], or
++dereference of valid iterators.
++</p></blockquote>
++
++<p>
++The standard should make better clear what "singular pointer" and "valid
++iterator" means. The fact that the meaning of a valid <em>value</em>
++has a core language meaning doesn't imply that for an iterator concept
++the term "valid iterator" has the same meaning.
++</p>
++
++<p>
++Let me add a final example: In X [allocator.concepts.members] of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>
++we find:
++</p>
++
++<blockquote><pre>
++pointer X::allocate(size_type n);
++</pre>
++
++<blockquote><p>
++11 <i>Returns:</i> a pointer to the allocated memory. [<i>Note:</i> if <tt>n == 0</tt>, the return
++value is unspecified. &mdash;<i>end note</i>]
++</p></blockquote>
++
++<p>
++[..]
++</p>
++
++<pre>
++void X::deallocate(pointer p, size_type n);
++</pre>
++
++<blockquote><p>
++<i>Preconditions:</i> <tt>p</tt> shall be a non-singular pointer value obtained from a call
++to <tt>allocate()</tt> on this allocator or one that compares equal to it.
++</p></blockquote>
++</blockquote>
++
++<p>
++If singular pointer value would include null pointers this make the
++preconditions
++unclear if the pointer value is a result of <tt>allocate(0)</tt>: Since the return value
++is unspecified, it could be a null pointer. Does that mean that programmers
++need to check the pointer value for a null value before calling deallocate?
++</p>
++
++<p><i>[
++2010-11-09 Daniel comments:
++]</i></p>
++
++
++<p>
++A later paper is in preparation.
++</p>
++
++<p><i>[
++2010 Batavia:
++]</i></p>
++
++
++<p>
++Doesn't need to be resolved for Ox
++</p>
++
++
++<p><i>[2014-02-20 Re-open Deferred issues as Priority 4]</i></p>
++
++
++<p>
++Consider to await the paper.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1217"></a>1217. Quaternion support</h3>
++<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Ted Shaneyfelt <b>Opened:</b> 2009-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#complex.numbers">active issues</a> in [complex.numbers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Concerning mathematically proper operation of the type:
++</p>
++
++<blockquote><pre>
++complex&lt;complex&lt;T&gt; &gt;
++</pre></blockquote>
++
++<p>
++Generally accepted mathematical semantics of such a construct correspond
++to quaternions through Cayly-Dickson construct
++</p>
++
++<blockquote><pre>
++(w+xi) + (y+zi) j
++</pre></blockquote>
++
++<p>
++The proper implementation seems straightforward by adding a few
++declarations like those below. I have included operator definition for
++combining real scalars and complex types, as well, which seems
++appropriate, as algebra of complex numbers allows mixing complex and
++real numbers with operators. It also allows for constructs such as
++<tt>complex&lt;double&gt; i=(0,1), x = 12.34 + 5*i;</tt>
++</p>
++
++<p>
++Quaternions are often used in areas such as computer graphics, where,
++for example, they avoid the problem of Gimbal lock when rotating objects
++in 3D space, and can be more efficient than matrix multiplications,
++although I am applying them to a different field.
++</p>
++
++<pre>
++/////////////////////////ALLOW OPERATORS TO COMBINE REAL SCALARS AND COMPLEX VALUES /////////////////////////
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt; x,const S a) {
++ complex&lt;T&gt; result(x.real()+a, x.imag());
++ return result;
++}
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator+(const S a,const complex&lt;T&gt; x) {
++ complex&lt;T&gt; result(a+x.real(), x.imag());
++ return result;
++}
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt; x,const S a) {
++ complex&lt;T&gt; result(x.real()-a, x.imag());
++ return result;
++}
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator-(const S a,const complex&lt;T&gt; x) {
++ complex&lt;T&gt; result(a-x.real(), x.imag());
++ return result;
++}
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt; x,const S a) {
++ complex&lt;T&gt; result(x.real()*a, x.imag()*a);
++ return result;
++}
++template&lt;typename T,typename S&gt; complex&lt;T&gt; operator*(const S a,const complex&lt;T&gt; x) {
++ complex&lt;T&gt; result(a*x.real(), a*x.imag());
++ return result;
++}
++
++/////////////////////////PROPERLY IMPLEMENT QUATERNION SEMANTICS/////////////////////////
++template&lt;typename T&gt; double normSq(const complex&lt;complex&lt;T&gt; &gt;q) {
++ return q.real().real()*q.real().real()
++ + q.real().imag()*q.real().imag()
++ + q.imag().real()*q.imag().real()
++ + q.imag().imag()*q.imag().imag();
++}
++template&lt;typename T&gt; double norm(const complex&lt;complex&lt;T&gt; &gt;q) {
++ return sqrt(normSq(q));
++}
++/////// Cayley-Dickson Construction
++template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; conj(const complex&lt;complex&lt;T&gt; &gt; x) {
++ complex&lt;complex&lt;T&gt; &gt; result(conj(x.real()),-x.imag());
++ return result;
++}
++template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator*(const complex&lt;complex&lt;T&gt; &gt; ab,const complex&lt;complex&lt;T&gt; &gt; cd) {
++ complex&lt;T&gt; re(ab.real()*cd.real()-conj(cd.imag())*ab.imag());
++ complex&lt;T&gt; im(cd.imag()*ab.real()+ab.imag()*conj(cd.real()));
++ complex&lt;complex&lt;double&gt; &gt; q(re,im);
++ return q;
++}
++//// Quaternion division
++template&lt;typename S,typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const complex&lt;complex&lt;T&gt; &gt; q,const S a) {
++ return q * (1/a);
++}
++template&lt;typename S,typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const S a,const complex&lt;complex&lt;T&gt; &gt; q) {
++ return a*conj(q)/normSq(q);
++}
++template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const complex&lt;complex&lt;T&gt; &gt; n, const complex&lt;complex&lt;T&gt; &gt; d) {
++ return n * (conj(d)/normSq(d));
++}
++</pre>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++NAD Future. There is no consensus or time to move this into C++0X.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1235"></a>1235. Issue with C++0x random number proposal</h3>
++<p><b>Section:</b> X [rand.concept.dist] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Matthias Troyer <b>Opened:</b> 2009-10-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++There exist optimized, vectorized vendor libraries for the creation of
++random number generators, such as Intel's MKL [1] and AMD's ACML [2]. In
++timing tests we have seen a performance gain of a factor of up to 80
++(eighty) compared to a pure C++ implementation (in Boost.Random) when
++using these generator to generate a sequence of normally distributed
++random numbers. In codes dominated by the generation of random numbers
++(we have application codes where random number generation is more than
++50% of the CPU time) this factor 80 is very significant.
++</p>
++
++<p>
++To make use of these vectorized generators, we use a C++ class modeling
++the <tt>RandomNumberEngine</tt> concept and forwarding the generation of random
++numbers to those optimized generators. For example:
++</p>
++
++<blockquote><pre>
++namespace mkl {
++ class mt19937 {.... };
++}
++</pre></blockquote>
++
++<p>
++For the generation of random variates we also want to dispatch to
++optimized vectorized functions in the MKL or ACML libraries. See this
++example:
++</p>
++
++<blockquote><pre>
++mkl::mt19937 eng;
++std::normal_distribution&lt;double&gt; dist;
++
++double n = dist(eng);
++</pre></blockquote>
++
++<p>
++Since the variate generation is done through the <tt>operator()</tt> of the
++distribution there is no customization point to dispatch to Intel's or
++AMD's optimized functions to generate normally distributed numbers based
++on the <tt>mt19937</tt> generator. Hence, the performance gain of 80 cannot be
++achieved.
++</p>
++
++<p>
++Contrast this with TR1:
++</p>
++
++<blockquote><pre>
++mkl::mt19937 eng;
++std::tr1::normal_distribution&lt;double&gt; dist;
++std::tr1::variate_generator&lt;mkl::mt19937,std::tr1::normal_distribution&lt;double&gt; &gt; rng(eng,dist);
++double n = rng();
++</pre></blockquote>
++
++<p>
++This - admittedly much uglier from an aestethic point of view - design
++allowed optimization by specializing the <tt>variate_generator</tt> template for
++<tt>mkl::mt19937</tt>:
++</p>
++
++<blockquote><pre>
++namespace std { namespace tr1 {
++
++template&lt;&gt;
++class variate_generator&lt;mkl::mt19937,std::tr1::normal_distribution&lt;double&gt; &gt; { .... };
++
++} }
++</pre></blockquote>
++
++<p>
++A similar customization point is missing in the C++0x design and
++prevents the optimized vectorized version to be used.
++</p>
++
++<p>
++Suggested resolution:
++</p>
++
++<p>
++Add a customization point to the distribution concept. Instead of the
++<tt>variate_generator</tt> template this can be done through a call to a
++free function <tt>generate_variate</tt> found by ADL instead of
++<tt>operator()</tt> of the distribution:
++</p>
++
++<blockquote><pre>
++template &lt;RandomNumberDistribution, class RandomNumberEngine&gt;
++typename RandomNumberDistribution ::result_type
++generate_variate(RandomNumberDistribution const&amp; dist, RandomNumberEngine&amp; eng);
++</pre></blockquote>
++
++<p>
++This function can be overloaded for optimized enginges like
++<tt>mkl::mt19937</tt>.
++</p>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++NAD Future. No time to add this feature for C++0X.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1238"></a>1238. defining algorithms taking iterator for range</h3>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The library has many algorithms that take a source range represented by
++a pair of iterators, and the start of some second sequence given by a
++single iterator. Internally, these algorithms will produce undefined
++behaviour if the second 'range' is not as large as the input range, but
++none of the algorithms spell this out in Requires clauses, and there is
++no catch-all wording to cover this in clause 17 or the front matter of
++25.
++</p>
++
++<p>
++There was an attempt to provide such wording in paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf">n2944</a>
++but this
++seems incidental to the focus of the paper, and getting the wording of
++this issue right seems substantially more difficult than the simple
++approach taken in that paper. Such wording will be removed from an
++updated paper, and hopefully tracked via the LWG issues list instead.
++</p>
++
++<p>
++It seems there are several classes of problems here and finding wording
++to solve all in one paragraph could be too much. I suspect we need
++several overlapping requirements that should cover the desired range of
++behaviours.
++</p>
++
++<p>
++Motivating examples:
++</p>
++
++<p>
++A good initial example is the <tt>swap_ranges</tt> algorithm. Here there is a
++clear requirement that <tt>first2</tt> refers to the start of a valid range at
++least as long as the range <tt>[first1, last1)</tt>. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf">n2944</a> tries to solve this
++by positing a hypothetical <tt>last2</tt> iterator that is implied by the
++signature, and requires <tt>distance(first2,last2) &lt; distance(first1,last1)</tt>.
++ This mostly works, although I am uncomfortable assuming that <tt>last2</tt> is
++clearly defined and well known without any description of how to obtain
++it (and I have no idea how to write that).
++</p>
++
++<p>
++A second motivating example might be the <tt>copy</tt> algorithm. Specifically,
++let us image a call like:
++</p>
++
++<blockquote><pre>
++copy(istream_iterator&lt;int&gt;(is),istream_iterator(),ostream_iterator&lt;int&gt;(os));
++</pre></blockquote>
++
++<p>
++In this case, our input iterators are literally simple <tt>InputIterators</tt>,
++and the destination is a simple <tt>OutputIterator</tt>. In neither case am I
++happy referring to <tt>std::distance</tt>, in fact it is not possible for the
++<tt>ostream_iterator</tt> at all as it does not meet the requirements. However,
++any wording we provide must cover both cases. Perhaps we might deduce
++<tt>last2 == ostream_iterator&lt;int&gt;{}</tt>, but that might not always be valid for
++user-defined iterator types. I can well imagine an 'infinite range'
++that writes to <tt>/dev/null</tt> and has no meaningful <tt>last2</tt>.
++</p>
++
++<p>
++The motivating example in <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf"
++>n2944</a> is <tt>std::equal</tt>, and that seems to fall somewhere between the
++two.
++</p>
++
++<p>
++Outlying examples might be <tt>partition_copy</tt> that takes two output
++iterators, and the <tt>_n</tt> algorithms where a range is specified by a
++specific number of iterations, rather than traditional iterator pair.
++We should also <em>not</em> accidentally apply inappropriate constraints to
++<tt>std::rotate</tt> which takes a third iterator that is not intended to be a
++separate range at all.
++</p>
++
++<p>
++I suspect we want some wording similar to:
++</p>
++
++<blockquote><p>
++For algorithms that operate on ranges where the end iterator of the
++second range is not specified, the second range shall contain at least
++as many elements as the first.
++</p></blockquote>
++
++<p>
++I don't think this quite captures the intent yet though. I am not sure
++if 'range' is the right term here rather than sequence. More awkwardly,
++I am not convinced we can describe an Output sequence such as produce by
++an <tt>ostream_iterator</tt> as "containing elements", at least not as a
++precondition to the call before they have been written.
++</p>
++
++<p>
++Another idea was to describe require that the trailing iterator support
++at least distance(input range) applications of <tt>operator++</tt> and may be
++written through the same number of times if a mutable/output iterator.
++</p>
++
++<p>
++We might also consider handling the case of an output range vs. an input
++range in separate paragraphs, if that simplifies how we describe some of
++these constraints.
++</p>
++
++<p><i>[
++2009-11-03 Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++
++<p><b>Rationale:</b></p>
++<p>
++Does not have sufficient support at this time. May wish to reconsider for a
++future standard.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1242"></a>1242. Enable SCARY iterators</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2009-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2980.pdf">N2980</a>.
++</p>
++
++<p><i>[
++2009-10 Santa Cruz
++]</i></p>
++
++
++<blockquote><p>
++The paper was lengthy discussed but considerable concern remained to add this feature to C++0x.
++Strong consensus was found to consider it for C++1x, though.
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++The LWG does not wish to make a change at this time.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1282"></a>1282. A proposal to add <tt>std::split</tt> algorithm</h3>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Igor Semenov <b>Opened:</b> 2009-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<ol style="list-style-type:upper-roman">
++
++<li>
++<p>
++Motivation and Scope
++</p>
++<p>
++Splitting strings into parts by some set of delimiters is an often task, but
++there is no simple and generalized solution in C++ Standard. Usually C++
++developers use <tt>std::basic_stringstream&lt;&gt;</tt> to split string into
++parts, but there are several inconvenient restrictions:
++</p>
++
++<ul>
++<li>
++we cannot explicitly assign the set of delimiters;
++</li>
++<li>
++this approach is suitable only for strings, but not for other types of
++containers;
++</li>
++<li>
++we have (possible) performance leak due to string instantiation.
++</li>
++</ul>
++</li>
++
++<li>
++<p>
++Impact on the Standard
++</p>
++<p>
++This algorithm doesn't interfere with any of current standard algorithms.
++</p>
++</li>
++
++<li>
++<p>
++Design Decisions
++</p>
++<p>
++This algorithm is implemented in terms of input/output iterators. Also, there is
++one additional wrapper for <tt>const CharType *</tt> specified delimiters.
++</p>
++</li>
++
++<li>
++<p>
++Example implementation
++</p>
++<pre>
++template&lt; class It, class DelimIt, class OutIt &gt;
++void split( It begin, It end, DelimIt d_begin, DelimIt d_end, OutIt out )
++{
++ while ( begin != end )
++ {
++ It it = std::find_first_of( begin, end, d_begin, d_end );
++ *out++ = std::make_pair( begin, it );
++ begin = std::find_first_of( it, end, d_begin, d_end,
++ std::not2( std::equal_to&lt; typename It::value_type &gt;() ) );
++ }
++}
++
++template&lt; class It, class CharType, class OutIt &gt;
++void split( It begin, It end, const CharType * delim, OutIt out )
++{
++ split( begin, end, delim, delim + std::strlen( delim ), out );
++}
++</pre>
++</li>
++
++<li>
++<p>
++Usage
++</p>
++<pre>
++std::string ss( "word1 word2 word3" );
++std::vector&lt; std::pair&lt; std::string::const_iterator, std::string::const_iterator &gt; &gt; v;
++split( ss.begin(), ss.end(), " ", std::back_inserter( v ) );
++
++for ( int i = 0; i &lt; v.size(); ++i )
++{
++ std::cout &lt;&lt; std::string( v[ i ].first, v[ i ].second ) &lt;&lt; std::endl;
++}
++// word1
++// word2
++// word3
++</pre>
++</li>
++
++</ol>
++
++<p><i>[
++2010-01-22 Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
++Rationale added below.
++]</i></p>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++The LWG is not considering completely new features for standardization at this
++time. We would like to revisit this good suggestion for a future TR and/or
++standard.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add to the synopsis in 25.1 [algorithms.general]:
++</p>
++
++<blockquote><pre>
++template&lt; class ForwardIterator1, class ForwardIterator2, class OutputIterator &gt;
++ void split( ForwardIterator1 first, ForwardIterator1 last,
++ ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
++ OutputIterator result );
++
++template&lt; class ForwardIterator1, class CharType, class OutputIterator &gt;
++ void split( ForwardIterator1 first, ForwardIterator1 last,
++ const CharType * delimiters, OutputIterator result );
++</pre></blockquote>
++
++<p>
++Add a new section [alg.split]:
++</p>
++
++<blockquote><pre>
++template&lt; class ForwardIterator1, class ForwardIterator2, class OutputIterator &gt;
++ void split( ForwardIterator1 first, ForwardIterator1 last,
++ ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
++ OutputIterator result );
++</pre>
++
++<blockquote>
++<p>
++1. <i>Effects:</i> splits the range <tt>[first, last)</tt> into parts, using any
++element of <tt>[delimiter_first, delimiter_last)</tt> as a delimiter. Results
++are pushed to output iterator in the form of <tt>std::pair&lt;ForwardIterator1,
++ForwardIterator1&gt;</tt>. Each of these pairs specifies a maximal subrange of
++<tt>[first, last)</tt> which does not contain a delimiter.
++</p>
++<p>
++2. <i>Returns:</i> nothing.
++</p>
++<p>
++3. <i>Complexity:</i> Exactly <tt>last - first</tt> assignments.
++</p>
++</blockquote>
++
++<pre>
++template&lt; class ForwardIterator1, class CharType, class OutputIterator &gt;
++ void split( ForwardIterator1 first, ForwardIterator1 last,
++ const CharType * delimiters, OutputIterator result );
++</pre>
++
++<blockquote>
++<p>
++1. <i>Effects:</i> split the range <tt>[first, last)</tt> into parts, using any
++element of <tt>delimiters</tt> (interpreted as zero-terminated string) as a
++delimiter. Results are pushed to output iterator in the form of
++<tt>std::pair&lt;ForwardIterator1, ForwardIterator1&gt;</tt>. Each of these
++pairs specifies a maximal subrange of <tt>[first, last)</tt> which does not
++contain a delimiter.
++</p>
++<p>
++2. <i>Returns:</i> nothing.
++</p>
++<p>
++3. <i>Complexity:</i> Exactly <tt>last - first</tt> assignments.
++</p>
++</blockquote>
++
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1289"></a>1289. Generic casting requirements for smart pointers</h3>
++<p><b>Section:</b> 20.2 [utility] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Ion Gazta&ntilde;aga <b>Opened:</b> 2009-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In section 17.6.3.5 [allocator.requirements], Table 40 &mdash; Allocator requirements,
++the following expression is required for allocator pointers:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 40 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Default</th>
++</tr>
++<tr>
++<td><tt>static_cast&lt;X::pointer&gt;(w)</tt></td>
++<td><tt>X::pointer</tt></td>
++<td><tt>static_cast&lt;X::pointer&gt;(w) == p</tt></td>
++<td>&nbsp;</td>
++</tr>
++</table>
++</blockquote>
++
++<p>
++To achieve this expression, a smart pointer writer must introduce an explicit
++conversion operator from <tt>smart_ptr&lt;void&gt;</tt> to
++<tt>smart_ptr&lt;T&gt;</tt> so that
++<tt>static_cast&lt;pointer&gt;(void_ptr)</tt> is a valid expression.
++Unfortunately this explicit conversion weakens the safety of a smart pointer
++since the following expression (invalid for raw pointers) would become valid:
++</p>
++
++<blockquote><pre>
++smart_ptr&lt;void&gt; smart_v = ...;
++smart_ptr&lt;T&gt; smart_t(smart_v);
++</pre></blockquote>
++
++<p>
++On the other hand, <tt>shared_ptr</tt> also defines its own casting functions in
++20.8.2.2.9 [util.smartptr.shared.cast], and although it's unlikely that a
++programmer will use <tt>shared_ptr</tt> as <tt>allocator::pointer</tt>, having
++two different ways to do the same cast operation does not seem reasonable. A
++possible solution would be to replace <tt>static_cast&lt;X::pointer&gt;(w)</tt>
++expression with a user customizable (via ADL)
++<tt>static_pointer_cast&lt;value_type&gt;(w)</tt>, and establish the
++<tt>xxx_pointer_cast</tt> functions introduced by <tt>shared_ptr</tt> as the
++recommended generic casting utilities of the standard.
++</p>
++
++<p>
++Unfortunately, we've experienced problems in Boost when trying to establish
++<tt>xxx_pointer_cast</tt> as customization points for generic libraries (<a
++href="http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html"
++>http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html</a>)
++because these casting functions are called with explicit template parameters and
++the standard says in 14.8.1 [temp.arg.explicit] p.8 "Explicit template
++argument specification":
++</p>
++
++<blockquote><p>
++8 ...But when a function template with explicit template arguments is used, the
++call does not have the correct syntactic form unless there is a function
++template with that name visible at the point of the call. If no such name is
++visible, the call is not syntactically well-formed and argument-dependent lookup
++does not apply.
++</p></blockquote>
++
++<p>
++So we can do this:
++</p>
++
++<blockquote><pre>
++template&lt;class BasePtr&gt;
++void generic_ptr_swap(BasePtr p)
++{
++ //ADL customization point
++ swap(p, p);
++ //...
++}
++</pre></blockquote>
++
++<p>
++but not the following:
++</p>
++
++<blockquote><pre>
++template&lt;class BasePtr&gt;
++void generic_ptr_algo(BasePtr p)
++{
++ typedef std::pointer_traits&lt;BasePtr&gt;::template
++ rebind&lt;Derived&gt; DerivedPtr;
++ DerivedPtr dp = static_pointer_cast&lt;Derived&gt;(p);
++}
++</pre></blockquote>
++
++<p>
++The solution to make <tt>static_pointer_cast</tt> a customization point is to
++add a generic declaration (no definition) of <tt>static_pointer_cast</tt> in a
++namespace (like <tt>std</tt>) and apply "<tt>using
++std::static_pointer_cast</tt>" declaration to activate ADL:
++</p>
++
++<blockquote><pre>
++namespace std{
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++static_pointer_cast(T&amp;&amp;) = delete;
++
++}
++
++template&lt;class BasePtr&gt;
++void generic_ptr_algo(BasePtr p)
++{
++ typedef std::pointer_traits&lt;BasePtr&gt;::template
++ rebind&lt;Derived&gt; DerivedPtr;
++
++ //ADL applies because static_pointer_cast is made
++ // visible according to [temp.arg.explicit]/8
++ using std::static_pointer_cast;
++
++ DerivedPtr dp = static_pointer_cast&lt;Derived&gt;(p);
++
++ //...
++}
++</pre></blockquote>
++
++<p>
++A complete solution will need also the definition of
++<tt>static_pointer_cast</tt> for raw pointers, and this definition has been
++present in Boost (<a
++href="http://www.boost.org/boost/pointer_cast.hpp">http://www.boost.org/boost/
++pointer_cast.hpp</a>) for years.
++</p>
++
++<p><i>[
++2010-03-26 Daniel made editorial adjustments to the proposed wording.
++]</i></p>
++
++
++<p><i>[
++Moved to NAD Future at 2010-11 Batavia
++]</i></p>
++
++<blockquote><p>
++This is a new feature rather than a defect.
++It can be added later: "this is such a hairy area that people will put up with changes"
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add to section 20.2 [utility] Utility components, Header
++<tt>&lt;utility&gt;</tt> synopsis:
++</p>
++
++<blockquote><pre>
++// 20.3.X, generic pointer cast functions
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++static_pointer_cast(T&amp;&amp;) = delete;
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++dynamic_pointer_cast(T&amp;&amp;) = delete;
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++const_pointer_cast(T&amp;&amp;) = delete;
++
++//Overloads for raw pointers
++template&lt;typename U, typename T&gt;
++auto static_pointer_cast(T* t) -&gt; decltype(static_cast&lt;U*&gt;(t));
++
++template&lt;typename U, typename T&gt;
++auto dynamic_pointer_cast(T* t) -&gt; decltype(dynamic_cast&lt;U*&gt;(t));
++
++template&lt;typename U, typename T&gt;
++auto const_pointer_cast(T* t) -&gt; decltype(const_cast&lt;U*&gt;(t));
++</pre></blockquote>
++
++<p>
++Add to section 20.2 [utility] Utility components, a new subclause
++20.3.X Pointer cast utilities [pointer.cast]:
++</p>
++
++<blockquote>
++<p>
++20.3.X Pointer cast utilities [pointer.cast]
++</p>
++
++<p>
++1 The library defines generic pointer casting function templates so that template code
++can explicitly make these names visible and activate argument-dependent lookup
++for pointer cast calls.
++</p>
++
++<pre>
++//Generic declarations
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++static_pointer_cast(T&amp;&amp;) = delete;
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++dynamic_pointer_cast(T&amp;&amp;) = delete;
++
++template&lt;typename U, typename T&gt;
++<i>unspecified</i>
++const_pointer_cast(T&amp;&amp;) = delete;
++</pre>
++
++<p>
++2 The library also defines overloads of these functions for raw pointers.
++</p>
++
++<pre>
++//Overloads for raw pointers
++template&lt;typename U, typename T&gt;
++auto static_pointer_cast(T* t) -&gt; decltype(static_cast&lt;U*&gt;(t));
++</pre>
++
++<blockquote><p>
++<i>Returns:</i> <tt>static_cast&lt;U*&gt;(t)</tt>
++</p></blockquote>
++
++<pre>
++template&lt;typename U, typename T&gt;
++auto dynamic_pointer_cast(T* t) -&gt; decltype(dynamic_cast&lt;U*&gt;(t));
++</pre>
++
++<blockquote><p>
++<i>Returns:</i> <tt>dynamic_cast&lt;U*&gt;(t)</tt>
++</p></blockquote>
++
++<pre>
++template&lt;typename U, typename T&gt;
++auto const_pointer_cast(T* t) -&gt; decltype(const_cast&lt;U*&gt;(t));
++</pre>
++
++<blockquote><p>
++<i>Returns:</i> <tt>const_cast&lt;U*&gt;(t)</tt>
++</p></blockquote>
++
++<p>
++[<i>Example:</i>
++</p>
++
++<blockquote><pre>
++#include &lt;utility&gt; //static_pointer_cast
++#include &lt;memory&gt; //pointer_traits
++
++class Base{};
++class Derived : public Base{};
++
++template&lt;class BasePtr&gt;
++void generic_pointer_code(BasePtr b)
++{
++ typedef std::pointer_traits&lt;BasePtr&gt;::template
++ rebind&lt;Derived&gt; DerivedPtr;
++
++ using std::static_pointer_cast;
++ //ADL applies now that static_pointer_cast is visible
++ DerivedPtr d = static_pointer_cast&lt;Derived&gt;(b);
++}
++</pre></blockquote>
++
++<p>
++&mdash; <i>end example</i>]
++</p>
++
++</blockquote>
++
++<p>
++Replace in section 17.6.3.5 [allocator.requirements] Table 40 &mdash; Allocator
++requirements, the following table entries for allocator pointers:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 40 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Default</th>
++</tr>
++
++<tr>
++<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::pointer</del><ins>T</ins>&gt;(w)</tt></td>
++<td><tt>X::pointer</tt></td>
++<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::pointer</del><ins>T</ins>&gt;(w) == p</tt></td>
++<td>&nbsp;</td>
++</tr>
++
++<tr>
++<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::const_pointer</del><ins>const T</ins>&gt;(w)</tt></td>
++<td><tt>X::const_pointer</tt></td>
++<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::const_pointer</del><ins>const T</ins>&gt;(z) == q</tt></td>
++<td>&nbsp;</td>
++</tr>
++
++</table>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1317"></a>1317. make_hash</h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Nicolai M. Josuttis <b>Opened:</b> 2010-02-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Currently, the library lacks a convenient way to provide a hash function that
++can be used with the provided unordered containers to allow the usage of non
++trivial element types.
++</p>
++
++<p>
++While we can easily declare an
++</p>
++
++<blockquote><pre>
++std::unordered_set&lt;int&gt;
++</pre></blockquote>
++
++<p>
++or
++</p>
++
++<blockquote><pre>
++std::unordered_set&lt;std::string&gt;
++</pre></blockquote>
++
++<p>
++we have no easy way to declare an <tt>unordered_set</tt> for a user defined
++type. IMO, this is a big obstacle to use unordered containers in practice. Note
++that in Java, the wide usage of <tt>HashMap</tt> is based on the fact that there
++is always a default hash function provided.
++</p>
++
++<p>
++Of course, a default hash function implies the risk to provide poor hash
++functions. But often even poor hash functions are good enough.
++</p>
++
++<p>
++While I really would like to see a default hash function, I don't propose it
++here because this would probably introduce a discussion that's too big for this
++state of C++0x.
++</p>
++
++<p>
++However, I strongly suggest at least to provide a convenience variadic template
++function <tt>make_hash&lt;&gt;()</tt> to allow an easy definition of a (possibly
++poor) hash function.
++</p>
++
++<p>
++As a consequence for a user-defined type such as
++</p>
++
++<blockquote><pre>
++class Customer {
++ friend class CustomerHash;
++ private:
++ string firstname;
++ string lastname;
++ long no;
++ ...
++ };
++</pre></blockquote>
++
++<p>
++would allow to specify:
++</p>
++
++<blockquote><pre>
++class CustomerHash : public std::unary_function&lt;Customer, std::size_t&gt;
++{
++ public:
++ std::size_t operator() (const Customer&amp; c) const {
++ return make_hash(c.firstname,c.lastname,c.no);
++ }
++};
++</pre></blockquote>
++
++<p>
++instead of:
++</p>
++
++<blockquote><pre>
++class CustomerHash : public std::unary_function&lt;Customer, std::size_t&gt;
++{
++ public:
++ std::size_t operator() (const Customer&amp; c) const {
++ return std::hash&lt;std::string&gt;()(c.firstname) +
++ std::hash&lt;std::string&gt;()(c.lastname) +
++ std::hash&lt;long&gt;()(c.no);
++ }
++};
++</pre></blockquote>
++
++<p>
++Note that, in principle, we can either specify that
++</p>
++
++<blockquote><p>
++<tt>make_hash</tt> returns the sum of a call of
++<tt>std::hash&lt;T&gt;()(x)</tt> for each argument <tt>x</tt> of type
++<tt>T</tt>
++</p></blockquote>
++
++<p>
++or we can specify that
++</p>
++
++<blockquote><p>
++<tt>make_hash</tt> provides a hash value for each argument, for which a
++<tt>std::hash()</tt> function is provided
++</p></blockquote>
++
++<p>
++with the possible note that the hash value may be poor or only a good hash value
++if the ranges of all passed arguments is equally distributed.
++</p>
++
++<p>
++For my convenience, I propose wording that describes
++the concrete implementation.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to NAD Editorial, rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++There is no consensus to make this change at this time.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++In Function objects 20.9 [function.objects]
++in paragraph 2 at the end of the Header <tt>&lt;functional&gt;</tt> synopsis
++insert:
++</p>
++
++<blockquote><pre>
++// convenience functions
++template &lt;class T&gt;
++ size_t make_hash (const T&amp;);
++template &lt;class T, class... Types&gt;
++ size_t make_hash (const T&amp;, const Types&amp;...);
++</pre></blockquote>
++
++<p>
++In Class template hash 20.9.13 [unord.hash]
++add:
++</p>
++
++<blockquote>
++<p>
++<b>20.7.16.1 Hash creation functions [hash.creation]</b>
++</p>
++
++<pre>
++template &lt;class T&gt;
++ size_t make_hash (const T&amp; val);
++</pre>
++
++<blockquote><p>
++<i>Returns:</i> <tt>hash&lt;T&gt;()(val);</tt>
++</p></blockquote>
++
++<pre>
++template &lt;class T, class... Types&gt;
++ size_t make_hash (const T&amp; val, const Types&amp;... args);
++</pre>
++
++<blockquote><p>
++<i>Returns:</i> <tt>hash&lt;T&gt;()(val) + std::make_hash(args...)</tt>
++</p></blockquote>
++
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1320"></a>1320. Header for <tt>iter_swap</tt></h3>
++<p><b>Section:</b> 24.3 [iterator.synopsis] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.synopsis">issues</a> in [iterator.synopsis].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>iter_swap</tt> function template appears in the
++<tt>&lt;algorithm&gt;</tt> header, yet its main use is in building further
++algorithms, not calling existing ones. The main clients are implementers of data
++structures and their iterators, so it seems most appropriate to place the
++template in the <tt>&lt;iterator&gt;</tt> header instead.
++</p>
++
++<p>
++Note that this is not an issue for implementers of the standard library, as they
++rarely use the standard headers directly, designing a more fine-grained set of
++headers for their own internal use. This option is not available to customers
++of the standard library.
++</p>
++
++<p>
++Note that we cannot remove <tt>iter_swap</tt> from <tt>&lt;algorithm&gt;</tt>
++without breaking code, but there is no reason we cannot offer the same
++declaration via two standard headers. Alternatively, require
++<tt>&lt;algorithm&gt;</tt> to <tt>#include &lt;iterator&gt;</tt>, but
++introducing the dependency on the iterator adaptors seems un-necessary.
++</p>
++
++<p><i>[
++]</i></p>
++
++
++<p>
++Discussed possibly moving to <tt>&lt;utility&gt;</tt> but don't like that. Some not seeing this
++as a defect, and want to keep it in <tt>&lt;algorithm&gt;</tt>. No one seems to feel strongly
++about moving to <tt>&lt;iterator&gt;</tt>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Add the declaration of <tt>iter_swap</tt> to the <tt>&lt;iterator&gt;</tt>
++header synopsis (24.3 [iterator.synopsis]), with a note that it is
++documented in clause 25 [algorithms].
++</p>
++
++<blockquote><pre>
++...
++template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
++
++<ins><i>// documented in 25 [algorithms]</i>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++ void iter_swap(ForwardIterator1 a, ForwardIterator2 b);</ins>
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1396"></a>1396. <tt>regex</tt> should support allocators</h3>
++<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex">issues</a> in [re.regex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1451">1451</a></p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-104, US-141</b></p>
++<p>
++<tt>std::basic_regex</tt> should have an allocator for all the
++reasons that a <tt>std::string</tt> does. For example, I can use
++<tt>boost::interprocess</tt> to put a <tt>string</tt> or <tt>vector</tt>
++in shared memory, but not a <tt>regex</tt>.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
++<p>
++Add allocators to regexes
++</p>
++
++<p><i>[
++2010-10-24 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">n3171</a>
++would solve this issue.
++</p></blockquote>
++
++<p><i>[2011-03-22 Madrid]</i></p>
++
++
++<p>Close 1396 as NAD Future.</p>
++
++
++<p><b>Rationale:</b></p><p>No consensus for a change at this time</p>
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1406"></a>1406. Support hashing smart-pointers based on <i>owner</i></h3>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP-5</b></p>
++<p>
++Hash support based on ownership sharing should be
++supplied for <tt>shared_ptr</tt> and <tt>weak_ptr</tt>.
++For two <tt>shared_ptr</tt> objects <tt>p</tt> and <tt>q</tt>, two distinct
++equivalence relations can be defined. One is based on
++equivalence of pointer values, which is derived from the
++expression <tt>p.get() == q.get()</tt> (hereafter called <i>address based
++equivalence relation</i>), the other is based on
++equivalence of ownership sharing, which is derived from
++the expression <tt>!p.owner_before(q) &amp;&amp; !q.owner_before(p)</tt>
++(hereafter called <i>ownership-based equivalence relation</i>).
++These two equivalence relations are independent in
++general. For example, a <tt>shared_ptr</tt> object created by the
++constructor of the signature <tt>shared_ptr(shared_ptr&lt;U>
++const &amp;, T *)</tt> could reveal a difference between these two
++relations. Therefore, hash support based on each
++equivalence relation should be supplied for <tt>shared_ptr</tt>.
++However, while the standard library provides the hash
++support for address-based one (20.9.11.6 paragraph 2), it
++lacks the hash support for ownership-based one. In
++addition, associative containers work well in combination
++with the <tt>shared_ptr</tt>'s ownership-based comparison but
++unordered associative containers don't. This is
++inconsistent.
++</p>
++<p>
++For the case of <tt>weak_ptr</tt>, hash support for the ownership based
++equivalence relation can be safely defined on
++<tt>weak_ptr</tt>s, and even on expired ones. The absence of
++hash support for the ownership-based equivalence
++relation is fatal, especially for expired <tt>weak_ptr</tt>s. And the
++absence of such hash support precludes some quite
++effective use-cases, e.g. erasing the <tt>unordered_map</tt> entry
++of an expired <tt>weak_ptr</tt> key from a customized deleter
++supplied to <tt>shared_ptr</tt>s.
++</p>
++<p>
++Hash support for the ownership-based equivalence
++relation cannot be provided by any user-defined manner
++because information about ownership sharing is not
++available to users at all. Therefore, the only way to provide
++ownership-based hash support is to offer it intrusively by
++the standard library.
++</p>
++<p>
++As far as we know, such hash support is implementable.
++Typical implementation of such hash function could return
++the hash value of the pointer of the counter object that is
++internally managed by <tt>shared_ptr</tt> and <tt>weak_ptr</tt>.
++</p>
++
++<p><i>[2010 Rapperswil:]</i></p>
++
++<blockquote>
++<p>No consensus to make this change at this time.</p>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add the following non-static member functions to
++<tt>shared_ptr</tt> and <tt>weak_ptr</tt> class template;
++</p>
++<p>
++Update [util.smartptr.shared], 20.9.11.2 paragraph 1
++</p>
++<pre>
++namespace std{
++template&lt;class T&gt; class shared_ptr {
++public:
++...
++ <ins>size_t owner_hash() const;</ins>
++...
++};
++}
++</pre>
++<p>
++Update [util.smartptr.weak], 20.9.11.3 paragraph 1
++</p>
++<pre>
++namespace std{
++template&lt;class T&gt; class weak_ptr {
++public:
++...
++ <ins>size_t owner_hash() const;</ins>
++...
++};
++}
++</pre>
++<p>
++These functions satisfy the following
++requirements. Let <tt>p</tt> and <tt>q</tt> be objects of either
++<tt>shared_ptr</tt> or <tt>weak_ptr</tt>, <tt>H</tt> be a hypothetical
++function object type that satisfies the hash
++requirements ([hash.requirements], 20.2.4) and <tt>h</tt> be an object of the
++type <tt>H</tt>. The expression <tt>p.owner_hash()</tt> behaves
++as if it were equivalent to the expression <tt>h(p)</tt>. In
++addition, <tt>h(p) == h(q)</tt> must become <tt>true</tt> if <tt>p</tt> and
++<tt>q</tt> share ownership.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1422"></a>1422. <tt>vector&lt;bool&gt;</tt> iterators are not random access</h3>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-118</b></p>
++<p>
++<tt>vector&lt;bool&gt;</tt> iterators are not random access iterators
++because their reference type is a special class, and not
++<tt>bool &amp;</tt>. All standard libary operations taking iterators
++should treat this iterator as if it was a random access iterator, rather
++than a simple input iterator.
++</p>
++
++<p><i>[
++Resolution proposed in ballot comment
++]</i></p>
++
++<p>
++Either revise the iterator requirements to support proxy iterators
++(restoring functionality that was lost when the Concept facility was
++removed) or add an extra paragraph to the <tt>vector&lt;bool&gt;</tt>
++specification requiring the library to treat <tt>vector&lt;bool&gt;</tt>
++iterators as-if they were random access iterators, despite having the wrong
++reference type.
++</p>
++
++<p><i>[
++Rapperswil Review
++]</i></p>
++
++<p>
++The consensus at Rapperswil is that it is too late for full support for
++proxy iterators, but requiring the library to respect <tt>vector&lt;bool&gt;</tt>
++iterators as-if they were random access would be preferable to flagging
++this container as deliberately incompatible with standard library algorithms.
++</p>
++<p>
++Alisdair to write the note, which may become normative <i>Remark</i> depending
++on the preferences of the project editor.
++</p>
++
++<p><i>[
++Post-Rapperswil Alisdair provides wording
++]</i></p>
++
++<p>
++Initial wording is supplied, deliberately using <i>Note</i> in preference to
++<i>Remark</i> although the author notes his preference for <i>Remark</i>. The
++issue of whether <tt>iterator_traits&lt;vector&lt;bool&gt;&gt;::iterator_category</tt>
++is permitted to report <tt>random_access_iterator_tag</tt> or must report
++<tt>input_iterator_tag</tt> is not addressed.
++</p>
++
++<p><i>[
++Old Proposed Resolution:
++]</i></p>
++
++<blockquote>
++<p>
++Insert a new paragraph into 23.3.7 [vector.bool] between p4 and p5:
++</p>
++<blockquote><p>
++[<i>Note</i> All functions in the library that take a pair of iterators to
++denote a range shall treat <tt>vector&lt;bool&gt;</tt> iterators as-if they were
++random access iterators, even though the <tt>reference</tt> type is not a
++true reference.<i>-- end note</i>]
++</p></blockquote>
++</blockquote>
++
++<p><i>[
++2010-11 Batavia:
++]</i></p>
++
++<blockquote><p>
++Closed as NAD Future, because the current iterator categories cannot correctly describe
++<tt>vector&lt;bool&gt;::iterator</tt>. But saying that they are Random Access Iterators
++is also incorrect, because it is not too hard to create a corresponding test that fails.
++We should deal with the more general proxy iterator problem in the future, and see no
++benefit to take a partial workaround specific to <tt>vector&lt;bool&gt;</tt> now.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++<p><b>Rationale:</b></p>
++<p>
++No consensus to make this change at this time.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1459"></a>1459. Overlapping evaluations are allowed</h3>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1458">1458</a></p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CA-21, GB-131</b></p>
++<p>
++29.4 [atomics.lockfree] p.8 states:
++</p>
++<blockquote><p>
++An atomic store shall only store a value that has
++been computed from constants and program input values
++by a finite sequence of program evaluations, such
++that each evaluation observes the values of variables
++as computed by the last prior assignment in the
++sequence.
++</p></blockquote>
++<p>
++... but 1.9 [intro.execution] p.13 states:
++</p>
++<blockquote><p>
++If A is not sequenced before B and B is not
++sequenced before A, then A and B are unsequenced.
++[ <em>Note</em>: The execution of unsequenced
++evaluations can overlap. &mdash; <em>end note</em> ]
++</p></blockquote>
++<p>
++Overlapping executions can make it impossible to
++construct the sequence described in 29.4 [atomics.lockfree] p.8. We are not
++sure of the intention here and do not offer a suggestion for
++change, but note that 29.4 [atomics.lockfree] p.8 is the condition that prevents
++out-of-thin-air reads.
++</p>
++<p>
++For an example, suppose we have a function invocation
++f(e1,e2). The evaluations of e1 and e2 can overlap.
++Suppose that the evaluation of e1 writes y and reads x
++whereas the evaluation of e2 reads y and writes x, with
++reads-from edges as below (all this is within a single
++thread).
++</p>
++<pre>
++ e1 e2
++Wrlx y-- --Wrlx x
++ rf\ /rf
++ X
++ / \
++Rrlx x&lt;- -&gt;Rrlx y
++</pre>
++<p>
++This seems like it should be allowed, but there seems to
++be no way to produce a sequence of evaluations with the
++property above.
++</p>
++<p>
++In more detail, here the two evaluations, e1 and e2, are
++being executed as the arguments of a function and are
++consequently not sequenced-before each other. In
++practice we'd expect that they could overlap (as allowed
++by 1.9 [intro.execution] p.13), with the two writes taking effect before the two
++reads. However, if we have to construct a linear order of
++evaluations, as in 29.4 [atomics.lockfree] p.8, then the execution above is not
++permited. Is that really intended?
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
++<p>
++Please clarify.
++</p>
++
++<p><i>[2011-03-09 Hans comments:]</i></p>
++
++
++<p>I'm not proud of 29.3 [atomics.order] p9 (formerly p8), and I agree with the comments that this
++isn't entirely satisfactory. 29.3 [atomics.order] p9 was designed to preclude
++out-of-thin-air results for races among <tt>memory_order_relaxed</tt> atomics, in spite of
++the fact that Java experience has shown we don't really know how to do that adequately. In
++the long run, we probably want to revisit this.
++<p/>
++However, in the short term, I'm still inclined to declare this NAD, for two separate reasons:
++</p>
++
++<ol>
++<li><p>1.9 [intro.execution] p15 states: "If a side effect on a scalar
++object is unsequenced relative to either another side
++effect on the same scalar object or a value computation
++using the value of the same scalar object, the behavior is undefined."
++I think the examples presented here have undefined behavior as a result.
++It's not completely clear to me whether examples can be constructed
++that exhibit this problem, and don't have undefined behavior.</p></li>
++
++<li><p>This comment seems to be using a different meaning of "evaluation"
++from what is used elsewhere in the standard. The sequence of evaluations
++here doesn't have to consist of full expression evaluations. They
++can be evaluations of operations like lvalue to rvalue conversion,
++or individual assignments. In particular, the reads and writes
++executed by <tt>e1</tt> and <tt>e2</tt> in the example could be treated as separate
++evaluations for purposes of producing the sequence.
++The definition of "sequenced before" in 1.9 [intro.execution] makes
++little sense if the term "evaluation" is restricted to any notion
++of complete expression. Perhaps we should add yet another note
++to clarify this? 29.3 [atomics.order] p10 probably leads to
++the wrong impression here.
++<p/>
++An alternative resolution would be to simply delete our flakey
++attempt at preventing out-of-thin-air reads, by removing 29.3 [atomics.order] p9-11,
++possibly adding a note that explains that we technically allow,
++but strongly discourage them. If we were starting this from scratch
++now, that would probably be my preference. But it seems like too drastic
++a resolution at this stage.
++</p></li>
++</ol>
++
++<p><i>[2011-03-24 Madrid]</i></p>
++
++<p>
++Moved to NAD Future
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1484"></a>1484. Need a way to join a thread with a timeout</h3>
++<p><b>Section:</b> 30.3.1 [thread.thread.class] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-183</b></p>
++
++<p>
++There is no way to join a thread with a timeout.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Add <tt>join_for</tt> and <tt>join_until</tt>. Or decide one should
++never join a thread with a timeout since <tt>pthread_join</tt> doesn't have a
++timeout version.
++</p></blockquote>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++The concurrency working group deemed this an extension beyond the scope of C++0x.
++</p>
++<p><b>Rationale:</b></p><p>The LWG does not wish to make a change at this time.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1488"></a>1488. Improve interoperability between the C++0x and C1x threads APIs</h3>
++<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-185</b></p>
++
++<p>
++Cooperate with WG14 to improve interoperability between
++the <tt>C++0x</tt> and <tt>C1x</tt> threads APIs. In particular, <tt>C1x</tt>
++mutexes should be conveniently usable with a <tt>C++0x</tt>
++<tt>lock_guard</tt>. Performance overheads for this combination
++should be considered.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Remove <tt>C++0x</tt> <tt>timed_mutex</tt> and
++<tt>timed_recursive_mutex</tt> if that facilitates
++development of more compatible APIs.
++</p></blockquote>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++The concurrency sub-group reviewed the options, and decided that closer harmony should wait until both standards are published.
++</p>
++
++<p><b>Rationale:</b></p>
++<p>
++The LWG does not wish to make any change at this time.
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1493"></a>1493. Add <tt>mutex</tt>, <tt>recursive_mutex</tt>, <tt>is_locked</tt> function</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-189</b></p>
++
++<p>
++<tt>mutex</tt> and <tt>recursive_mutex</tt> should have an <tt>is_locked()</tt>
++member function. <tt>is_locked</tt> allows a user to test a lock
++without acquiring it and can be used to implement a lightweight
++<tt>try_try_lock</tt>.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Add a member function:
++</p>
++<pre>
++bool is_locked() const;
++</pre>
++<p>
++to <tt>std::mutex</tt> and <tt>std::recursive_mutex</tt>. These
++functions return true if the current thread would
++not be able to obtain a mutex. These functions do
++not synchronize with anything (and, thus, can
++avoid a memory fence).
++</p></blockquote>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++The Concurrency subgroup reviewed this issue and deemed it to be an extension to be handled after publishing C++0x.
++</p>
++
++<p><b>Rationale:</b></p><p>The LWG does not wish to make a change at this time.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1499"></a>1499. Condition variables preclude wakeup optimization</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-193</b></p>
++
++<p>
++Condition variables preclude a wakeup optimization.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++
++<blockquote><p>
++Change condition_variable to allow such
++optimization. See Appendix 1 - Additional Details
++</p></blockquote>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++The Concurrency subgroup reviewed the issue, and deemed it an extension to be handled after C++0x.
++</p>
++
++<p><b>Rationale:</b></p><p>The LWG does not wish to make the change at this time.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1521"></a>1521. Requirements on internal pointer representations in containers</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Mike Spertus <b>Opened:</b> 2010-10-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-104, US-141</b></p>
++
++<p>
++The standard doesn't say that containers should use abstract pointer
++types internally. Both Howard and Pablo agree that this is the intent.
++Further, it is necessary for containers to be stored, for example, in
++shared memory with an interprocess allocator (the type of scenario that
++allocators are intended to support).
++</p>
++<p>
++In spite of the (possible) agreement on intent, it is necessary to make
++this explicit:
++</p>
++<p>
++An implementations may like to store the result of dereferencing the
++pointer (which is a raw reference) as an optimization, but that prevents
++the data structure from being put in shared memory, etc. In fact, a
++container could store raw references to the allocator, which would be a
++little weird but conforming as long as it has one by-value copy.
++Furthermore, pointers to locales, ctypes, etc. may be there, which also
++prevents the data structure from being put in shared memory, so we
++should make explicit that a container does not store raw pointers or
++references at all.
++</p>
++
++<p><i>[
++Pre-batavia
++]</i></p>
++
++<p>
++This issue is being opened as part of the response to NB comments US-104/141.
++See paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">N3171</a>
++in the pre-Batavia mailing.
++</p>
++
++<p><i>[2011-03-23 Madrid meeting]</i></p>
++
++
++<p>Deferred</p>
++
++<p><i>[
++2011 Batavia
++]</i></p>
++
++
++<p>
++This may be an issue, but it is not clear. We want to gain a few years experience
++with the C++11 allocator model to see if this is already implied by the existing
++specification.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add to the end of 23.2.1 [container.requirements.general] p. 8:
++</p>
++<blockquote><p>
++[..] In all container types defined in this Clause, the member <tt>get_allocator()</tt> returns
++a copy of the allocator used to construct the container or, if that allocator has been replaced,
++a copy of the most recent replacement. <ins>The container may not store internal objects whose
++types are of the form <tt>T *</tt> or <tt>T &amp;</tt> except insofar as they are part of the
++item type or members.</ins>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2035"></a>2035. Output iterator requirements are broken</h3>
++<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#output.iterators">active issues</a> in [output.iterators].</p>
++<p><b>View all other</b> <a href="lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>During the Pittsburgh meeting the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>
++became accepted because it fixed several severe issues related to the iterator specification. But the current working draft (N3225)
++does not reflect all these changes. Since I'm unaware whether every correction can be done editorial, this issue is submitted to take
++care of that. To give one example: All expressions of Table 108 &mdash; &quot;Output iterator requirements&quot; have a post-condition
++that the iterator is incrementable. This is impossible, because it would exclude any finite sequence that is accessed by an output
++iterator, such as a pointer to a C array. The N3066 wording changes did not have these effects.
++</p>
++
++<p><i>[2011-03-01: Daniel comments:]</i></p>
++
++
++<p>This issue has some overlap with the issue <a href="lwg-active.html#2038">2038</a> and I would prefer if we
++could solve both at one location. I suggest the following approach:
++</p>
++<ol>
++<li><p>The terms <tt><i>dereferencable</i></tt> and <tt><i>incrementable</i></tt> could be defined in a more
++general way not restricted to iterators (similar to the concepts <tt>HasDereference</tt> and
++<tt>HasPreincrement</tt> from working draft N2914). But on the other hand, all current usages of
++<tt><i>dereferencable</i></tt> and <tt><i>incrementable</i></tt> are involved with types that satisfy
++iterator requirements. Thus, I believe that it is sufficient for C++0x to add corresponding definitions to
++24.2.1 [iterator.requirements.general] and to let all previous usages of these terms refer to this
++sub-clause. Since the same problem occurs with the past-the-end iterator, this proposal suggest providing
++similar references to usages that precede its definition as well.
++</p></li>
++<li><p>We also need to ensure that all iterator expressions get either an operational semantics in
++terms of others or we need to add missing pre- and post-conditions. E.g. we have the following
++ones without semantics:
++</p><blockquote><pre>
++*r++ = o // output iterator
++*r-- // bidirectional iterator
++</pre></blockquote><p>
++According to the <a href="http://www.sgi.com/tech/stl/OutputIterator.html">SGI specification</a>
++these correspond to
++</p><blockquote><pre>
++{ *r = o; ++r; } // output iterator
++{ reference tmp = *r; --r; return tmp; } // bidirectional iterator
++</pre></blockquote><p>
++respectively. Please note especially the latter expression for bidirectional iterator. It fixes a problem
++that we have for forward iterator as well: Both these iterator categories provide stronger guarantees
++than input iterator, because the result of the dereference operation is <tt>reference</tt>, and <strong>not</strong>
++only convertible to the value type (The exact form from the SGI documentation does not correctly refer to
++<tt>reference</tt>).
++</p></li>
++</ol>
++
++<p><i>[2011-03-14: Daniel comments and updates the suggested wording]</i></p>
++
++
++<p>In addition to the before mentioned necessary changes there is another one need, which
++became obvious due to issue <a href="lwg-defects.html#2042">2042</a>: <tt>forward_list&lt;&gt;::before_begin()</tt> returns
++an iterator value which is not dereferencable, but obviously the intention is that it should
++be incrementable. This leads to the conclusion that imposing dereferencable as a requirement
++for the expressions <tt>++r</tt> is wrong: We only need the iterator to be incrementable. A
++similar conclusion applies to the expression <tt>--r</tt> of bidirectional iterators.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Consensus this is the correct direction, but there are (potentially) missing <i>incrementable</i>
++preconditions on some table rows, and the Remarks on when an output iterator becomes dereferencable
++are probably better handled outside the table, in a manner similar to the way we word for input
++iterators.
++</p>
++
++<p>
++There was some concern about redundant pre-conditions when the operational semantic is defined in
++terms of operations that have preconditions, and a similar level of concern over dropping such
++redundancies vs. applying a consistent level of redundant specification in all the iterator tables.
++Wording clean-up in either direction would be welcome.
++</p>
++
++<p><i>[2011-08-18: Daniel adapts the proposed resolution to honor the Bloomington request]</i></p>
++
++
++<p>
++There is only a small number of further changes suggested to get rid of superfluous
++requirements and essentially non-normative assertions. Operations should not have extra
++pre-conditions, if defined by "in-terms-of" semantics, see e.g. <tt>a != b</tt> or <tt>a-&gt;m</tt>
++for Table 107. Further, some remarks, that do not impose anything or say nothing new have been removed,
++because I could not find anything helpful they provide.
++E.g. consider the remarks for Table 108 for the operations dereference-assignment and
++preincrement: They don't provide additional information say nothing surprising. With the
++new pre-conditions <em>and</em> post-conditions it is implied what the remarks intend to say.
++</p>
++
++<p><i>[
++2011-11-03: Some observations from Alexander Stepanov via c++std-lib-31405
++]</i></p>
++
++
++<p>
++The following sentence is dropped from the standard section on OutputIterators:
++<p/>
++"In particular, the following two conditions should hold: first, any
++iterator value should be assigned through before it is incremented
++(this is, for an output iterator <tt>i, i++; i++;</tt> is not a valid code
++sequence); second, any value of an output iterator may have at most
++one active copy at any given time (for example, <tt>i = j; *++i = a; *j = b;</tt>
++is not a valid code sequence)."
++</p>
++
++<p><i>[
++2011-11-04: Daniel comments and improves the wording
++]</i></p>
++
++
++<p>
++In regard to the first part of the comment, the intention of the newly proposed wording
++was to make clear that for the expression
++</p>
++<blockquote><pre>
++*r = o
++</pre></blockquote>
++<p>
++we have the precondition dereferenceable and the post-condition
++incrementable. And for the expression
++</p>
++<blockquote><pre>
++++r
++</pre></blockquote>
++<p>
++we have the precondition incrementable and the post-condition dereferenceable
++or past-the-end. This <em>should not</em> allow for a sequence like <tt>i++; i++;</tt>
++but I agree that it doesn't exactly say that.
++<p/>
++In regard to the second point: To make this point clearer, I suggest to
++add a similar additional wording as we already have for input iterator to the
++"Assertion&#47;note" column of the expression <tt>++r</tt>:
++<p/>
++"Post: any copies of the previous value of <tt>r</tt> are no longer
++required to be dereferenceable or incrementable."
++<p/>
++The proposed has been updated to honor the observations of Alexander Stepanov.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++The matter is complicated, Daniel volunteers to write a paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Add a reference to 24.2.1 [iterator.requirements.general] to the following parts of the
++library preceding Clause 24 Iterators library: (I stopped from 23.2.5 [unord.req] on, because
++the remaining references are the concrete containers)</p>
++<ol>
++<li><p>17.6.3.2 [swappable.requirements] p5:</p>
++
++<blockquote><p>
++-5- A type <tt>X</tt> satisfying any of the iterator requirements (24.2) is <tt><i>ValueSwappable</i></tt> if,
++for any dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins> object <tt>x</tt> of type
++<tt>X</tt>, <tt>*x</tt> is swappable.
++</p></blockquote>
++</li>
++
++<li><p>17.6.3.5 [allocator.requirements], Table 27 &mdash; &quot;Descriptive variable definitions&quot;,
++row with the expression <tt>c</tt>:</p>
++
++<blockquote><p>
++a dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins> pointer of type <tt>C*</tt>
++</p></blockquote>
++
++</li>
++
++<li><p>20.7.3.2 [pointer.traits.functions]:</p>
++<blockquote><p>
++<i>Returns</i>: The first template function returns a dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins>
++pointer to <tt>r</tt> obtained by calling <tt>Ptr::pointer_to(r)</tt>; [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>21.4.3 [string.iterators] p. 2:</p>
++<blockquote><p>
++<i>Returns</i>: An iterator which is the past-the-end value <ins>(24.2.1 [iterator.requirements.general])</ins>.
++</p></blockquote>
++</li>
++
++<li><p>22.4.5.1.2 [locale.time.get.virtuals] p. 11:</p>
++<blockquote><pre>
++iter_type do_get(iter_type s, iter_type end, ios_base&amp; f,
++ ios_base::iostate&amp; err, tm *t, char format, char modifier) const;
++</pre><blockquote><p>
++<i>Requires</i>: <tt>t</tt> shall be dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins>.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>23.2.1 [container.requirements.general] p. 6:</p>
++
++<blockquote><p>
++[&hellip;] <tt>end()</tt> returns an iterator which is the past-the-end <ins>(24.2.1 [iterator.requirements.general])</ins>
++value for the container. [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>23.2.3 [sequence.reqmts] p. 3:</p>
++
++<blockquote><p>
++[&hellip;] <tt>q</tt> denotes a valid dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins>
++const iterator to <tt>a</tt>, [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>23.2.4 [associative.reqmts] p. 8 (I omit intentionally one further reference in the same sub-clause):</p>
++
++<blockquote><p>
++[&hellip;] <tt>q</tt> denotes a valid dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins>
++const iterator to <tt>a</tt>, [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>23.2.5 [unord.req] p. 10 (I omit intentionally one further reference in the same sub-clause):</p>
++
++<blockquote><p>
++[&hellip;] <tt>q</tt> and <tt>q1</tt> are valid dereferenceable <ins>(24.2.1 [iterator.requirements.general])</ins>
++const iterators to <tt>a</tt>, [&hellip;]
++</p></blockquote>
++</li>
++</ol>
++
++</li>
++<li><p>Edit 24.2.1 [iterator.requirements.general] p. 5 as indicated (The intent is to properly define
++<i>incrementable</i> and to ensure some further library guarantee related to past-the-end iterator values):</p>
++
++<blockquote><p>
++-5- Just as a regular pointer to an array guarantees that there is a pointer value pointing past the last element
++of the array, so for any iterator type there is an iterator value that points past the last element of a
++corresponding sequence. These values are called <i>past-the-end values</i>. Values of an iterator <tt>i</tt> for which the
++expression <tt>*i</tt> is defined are called <i>dereferenceable</i>. <ins>Values of an iterator <tt>i</tt> for which the
++expression <tt>++i</tt> is defined are called <i>incrementable</i>. </ins> The library never assumes that
++past-the-end values are dereferenceable <ins>or incrementable</ins>. Iterators can also have singular values
++that are not associated with any sequence. [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>Modify the column contents of Table 106 &mdash; &quot;Iterator requirements&quot;,
++24.2.2 [iterator.iterators], as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 106 &mdash; Iterator requirements</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td><tt>*r</tt></td>
++<td><tt>reference</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td>pre: <tt>r</tt> is dereferenceable.</td>
++</tr>
++
++<tr>
++<td><tt>++r</tt></td>
++<td><tt>X&amp;</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td><ins>pre: <tt>r</tt> is incrementable.</ins></td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>Modify the column contents of Table 107 &mdash; &quot;Input iterator requirements&quot;,
++24.2.3 [input.iterators], as indicated [<i>Rationale</i>: The wording changes attempt
++to define a minimal "independent" set of operations, namely <tt>*a</tt> and <tt>++r</tt>, and
++to specify the semantics of the remaining ones. This approach seems to be in agreement with the
++original <a href="http://www.sgi.com/tech/stl/InputIterator.html">SGI specification</a>
++&mdash; <i>end rationale</i>]:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 107 &mdash; Input iterator requirements (in addition to Iterator)</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td><tt>a != b</tt></td>
++<td>contextually<br/>
++convertible to <tt>bool</tt></td>
++<td><tt>!(a == b)</tt></td>
++<td><del>pre: <tt>(a, b)</tt> is in the domain<br/>
++of <tt>==</tt>.</del>
++</td>
++</tr>
++
++<tr>
++<td><tt>*a</tt></td>
++<td>convertible to <tt>T</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td>pre: <tt>a</tt> is dereferenceable.<br/>
++The expression<br/>
++<tt>(void)*a, *a</tt> is equivalent<br/>
++to <tt>*a</tt>.<br/>
++If <tt>a == b</tt> and <tt>(a,b)</tt> is in<br/>
++the domain of <tt>==</tt> then <tt>*a</tt> is<br/>
++equivalent to <tt>*b</tt>.
++</td>
++</tr>
++
++<tr>
++<td><tt>a-&gt;m</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td><tt>(*a).m</tt></td>
++<td><del>pre: <tt>a</tt> is dereferenceable.</del></td>
++</tr>
++
++<tr>
++<td><tt>++r</tt></td>
++<td><tt>X&amp;</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td>pre: <tt>r</tt> is <del>dereferenceable</del><ins>incrementable</ins>.<br/>
++post: <tt>r</tt> is dereferenceable or<br/>
++<tt>r</tt> is past-the-end.<br/>
++post: any copies of the<br/>
++previous value of <tt>r</tt> are no<br/>
++longer required either to be<br/>
++dereferenceable<ins>, incrementable,</ins><br/>
++or to be in the domain of <tt>==</tt>.
++</td>
++</tr>
++
++<tr>
++<td><tt>(void)r++</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td><ins><tt>(void)++r</tt></ins></td>
++<td><del>equivalent to <tt>(void)++r</tt></del></td>
++</tr>
++
++<tr>
++<td><tt>*r++</tt></td>
++<td>convertible to <tt>T</tt></td>
++<td><tt>{ T tmp = *r;<br/>
++++r;<br/>
++return tmp; }
++</tt></td>
++<td><tt>&nbsp;</tt></td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li>
++<p>Modify the column contents of Table 108 &mdash; &quot;Output iterator requirements&quot;,
++24.2.4 [output.iterators], as indicated [<i>Rationale</i>: The wording changes attempt
++to define a minimal "independent" set of operations, namely <tt>*r = o</tt> and <tt>++r</tt>,
++and to specify the semantics of the remaining ones. This approach seems to be in agreement with
++the original <a href="http://www.sgi.com/tech/stl/OutputIterator.html">SGI specification</a>
++&mdash; <i>end rationale</i>]:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 108 &mdash; Output iterator requirements (in addition to Iterator)</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td><tt>*r = o</tt></td>
++<td>result is not used</td>
++<td><tt>&nbsp;</tt></td>
++<td><ins>pre: <tt>r</tt> is dereferenceable.</ins><br/>
++<i>Remark</i>: After this operation<br/>
++<tt>r</tt> is not required to be<br/>
++dereferenceable <ins>and any copies of<br/>
++the previous value of <tt>r</tt> are no<br/>
++longer required to be dereferenceable<br/>
++or incrementable.</ins><br/>
++post: <tt>r</tt> is incrementable.
++</td>
++</tr>
++
++<tr>
++<td><tt>++r</tt></td>
++<td><tt>X&amp;</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td><ins>pre: <tt>r</tt> is incrementable.</ins><br/>
++<tt>&amp;r == &amp;++r</tt>.<br/>
++<del><i>Remark</i>: After this operation<br/>
++<tt>r</tt> is not required to be<br/>
++dereferenceable.<br/></del>
++<ins><i>Remark</i>: After this operation<br/>
++<tt>r</tt> is not required to be<br/>
++incrementable and any copies of<br/>
++the previous value of <tt>r</tt> are no<br/>
++longer required to be dereferenceable<br/>
++or incrementable.</ins><br/>
++post: <tt>r</tt> is <ins>dereferenceable<br/>
++or <tt>r</tt> is past-the-end</ins><del>incrementable</del>.<br/>
++</td>
++</tr>
++
++<tr>
++<td><tt>r++</tt></td>
++<td>convertible to <tt>const X&amp;</tt></td>
++<td><tt>{ X tmp = r;<br/>
++ ++r;<br/>
++ return tmp; }</tt>
++</td>
++<td><del><i>Remark</i>: After this operation<br/>
++<tt>r</tt> is not required to be<br/>
++dereferenceable.<br/>
++post: <tt>r</tt> is incrementable.</del>
++</td>
++</tr>
++
++<tr>
++<td><tt>*r++ = o</tt></td>
++<td>result is not used</td>
++<td><ins><tt>{ *r = o; ++r; }</tt></ins></td>
++<td><del><i>Remark</i>: After this operation<br/>
++<tt>r</tt> is not required to be<br/>
++dereferenceable.<br/>
++post: <tt>r</tt> is incrementable.</del>
++</td>
++</tr>
++</table>
++</blockquote>
++</li>
++
++<li><p>Modify the column contents of Table 109 &mdash; &quot;Forward iterator requirements&quot;,
++24.2.5 [forward.iterators], as indicated [<i>Rationale</i>: Since the return type of the
++expression <tt>*r++</tt> is now guaranteed to be type <tt>reference</tt>, the implied operational
++semantics from input iterator based on value copies is wrong &mdash; <i>end rationale</i>]</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 109 &mdash; Forward iterator requirements (in addition to input iterator)</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td><tt>r++</tt></td>
++<td>convertible to <tt>const X&amp;</tt></td>
++<td><tt>{ X tmp = r;<br/>
++ ++r;<br/>
++ return tmp; }</tt>
++</td>
++<td><tt>&nbsp;</tt></td>
++</tr>
++
++<tr>
++<td><tt>*r++</tt></td>
++<td>reference</td>
++<td><ins><tt>{ reference tmp = *r;<br/>
++ ++r;<br/>
++ return tmp; }</tt></ins></td>
++<td><tt>&nbsp;</tt></td>
++</tr>
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Modify the column contents of Table 110 &mdash; &quot;Bidirectional iterator requirements&quot;,
++24.2.6 [bidirectional.iterators], as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 110 &mdash; Bidirectional iterator requirements (in addition to forward iterator)</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td><tt>--r</tt></td>
++<td><tt>X&amp;</tt></td>
++<td><tt>&nbsp;</tt></td>
++<td>pre: there exists <tt>s</tt> such that<br/>
++<tt>r == ++s</tt>.<br/>
++post: <tt>r</tt> is <del>dereferenceable</del><ins>incrementable</ins>.<br/>
++<tt>--(++r) == r</tt>.<br/>
++<tt>--r == --s</tt> implies <tt>r == s</tt>.<br/>
++<tt>&amp;r == &amp;--r</tt>.
++</td>
++</tr>
++
++<tr>
++<td><tt>r--</tt></td>
++<td>convertible to <tt>const X&amp;</tt></td>
++<td><tt>{ X tmp = r;<br/>
++ --r;<br/>
++ return tmp; }</tt>
++</td>
++<td><tt>&nbsp;</tt></td>
++</tr>
++
++<tr>
++<td><tt>*r--</tt></td>
++<td>reference</td>
++<td><ins><tt>{ reference tmp = *r;<br/>
++ --r;<br/>
++ return tmp; }</tt></ins></td>
++<td><tt>&nbsp;</tt></td>
++</tr>
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2038"></a>2038. Missing definition for <tt>incrementable</tt> iterator</h3>
++<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#output.iterators">active issues</a> in [output.iterators].</p>
++<p><b>View all other</b> <a href="lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>In comp.lang.c++, Vicente Botet raises the following questions:</p>
++
++<blockquote><p>
++&quot;In "24.2.4 Output iterators" there are 3 uses of incrementable. I've
++not found the definition. Could some one point me where it is defined?
++<p/>
++Something similar occurs with dereferenceable. While the definition is
++given in "24.2.1 In general" it is used several times before.
++<p/>
++Shouldn't these definitions be moved to some previous section?&quot;
++</p></blockquote>
++
++<p>He's right: both terms are used without being properly defined.
++<p/>
++There is no definition of "incrementable".
++<p/>
++While there is a definition of "dereferenceable", it is, in fact, a definition of
++"dereferenceable iterator". "dereferenceable" is used throughout Clause 23 (Containers)
++before its definition in Clause 24. In almost all cases it's referring to iterators,
++but in 17.6.3.2 [swappable.requirements] there is a mention of "dereferenceable object"; in
++17.6.3.5 [allocator.requirements] the table of Descriptive variable definitions refers to a
++"dereferenceable pointer"; 20.7.3.2 [pointer.traits.functions] refers to a
++"dereferenceable pointer"; in 22.4.5.1.2 [locale.time.get.virtuals]&#47;11 (<tt>do_get</tt>)
++there is a requirement that a pointer "shall be dereferenceable". In those specific cases
++it is not defined.
++</p>
++
++<p><i>[2011-03-02: Daniel comments:]</i></p>
++
++
++<p>I believe that the currently proposed resolution of issue <a href="lwg-active.html#2035">2035</a> solves this
++issue as well.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Agree with Daniel, this will be handled by the resolution of <a href="lwg-active.html#2035">2035</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p></p>
++
++
++
++
++
++<hr>
++<h3><a name="2040"></a>2040. Missing type traits related to <tt>is_convertible</tt></h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>When <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>
++was suggested, it concentrated on constructions, assignments, and destructions, but overlooked
++to complement the single remaining compiler-support trait</p>
++
++<blockquote><pre>
++template &lt;class From, class To&gt; struct is_convertible;
++</pre></blockquote>
++
++<p>with the no-throw and triviality related aspects as it had been done with the other
++expression-based traits. Specifically, the current specification misses to add the
++following traits:
++</p>
++
++<blockquote><pre>
++template &lt;class From, class To&gt; struct is_nothrow_convertible;
++template &lt;class From, class To&gt; struct is_trivially_convertible;
++</pre></blockquote>
++
++<p>In particular the lack of <tt>is_nothrow_convertible</tt> is severly restricting. This
++was recently recognized when the proposal for <tt>decay_copy</tt> was prepared by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3255.html">n3255</a>.
++There does not exist a portable means to define the correct conditional <tt>noexcept</tt>
++specification for the <tt>decay_copy</tt> function template, which is declared as:</p>
++
++<blockquote><pre>
++template &lt;class T&gt;
++typename decay&lt;T&gt;::type decay_copy(T&amp;&amp; v) noexcept(<i>???</i>);
++</pre></blockquote>
++
++<p>The semantics of <tt>decay_copy</tt> bases on an implicit conversion which again
++influences the overload set of functions that are viable here. In most circumstances
++this will have the same effect as comparing against the trait
++<tt>std::is_nothrow_move_constructible</tt>, but there is no guarantee for that being
++the right answer. It is possible to construct examples, where this would lead
++to the false result, e.g.</p>
++
++<blockquote><pre>
++struct S {
++ S(const S&amp;) noexcept(false);
++
++ template&lt;class T&gt;
++ explicit S(T&amp;&amp;) noexcept(true);
++};
++</pre></blockquote>
++
++<p><tt>std::is_nothrow_move_constructible</tt> will properly honor the explicit template
++constructor because of the direct-initialization context which is part of the
++<tt>std::is_constructible</tt> definition and will in this case select it, such that
++<tt>std::is_nothrow_move_constructible&lt;S&gt;::value == true</tt>, but if we had
++the traits <tt>is_nothrow_convertible</tt>, <tt>is_nothrow_convertible&lt;S, S&gt;::value</tt>
++would evaluate to <tt>false</tt>, because it would use the copy-initialization context
++that is part of the <tt>is_convertible</tt> definition, excluding any explicit
++constructors and giving the opposite result.</p>
++
++<p>The <tt>decay_copy</tt> example is surely not one of the most convincing examples, but
++<tt>is_nothrow_convertible</tt> has several use-cases, and can e.g. be used to express
++whether calling the following implicit conversion function could throw an exception or not:</p>
++
++<blockquote><pre>
++template&lt;class T, class U&gt;
++T implicit_cast(U&amp;&amp; u) noexcept(is_nothrow_convertible&lt;U, T&gt;::value)
++{
++ return std::forward&lt;U&gt;(u);
++}
++</pre></blockquote>
++
++<p>Therefore I suggest to add the missing trait <tt>is_nothrow_convertible</tt> and for
++completeness also the missing trait <tt>is_trivially_convertible</tt> to 20.10 [meta].</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++Daniel K: This is a new feature so out of scope.
++<p/>
++Pablo: Any objections to moving 2040 to Open?
++<p/>
++No objections.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to NAD Future, this would be an extension to existing functionality.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Ammend the following declarations to the header <tt>&lt;type_traits&gt;</tt> synopsis
++in 20.10.2 [meta.type.synop]:</p>
++
++<blockquote><pre>
++namespace std {
++ &hellip;
++ // 20.9.6, type relations:
++ template &lt;class T, class U&gt; struct is_same;
++ template &lt;class Base, class Derived&gt; struct is_base_of;
++ template &lt;class From, class To&gt; struct is_convertible;
++ <ins>template &lt;class From, class To&gt; struct is_trivially_convertible;</ins>
++ <ins>template &lt;class From, class To&gt; struct is_nothrow_convertible;</ins>
++
++ &hellip;
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify Table 51 &mdash; &quot;Type relationship predicates&quot; as indicated. The removal of the
++remaining traces of the trait <tt>is_explicitly_convertible</tt> is an editorial
++step, it was removed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3047.html">n3047</a>:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 51 &mdash; Type relationship predicates</caption>
++
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">&hellip;</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class From, class To&gt;<br/>
++struct is_convertible;</tt></td>
++<td><i>see below</i></td>
++<td><tt>From</tt> and <tt>To</tt> shall be complete<br/>
++types, arrays of unknown bound, or<br/>
++(possibly cv-qualified) <tt>void</tt><br/>
++types.</td>
++</tr>
++
++<tr>
++<td><del><tt>template &lt;class From, class To&gt;<br/>
++struct is_explicitly_convertible;</tt></del></td>
++<td><del><tt>is_constructible&lt;To, From&gt;::value</tt></del></td>
++<td><del>a synonym for a two-argument<br/>
++version of <tt>is_constructible</tt>.<br/>
++An implementation may define it<br/>
++as an alias template.</del></td>
++</tr>
++
++<tr>
++<td><ins><tt>template &lt;class From, class To&gt;<br/>
++struct is_trivially_convertible;</tt></ins></td>
++<td><ins><tt>is_convertible&lt;From,<br/>
++ To&gt;::value</tt> is <tt>true</tt> and the<br/>
++conversion, as defined by<br/>
++<tt>is_convertible</tt>, is known<br/>
++to call no operation that is<br/>
++not trivial ([basic.types], [special]).</ins></td>
++<td><ins><tt>From</tt> and <tt>To</tt> shall be complete<br/>
++types, arrays of unknown bound,<br/>
++or (possibly cv-qualified) <tt>void</tt><br/>
++types.</ins></td>
++</tr>
++
++<tr>
++<td><ins><tt>template &lt;class From, class To&gt;<br/>
++struct is_nothrow_convertible;</tt></ins></td>
++<td><ins><tt>is_convertible&lt;From,<br/>
++ To&gt;::value</tt> is <tt>true</tt> and the<br/>
++conversion, as defined by<br/>
++<tt>is_convertible</tt>, is known<br/>
++not to throw any<br/>
++exceptions ([expr.unary.noexcept]).</ins></td>
++<td><ins><tt>From</tt> and <tt>To</tt> shall be complete<br/>
++types, arrays of unknown bound,<br/>
++or (possibly cv-qualified) <tt>void</tt><br/>
++types.</ins></td>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">&hellip;</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2051"></a>2051. Explicit <tt>tuple</tt> constructors for more than one parameter</h3>
++<p><b>Section:</b> 20.4.2 [tuple.tuple], 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Ville Voutilainen <b>Opened:</b> 2011-05-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.tuple">issues</a> in [tuple.tuple].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++One of my constituents wrote the following:
++<p/>
++-------snip------------
++<p/>
++So far the only use I've found for <tt>std::tuple</tt> is as an ad-hoc type to emulate
++multiple return values. If the tuple ctor was made non-explicit one could
++almost think C++ supported multiple return values especially when combined
++with <tt>std::tie()</tt>.
++</p>
++<blockquote><pre>
++// assume types line_segment and point
++// assume function double distance(point const&amp;, point const&amp;)
++
++std::tuple&lt;point, point&gt;
++closest_points(line_segment const&amp; a, line_segment const&amp; b) {
++ point ax;
++ point bx;
++ /* some math */
++
++ return {ax, bx};
++}
++
++
++double
++distance(line_segment const&amp; a, line_segment const&amp; b) {
++ point ax;
++ point bx;
++ std::tie(ax, bx) = closest_points(a, b);
++
++ return distance(ax, bx);
++}
++</pre></blockquote>
++<p>
++-------snap----------
++<p/>
++See also the messages starting from lib-29330.
++<p/>
++Some notes:
++</p>
++<ol>
++<li><tt>pair</tt> allows such a return</li>
++<li>a lambda with a deduced return type doesn't allow it for any type</li>
++<li><tt>decltype</tt> refuses <tt>{1, 2}</tt></li>
++</ol>
++<p>
++I would recommend making non-unary <tt>tuple</tt> constructors non-explicit.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to NAD Future, this would be an extension to existing functionality.
++</p>
++
++<p><i>[Portland, 2012]</i></p>
++
++<p>
++Move to Open at the request of the Evolution Working Group.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2055"></a>2055. <tt>std::move</tt> in <tt>std::accumulate</tt> and other algorithms</h3>
++<p><b>Section:</b> 26.7 [numeric.ops] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2011-01-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.ops">issues</a> in [numeric.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The C++0x draft says <tt>std::accumulate</tt> uses: <tt>acc = binary_op(acc, *i)</tt>.
++<p/>
++Eelis van der Weegen has pointed out, on the libstdc++ mailing list, that using
++<tt>acc = binary_op(std::move(acc), *i)</tt> can lead to massive improvements (particularly,
++it means accumulating strings is linear rather than quadratic).
++<p/>
++Consider the simple case, accumulating a bunch of strings of length 1 (the same argument holds for other length buffers).
++For strings <tt>s</tt> and <tt>t</tt>, <tt>s+t</tt> takes time <tt>length(s)+length(t)</tt>, as you have to copy
++both <tt>s</tt> and <tt>t</tt> into a new buffer.
++<p/>
++So in accumulating <tt>n</tt> strings, step <tt>i</tt> adds a string of length <tt>i-1</tt> to a string of length
++1, so takes time <tt>i</tt>.
++<p/>
++Therefore the total time taken is: <tt>1+2+3+...+n</tt> = O(<tt>n<sup>2</sup></tt>)
++<p/>
++<tt>std::move(s)+t</tt>, for a "good" implementation, is amortized time <tt>length(t)</tt>, like <tt>vector</tt>,
++just copy <tt>t</tt> onto the end of the buffer. So the total time taken is:
++<p/>
++<tt>1+1+1+...+1</tt> (<tt>n</tt> times) = O(<tt>n</tt>). This is the same as <tt>push_back</tt> on a <tt>vector</tt>.
++<p/>
++I'm trying to decide if this implementation might already be allowed. I suspect it might not
++be (although I can't imagine any sensible code it would break). There are other algorithms
++which could benefit similarly (<tt>inner_product</tt>, <tt>partial_sum</tt> and
++<tt>adjacent_difference</tt> are the most obvious).
++<p/>
++Is there any general wording for "you can use rvalues of temporaries"?
++<p/>
++The reflector discussion starting with message c++std-lib-29763 came to the conclusion
++that above example is not covered by the "as-if" rules and that enabling this behaviour
++would seem quite useful.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Moved to NAD Future. This would be a larger change than we would consider for a simple TC.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2062"></a>2062. Effect contradictions w&#47;o no-throw guarantee of <tt>std::function</tt> swaps</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func], 20.9.12.2.2 [func.wrap.func.mod] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Howard Hinnant observed in reflector message c++std-lib-30841 that 20.9.12.2 [func.wrap.func]
++makes the member swap <tt>noexcept</tt>, even though the non-member swap is not <tt>noexcept</tt>.
++<p/>
++The latter was an outcome of the discussions during the Batavia meeting and the Madrid meeting
++involving LWG <a href="lwg-defects.html#1349">1349</a>, which seems to indicate that the remaining <tt>noexcept</tt>
++specifier at the member swap is incorrect and should be removed.
++<p/>
++But if we allow for a potentially throwing member swap of <tt>std::function</tt>, this causes
++another conflict with the exception specification for the following member function:
++</p>
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt; f) <span style="color:#C80000;font-weight:bolder">noexcept</span>;
++</pre><blockquote><p>
++<i>Effects</i>: <tt>function(f).<span style="color:#C80000;font-weight:bolder">swap</span>(*this);</tt>
++</p>
++</blockquote></blockquote>
++<p>
++Note that in this example the sub-expression <tt>function(f)</tt> does not cause any problems,
++because of the nothrow-guarantee given in 20.9.12.2.1 [func.wrap.func.con] p. 10. The problem
++is located in the usage of the swap which could potentially throw given the general latitude.
++<p/>
++So, either the Madrid meeting decision need to be revised (and both member and free swap of
++<tt>std::function</tt> should be noexcept), or this function needs to be adapted as well,
++e.g. by taking the exception-specification away or by changing the semantics.
++<p/>
++One argument for "swap-may-throw" would be to allow for small-object optimization techniques
++where the copy of the target may throw. But given the fact that the swap function has been guaranteed
++to be "Throws: Nothing" from TR1 on, it seems to me that that there would still be opportunities to
++perform small-object optimizations just restricted to the set of target copies that cannot throw.
++<p/>
++In my opinion member swap of <tt>std::function</tt> has always been intended to be no-throw, because
++otherwise there would be no good technical reason to specify the effects of several member
++functions in terms of the "construct-swap" idiom (There are three functions that are defined
++this way), which provides the strong exception safety in this case. I suggest to enforce that both
++member swap and non-member swap of <tt>std::function</tt> are nothrow functions as it had been guaranteed
++since TR1 on.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++<p>
++Dietmar: May not be swappable in the first place.
++</p>
++<p>
++Alisdair: This is wide contact. Then we should be taking noexcept off instead of putting it on. This is preferred resolution.
++</p>
++<p>
++Pablo: This is bigger issue. Specification of assignment in terms of swap is suspect to begin with. It is over specification.
++How this was applied to string is a better example to work from.
++</p>
++<p>
++Pablo: Two problems: inconsistency that should be fixed (neither should have noexcept), the other issues is that assignment
++should not be specified in terms of swap. There are cases where assignment should succeed where swap would fail. This is easier
++with string as it should follow container rules.
++</p>
++<p>
++<b>Action Item</b> (Alisdair): There are a few more issues found to file.
++</p>
++<p>
++Dave: This is because of allocators? The allocator makes this not work.
++</p>
++<p>
++Howard: There is a type erased allocator in shared_ptr. There is a noexcept allocator in shared_ptr.
++</p>
++<p>
++Pablo: shared_ptr is a different case. There are shared semantics and the allocator does move around.
++A function does not have shared semantics.
++</p>
++<p>
++Alisdair: Function objects think they have unique ownership.
++</p>
++<p>
++Howard: In function we specify semantics with copy construction and swap.
++</p>
++<p>
++<b>Action Item</b> (Pablo): Write this up better (why assignment should not be defined in terms of swap)
++</p>
++<p>
++Howard: Not having trouble making function constructor no throw.
++</p>
++<p>
++Dietmar: Function must allocate memory.
++</p>
++<p>
++Howard: Does not put stuff that will throw on copy or swap in small object optimization. Put those on heap.
++Storing allocator, but has to be no throw copy constructable.
++</p>
++<p>
++Pablo: Are you allowed to or required to swap or move allocators in case or swap or move.
++</p>
++<p>
++Dave: An allocator that is type erased should be different...
++</p>
++<p>
++Pablo: it is
++</p>
++<p>
++Dave: Do you need to know something about allocator types? But only at construction time.
++</p>
++<p>
++Pablo: You could have allocators that are different types.
++</p>
++<p>
++Dave: Swap is two ended operation.
++</p>
++<p>
++Pablo: Opinion is that both have to say propagate on swap for them to swap.
++</p>
++<p>
++John: It is not arbitrary. If one person says no. No is no.
++</p>
++<p>
++Howard: Find noexcept swap to be very useful. Would like to move in that direction and bring container design along.
++</p>
++<p>
++Dave: If you have something were allocator must not propagate you can detect that at construction time.
++</p>
++<p>
++...
++</p>
++<p>
++Pablo: Need to leave this open and discuss in smaller group.
++</p>
++<p>
++Alisdair: Tried to add boost::any as TR2 proposal and ran into this issue. Only the first place where we run into
++issues with type erased allocators. Suggest we move it to open.
++</p>
++<p>
++<b>Action Item</b>: Move to open.
++</p>
++<p>
++<b>Action Item</b> (Pablo works with Howard and Daniel): Address the more fundamental issue
++(which may be multiple issues) and write up findings.
++</p>
++
++<p><i>[
++<b>Original resolution</b>:
++]</i></p>
++
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the header <tt>&lt;functional&gt;</tt> synopsis in 20.9 [function.objects] as indicated:</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++
++ template&lt;class R, class... ArgTypes&gt;
++ void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;) <ins>noexcept</ins>;
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify the class template <tt>function</tt> synopsis in 20.9.12.2 [func.wrap.func] as indicated:</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++
++ <i>// [func.wrap.func.alg], specialized algorithms:</i>
++ template&lt;class R, class... ArgTypes&gt;
++ void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;) <ins>noexcept</ins>;
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify 20.9.12.2.7 [func.wrap.func.alg] as indicated:</p>
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2) <ins>noexcept</ins>;
++</pre><blockquote><p>
++-1- <i>Effects</i>: <tt>f1.swap(f2);</tt>
++</p></blockquote></blockquote>
++</li>
++
++</ol>
++
++<p><i>[2014-02-28 (Post Issaquah), Pablo provides more information]</i></p>
++
++
++<p>
++For cross-referencing purposes: The resolution of this issue should be
++harmonized with any resolution to LWG <a href="lwg-active.html#2370">2370</a>, which addresses
++inappropriate <tt>noexcept</tt>s in some function constructors.
++</p>
++
++<p>We have the following choices:</p>
++
++<ol>
++<li>
++<p><tt>swap()</tt> does not throw</p>
++
++<blockquote><p>
++<i>Discussion</i>: This definition is desirable, and allows assignment
++ to be implemented with the strong exception guarantee, but it does have
++ consequences: The implementation cannot use the small-object optimization
++ for a function-object <tt>F</tt> unless <tt>F</tt> is <tt>NothrowMovable</tt>
++ (nothrow-swappable is unimportant because <tt>F</tt> is not swapped with another <tt>F</tt>).
++ Note that many functors written before C++11 will not have move constructors decorated
++ with <tt>noexcept</tt>, so this limitation could affect a lot of code.
++</p>
++<p>
++It is not clear what other implementation restrictions might be
++ needed. Allocators are required not to throw on move or copy. Is that
++ sufficient?
++</p>
++</blockquote>
++</li>
++
++<li>
++<p><tt>swap()</tt> can throw</p>
++
++<blockquote>
++<p>
++<i>Discussion</i>: This definition gives maximum latitude to implementation to
++ use small-object optimization. However, the strong guarantee on assignment
++ is difficult to achieve. Should we consider giving up on the strong
++ guarantee? How much are we willing to pessimize code for exceptions?
++</p>
++</blockquote>
++</li>
++<li>
++<p><tt>swap()</tt> will not throw if both functions have <tt>NoThrowMoveable</tt> functors</p>
++
++<blockquote>
++<p>
++<i>Discussion</i>: This definition is similar to option 2, but gives slightly
++ stronger guarantees. Here, <tt>swap()</tt> can throw, but the programmer can
++ theoretically prevent that from happening. This should be straight-forward
++ to implement and gives the implementation a lot of latitude for
++ optimization. However, because this is a dynamic decision, the program is
++ not as easy to reason about. Also, the strong guarantee for assignment is
++ compromized as in option 2.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2070"></a>2070. <tt>allocate_shared</tt> should use <tt>allocator_traits&lt;A&gt;::construct</tt></h3>
++<p><b>Section:</b> 20.8.2.2.6 [util.smartptr.shared.create] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-07-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.8.2.2.6 [util.smartptr.shared.create] says:
++</p>
++<blockquote><p>
++-2- <i>Effects</i>: Allocates memory suitable for an object of type <tt>T</tt> and constructs an object in that memory
++via the placement new expression <tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt>. The template
++<tt>allocate_shared</tt> uses a copy of a to allocate memory. If an exception is thrown, the functions have
++no effect.
++</p></blockquote>
++<p>
++This explicitly requires placement new rather than using
++<tt>allocator_traits&lt;A&gt;::construct(a, (T*)pv, std::forward&lt;Args&gt;(args)...)</tt>
++In most cases that would result in the same placement new expression,
++but would allow more control over how the object is constructed e.g.
++using <tt>scoped_allocator_adaptor</tt> to do uses-allocator construction, or
++using an allocator declared as a friend to construct objects with no
++public constructors.
++</p>
++
++<p><i>[
++2011-08-16 Bloomington:
++]</i></p>
++
++<p>
++Agreed to fix in principle, but believe that <tt>make_shared</tt> and
++<tt>allocate_shared</tt> have now diverged enough that their descriptions
++should be separated. Pablo and Stefanus to provide revised wording.
++</p>
++
++<p><strong>Daniel's (old) proposed resolution:</strong></p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change the following paragraphs of 20.8.2.2.6 [util.smartptr.shared.create] as indicated (The suggested
++removal of the last sentence of p1 is not strictly required to resolve this issue, but is still recommended,
++because it does not say anything new but may give the impression that it says something new):
++</p><blockquote><pre>
++template&lt;class T, class... Args&gt; shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);
++template&lt;class T, class A, class... Args&gt;
++ shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);
++</pre><blockquote>
++<p>
++-1- <i>Requires</i>: <ins>For the template <tt>make_shared</tt>, t</ins><del>T</del>he expression
++<tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt>, where <tt>pv</tt>
++has type <tt>void*</tt> and points to storage suitable to hold an object of type <tt>T</tt>, shall be well
++formed. <ins>For the template <tt>allocate_shared</tt>, the expression
++<tt>allocator_traits&lt;A&gt;::construct(a, pt, std::forward&lt;Args&gt;(args)...)</tt>,
++where <tt>pt</tt> has type <tt>T*</tt> and points to storage suitable to hold an object
++of type <tt>T</tt>, shall be well formed.</ins> <tt>A</tt> shall be an allocator ([allocator.requirements]).
++<del>The copy constructor and destructor of <tt>A</tt> shall not throw exceptions.</del>
++<p/>
++-2- <i>Effects</i>: Allocates memory suitable for an object of type <tt>T</tt> and constructs an object in
++that memory<ins>. The template <tt>make_shared</tt> constructs the object</ins> via the placement new expression
++<tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt>. The template <tt>allocate_shared</tt> uses a copy
++of <tt>a</tt> to allocate memory<ins> and constructs the object by calling <tt>allocator_traits&lt;A&gt;::construct(a, pt,
++std::forward&lt;Args&gt;(args)...)</tt></ins>. If an exception is thrown, the functions have no effect.
++<p/>
++-3- <i>Returns</i>: A <tt>shared_ptr</tt> instance that stores and owns the address of the newly constructed
++object of type <tt>T</tt>.
++<p/>
++-4- <i>Postconditions</i>: <tt>get() != 0 &amp;&amp; use_count() == 1</tt>
++<p/>
++-5- <i>Throws</i>: <tt>bad_alloc</tt>, or<ins>, for the template <tt>make_shared</tt>, an exception thrown from
++the constructor of <tt>T</tt>, or, for the template <tt>allocate_shared</tt>,</ins> an exception thrown from
++<tt>A::allocate</tt> or <ins>from <tt>allocator_traits&lt;A&gt;::construct</tt></ins><del>from the constructor of
++<tt>T</tt></del>.
++<p/>
++-6- <i>Remarks</i>: Implementations are encouraged, but not required, to perform no more than one memory
++allocation. [ <i>Note</i>: This provides efficiency equivalent to an intrusive smart pointer. &mdash; <i>end note</i> ]
++<p/>
++-7- [ <i>Note</i>: These functions will typically allocate more memory than <tt>sizeof(T)</tt> to allow for internal
++bookkeeping structures such as the reference counts. &mdash; <i>end note</i> ]
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2011-12-04: Jonathan and Daniel improve wording]</i></p>
++
++
++<p>See also c++std-lib-31796</p>
++
++
++
++
++<p><i>[2013-10-13, Ville]</i></p>
++
++<p>
++This issue is related to <a href="lwg-active.html#2089">2089</a>.
++</p>
++
++
++<p><i>[2014-02-15 post-Issaquah session : move to Tentatively NAD]</i></p>
++
++<p>
++STL: This takes an allocator, but then ignores its construct. That's squirrely.
++</p>
++<p>
++Alisdair: The convention is when you take an allocator, you use its construct.
++</p>
++<p>
++STL: 23.2.1 [container.requirements.general]/3, argh! This fills me with despair, but I understand it now.
++</p>
++<p>
++STL: Ok, this is some cleanup.
++</p>
++<p>
++STL: You're requiring <tt>b</tt> to be of type <tt>A</tt> and not being rebound, is that an overspecification?
++</p>
++<p>
++Pablo: Good point. Hmm, that's only a requirement on what must be well-formed.
++</p>
++<p>
++STL: If it's just a well-formed requirement, then why not just use a directly?
++</p>
++<p>
++Pablo: Yeah, the well-formed requirement is overly complex. It's not a real call, we could just use a directly. It makes it harder to read.
++</p>
++<p>
++Alisdair: <tt>b</tt> should be an allocator in the same family as <tt>a</tt>.
++</p>
++<p>
++Pablo: This is a well-formed requirement, I wonder if it's the capital A that's the problem here. It doesn't matter here, this is way too much wording.
++</p>
++<p>
++Alisdair: It's trying to tie the constructor arguments into the allocator requirements.
++</p>
++<p>
++Pablo: <tt>b</tt> could be struck, that's a runtime quality. The construct will work with anything that's in the family of <tt>A</tt>.
++</p>
++<p>
++Alisdair: The important part is the <tt>forward</tt> of <tt>Args</tt>.
++</p>
++<p>
++Pablo: <tt>A</tt> must be an allocator, and <tt>forward</tt> <tt>Args</tt> must work with that.
++</p>
++<p>
++Alisdair: First let's nail down <tt>A</tt>.
++</p>
++<p>
++Pablo: Then replace <tt>b</tt> with <tt>a</tt>, and strike the rest.
++</p>
++<p>
++STL: You need <tt>pt</tt>'s type, at least.
++</p>
++<p>
++Pablo: There's nothing to be said about runtime constraints here, this function doesn't even take a <tt>pt</tt>.
++</p>
++<p>
++STL: Looking at the Effects, I believe <tt>b</tt> is similarly messed up, we can use <tt>a2</tt> to construct an object.
++</p>
++<p>
++Alisdair: Or any allocator in the family of <tt>a</tt>.
++</p>
++<p>
++STL: We say this stuff for the deallocate too, it should be lifted up.
++</p>
++<p>
++STL: "owns the address" is weird.
++</p>
++<p>
++Alisdair: shared_ptr owns pointers, although it does sound funky.
++</p>
++<p>
++Walter: "to destruct" is ungrammatical.
++</p>
++<p>
++STL: "When ownership is given up" is not what we usually say.
++</p>
++<p>
++Alisdair: I think the Returns clause is the right place to say this.
++</p>
++<p>
++STL: The right place to say this is <tt>shared_ptr</tt>'s dtor, we don't want to use Core's "come from" convention.
++</p>
++<p>
++Alisdair: I'm on the hook to draft cleaner wording.
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change the following paragraphs of 20.8.2.2.6 [util.smartptr.shared.create] as indicated:
++</p>
++<blockquote><pre>
++template&lt;class T, class... Args&gt; shared_ptr&lt;T&gt; make_shared(Args&amp;&amp;... args);
++<del>template&lt;class T, class A, class... Args&gt;
++ shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);</del>
++</pre></blockquote>
++<p>
++<del>-1- <i>Requires</i>: The expression <tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt>, where <tt>pv</tt>
++has type <tt>void*</tt> and points to storage suitable to hold an object of type <tt>T</tt>, shall be well
++formed. <tt>A</tt> shall be an allocator (17.6.3.5 [allocator.requirements]). The copy constructor
++and destructor of <tt>A</tt> shall not throw exceptions.</del>
++<p/>
++-2- <i>Effects</i>: <ins>Equivalent to</ins>
++</p>
++<blockquote><pre>
++<ins>return allocate_shared&lt;T&gt;(allocator&lt;T&gt;(), std::forward&lt;Args&gt;(args)...);</ins>
++</pre></blockquote>
++<p>
++<del>Allocates memory suitable for an object of type <tt>T</tt>
++and constructs an object in that memory via the placement new expression
++<tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt>. The template <tt>allocate_shared</tt> uses a copy
++of <tt>a</tt> to allocate memory. If an exception is thrown, the functions have no effect.</del>
++<p/>
++<ins>-?- <i>Remarks</i>: An implementation may meet the effects (and the implied guarantees) without
++creating the allocator object [<i>Note</i>: That is, user-provided specializations of <tt>std::allocator</tt>
++may not be instantiated, the expressions <tt>::new (pv) T(std::forward&lt;Args&gt;(args)...)</tt> and
++<tt>pv-&gt;~T()</tt> may be evaluated directly &mdash; <i>end note</i>].</ins>
++<p/>
++<del>-3- <i>Returns</i>: A <tt>shared_ptr</tt> instance that stores and owns the address of the newly constructed
++object of type <tt>T</tt>.</del>
++<p/>
++<del>-4- <i>Postconditions</i>: <tt>get() != 0 &amp;&amp; use_count() == 1</tt></del>
++<p/>
++<del>-5- <i>Throws</i>: <tt>bad_alloc</tt>, or an exception thrown from <tt>A::allocate</tt> or from the
++constructor of <tt>T</tt>.</del>
++<p/>
++<del>-6- <i>Remarks</i>: Implementations are encouraged, but not required, to perform no more than one memory
++allocation. [<i>Note</i>: This provides efficiency equivalent to an intrusive smart pointer. &mdash; <i>end note</i>]</del>
++<p/>
++<del>-7- [<i>Note</i>: These functions will typically allocate more memory than <tt>sizeof(T)</tt> to allow
++for internal bookkeeping structures such as the reference counts. &mdash; <i>end note</i>]</del>
++</p>
++</li>
++<li><p>
++Add the following set of <ins>new paragraphs</ins> immediately following the previous paragraph 7 of
++20.8.2.2.6 [util.smartptr.shared.create]:
++</p>
++<blockquote><pre>
++template&lt;class T, class A, class... Args&gt;
++ shared_ptr&lt;T&gt; allocate_shared(const A&amp; a, Args&amp;&amp;... args);
++</pre></blockquote>
++<p>
++-?- <i>Requires</i>: The expressions
++<tt>allocator_traits&lt;A&gt;::construct(b, pt, std::forward&lt;Args&gt;(args)...)</tt> and
++<tt>allocator_traits&lt;A&gt;::destroy(b, pt)</tt> shall be well-formed and well-defined,
++where <tt>b</tt> has type <tt>A</tt> and is a copy of <tt>a</tt> and where <tt>pt</tt>
++has type <tt>T*</tt> and points to storage suitable to hold an object of type <tt>T</tt>.
++<tt>A</tt> shall meet the allocator requirements (17.6.3.5 [allocator.requirements]).
++<p/>
++-?- <i>Effects</i>: Uses an object <tt>a2</tt>
++of type <tt>allocator_traits&lt;A&gt;::rebind_alloc&lt;<i>unspecified</i>&gt;</tt> that compares equal to
++<tt>a</tt> to allocate memory suitable for an object of type <tt>T</tt>.
++Uses a copy <tt>b</tt> of type <tt>A</tt> from <tt>a</tt> to construct an object of type <tt>T</tt> in
++that memory by calling <tt>allocator_traits&lt;A&gt;::construct(b, pt, std::forward&lt;Args&gt;(args)...)</tt>.
++If an exception is thrown, the function has no effect.
++<p/>
++-?- <i>Returns</i>: A <tt>shared_ptr</tt> instance that stores and owns the address of the newly constructed
++object of type <tt>T</tt>. When ownership is given up, the effects are as follows: Uses a copy <tt>b2</tt>
++of type <tt>A</tt> from <tt>a</tt> to destruct an object of type <tt>T</tt> by calling
++<tt>allocator_traits&lt;A&gt;::destroy(b2, pt2)</tt> where <tt>pt2</tt> has type <tt>T*</tt>
++and refers to the newly constructed object. Then uses an object of type
++<tt>allocator_traits&lt;A&gt;::rebind_alloc&lt;<i>unspecified</i>&gt;</tt> that compares equal to
++<tt>a</tt> to deallocate the allocated memory.
++<p/>
++-?- <i>Postconditions</i>: <tt>get() != 0 &amp;&amp; use_count() == 1</tt>
++<p/>
++-?- <i>Throws</i>: Nothing unless memory allocation or <tt>allocator_traits&lt;A&gt;::construct</tt>
++throws an exception.
++<p/>
++-?- <i>Remarks</i>: Implementations are encouraged, but not required, to perform no more than one memory
++allocation. [<i>Note</i>: Such an implementation provides efficiency equivalent to an intrusive smart
++pointer. &mdash; <i>end note</i>]
++<p/>
++-?- [<i>Note</i>: This function will typically allocate more memory than <tt>sizeof(T)</tt> to allow for internal
++bookkeeping structures such as the reference counts. &mdash; <i>end note</i>]
++</p>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2072"></a>2072. Unclear wording about capacity of temporary buffers</h3>
++<p><b>Section:</b> 20.7.11 [temporary.buffer] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Kazutoshi Satoda <b>Opened:</b> 2011-08-10 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#temporary.buffer">issues</a> in [temporary.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 20.7.11 [temporary.buffer] p1+2:
++
++</p><blockquote><pre>
++template &lt;class T&gt;
++pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n) noexcept;
++</pre><blockquote><p>
++-1- <i>Effects</i>: Obtains a pointer to storage sufficient to store up to <tt>n</tt> adjacent <tt>T</tt>
++objects. It is implementation-defined whether over-aligned types are supported (3.11).
++<p/>
++-2- <i>Returns</i>: A pair containing the buffer's address and capacity (in the units of <tt>sizeof(T)</tt>),
++or a pair of 0 values if no storage can be obtained or if <tt>n &lt;= 0</tt>.
++</p></blockquote></blockquote>
++<p>
++I read this as prohibiting to return a buffer of which capacity is less than <tt>n</tt>, because
++such a buffer is not sufficient to store <tt>n</tt> objects.
++<p/>
++The corresponding description in <a href="http://www.sgi.com/tech/stl/get_temporary_buffer.html">SGI STL</a>
++is clear on this point, but I think it is a bit too verbose:
++</p>
++
++<blockquote class="note"><p>
++(for the return value, a pair <tt>P</tt>) [...] the buffer pointed to by <tt>P.first</tt> is large enough
++to hold <tt>P.second</tt> objects of type <tt>T</tt>. <tt>P.second</tt> is greater than or equal to 0,
++and less than or equal to <tt>len</tt>.
++</p></blockquote>
++
++<p>
++There seems to be two different targets of the "up to n" modification:
++The capacity of obtained buffer, and the actual number that the caller
++will store into the buffer.
++<p/>
++First I read as the latter, and got surprised seeing that libstdc++
++implementation can return a smaller buffer. I started searching about
++<tt>get_temporary_buffer()</tt>. After reading a quote from TC++PL at
++<a href="http://stackoverflow.com/questions/3264299/why-do-i-need-stdget-temporary-buffer">stackoverflow</a>,
++I realized that the former is intended.
++<p/>
++Such misinterpretation seems common:
++</p>
++<ul>
++<li>The above question is likely started from same misinterpretation.</li>
++<li><p>JIS standard (Japanese translation of ISO&#47;IEC standard) says nothing
++ like "up to". I think the editor misinterpreted the original wording,
++ and omitted words for "up to" as it is redundant. (If a buffer is
++ sufficient to store <tt>n</tt> objects, it is also sufficient to store
++ up to <tt>n</tt> objects.)</p></li>
++<li><p>Rogue Wave implementation doesn't return smaller buffer, instead, it
++ can return larger buffer on some circumstances. Apache
++ <a href="http://stdcxx.apache.org/">STDCXX</a> is a derived version of that
++ implementation, and <a href="https://stdcxx.apache.org/doc/stdlibref/get-temporary-buffer.html">publicly accessible</a>:
++</p>
++<blockquote class="note"><p>
++Specializations of the <tt>get_temporary_buffer()</tt> function template
++attempt to allocate a region of storage sufficiently large to store at
++least <tt>n</tt> adjacent objects of type <tt>T</tt>.
++</p></blockquote>
++<p>
++I know one commercial compiler package based on Rogue Wave implementation,
++and its implementation is essentially same as the above.
++</p>
++</li>
++</ul>
++
++<p><i>[2014-05-18, Daniel comments and suggests concrete wording]</i></p>
++
++
++<p>
++The provided wording attempts to clarify the discussed capacity freedom, but it also makes it clearer that the returned
++memory is just "raw memory", which is currently not really clear. In addition the wording clarifies that the deallocating
++<tt>return_temporary_buffer</tt> function does not throw exceptions, which I believe is the intention when the preconditions
++of the functions are satisfied. Then, my understanding is that we can provide to <tt>return_temporary_buffer</tt> a
++null pointer value if that was the value, <tt>get_temporary_buffer()</tt> had returned. Furthermore, as STL noticed, the current
++wording seemingly allows multiple invocations of <tt>return_temporary_buffer</tt> with the same value returned by
++<tt>get_temporary_buffer</tt>; this should be constrained similar to the wording we have for <tt>operator delete</tt> (unfortunately
++we miss such wording for allocators).
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: move to ready? in favor: 14, opposed: 0, abstain: 0
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol><li><p>Change 20.7.11 [temporary.buffer] as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class T&gt;
++ pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n) noexcept;
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects</i>: <ins>Obtains a pointer to uninitialized, contiguous storage for <tt><i>N</i></tt> adjacent objects of type
++<tt>T</tt>, for some non-negative number <tt><i>N</i></tt>.</ins><del>Obtains a pointer to storage sufficient
++to store up to <tt>n</tt> adjacent <tt>T</tt> objects.</del> It is implementation-defined whether over-aligned types are supported (3.11).
++<p/>
++<ins>-?- <i>Remarks</i>: Calling <tt>get_temporary_buffer</tt> with a positive number <tt>n</tt> is a non-binding request to return
++storage for <tt>n</tt> objects of type <tt>T</tt>. In this case, an implementation is permitted to return instead storage for a
++non-negative number <tt><i>N</i></tt> of such objects, where <tt><i>N</i> != n</tt> (including <tt><i>N</i> == 0</tt>). [<i>Note</i>: The
++request is non-binding to allow latitude for implementation-specific optimizations of its memory management. &mdash; <i>end note</i>].</ins>
++<p/>
++-2- <i>Returns</i>: <ins>If <tt>n &lt;= 0</tt> or if no storage could be obtained, returns a pair <tt>P</tt> such that <tt>P.first</tt>
++is a null pointer value and <tt>P.second == 0</tt>; otherwise returns a pair <tt>P</tt> such that <tt>P.first</tt> refers to the
++address of the uninitialized storage and <tt>P.second</tt> refers to its capacity <tt><i>N</i></tt> (in the units of
++<tt>sizeof(T)</tt>).</ins><del>A <tt>pair</tt> containing the buffer's address and capacity (in the units of <tt>sizeof(T)</tt>), or a
++pair of 0 values if no storage can be obtained or if <tt>n &lt;= 0</tt>.</del>
++</p>
++</blockquote>
++
++<pre>
++template &lt;class T&gt; void return_temporary_buffer(T* p);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: Deallocates the <del>buffer to which <tt>p</tt> points</del><ins>storage referenced by <tt>p</tt></ins>.
++<p/>
++-4- <i>Requires</i>: <del>The buffer shall have been previously allocated by</del><ins><tt>p</tt> shall be a pointer value
++returned by an earlier call to</ins> <tt>get_temporary_buffer</tt> <ins>which has not been invalidated by an intervening call to
++<tt>return_temporary_buffer(T*)</tt></ins>.
++<p/>
++<ins>-?- <i>Throws</i>: Nothing.</ins>
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2077"></a>2077. Further incomplete constraints for type traits</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-08-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The currently agreed on proposed wording for <a href="lwg-defects.html#2015">2015</a> using
++<tt>remove_all_extents&lt;T&gt;::type</tt> instead of the "an array of
++unknown bound" terminology in the precondition should be extended to
++some further entries especially in Table 49, notably the
++<tt>is_*constructible</tt>, <tt>is_*assignable</tt>, and
++<tt>is_*destructible</tt> entries. To prevent ODR violations, incomplete
++element types of arrays must be excluded for value-initialization and
++destruction for example. Construction and assignment has to be honored,
++when we have array-to-pointer conversions or pointer conversions of
++incomplete pointees in effect.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++The issue is that in three type traits, we are accidentally saying that in certain
++circumstances the type must give a specified answer when given an incomplete type.
++(Specifically: an array of unknown bound of incomplete type.) The issue asserts
++that there's an ODR violation, since the trait returns false in that case but might
++return a different version when the trait is completed.
++</p>
++<p>
++Howard argues: no, there is no risk of an ODR violation.
++<tt>is_constructible&lt;A[]></tt> must return <tt>false</tt> regardless of whether
++<tt>A</tt> is complete, so there's no reason to forbid an array of unknown bound of
++incomplete types. Same argument applies to <tt>is_assignable</tt>. General agreement
++with Howard's reasoning.
++</p>
++<p>
++There may be a real issue for <tt>is_destructible</tt>. None of us are sure what
++<tt>is_destructible</tt> is supposed to mean for an array of unknown bound
++(regardless of whether its type is complete), and the standard doesn't make it clear.
++The middle column doesn't say what it's supposed to do for incomplete types.
++</p>
++<p>
++In at least one implementation, <tt>is_destructible&lt;A[]></tt> does return <tt>true</tt>
++if <tt>A</tt> is complete, which would result in ODR violation unless we forbid it for
++incomplete types.
++</p>
++<p>
++Move to open. We believe there is no issue for <tt>is_constructible</tt> or
++<tt>is_assignable</tt>, but that there is a real issue for <tt>is_destructible</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2088"></a>2088. <tt>std::terminate</tt> problem</h3>
++<p><b>Section:</b> 18.8.3 [exception.terminate] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Andrzej Krzemienski reported the following on comp.std.c++:
++</p>
++<blockquote>
++<p>
++In N3290, which is to become the official standard, in 18.8.3.4 [terminate],
++paragraph 1 reads
++</p>
++<blockquote><p>
++<i>Remarks</i>: Called by the implementation when exception handling must
++be abandoned for any of several reasons (15.5.1), in effect immediately after
++evaluating the <em>throw-expression</em> (18.8.3.1). May also be called directly by the
++program.
++</p></blockquote>
++<p>It is not clear what is "in effect". It was clear in previous drafts where paragraphs
++1 and 2 read:
++</p>
++<blockquote><p>
++Called by the implementation when exception handling must be
++abandoned for any of several reasons (15.5.1). May also be called directly
++by the program.
++<p/>
++<i>Effects</i>: Calls the <tt>terminate_handler</tt> function in effect
++immediately after evaluating the <em>throw-expression</em> (18.8.3.1), if called by the
++implementation, or calls the current <tt>terminate_handler</tt> function,
++if called by the program.
++</p>
++</blockquote>
++<p>
++It was changed by N3189. The same applies to function unexpected (D. 11.4, paragraph 1).
++<p/>
++Assuming the previous wording is still intended, the wording can be read
++"unless <tt>std::terminate</tt> is called by the program, we will use the handler
++that was in effect immediately after evaluating the throw-expression".
++<p/>
++ This assumes that there is some throw-expression connected to every
++ situation that triggers the call to <tt>std::terminate</tt>. But this is not
++ the case:
++</p>
++<ul>
++<li>
++ In case <tt>std::thread</tt> is assigned to or destroyed while being joinable
++ there is no throw-expression involved.
++</li>
++<li>
++ In case <tt>std::unexpected</tt> is called by the program, <tt>std::terminate</tt> is
++ triggered by the implementation - no throw-expression involved.
++</li>
++<li>
++ In case a destructor throws during stack unwinding we have two throw-expressions
++ involved.
++ </li>
++ </ul>
++<p>
++Which one is referred to?
++<p/>
++In case <tt>std::nested_exception::rethrow_nested</tt> is called for an object that has
++captured no exception, there is no throw-expression involved directly (and may no throw
++be involved even indirectly).
++<p/>
++Next, 18.8.3.1 [terminate.handler], paragraph 2 says
++</p>
++<blockquote><p>
++<i>Required behavior</i>: A <tt>terminate_handler</tt> shall terminate execution
++of the program without returning to the caller.
++</p></blockquote>
++<p>
++This seems to allow that the function may exit by throwing an
++exception (because word "return" implies a normal return).
++<p/>
++One could argue that words "terminate execution of the program" are sufficient,
++but then why "without returning to the caller" would be mentioned. In
++case such handler throws, noexcept specification in function <tt>std::terminate</tt>
++is violated, and <tt>std::terminate</tt> would be called recursively - should
++<tt>std::abort</tt> not be called in case of recursive <tt>std::terminate</tt>
++call? On the other hand some controlled recursion could be useful, like in the
++<a href="http://cplusplus.co.il/2010/03/21/catching-uncaught-exceptions-within-terminate/">following technique</a>.
++</p>
++</blockquote>
++
++<p>
++The here mentioned wording changes by N3189 in regard to 18.8.3.4 [terminate] p1
++were done for a better separation of effects (Effects element) and additional normative
++wording explanations (Remarks element), there was no meaning change intended. Further,
++there was already a defect existing in the previous wording, which was not updated when
++further situations where defined, when <tt>std::terminate</tt> where supposed to be
++called by the implementation.
++<p/>
++The part
++<p/>
++"in effect immediately after evaluating the throw-expression"
++<p/>
++should be removed and the quoted reference to 18.8.3.1 [terminate.handler]
++need to be part of the effects element where it refers to the current <tt>terminate_handler</tt>
++function, so should be moved just after
++<p/>
++"Effects: Calls the current <tt>terminate_handler</tt> function."
++<p/>
++It seems ok to allow a termination handler to exit via an exception, but the
++suggested idiom should better be replaced by a more simpler one based on
++evaluating the current exception pointer in the terminate handler, e.g.
++</p>
++<blockquote><pre>
++void our_terminate (void) {
++ std::exception_ptr p = std::current_exception();
++ if (p) {
++ ... // OK to rethrow and to determine it's nature
++ } else {
++ ... // Do something else
++ }
++}
++</pre></blockquote>
++
++<p><i>[2011-12-09: Daniel comments]</i></p>
++
++
++<p>
++A related issue is <a href="lwg-active.html#2111">2111</a>.
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++There is an interaction with Core issues in this area that Jens is already supplying wording
++for. Review this issue again once Jens wording is available.
++</p>
++<p>
++Alisdair to review clause 15.5 (per Jens suggestion) and recommend any changes, then integrate
++Jens wording into this issue.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2089"></a>2089. <tt>std::allocator::construct</tt> should use uniform initialization</h3>
++<p><b>Section:</b> 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#EWG">EWG</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2011-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#EWG">EWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++When the <tt>EmplaceConstructible</tt> (23.2.1 [container.requirements.general]&#47;13) requirement is used
++to initialize an object, direct-initialization occurs. Initializing an aggregate or using a <tt>std::initializer_list</tt>
++constructor with emplace requires naming the initialized type and moving a temporary. This is a result of
++<tt>std::allocator::construct</tt> using direct-initialization, not list-initialization (sometimes called "uniform
++initialization") syntax.
++<p/>
++Altering <tt>std::allocator&lt;T&gt;::construct</tt> to use list-initialization would, among other things, give
++preference to <tt>std::initializer_list</tt> constructor overloads, breaking valid code in an unintuitive and
++unfixable way &mdash; there would be no way for <tt>emplace_back</tt> to access a constructor preempted by
++<tt>std::initializer_list</tt> without essentially reimplementing <tt>push_back</tt>.
++</p>
++<blockquote><pre>
++std::vector&lt;std::vector&lt;int&gt;&gt; v;
++v.emplace_back(3, 4); // v[0] == {4, 4, 4}, not {3, 4} as in list-initialization
++</pre></blockquote>
++<p>
++The proposed compromise is to use SFINAE with <tt>std::is_constructible</tt>, which tests whether direct-initialization
++is well formed. If <tt>is_constructible</tt> is false, then an alternative <tt>std::allocator::construct</tt> overload
++is chosen which uses list-initialization. Since list-initialization always falls back on direct-initialization, the
++user will see diagnostic messages as if list-initialization (uniform-initialization) were always being used, because
++the direct-initialization overload cannot fail.
++<p/>
++I can see two corner cases that expose gaps in this scheme. One occurs when arguments intended for
++<tt>std::initializer_list</tt> satisfy a constructor, such as trying to emplace-insert a value of <tt>{3, 4}</tt> in
++the above example. The workaround is to explicitly specify the <tt>std::initializer_list</tt> type, as in
++<tt>v.emplace_back(std::initializer_list&lt;int&gt;(3, 4))</tt>. Since this matches the semantics as if
++<tt>std::initializer_list</tt> were deduced, there seems to be no real problem here.
++<p/>
++The other case is when arguments intended for aggregate initialization satisfy a constructor. Since aggregates cannot
++have user-defined constructors, this requires that the first nonstatic data member of the aggregate be implicitly
++convertible from the aggregate type, and that the initializer list have one element. The workaround is to supply an
++initializer for the second member. It remains impossible to in-place construct an aggregate with only one nonstatic
++data member by conversion from a type convertible to the aggregate's own type. This seems like an acceptably small
++hole.
++<p/>
++The change is quite small because <tt>EmplaceConstructible</tt> is defined in terms of whatever allocator is specified,
++and there is no need to explicitly mention SFINAE in the normative text.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++There appears to be a real concern with initializing aggregates, that can be performed only
++using brace-initialization. There is little interest in the rest of the issue, given the existence
++of 'emplace' methods in C++11.
++</p>
++<p>
++Move to Open, to find an acceptable solution for intializing aggregates. There is the potential
++that EWG may have an interest in this area of language consistency as well.
++</p>
++
++<p><i>[2013-10-13, Ville]</i></p>
++
++<p>
++This issue is related to <a href="lwg-active.html#2070">2070</a>.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Move to EWG, Ville to write a paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 20.7.9.1 [allocator.members] p12 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class U, class... Args&gt;
++ void construct(U* p, Args&amp;&amp;... args);
++</pre><blockquote>
++<p>
++12 <i>Effects</i>: <tt>::new((void *)p) U(std::forward&lt;Args&gt;(args)...)</tt> <ins>if <tt>is_constructible&lt;U, Args...&gt;::value</tt>
++is <tt>true</tt>, else <tt>::new((void *)p) U{std::forward&lt;Args&gt;(args)...}</tt></ins>
++</p>
++</blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2095"></a>2095. <tt>promise</tt> and <tt>packaged_task</tt> missing constructors needed for uses-allocator construction</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise], 30.6.9 [futures.task] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++This example is ill-formed according to C++11 because <tt>uses_allocator&lt;promise&lt;R&gt;, A&gt;::value</tt> is true, but
++<tt>is_constructible&lt;promise&lt;R&gt;, A, promise&lt;R&gt;&amp;&amp;&gt;::value</tt> is false. Similarly for <tt>packaged_task</tt>.
++</p>
++<blockquote><pre>
++#include &lt;future&gt;
++#include &lt;memory&gt;
++#include &lt;tuple&gt;
++
++using namespace std;
++
++typedef packaged_task&lt;void()&gt; task;
++typedef promise&lt;void&gt; prom;
++allocator&lt;task&gt; a;
++
++tuple&lt;task, prom&gt; t1{ allocator_arg, a };
++tuple&lt;task, prom&gt; t2{ allocator_arg, a, task{}, prom{} };
++</pre></blockquote>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++This is an allocator issue, and should be dealt with directly by LWG.
++</p>
++
++<p><i>[2013-03-06]</i></p>
++
++
++<p>
++Jonathan suggests to make the new constructors non-explicit and makes some representational improvements.
++</p>
++
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Move to deferred.
++</p>
++<p>
++This issue has much in common with similar problems with <tt>std::function</tt> that are being addressed
++by the polymorphic allocators proposal currently under evaluation in LEWG. Defer further discussion on
++this topic until the final outcome of that paper and its proposed resolution is known.
++</p>
++
++<p><i>[2014-02-20 Re-open Deferred issues as Priority 4]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to the FDIS.]</i></p>
++
++
++<ol>
++<li><p>Add to 30.6.5 [futures.promise], class template <tt>promise</tt> synopsis,
++as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class R&gt;
++ class promise {
++ public:
++ promise();
++ template &lt;class Allocator&gt;
++ promise(allocator_arg_t, const Allocator&amp; a);
++ <ins>template &lt;class Allocator&gt;
++ promise(allocator_arg_t, const Allocator&amp; a, promise&amp;&amp; rhs) noexcept;</ins>
++ promise(promise&amp;&amp; rhs) noexcept;
++ promise(const promise&amp; rhs) = delete;
++ ~promise();
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 30.6.5 [futures.promise] as indicated:</p>
++
++<blockquote><pre>
++promise(promise&amp;&amp; rhs) noexcept;
++<ins>template &lt;class Allocator&gt;
++promise(allocator_arg_t, const Allocator&amp; a, promise&amp;&amp; rhs) noexcept;</ins>
++</pre><blockquote>
++<p>
++-5- <i>Effects</i>: constructs a new <tt>promise</tt> object and transfers ownership of
++the shared state of <tt>rhs</tt> (if any) to the newly-constructed object.
++<p/>
++-6- <i>Postcondition</i>: <tt>rhs</tt> has no shared state.
++<p/>
++<ins>-?- [<i>Note</i>: <tt>a</tt> is not used &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Add to 30.6.9 [futures.task], class template <tt>packaged_task</tt> synopsis,
++as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class&gt; class packaged_task; // <i>undefined</i>
++
++ template&lt;class R, class... ArgTypes&gt;
++ class packaged_task&lt;R(ArgTypes...)&gt; {
++ public:
++ // construction and destruction
++ packaged_task() noexcept;
++ <ins>template &lt;class Allocator&gt;
++ packaged_task(allocator_arg_t, const Allocator&amp; a) noexcept;</ins>
++ template &lt;class F&gt;
++ explicit packaged_task(F&amp;&amp; f);
++ template &lt;class F, class Allocator&gt;
++ explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++ ~packaged_task();
++
++ // no copy
++ packaged_task(const packaged_task&amp;) = delete;
++ <ins>template&lt;class Allocator&gt;
++ packaged_task(allocator_arg_t, const Allocator&amp; a, const packaged_task&amp;) = delete;</ins>
++ packaged_task&amp; operator=(const packaged_task&amp;) = delete;
++
++ // move support
++ packaged_task(packaged_task&amp;&amp; rhs) noexcept;
++ <ins>template &lt;class Allocator&gt;
++ packaged_task(allocator_arg_t, const Allocator&amp; a, packaged_task&amp;&amp; rhs) noexcept;</ins>
++ packaged_task&amp; operator=(packaged_task&amp;&amp; rhs) noexcept;
++ void swap(packaged_task&amp; other) noexcept;
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 30.6.9.1 [futures.task.members] as indicated:</p>
++
++<blockquote><pre>
++packaged_task() noexcept;
++<ins>template &lt;class Allocator&gt;
++ packaged_task(allocator_arg_t, const Allocator&amp; a) noexcept;</ins>
++</pre><blockquote>
++<p>
++-1- <i>Effects</i>: constructs a <tt>packaged_task</tt> object with no shared state and no stored task.
++<p/>
++<ins>-?- [<i>Note</i>: <tt>a</tt> is not used &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
++<p>[&hellip;]</p>
++<blockquote><pre>
++packaged_task(packaged_task&amp;&amp; rhs) noexcept;
++<ins>template &lt;class Allocator&gt;
++ packaged_task(allocator_arg_t, const Allocator&amp; a, packaged_task&amp;&amp; rhs) noexcept;</ins>
++</pre><blockquote>
++<p>
++-5- <i>Effects</i>: constructs a new <tt>packaged_task</tt> object and transfers ownership of <tt>rhs</tt>'s
++shared state to <tt>*this</tt>, leaving <tt>rhs</tt> with no shared state. Moves the stored task from <tt>rhs</tt>
++to <tt>*this</tt>.
++<p/>
++-6- <i>Postcondition</i>: <tt>rhs</tt> has no shared state.
++<p/>
++<ins>-?- [<i>Note</i>: <tt>a</tt> is not used &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++<blockquote><pre>
++</pre><blockquote>
++<p>
++</p></blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2101"></a>2101. Some transformation types can produce impossible types</h3>
++<p><b>Section:</b> 20.10.7 [meta.trans] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-11-18 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Table 53 &mdash; "Reference modifications" says in regard to the type trait
++<tt>add_lvalue_reference</tt> (emphasize mine)
++</p>
++
++<blockquote>
++<p>
++If <tt>T</tt> names an object or <strong>function</strong> type then the member typedef type
++shall name <tt>T&amp;</tt>;
++</p>
++</blockquote>
++
++<p>
++The problem with this specification is that function types with <i>cv</i>-qualifier or <i>ref</i>-qualifier,
++like
++</p>
++<blockquote><pre>
++void() const
++void() &amp;
++</pre></blockquote>
++<p>
++are also affected by the first part of the rule, but this would essentially mean, that
++instantiating <tt>add_lvalue_reference</tt> with such a type would attempt to form
++a type that is not defined in the C++ type system, namely
++</p>
++<blockquote><pre>
++void(&amp;)() const
++void(&amp;)() &amp;
++</pre></blockquote>
++<p>
++The general policy for <i>TransformationTrait</i>s is to define always some meaningful
++mapping type, but this does not hold for <tt>add_lvalue_reference</tt>, <tt>add_rvalue_reference</tt>,
++and in addition to these two for <tt>add_pointer</tt> as well. The latter one would
++attempt to form the invalid types
++</p>
++<blockquote><pre>
++void(*)() const
++void(*)() &amp;
++</pre></blockquote>
++<p>
++A possible reason why those traits were specified in this way is that in C++03 (and that means
++for TR1), <i>cv</i>-qualifier were underspecified in the core language and several compilers
++just ignored them during template instantiations. This situation became fixed by adopting
++CWG issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#295">295</a> and
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#547">547</a>.
++<p/>
++While there is possibly some core language clarification needed (see reflector messages
++starting from c++std-core-20740), it seems also clear that the library should fix the
++specification. The suggested resolution follows the style of the specification of the
++support concepts <tt>PointeeType</tt> and <tt>ReferentType</tt> defined in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>.
++</p>
++
++
++<p><i>[2012-02-10, Kona]</i></p>
++
++<p>
++Move to NAD.
++</p>
++<p>
++These cv- and ref-qualified function types are aberrations in the type system, and do
++not represent any actual entity defined by the language. The notion of cv- and ref-
++qualification applies only to the implicit <tt>*this</tt> reference in a member function.
++</p>
++<p>
++However, these types can be produced by quirks of template metaprogramming, the question
++remains what the library should do about it. For example, <tt>add_reference</tt> returns
++the original type if passed a reference type, or a <tt>void</tt> type. Conversely,
++<tt>add_pointer</tt> will return a pointer to the referenced type when passed a reference.
++</p>
++<p>
++It is most likely that the 'right' answer in any case will depend on the context that the
++question is being asked, in terms of forming these obscure types. The best the LWG can
++do is allow an error to propagate back to the user, so they can provide their own meaningful
++answer in their context - with additional metaprogramming on their part. The consensus is
++that if anyone is dangerous enough with templates to get themselves into this problem, they
++will also have the skills to resolve the problem themselves. This is not going to trip up
++the non-expert developer.
++</p>
++<p>
++Lastly, it was noted that this problem arises only because the language is inconsistent in
++providing us these nonsense types that do no really represent anything in the language.
++There may be some way Core or Evolution could give us a more consistent type system so that
++the LWG does not need to invent an answer at all, should this question need resolving. This
++is another reason to not specify anything at the LWG trait level at this time, leaving the
++other working groups free to produce the 'right' answer that we can then follow without
++changing the meaning of existing, well-defined programs.
++</p>
++
++<p><i>[2012-02-10, post-Kona]</i></p>
++
++<p>
++Move back to Open. Daniel is concerned that this is not an issue we can simply ignore,
++further details to follow.
++</p>
++
++<p><i>[2012-10-06, Daniel comments]</i></p>
++
++<p>
++This issue really should be resolved as a defect: First, the argument that "forming these obscure types"
++should "allow an error to propagate" is inconsistent with the exact same "obscure type" that would be formed
++when <tt>std::add_lvalue_reference&lt;void&gt;</tt> wouldn't have an extra rules for <tt>void</tt> types, which
++also cannot form references. The originally proposed resolution attempts to apply the same solution for the same
++common property of <tt>void</tt> types and function types with <em>cv</em>-qualifiers or <em>ref</em>-qualifier.
++These functions had the property of <tt>ReferentType</tt> during concept time (see
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#749">CWG 749</a> bullet three for the final
++wording).
++<p/>
++Core issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1417">CWG 1417</a> has clarified
++that any attempt to form a reference of a pointer to a function type with <em>cv</em>-qualifiers or
++<em>ref</em>-qualifier is ill-formed. Unfortunately, many compilers don't implement this yet.
++<p/>
++I also would like to warn about so-called "obscure" types: The problem is that these can occur as the side effect
++of finding a best match overload of function templates, where this type is exactly correct for one of these
++overloads, but causes a deep (not-sfinae-friendly) error for others where one of these traits are part of the
++signature.
++<p/>
++Existing experience with <tt>void</tt> types shows, that this extra rule is not so unexpected. Further, any usage
++of the result types of these traits as argument types or return types of functions would make these ill-formed
++(and in a template context would be sfinaed away), so the expected effects are rarely unnoticed. Checking
++all existing explicit usages of the traits <tt>add_rvalue_reference</tt>, <tt>add_lvalue_reference</tt>, and
++<tt>add_pointer</tt> didn't show any example where the error would be silent: <tt>add_rvalue_reference</tt>
++is used to specify the return value of <tt>declval()</tt> and the instantiation of <tt>declval&lt;void() const&gt;()</tt>
++would be invalid, because of the attempt to return a function type. Similarly, <tt>add_lvalue_reference</tt>
++is used to specify the return type of <tt>unique_ptr&lt;T&gt;::operator*()</tt>. Again, any instantiation with
++<tt>void() const</tt> wouldn't remain unnoticed. The trait <tt>add_pointer</tt> is used to specify the trait
++<tt>std::decay</tt> and this is an interesting example, because it is well-formed when instantiated with <tt>void</tt>
++types, too, and is heavily used throughout the library specification. All use-cases would not be negatively affected
++by the suggested acceptance of function types with <em>cv</em>-qualifiers or <em>ref</em>-qualifier, because they involve
++types that are either function arguments, function parameters or types were references are formed from.
++<p/>
++The alternative would be to add an additional extra rule that doesn't define a type member 'type' when
++we have a function type with <em>cv</em>-qualifiers or <em>ref</em>-qualifier. This is better than the
++current state but it is not superior than the proposal to specify the result as the original type, because
++both variants are sfinae-friendly. A further disadvantage of the "non-type" approach here would be that any
++usage of <tt>std::decay</tt> would require special protection against these function types, because
++instantiating <tt>std::decay&lt;void() const&gt;</tt> again would lead to a deep, sfinae-unfriendly error.
++<p/>
++The following example demonstrates the problem: Even though the second <tt>f</tt> template is the best final
++match here, the first one will be instantiated. During that process <tt>std::decay&lt;T&gt;::type</tt>
++becomes instantiated as well and will raise a deep error, because as part of the implementation the trait
++<tt>std::add_pointer&lt;void() const&gt;</tt> becomes instantiated:
++</p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++
++template&lt;class T&gt;
++typename std::decay&lt;T&gt;::type f(T&amp;&amp; t);
++
++template&lt;class T, class U&gt;
++U f(U u);
++
++int main() {
++ f&lt;void() const&gt;(0);
++}
++</pre></blockquote>
++<p>
++When the here proposed resolution would be applied this program would be well-formed and selects the expected function.
++</p>
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Change Table 53 &mdash; "Reference modifications" in 20.10.7.2 [meta.trans.ref] as indicated:</p>
++
++<table border="1">
++<caption>Table 53 &mdash; Reference modifications</caption>
++<tr>
++<th>Template</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct<br/>
++add_lvalue_reference;</tt>
++</td>
++<td>
++If <tt>T</tt> names an object <tt>type</tt> or <ins>if <tt>T</tt> names a</ins> function type <ins>that does not have<br/>
++<i>cv</i>-qualifiers or a <i>ref</i>-qualifier</ins> then the member typedef <tt>type</tt><br/>
++shall name <tt>T&amp;</tt>; otherwise, if <tt>T</tt> names a type "rvalue reference to <tt>T1</tt>" then<br/>
++the member typedef <tt>type</tt> shall name <tt>T1&amp;</tt>; otherwise, <tt>type</tt> shall name <tt>T</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct<br/>
++add_rvalue_reference;</tt>
++</td>
++<td>
++If <tt>T</tt> names an object <tt>type</tt> or <ins>if <tt>T</tt> names a</ins> function type <ins>that does not have<br/>
++<i>cv</i>-qualifiers or a <i>ref</i>-qualifier</ins> then the member typedef <tt>type</tt><br/>
++shall name <tt>T&amp;&amp;</tt>; otherwise, <tt>type</tt> shall name <tt>T</tt>. [<i>Note</i>: This rule reflects<br/>
++the semantics of reference collapsing (8.3.2 [dcl.ref]). For example, when a type <tt>T</tt><br/>
++names a type <tt>T1&amp;</tt>, the type <tt>add_rvalue_reference&lt;T&gt;::type</tt> is not an<br/>
++rvalue reference. &mdash; <i>end note</i>]
++</td>
++</tr>
++</table>
++
++</li>
++
++<li><p>Change Table 56 &mdash; "Pointer modifications" in 20.10.7.5 [meta.trans.ptr] as indicated:</p>
++
++<table border="1">
++<caption>Table 56 &mdash; Pointer modifications</caption>
++<tr>
++<th>Template</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct add_pointer;</tt>
++</td>
++<td>
++<del>The member typedef <tt>type</tt> shall name the same type as</del><br/>
++<ins>If <tt>T</tt> names a function type that has <i>cv</i>-qualifiers or a <i>ref</i>-qualifier<br/>
++then the member typedef <tt>type</tt> shall name <tt>T</tt>; otherwise, it<br/>
++shall name the same type as</ins> <tt>remove_reference&lt;T&gt;::type*</tt>.
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++</blockquote>
++
++<p>
++The following revised proposed resolution defines - in the absence of a proper core language definition - a new
++term <em>referenceable type</em> as also suggested by the resolution for LWG <a href="lwg-defects.html#2196">2196</a> as an
++umbrella of the negation of <tt>void</tt> types and function types with <em>cv</em>-qualifiers or <em>ref</em>-qualifier.
++This simplifies and minimizes the requires wording changes.
++</p>
++
++<p><i>[
++2013-09-26, Daniel synchronizes wording with recent draft
++]</i></p>
++
++
++<p><i>[
++2014-05-18, Daniel synchronizes wording with recent draft and comments
++]</i></p>
++
++
++<p>
++My impression is that this urgency of action this issue attempts to point out is partly caused by the fact that even for
++the most recent C++14 compilers the implementations have just recently changed to adopt the core wording. Examples for these
++are bug reports to <a href="https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61182">gcc</a> or
++<a href="http://llvm.org/bugs/show_bug.cgi?id=19742">clang</a>.
++<p/>
++Occasionally the argument has been presented to me that the suggested changes to the traits affected by this issue would
++lead to irregularities compared to other traits, especially the lack of guarantee that <tt>add_pointer</tt> might not return
++a pointer or that <tt>add_(l/r)value_reference</tt> might not return a reference type. I would like to point out that this
++kind of divergence is actually already present in most <tt>add/remove</tt> traits: For example, we have no guarantee that
++<tt>add_const</tt> returns a const type (Reference types or function types get special treatments), or that <tt>add_rvalue_reference</tt>
++returns an rvalue-reference (e.g. when applied to an lvalue-reference type).
++<p/>
++Zhihao Yuan brought to my attention, that the originally proposing paper
++<a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2002/n1345.html">N1345</a> carefully discussed these design choices.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: move to Ready: in favor: 16, opposed: 0, abstain: 1<br/>
++STL: have libstdc++, libc++ implemented this? we would need to change your implementation<br/>
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change Table 53 &mdash; "Reference modifications" in 20.10.7.2 [meta.trans.ref] as indicated:</p>
++
++<table border="1">
++<caption>Table 53 &mdash; Reference modifications</caption>
++<tr>
++<th>Template</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct<br/>
++add_lvalue_reference;</tt>
++</td>
++<td>
++If <tt>T</tt> names <del>an object or function type</del><ins>a referenceable type</ins><br/>
++then the member typedef <tt>type</tt><br/>
++shall name <tt>T&amp;</tt>; otherwise, <del>if <tt>T</tt> names a type "rvalue reference to <tt>T1</tt>" then<br/>
++the member typedef <tt>type</tt> shall name <tt>T1&amp;</tt>; otherwise,</del> <tt>type</tt> shall name <tt>T</tt>.<br/>
++<ins>[<i>Note</i>: This rule reflects the semantics of reference collapsing (8.3.2 [dcl.ref]). &mdash; <i>end note</i>]</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct<br/>
++add_rvalue_reference;</tt>
++</td>
++<td>
++If <tt>T</tt> names <del>an object or function type</del><ins>a referenceable type</ins><br/>
++then the member typedef <tt>type</tt><br/>
++shall name <tt>T&amp;&amp;</tt>; otherwise, <tt>type</tt> shall name <tt>T</tt>. [<i>Note</i>: This rule reflects<br/>
++the semantics of reference collapsing (8.3.2 [dcl.ref]). For example, when a type <tt>T</tt><br/>
++names a type <tt>T1&amp;</tt>, the type <tt>add_rvalue_reference_t&lt;T&gt;</tt> is not an<br/>
++rvalue reference. &mdash; <i>end note</i>]
++</td>
++</tr>
++</table>
++
++</li>
++
++<li><p>Change Table 56 &mdash; "Pointer modifications" in 20.10.7.5 [meta.trans.ptr] as indicated:</p>
++
++<table border="1">
++<caption>Table 56 &mdash; Pointer modifications</caption>
++<tr>
++<th>Template</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct add_pointer;</tt>
++</td>
++<td>
++<ins>If <tt>T</tt> names a referenceable type or a (possibly <i>cv</i>-qualified) <tt>void</tt> type then<br/></ins>
++<del>T</del><ins>t</ins>he member typedef <tt>type</tt> shall name the same type as<br/>
++<tt>remove_reference_t&lt;T&gt;*</tt><ins>; otherwise, <tt>type</tt> shall name <tt>T</tt></ins>.
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2111"></a>2111. Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</h3>
++<p><b>Section:</b> 18.8.3.4 [terminate], D.8.4 [unexpected] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-12-06 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#terminate">issues</a> in [terminate].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Prior to N3242, modified by N3189, we said this about <tt>unexpected()</tt>:
++</p>
++
++<blockquote><p>
++<i>Effects</i>: Calls the <tt>unexpected_handler</tt> function in effect immediately after evaluating the throw-expression
++(D.13.1), if called by the implementation, or calls the current <tt>unexpected_handler</tt>, if called by the program.
++</p></blockquote>
++
++<p>
++and this about <tt>terminate()</tt>:
++</p>
++
++<blockquote><p>
++<i>Effects</i>: Calls the <tt>terminate_handler</tt> function in effect immediately after evaluating the throw-expression (18.8.3.1),
++if called by the implementation, or calls the current <tt>terminate_handler</tt> function, if called by the program.
++</p></blockquote>
++
++<p>
++But now in both places we say:
++</p>
++
++<blockquote><p>
++Calls the current <tt>unexpected_handler</tt> function.
++</p></blockquote>
++
++<p>
++and:
++</p>
++
++<blockquote><p>
++Calls the current <tt>terminate</tt> function.
++</p></blockquote>
++
++<p>
++The difference is that in C++98&#47;03 if a destructor reset a handler during stack unwinding, that new handler was
++not called if the unwinding later led to <tt>unexpected()</tt> or <tt>terminate()</tt> being called. But these new
++words say that this new handler <em>is</em> called. This is an ABI-breaking change in the way exceptions are handled.
++Was this change intentional?
++<p/>
++N3189 was mainly about introducing exception safety and getters for the handlers. I don't recall the issue of
++<em>which</em> handler gets called being part of the discussion.
++<p/>
++I propose that we revert to the C++98&#47;03 behavior in this regard, lest ABI's such as the Itanium ABI are invalidated.
++A mechanical way to do this is to revert bullets 9 and 12 of N3189.
++</p>
++
++<p><i>[2011-12-09: Daniel comments]</i></p>
++
++
++<p>
++There was no such semantic change intended. It was an unfortunate side effect when trying to better separate different
++responsibilities in the previous wording.
++<p/>
++A related issue is <a href="lwg-active.html#2088">2088</a>.
++</p>
++
++<p><i>[2012-01-30: Howard comments]</i></p>
++
++
++<p>
++The C++98&#47;03 wording is somewhat ambiguous:
++</p>
++<blockquote><p>
++Calls the terminate_handler function in effect immediately after evaluating the throw-expression...
++</p></blockquote>
++<p>
++There are potentially two throw-expressions being referred to here, and it is not clear if this sentence is referring to just the first or both:
++</p>
++<ol>
++<li><tt>throw <i>assignment-expression</i>;</tt></li>
++<li><tt>throw;</tt></li>
++</ol>
++<p>
++There is ample evidence in current implementations that it is understood that <i>only</i>
++1. was meant. But clearly both 1 and 2 could have been meant. We need a clarification. Does an execution
++of a rethrow (throw;) update which handlers can potentially be called?
++</p>
++<ol>
++<li value="2"><tt>throw;</tt> // update handlers to get_xxx()?</li>
++</ol>
++<p>
++My opinion: Go with existing practice, and clarify what that practice is, if surveys find that everyone
++does the same thing. Gcc 4.2 and Apple do 1. only, and do not reset the handlers to the current handlers
++on throw;.
++<p/>
++If current practice is not unanimously one way or the other, I have no strong opinion. I have not found
++a motivating use case for the use of any particular handler. Most applications set the handlers once at
++the beginning of the program and then do not change them, and so will not be impacted by whatever decision
++is made here.
++</p>
++
++<p><i>[2014-02-15 Issaquah: Move to Review]</i></p>
++
++
++<p>
++STL: Original change in N3242 came from trying to make set/get exception handler thread safe.
++The issue requests we revert to 98/03, which Howard notes was already ambiguous.
++</p>
++
++<p>
++Alisdair: Issue author thinks we made this change in C++11 without taking into account Itanium ABI,
++which cannot implement the new semantic (without breaking compatibility).
++</p>
++
++<p>
++Alisdair: original change in N3242 was trying to solve the problem of which handler is called when
++the handler is changing in another thread, but this turns out to be an issue in even the
++single-threaded case.
++</p>
++
++<p>
++Pablo: despite wanting to make it thread safe, you are still changing a global
++</p>
++
++<p>
++STL and Marshall confirm that there is real implementation divergance on the question, so
++we cannot pick just one behavior if we want to avoid breaking exisitng practice.
++</p>
++
++<p>
++Alisdair: not sure who to talk to across all library vendors to fix, need more information
++for progress (IBM and Sun)
++</p>
++
++<p>
++STL: Howard did identify a problem with the wording as well: <tt>throw;</tt> is a throw expression,
++but we typically want to re-activate the in-flight exception, not throw a new copy.
++</p>
++
++<p>
++Pablo: wondering why all of this wording is here (N3189)? It looks like we were trying to handle another thread
++changing handler between a <tt>throw</tt> and <tt>terminate</tt> in current thread.
++</p>
++
++<p>
++Alisdair: Anything working with exception handling should have used only thread-local resources, but that ship has sailed.
++We must account for the same exception object being re-thrown in multiple threads simultaneously, with no happens-before
++relationships.
++</p>
++
++<p>
++Room: Why on earth would we care about exactly which way the program dies when the terminate calls are racing?!
++</p>
++
++<p>
++Pablo: Reasonable to set the handler once (in <tt>main</tt>) and never change it.
++</p>
++
++<p>
++Pablo: If willing to put lots of work into this, you could say at point of a <tt>throw</tt> these handlers become
++thread local but that is overkill. We want destructors to be able to change these handlers (if only for backwards
++compatibility).
++</p>
++
++<p>
++Alisdair: the <i>&quot;do it right&quot;</i> is to do something per thread, but that is more work than vendors will want to do.
++Want to say setting handler while running multiple threads is unspecified.
++</p>
++
++<p>
++Pablo: possible all we need to do is say it is always the current handler
++</p>
++
++<p>
++STL: That prevents an implementation or single threaded program from calling a new handler after a <tt>throw</tt>,
++probably should say if <tt>terminate</tt> is called <i>by the implementation</i> (during EH), any handler that was
++current can be called. Leaves it up in the air as to when the handler is captured, supporting the diverging
++existing practices.
++</p>
++
++<p>
++Jeffrey: use <i>happens before</i> terminology to avoid introducing races
++</p>
++
++<p>
++STL: Give this to concurrency?
++</p>
++
++<p>
++Jeffrey: It is in clause 18, generally LWG and not SG1 territory.
++</p>
++
++<p>
++Alisdair: Concerned about introducing <i>happens before</i> into fundamental exception handling since it would affect
++single threaded performance as well. Want to give to concurrency or LEWG/EWG, we are into language design here.
++</p>
++
++<p>
++Jeffrey: suspect LEWG won't have a strong opinion. I don't want it to be ours!!!
++</p>
++
++<p>
++Pablo: Might be a case for core>
++</p>
++
++<p>
++Alisdair: Would be happier if at least one core person were in the discussion.
++</p>
++
++<p>
++STL: No sympathy for code that tries to guard the terminate handler.
++</p>
++
++<p>
++Alisdair: We are back to set it once, globally. Want to be clear that if <tt>set_terminate</tt> is called just once,
++when EH is not active, and never changed again, then the user should get the handler from that specific call.
++</p>
++
++<p>
++AlisdairM: "unspecified which handler is called if an exception is active when <tt>set_terminate</tt> is called."
++This supports existing behaviors, and guarantees which handler is called in non-conentious situations. Implicit
++assumption that a funtion becomes a handler only after a successful call to <tt>set_handler</tt>, so we are not
++leaving a door open to the implementation inventing entirely new handlers of its own.
++</p>
++
++<p>
++<i>Consensus.</i>
++</p>
++
++<p>
++Poll to confirm status as P1: new consensus is P3
++</p>
++
++<p>
++<i>Action:</i> Alisdair provides new wording. Drop from P1 to P3, and move to Review.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++HH: we accidentally changed semantics of which handler gets called during exception unwinding. This was attempt to put it back.
++Discovered implementations don't really do anything. [&hellip;] Fine with unspecified behavior to move this week.<br/>
++STL/MC: observed different behavior<br/>
++STL: legitimizes all implementations and tells users to not do this<br/>
++Move to ready? 9/0/1
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Amend 18.8.3.4 [terminate] as indicated:
++</p>
++
++<tt>[[noreturn]] void terminate() noexcept;</tt>
++<blockquote><p>
++<i>Remarks:</i> Called by the implementation when exception handling must be abandoned for any of several reasons (15.5.1)
++<del>, in effect immediately after throwing the exception</del>. May also be called directly by the program.
++</p></blockquote>
++
++<blockquote><p>
++<i>Effects:</i> <ins>Calls a <tt>terminate_handler</tt> function. It is unspecified which <tt>terminate_handler</tt> function will
++be called if an exception is active during a call to <tt>set_terminate</tt>. Otherwise c</ins><del>C</del>alls the current
++<tt>terminate_handler</tt> function. [<i>Note:</i> A default <tt>terminate_handler</tt> is always considered a callable handler in
++this context. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>
++Amend D.8.4 [unexpected] as indicated:
++</p>
++
++<tt>[[noreturn]] void unexpected();</tt>
++<blockquote><p>
++Remarks: Called by the implementation when a function exits via an exception not allowed by its <i>exception-specification</i>
++(15.5.2)<del>, in effect after evaluating the throw-expression (D.11.1)</del>. May also be called directly by the program.
++</p></blockquote>
++
++<blockquote><p>
++<i>Effects:</i> <ins>Calls an <tt>unexpected_handler</tt> function. It is unspecified which <tt>unexpected_handler</tt>
++function will be called if an exception is active during a call to <tt>set_unexpected</tt>. Otherwise c</ins><del>C</del>alls the current
++<tt>unexpected_handler</tt> function. [<i>Note:</i> A default <tt>unexpected_handler</tt> is always considered a callable handler in
++this context. &mdash; <i>end note</i>]
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2114"></a>2114. Incorrect "<em>contextually</em> convertible to <tt>bool</tt>" requirements</h3>
++<p><b>Section:</b> 17.6.3.3 [nullablepointer.requirements], 24.2.3 [input.iterators], 24.2.7 [random.access.iterators], 25.1 [algorithms.general], 25.4 [alg.sorting], 30.2.1 [thread.req.paramname] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-12-09 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++As of 17.6.3.1 [utility.arg.requirements] Table 17&#47;18, the return types of the expressions
++</p>
++<blockquote><pre>
++a == b
++</pre></blockquote>
++<p>
++or
++</p>
++<blockquote><pre>
++a &lt; b
++</pre></blockquote>
++<p>
++for types satisfying the <tt>EqualityComparable</tt> or <tt>LessThanComparable</tt>
++types, respectively, are required to be "convertible to <tt>bool</tt>" which corresponds to
++a copy-initialization context. But several newer parts of the library that refer to
++such contexts have lowered the requirements taking advantage of the new terminology of
++"<em>contextually</em> convertible to <tt>bool</tt>" instead, which corresponds to a
++direct-initialization context (In addition to "normal" direct-initialization constructions,
++operands of logical operations as well as <tt>if</tt> or <tt>switch</tt> conditions also
++belong to this special context).
++<p/>
++One example for these new requirements are input iterators which satisfy <tt>EqualityComparable</tt>
++but also specify that the expression
++</p>
++<blockquote><pre>
++a != b
++</pre></blockquote>
++<p>
++shall be just "<strong>contextually</strong> convertible to <tt>bool</tt>". The same discrepancy
++exists for requirement set <tt>NullablePointer</tt> in regard to several equality-related expressions.
++<p/>
++For random access iterators we have
++</p>
++<blockquote><p>
++<tt>a &lt; b</tt> contextually convertible to <tt>bool</tt>
++</p></blockquote>
++<p>
++as well as for all derived comparison functions, so strictly speaking we could have a random access
++iterator that does not satisfy the <tt>LessThanComparable</tt> requirements, which looks like an
++artifact to me.
++<p/>
++Even if we keep with the existing requirements based on <tt>LessThanComparable</tt> or
++<tt>EqualityComparable</tt> we still would have the problem that some current specifications
++are actually based on the assumption of implicit convertibility instead of "explicit convertibility", e.g.
++20.8.1.5 [unique.ptr.special] p3:
++</p>
++<blockquote><pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++<blockquote>
++<p>
++-3- <i>Returns</i>: <tt>x.get() != y.get()</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++Similar examples exist in 20.8.1.2.2 [unique.ptr.single.dtor] p2, 20.8.1.2.3 [unique.ptr.single.asgn] p9,
++20.8.1.2.4 [unique.ptr.single.observers] p1+3+8, etc.
++<p/>
++In all these places the expressions involving comparison functions (but <em>not</em> those of the conversion
++of a <tt>NullablePointer</tt> to <tt>bool</tt>!) assume to be "convertible to <tt>bool</tt>". I think this
++is a very natural assumption and all delegations of the comparison functions of some type <tt>X</tt> to some
++other API type <tt>Y</tt> in third-party code does so assuming that copy-initialization semantics will
++just work.
++<p/>
++The actual reason for using the newer terminology can be rooted back to LWG <a href="lwg-defects.html#556">556</a>. My hypotheses
++is that the resolution of that issue also needs a slight correction. Why so?
++<p/>
++The reason for opening that issue were worries based on the previous "convertible to <tt>bool</tt>"
++wording. An expressions like "<tt>!pred(a, b)</tt>" might not be well-formed in those situations, because
++<tt>operator!</tt> might not be accessible or might have an unusual semantics (and similarly for other logical
++operations). This can indeed happen with unusual proxy return types, so the idea was that the evaluation of
++<tt>Predicate</tt>, <tt>BinaryPredicate</tt> (25.1 [algorithms.general] p8+9), and <tt>Compare</tt>
++(25.4 [alg.sorting] p2) should be defined based on contextual conversion to <tt>bool</tt>.
++Unfortunately this <em>alone</em> is not sufficient: In addition, I think, we <em>also</em> want the predicates
++to be (implicitly) convertible to <tt>bool</tt>! Without this wording, several conditions are plain wrong,
++e.g. 25.2.5 [alg.find] p2, which talks about "<tt>pred(*i) != false</tt>" (<tt>find_if</tt>) and
++"<tt>pred(*i) == false</tt>" (<tt>find_if_not</tt>). These expressions are not within a boolean context!
++<p/>
++While we could simply fix all these places by proper wording to be considered in a "contextual conversion to
++<tt>bool</tt>", I think that this is not the correct solution: Many third-party libraries already refer to
++the previous C++03 <tt>Predicate</tt> definition &mdash; it actually predates C++98 and is as old as the
++<a href="http://www.sgi.com/tech/stl/Predicate.html">SGI specification</a>. It seems to be a high price to
++pay to switch to direct initialization here instead of fixing a completely different specification problem.
++<p/>
++A final observation is that we have another definition for a <tt>Predicate</tt> in 30.2.1 [thread.req.paramname] p2:
++</p>
++<blockquote><p>
++If a parameter is <tt>Predicate</tt>, <tt>operator()</tt> applied to the actual template argument shall return a value that
++is convertible to <tt>bool</tt>.
++</p></blockquote>
++<p>
++The problem here is not that we have two different definitions of <tt>Predicate</tt> in the standard &mdash; this
++is confusing, but this fact alone is not a defect. The first (minor) problem is that this definition does not properly
++apply to function objects that are function pointers, because <tt>operator()</tt> is not defined in a strict sense.
++But the actually worse second problem is that this wording has the very <tt>same</tt> problem that has originally lead to
++LWG <a href="lwg-defects.html#556">556</a>! We only need to look at 30.5.1 [thread.condition.condvar] p15 to recognice this:
++</p>
++<blockquote><pre>
++while (!pred())
++ wait(lock);
++</pre></blockquote>
++<p>
++The negation expression here looks very familiar to the example provided in LWG <a href="lwg-defects.html#556">556</a> and is sensitive
++to the same "unusual proxy" problem. Changing the 30.2.1 [thread.req.paramname] wording to a corresponding
++"contextual conversion to <tt>bool</tt>" wouldn't work either, because existing specifications rely on "convertible
++to <tt>bool</tt>", e.g. 30.5.1 [thread.condition.condvar] p32+33+42 or 30.5.2 [thread.condition.condvarany]
++p25+26+32+33.
++<p/>
++To summarize: I believe that LWG <a href="lwg-defects.html#556">556</a> was not completely resolved. A pessimistic interpretation is,
++that even with the current wording based on "contextually convertible to <tt>bool</tt>" the actual problem of that
++issue has <em>not</em> been fixed. What actually needs to be required here is some normative wording that basically
++expresses something along the lines of:
++</p>
++<blockquote><p>
++The semantics of <em>any</em> contextual conversion to <tt>bool</tt> shall be equivalent to the semantics of
++any implicit conversion to <tt>bool</tt>.
++</p></blockquote>
++<p>
++This is still not complete without having concepts, but it seems to be a better approximation. Another way of solving
++this issue would be to define a minimum requirements table with equivalent semantics. The proposed wording is a bit
++simpler but attempts to express the same thing.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Agree with Daniel that we potentially broke some C++03 user code, accept the changes striking
++"contextually" from tables. Stefan to provide revised wording for section 25, and figure out
++changes to section 30.
++</p>
++<p>
++Move to open, and then to Review when updated wording from Stefan is available.
++</p>
++
++<p><i>[2012-10-12, STL comments]</i></p>
++
++
++<ol>
++<li>
++<p>
++The current proposed resolution still isn't completely satisfying. It would certainly be possible for the Standard to
++require these various expressions to be implicitly and contextually convertible to <tt>bool</tt>, but that would have
++a subtle consequence (which, I will argue, is undesirable - regardless of the fact that it dates all the way back to
++C++98/03). It would allow users to provide really wacky types to the Standard Library, with one of two effects:
++</p>
++<ol style="list-style-type:upper-alpha">
++<li>
++<p>Standard Library implementations would have to go to great lengths to respect such wacky types, essentially using
++<tt>static_cast&lt;bool&gt;</tt> when invoking any predicates or comparators.
++</p>
++</li>
++
++<li>
++<p>
++Otherwise, such wacky types would be de facto nonportable, because they would make Standard Library implementations
++explode.
++</p>
++</li>
++</ol>
++
++<p>
++Effect B is the status quo we're living with today. What Standard Library implementations want to do with <tt>pred(args)</tt>
++goes beyond "<tt>if (pred(args))</tt>" (C++03), contextually converting <tt>pred(args)</tt> to <tt>bool</tt> (C++11), or
++implicitly and contextually converting <tt>pred(args)</tt> to <tt>bool</tt> (the current proposed resolution).
++Implementations want to say things like:
++</p>
++
++<blockquote><pre>
++if (pred(args))
++if (!pred(args))
++if (cond &amp;&amp; pred(args))
++if (cond &amp;&amp; !pred(args))
++</pre></blockquote>
++
++<p>
++These are real examples taken from Dinkumware's implementation. There are others that would be realistic
++("<tt>pred(args) &amp;&amp; cond</tt>", "<tt>cond || pred(args)</tt>", etc.)
++<p/>
++Although negation was mentioned in this issue's Discussion section, and in LWG <a href="lwg-defects.html#556">556</a>'s, the current proposed
++resolution doesn't fix this problem. Requiring <tt>pred(args)</tt> to be implicitly and contextually convertible to <tt>bool</tt>
++doesn't prevent <tt>operator!()</tt> from being overloaded and returning <tt>std::string</tt> (as a wacky example). More
++ominously, it doesn't prevent <tt>operator&amp;&amp;()</tt> and <tt>operator||()</tt> from being overloaded and destroying
++short-circuiting.
++</p>
++
++</li>
++
++<li>
++<p>
++I would like LWG input before working on Standardese for a new proposed resolution. Here's an outline of what I'd like to
++do:
++</p>
++<ol style="list-style-type:upper-alpha">
++<li>
++<p>
++Introduce a new "concept" in 17.6.3 [utility.requirements], which I would call <tt>BooleanTestable</tt> in the
++absence of better ideas.
++</p>
++</li>
++
++<li>
++<p>
++Centralize things and reduce verbosity by having everything simply refer to <tt>BooleanTestable</tt> when necessary.
++I believe that the tables could say "Return type: <tt>BooleanTestable</tt>", while Predicate/BinaryPredicate/Compare
++would need the incantation "shall satisfy the requirements of BooleanTestable".
++</p>
++</li>
++
++<li>
++<p>
++Resolve the tug-of-war between users (who occasionally want to do weird things) and implementers (who don't want to have
++to contort their code) by requiring that:
++</p>
++<ol style="list-style-type:upper-roman">
++<li>
++<p>
++Given a <tt>BooleanTestable x</tt>, <tt>x</tt> is both implicitly and contextually convertible to <tt>bool</tt>.
++</p>
++</li>
++
++<li>
++<p>
++Given a <tt>BooleanTestable x</tt>, <tt>!x</tt> is <tt>BooleanTestable</tt>. (This is intentionally "recursive".)
++</p>
++</li>
++
++<li>
++<p>
++Given a <tt>BooleanTestable x</tt>, <tt>bool t = x, t2(x), f = !x;</tt> has the postcondition <tt>t == t2 &amp;&amp; t != f</tt>.
++</p>
++</li>
++
++<li>
++<p>
++Given a <tt>BooleanTestable x</tt> and a <tt>BooleanTestable y</tt> of possibly different types, "<tt>x &amp;&amp; y</tt>"
++and "<tt>x || y</tt>" invoke the built-in <tt>operator&amp;&amp;()</tt> and <tt>operator||()</tt>, triggering short-circuiting.
++</p>
++</li>
++
++<li>
++<p>
++<tt>bool</tt> is <tt>BooleanTestable</tt>.
++</p>
++</li>
++</ol>
++
++</li>
++
++</ol>
++
++<p>
++ I believe that this simultaneously gives users great latitude to use types other than <tt>bool</tt>, while allowing
++ implementers to write reasonable code in order to get their jobs done. (If I'm forgetting anything that implementers
++ would want to say, please let me know.)
++</p>
++
++</li>
++
++<li>
++<p>
++About requirement (I): As Daniel patiently explained to me, we need to talk about both implicit conversions and
++contextual conversions, because it's possible for a devious type to have both "<tt>explicit operator bool()</tt>"
++and "<tt>operator int()</tt>", which might behave differently (or be deleted, etc.).
++</p>
++</li>
++
++<li>
++<p>
++About requirement (IV): This is kind of tricky. What we'd like to say is, "<tt>BooleanTestable</tt> can't ever trigger
++an overloaded logical operator". However, given a perfectly reasonable type <tt>Nice</tt> - perhaps even <tt>bool</tt> itself! -
++other code (perhaps a third-party library) could overload <tt>operator&amp;&amp;(Nice, Evil)</tt>. Therefore, I believe
++that the requirement should be "no first use" - the Standard Library will ask for various <tt>BooleanTestable</tt> types
++from users (for example, the result of "<tt>first != last</tt>" and the result of "<tt>pred(args)</tt>"), and as long
++as they don't trigger overloaded logical operators with each other, everything is awesome.
++</p>
++</li>
++
++
++<li>
++<p>
++About requirement (V): This is possibly redundant, but it's trivial to specify, makes it easier for users to understand
++what they need to do ("oh, I can always achieve this with <tt>bool</tt>"), and provides a "base case" for requirement
++(IV) that may or may not be necessary. Since <tt>bool</tt> is <tt>BooleanTestable</tt>, overloading
++<tt>operator&amp;&amp;(bool, Other)</tt> (etc.) clearly makes the <tt>Other</tt> type non-<tt>BooleanTestable</tt>.
++</p>
++</li>
++</ol>
++
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change Table 25 &mdash; "<tt>NullablePointer</tt> requirements" in 17.6.3.3 [nullablepointer.requirements]
++as indicated:</p>
++
++<table border="1">
++<caption>Table 25 &mdash; <tt>NullablePointer</tt> requirements</caption>
++<tr align="center">
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a != b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>!(a == b)</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a == np<br/>
++np == a</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>a == P()</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a != np<br/>
++np != a</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>!(a == np)</tt>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>Change Table 107 &mdash; "Input iterator requirements" in 24.2.3 [input.iterators]
++as indicated:</p>
++
++<table border="1">
++<caption>Table 107 &mdash; Input iterator requirements (in addition to Iterator)</caption>
++<tr align="center">
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td>
++<tt>a != b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>!(a == b)</tt>
++</td>
++<td>
++pre: <tt>(a, b)</tt> is in the domain of <tt>==</tt>.
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>Change Table 111 &mdash; "Random access iterator requirements" in 24.2.7 [random.access.iterators]
++as indicated:</p>
++
++<table border="1">
++<caption>Table 111 &mdash; Random access iterator requirements (in addition to bidirectional iterator)</caption>
++<tr align="center">
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt; b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>b - a &gt; 0</tt>
++</td>
++<td>
++<tt>&lt;</tt> is a total ordering relation
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt; b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>b &lt; a</tt>
++</td>
++<td>
++<tt>&gt;</tt> is a total ordering relation opposite to <tt>&lt;</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt;= b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>!(a &lt; b)</tt>
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt;= b</tt>
++</td>
++<td>
++<del>contextually</del> convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>!(a &gt; b)</tt>
++</td>
++<td>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>Change 25.1 [algorithms.general] p8+9 as indicated:</p>
++
++<blockquote>
++<p>
++-8- The <tt>Predicate</tt> parameter is used whenever an algorithm expects a function object
++(20.9 [function.objects]) that, when applied to the result of dereferencing the corresponding iterator,
++returns a value testable as <tt>true</tt>. In other words, if an algorithm takes <tt>Predicate pred</tt>
++as its argument and first as its iterator argument, it should work correctly in the construct
++<tt>pred(*first)</tt> <ins>implicitly or</ins> contextually converted to <tt>bool</tt> (Clause 4 [conv]).
++The function object <tt>pred</tt> shall not apply any non-constant function through the dereferenced iterator.
++<p/>
++-9- The <tt>BinaryPredicate</tt> parameter is used whenever an algorithm expects a function object that when applied
++to the result of dereferencing two corresponding iterators or to dereferencing an iterator and type
++<tt>T</tt> when <tt>T</tt> is part of the signature returns a value testable as <tt>true</tt>. In other words, if an algorithm takes
++<tt>BinaryPredicate binary_pred</tt> as its argument and <tt>first1</tt> and <tt>first2</tt> as its iterator arguments, it should
++work correctly in the construct <tt>binary_pred(*first1, *first2)</tt> <ins>implicitly or</ins> contextually converted to
++<tt>bool</tt> (Clause 4 [conv]).
++<tt>BinaryPredicate</tt> always takes the first iterator's <tt>value_type</tt> as its first argument, that is, in those cases
++when <tt>T</tt> value is part of the signature, it should work correctly in the construct <tt>binary_pred(*first1, value)</tt>
++<ins>implicitly or</ins> contextually converted to <tt>bool</tt> (Clause 4 [conv]). <tt>binary_pred</tt> shall
++not apply any non-constant function through the dereferenced iterators.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 25.4 [alg.sorting] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <tt>Compare</tt> is a function object type (20.9 [function.objects]). The return value of the function
++call operation applied to an object of type <tt>Compare</tt>, when <ins>implicitly or</ins> contextually converted
++to <tt>bool</tt> (4 [conv]), yields <tt>true</tt> if the first argument of the call is less than the second, and
++<tt>false</tt> otherwise. <tt>Compare comp</tt> is used throughout for algorithms assuming an ordering relation. It is assumed
++that <tt>comp</tt> will not apply any non-constant function through the dereferenced iterator.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 30.2.1 [thread.req.paramname] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <del>If a parameter is <tt>Predicate</tt>, operator() applied to the actual template argument shall return a value that
++is convertible to <tt>bool</tt></del><ins><tt>Predicate</tt> is a function object type (20.9 [function.objects]).
++The return value of the function call operation applied to an object of type <tt>Predicate</tt>, when implicitly or
++contextually converted to <tt>bool</tt> (4 [conv]), yields <tt>true</tt> if the corresponding test condition is
++satisfied, and <tt>false</tt> otherwise</ins>.
++</p>
++</blockquote>
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2014-05-20, Daniel suggests concrete wording based on STL's proposal]</i></p>
++
++<p>
++The presented wording follows relatively closely STL's outline with the following notable exceptions:
++</p>
++<ol style="list-style-type:upper-alpha">
++<li><p>
++A reference to <tt>BooleanTestable</tt> in table "Return Type" specifications seemed very unusual to me and
++I found no "prior art" for this in the Standard. Instead I decided to follow the usual style to add a symbol
++with a specific meaning to a specific paragraph that specifies symbols and their meanings.
++</p></li>
++<li><p>
++STL's requirement IV suggested to directly refer to built-in operators <tt>&amp;&amp;</tt> and <tt>||</tt>. In my
++opinion this concrete requirement isn't needed if we simply require that two <tt>BooleanTestable</tt> operands behave
++equivalently to two those operands after conversion to <tt>bool</tt> (each of them).
++</p></li>
++<li><p>
++I couldn't find a good reason to require normatively that type <tt>bool</tt> meets the requirements of <tt>BooleanTestable</tt>: My
++assertion is that after having defined them, the result simply falls out of this. But to make this a bit clearer, I added
++also a non-normative note to these effects.
++</p></li>
++</ol>
++
++<p><i>[2014-06-10, STL comments]</i></p>
++
++<p>
++In the current wording I would like to see changed the suggested changes described by bullet #6:
++</p>
++<ol style="list-style-type:upper-alpha">
++<li><p>In 23.2.1 [container.requirements.general] p4 undo the suggested change</p></li>
++<li><p>Then change the 7 occurrences of "convertible to <tt>bool</tt>" in the denoted tables to "<tt>bool</tt>".</p></li>
++</ol>
++
++<p><i>[2015-05-05 Lenexa]</i></p>
++
++<p>STL: Alisdair wanted to do something here, but Daniel gave us updated wording.</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 17.6.3.1 [utility.arg.requirements] p1, Table 17 &mdash; "EqualityComparable requirements", and
++Table 18 &mdash; "LessThanComparable requirements" as indicated:</p>
++
++<blockquote>
++<p>
++-1- [&hellip;] In these tables, <tt>T</tt> is an object or reference type to be supplied by a C++ program
++instantiating a template; <tt>a</tt>, <tt>b</tt>, and <tt>c</tt> are values of type (possibly <tt>const</tt>) <tt>T</tt>;
++<tt>s</tt> and <tt>t</tt> are modifiable lvalues of type <tt>T</tt>; <tt>u</tt> denotes an identifier; <tt>rv</tt>
++is an rvalue of type <tt>T</tt>; <del>and</del> <tt>v</tt> is an lvalue of type (possibly <tt>const</tt>) <tt>T</tt> or an
++rvalue of type <tt>const T</tt><ins>; and <tt>BT</tt> denotes a type that meets the <tt>BooleanTestable</tt>
++requirements ([booleantestable.requirements])</ins>.
++<p/>
++[&hellip;]
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 17 &mdash; <tt>EqualityComparable</tt> requirements [equalitycomparable]</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">Requirement</th>
++</tr>
++
++<tr>
++<td>
++<tt>a == b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++<tt>==</tt> is an equivalence relation, that is, it has the
++following properties: [&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 18 &mdash; <tt>LessThanComparable</tt> requirements [lessthancomparable]</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">Requirement</th>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt; b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++<tt>&lt;</tt> is a strict weak ordering relation (25.4 [alg.sorting])
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</blockquote>
++
++</li>
++
++<li><p>Between 17.6.3.2 [swappable.requirements] and 17.6.3.3 [nullablepointer.requirements] insert a new sub-clause
++as indicated:</p>
++
++<blockquote>
++?.?.?.? <b><tt>BooleanTestable</tt> requirements [booleantestable.requirements]</b>
++<blockquote>
++<p>
++-?- A <tt>BooleanTestable</tt> type is a boolean-like type that also supports conversions to <tt>bool</tt>.
++A type <tt>B</tt> meets the <tt>BooleanTestable</tt> requirements if the expressions described in Table ?? are valid
++and have the indicated semantics, and if <tt>B</tt> also satisfies all the other requirements of this sub-clause
++[booleantestable.requirements].
++<p/>
++An object <tt>b</tt> of type <tt>B</tt> can be implicitly converted to <tt>bool</tt> and can be contextually converted
++to <tt>bool</tt> (Clause 4). The result values of both kinds of conversions shall be equivalent.
++<p/>
++[<i>Example</i>: The types <tt>bool</tt>, <tt>std::true_type</tt>, and <tt>std::bitset&lt;&gt;::reference</tt> are
++<tt>BooleanTestable</tt> types. &mdash; <i>end example</i>]
++<p/>
++In Table ??, <tt>B2</tt> and <tt>Bn</tt> denote types (possibly equal to <tt>B</tt> or to each other) that meet the
++<tt>BooleanTestable</tt> requirements, <tt>b1</tt> denotes a (possibly <tt>const</tt>) value of <tt>B</tt>, <tt>b2</tt>
++denotes a (possibly <tt>const</tt>) value of <tt>B2</tt>, and <tt>t1</tt> denotes a value of type <tt>bool</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Somewhere within the new sub-clause [booleantestable.requirements] insert the following new Table (?? denotes
++the assigned table number):</p>
++
++<blockquote>
++<table border="1">
++<caption>Table ?? &mdash; <tt>BooleanTestable</tt> requirements [booleantestable]</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">Operational semantics</th>
++</tr>
++
++<tr>
++<td>
++<tt>bool(b1)</tt>
++</td>
++<td>
++<tt>bool</tt>
++</td>
++<td>
++<i>Remarks</i>: <tt>bool(b1) == t1</tt> for every value<br/>
++<tt>b1</tt> implicitly converted to <tt>t1</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>!b1</tt>
++</td>
++<td>
++<tt>Bn</tt>
++</td>
++<td>
++<i>Remarks</i>: <tt>bool(b1) == !bool(!b1)</tt> for<br/>
++every value <tt>b1</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>b1 &amp;&amp; b2</tt>
++</td>
++<td>
++<tt>bool</tt>
++</td>
++<td>
++<tt>bool(b1) &amp;&amp; bool(b2)</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>b1 || b2</tt>
++</td>
++<td>
++<tt>bool</tt>
++</td>
++<td>
++<tt>bool(b1) || bool(b2)</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Change 17.6.3.3 [nullablepointer.requirements] p5 and Table 25 &mdash; "NullablePointer requirements" as indicated:</p>
++
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-5- In Table 25, <tt>u</tt> denotes an identifier, <tt>t</tt> denotes a non-<tt>const</tt> lvalue of type <tt>P</tt>, <tt>a</tt>
++and <tt>b</tt> denote values of type (possibly <tt>const</tt>) <tt>P</tt>, <del>and</del> <tt>np</tt> denotes a value of type
++(possibly <tt>const</tt>) <tt>std::nullptr_t</tt><ins>, and <tt>BT</tt> denotes a type that meets the <tt>BooleanTestable</tt>
++requirements ([booleantestable.requirements])</ins>.
++<p/>
++[&hellip;]
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 25 &mdash; <tt>NullablePointer</tt> requirements [nullablepointer]</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">Operational semantics</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a != b</tt>
++</td>
++<td>
++<del>contextually convertible to <tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a == np</tt><br/>
++<tt>np == a</tt>
++</td>
++<td>
++<del>contextually convertible to <tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a != np</tt><br/>
++<tt>np != a</tt>
++</td>
++<td>
++<del>contextually convertible to <tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.7 [tuple.rel] as indicated;</p>
++
++<blockquote>
++<pre>
++template&lt;class... TTypes, class... UTypes&gt;
++constexpr bool operator==(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
++</pre>
++<blockquote>
++<p>
++-1- <i>Requires</i>: For all <tt>i</tt>, where <tt>0 &lt;= i</tt> and <tt>i &lt; sizeof...(TTypes)</tt>,
++<tt>get&lt;i&gt;(t) == get&lt;i&gt;(u)</tt> is a valid expression returning a type that <del>is convertible to
++<tt>bool</tt></del><ins>meets the <tt>BooleanTestable</tt> requirements ([booleantestable.requirements])</ins>.
++<tt>sizeof...(TTypes) == sizeof...(UTypes)</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++template&lt;class... TTypes, class... UTypes&gt;
++constexpr bool operator&lt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
++</pre>
++<blockquote>
++<p>
++-4- <i>Requires</i>: For all <tt>i</tt>, where <tt>0 &lt;= i</tt> and <tt>i &lt; sizeof...(TTypes)</tt>,
++<tt>get&lt;i&gt;(t) &lt; get&lt;i&gt;(u)</tt> and <tt>get&lt;i&gt;(u) &lt; get&lt;i&gt;(t)</tt> are valid
++expressions returning types that <del>are convertible to
++<tt>bool</tt></del><ins>meet the <tt>BooleanTestable</tt> requirements ([booleantestable.requirements])</ins>.
++<tt>sizeof...(TTypes) == sizeof...(UTypes)</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.2.1 [container.requirements.general], Table 96 &mdash; "Container requirements", and
++Table 98 &mdash; "Optional container operations" as indicated:</p>
++
++<blockquote>
++<p>
++-4- In Tables 96, 97, and 98 <tt>X</tt> denotes a container class containing objects of type <tt>T</tt>, <tt>a</tt> and
++<tt>b</tt> denote values of type <tt>X</tt>, <tt>u</tt> denotes an identifier, <tt>r</tt> denotes a non-<tt>const</tt> value
++of type <tt>X</tt>, <del>and</del> <tt>rv</tt> denotes a non-<tt>const</tt> rvalue of type <tt>X</tt><ins>, and <tt>BT</tt>
++denotes a type that meets the <tt>BooleanTestable</tt> requirements ([booleantestable.requirements])</ins>.
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 96 &mdash; Container requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">[&hellip;]</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a == b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a != b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.empty()</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 98 &mdash; Optional container requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">[&hellip;]</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt; b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt; b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt;= b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt;= b</tt>
++</td>
++<td>
++<del>convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 24.2.1 [iterator.requirements.general], Table 107 &mdash; "Input iterator requirements", and
++Table 111 &mdash; "Random access iterator requirements" as indicated:</p>
++
++<blockquote>
++<p>
++-11- In the following sections, <tt>a</tt> and <tt>b</tt> denote values of type <tt>X</tt> or <tt>const X</tt>,
++<tt>difference_type</tt> and <tt>reference</tt> refer to the types <tt>iterator_traits&lt;X&gt;::difference_type</tt> and
++<tt>iterator_traits&lt;X&gt;::reference</tt>, respectively, <tt>n</tt> denotes a value of <tt>difference_type</tt>, <tt>u</tt>,
++<tt>tmp</tt>, and <tt>m</tt> denote identifiers, <tt>r</tt> denotes a value of <tt>X&amp;</tt>, <tt>t</tt> denotes
++a value of value type <tt>T</tt>, <tt>o</tt> denotes a value of some type that is writable to the output iterator<ins>, and <tt>BT</tt>
++denotes a type that meets the <tt>BooleanTestable</tt> requirements ([booleantestable.requirements])</ins>.
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 107 &mdash; Input iterator requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">[&hellip;]</th>
++</tr>
++
++<tr>
++<td>
++<tt>a != b</tt>
++</td>
++<td>
++<del>contextually convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++</table>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 111 &mdash; Random access iterator requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">[&hellip;]</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt; b</tt>
++</td>
++<td>
++<del>contextually convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt; b</tt>
++</td>
++<td>
++<del>contextually convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &gt;= b</tt>
++</td>
++<td>
++<del>contextually convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a &lt;= b</tt>
++</td>
++<td>
++<del>contextually convertible to<br/>
++<tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 25.1 [algorithms.general] p8+p9 as indicated: [<i>Drafting note</i>: The wording change also fixes
++(a) unusual wording forms used ("should work") which are unclear in which sense they are imposing normative requirements and
++(b) the problem, that the current wording seems to allow that the predicate may mutate a call argument, if that is not a
++dereferenced iterator.
++Upon applying the new wording it became obvious that the wording has the effect that currently algorithms such as
++<tt>adjacent_find</tt>, <tt>search_n</tt>, <tt>unique</tt>, and <tt>unique_copy</tt> are not correctly described
++(because they have no iterator argument named <tt>first1</tt>), which could give raise to a new library issue.
++&mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<p>
++-8- The <tt>Predicate</tt> parameter is used whenever an algorithm expects a function object (20.9) that, when applied
++to the result of dereferencing the corresponding iterator, returns a value testable as <tt>true</tt>. <del>In other words,
++i</del><ins>I</ins>f an algorithm takes <tt>Predicate pred</tt> as its argument and <tt>first</tt> as its iterator argument,
++<del>it should work correctly in the construct <tt>pred(*first)</tt> contextually converted to
++<tt>bool</tt> (Clause 4)</del><ins>the expression <tt>pred(*first)</tt> shall have a type that meets the <tt>BooleanTestable</tt>
++requirements ( [booleantestable.requirements])</ins>.
++The function object <tt>pred</tt> shall not apply any non-constant function through <del>the dereferenced
++iterator</del><ins>its argument</ins>.
++<p/>
++-9- The <tt>BinaryPredicate</tt> parameter is used whenever an algorithm expects a function object that when applied
++to the result of dereferencing two corresponding iterators or to dereferencing an iterator and type
++<tt>T</tt> when <tt>T</tt> is part of the signature returns a value testable as <tt>true</tt>. <del>In other words,
++i</del><ins>I</ins>f an algorithm takes <tt>BinaryPredicate binary_pred</tt> as its argument and <tt>first1</tt> and
++<tt>first2</tt> as its iterator arguments, <del>it should work correctly in the construct <tt>binary_pred(*first1, *first2)</tt>
++contextually converted to <tt>bool</tt> (Clause 4)</del><ins>the expression <tt>binary_pred(*first1, *first2)</tt> shall
++have a type that meets the <tt>BooleanTestable</tt> requirements ( [booleantestable.requirements])</ins>.
++<tt>BinaryPredicate</tt> always takes the first iterator's <tt>value_type</tt> as its first argument, that is, in those cases
++when <tt>T</tt> value is part of the signature, <del>it should work correctly in the construct <tt>binary_pred(*first1, value)</tt>
++contextually converted to <tt>bool</tt> (Clause 4)</del><ins>the expression <tt>binary_pred(*first1, value)</tt> shall have a
++type that meets the <tt>BooleanTestable</tt> requirements ( [booleantestable.requirements])</ins>. <tt>binary_pred</tt>
++shall not apply any non-constant function through <del>the dereferenced iterators</del><ins>any of its arguments</ins>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 25.4 [alg.sorting] p2 as indicated:</p>
++
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-2- <tt>Compare</tt> is a function object type (20.9). <del>The return value of the function call
++operation applied to an object of type <tt>Compare</tt>, when contextually converted
++to <tt>bool</tt>(Clause 4), yields <tt>true</tt> if the first argument of the call is less than the second,
++and <tt>false</tt> otherwise.</del> <tt>Compare comp</tt> is used throughout for algorithms assuming an ordering relation.
++<ins>Let <tt>a</tt> and <tt>b</tt> denote two argument values whose types depend on the corresponding algorithm. Then the expression
++<tt>comp(a, b)</tt> shall have a type that meets the <tt>BooleanTestable</tt> requirements ( [booleantestable.requirements]).
++The return value of <tt>comp(a, b)</tt>, converted to <tt>bool</tt>, yields <tt>true</tt> if the
++first argument <tt>a</tt> is less than the second argument <tt>b</tt>, and <tt>false</tt> otherwise.</ins> It is assumed that
++<tt>comp</tt> will not apply any non-constant function through <del>the dereferenced iterator</del><ins>any of its arguments</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 27.5.4.2 [fpos.operations] and Table 127 &mdash; "Position type requirements" as indicated:</p>
++
++<blockquote>
++<p>
++-1- Operations specified in Table 127 are permitted. In that table,
++</p>
++<ul>
++<li><p><tt>P</tt> refers to an instance of <tt>fpos</tt>,</p></li>
++<li><p>[&hellip;]</p></li>
++<li><p><tt>o</tt> refers to a value of type <tt>streamoff</tt>,</p></li>
++<li><p><ins><tt>BT</tt> refers to a type that meets the <tt>BooleanTestable</tt> requirements ([booleantestable.requirements]),</ins></p></li>
++<li><p>[&hellip;]</p></li>
++</ul>
++<blockquote>
++<table border="1">
++<caption>Table 127 &mdash; Position type requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">[&hellip;]</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>p == q</tt>
++</td>
++<td>
++<del>convertible to <tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>p != q</tt>
++</td>
++<td>
++<del>convertible to <tt>bool</tt></del><ins><tt>BT</tt></ins>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++</blockquote>
++<blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 30.2.1 [thread.req.paramname] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <del>If a parameter is <tt>Predicate</tt>, <tt>operator()</tt> applied to the actual template argument shall return a value that
++is convertible to <tt>bool</tt></del><ins><tt>Predicate</tt> is a function object type (20.9 [function.objects]).
++Let <tt>pred</tt> denote an lvalue of type <tt>Predicate</tt>. Then the expression <tt>pred()</tt> shall have a type that meets the
++<tt>BooleanTestable</tt> requirements ( [booleantestable.requirements]). The return value of <tt>pred()</tt>,
++converted to <tt>bool</tt>, yields <tt>true</tt> if the corresponding test condition is satisfied, and <tt>false</tt> otherwise</ins>.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2115"></a>2115. Undefined behaviour for <tt>valarray</tt> assignments with <tt>mask_array</tt> index?</h3>
++<p><b>Section:</b> 26.6.8 [template.mask.array] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2011-12-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Recently I received a Service Request (SR) alleging that one of our testcases causes an
++undefined behavior. The complaint is that 26.6.8 [template.mask.array] in C++11
++(and the corresponding subclause in C++03) are interpreted by some people to require that
++in an assignment "<tt>a[mask] = b</tt>", the subscript <tt>mask</tt> and the rhs <tt>b</tt>
++must have the same number of elements.
++<p/>
++IMHO, if that is the intended requirement, it should be stated explicitly.
++<p/>
++In any event, there is a tiny editorial cleanup that could be made:
++<p/>
++In C++11, 26.6.8.1 [template.mask.array.overview] para 2 mentions
++</p>
++<blockquote><p>
++"the expression <tt>a[mask] = b;</tt>"
++</p></blockquote>
++<p>
++but the semicolon cannot be part of an expression. The correction could omit the
++semicolon, or change the word "expression" to "assignment" or "statement".
++<p/>
++Here is the text of the SR, slightly modified for publication:
++</p>
++<blockquote>
++<p>
++Subject: SR01174 LVS _26322Y31 has undefined behavior [open]
++<p/>
++[Client:]<br/>
++The test case t263.dir&#47;_26322Y31.cpp seems to be illegal as it has an undefined
++behaviour. I searched into the SRs but found SRs were not related to the topic
++explained in this mail (SR00324, SR00595, SR00838).
++</p>
++<blockquote><pre>
++const char vl[] = {"abcdefghijklmnopqrstuvwxyz"};
++const char vu[] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
++const std::valarray&lt;char&gt; v0(vl, 27), vm5(vu, 5), vm6(vu, 6);
++std::valarray&lt;char&gt; x = v0;
++[&hellip;]
++const bool vb[] = {false, false, true, true, false, true};
++const std::valarray&lt;bool&gt; vmask(vb, 6);
++x = v0;
++x[vmask] = vm5; // ***** HERE....
++steq(&amp;x[0], "abABeCghijklmnopqrstuvwxyz");
++x2 = x[vmask]; // ***** ....AND HERE
++[&hellip;]
++</pre></blockquote>
++<p>
++This problem has already been discussed between [experts]:
++See thread <a href="http://gcc.gnu.org/ml/libstdc++/2009-11/threads.html#00051">http:&#47;&#47;gcc.gnu.org&#47;ml&#47;libstdc++&#47;2009-11&#47;threads.html#00051</a>
++Conclusion <a href="http://gcc.gnu.org/ml/libstdc++/2009-11/msg00099.html">http:&#47;&#47;gcc.gnu.org&#47;ml&#47;libstdc++&#47;2009-11&#47;msg00099.html</a>
++<p/>
++[Plum Hall:]<br/>
++Before I log this as an SR, I need to check one detail with you.
++<p/>
++I did read the email thread you mentioned, and I did find a citation (see INCITS ISO&#47;IEC 14882-2003
++Section 26.3.2.6 on valarray computed assignments):
++<p/>
++Quote: "If the array and the argument array do not have the same length, the behavior is undefined",
++<p/>
++But this applies to computed assignment (<tt>*=</tt>, <tt>+=</tt>, etc), not to simple assignment. Here is the C++03 citation
++re simple assignment:
++<p/>
++26.3.2.2 valarray assignment [lib.valarray.assign]
++</p>
++<blockquote><pre>
++valarray&lt;T&gt;&amp; operator=(const valarray&lt;T&gt;&amp;);
++</pre><blockquote>
++<p>
++1 Each element of the <tt>*this</tt> array is assigned the value of the corresponding element of the argument array.
++The resulting behavior is undefined if the length of the argument array is not equal to the length of the
++<tt>*this</tt> array.
++</p>
++</blockquote></blockquote>
++<p>
++In the new C++11 (N3291), we find ...
++<p/>
++26.6.2.3 valarray assignment [valarray.assign]
++</p>
++<blockquote><pre>
++valarray&lt;T&gt;&amp; operator=(const valarray&lt;T&gt;&amp; v);
++</pre><blockquote>
++<p>
++1 Each element of the <tt>*this</tt> array is assigned the value of the corresponding element of the argument
++array. If the length of <tt>v</tt> is not equal to the length of <tt>*this</tt>, resizes <tt>*this</tt> to make
++the two arrays the same length, as if by calling <tt>resize(v.size())</tt>, before performing the assignment.
++</p>
++</blockquote></blockquote>
++<p>
++So it looks like the testcase might be valid for C++11 but not for C++03; what do you think?
++<p/>
++[Client:]<br/>
++I quite agree with you but the two problems I mentioned:
++</p>
++<blockquote><pre>
++x[vmask] = vm5; // ***** HERE....
++[&hellip;]
++x2 = x[vmask]; // ***** ....AND HERE
++</pre></blockquote>
++<p>
++refer to <tt>mask_array</tt> assignment hence target the C++03 26.3.8 paragraph. Correct?
++<p/>
++[Plum Hall:]<br/>
++I mentioned the contrast between C++03 26.3.2.2 para 1 versus C++11 26.6.2.3 para 1.
++<p/>
++But in C++03 26.3.8, I don't find any corresponding restriction. Could you quote the specific
++requirement you're writing about?
++<p/>
++[Client:]<br/>
++I do notice the difference between c++03 26.3.2.2 and c++11 26.6.2.3 about assignments between
++different sized <tt>valarray</tt> and I perfectly agree with you.
++<p/>
++But, as already stated, this is not a simple <tt>valarray</tt> assignment but a
++<tt>mask_array</tt> assignment (c++03 26.3.8 &#47; c++11 26.6.8). See c++11 quote below:
++<p/>
++26.6.8 Class template mask_array<br/>
++26.6.8.1 Class template mask_array overview<br/>
++[....]
++</p>
++<ol>
++<li><p>This template is a helper template used by the mask subscript operator:
++<tt>mask_array&lt;T&gt; valarray&lt;T&gt;::operator[](const valarray&lt;bool&gt;&amp;)</tt>.
++</p></li>
++<li><p>It has reference semantics to a subset of an array specified by a boolean mask. Thus,
++the expression <tt>a[mask] = b;</tt> has the effect of assigning <em>the elements of <tt>b</tt></em>
++to the masked elements in <tt>a</tt> (those for which the corresponding element in <tt>mask</tt> is true.)
++</p></li>
++</ol>
++<p>
++26.6.8.2 mask_array assignment
++</p>
++<blockquote><pre>
++void operator=(const valarray&lt;T&gt;&amp;) const;
++const mask_array&amp; operator=(const mask_array&amp;) const;
++</pre><blockquote>
++<p>
++1 These assignment operators have reference semantics, assigning the values of the argument array
++elements to selected elements of the <tt>valarray&lt;T&gt;</tt> object to which it refers.
++</p>
++</blockquote></blockquote>
++<p>
++In particular, [one of the WG21 experts] insisted on the piece "the elements of <tt>b</tt>".
++<p/>
++That is why I reported the test t263.dir&#47;_26322Y31.cpp having an undefined behaviour.
++<p/>
++[Plum Hall:]<br/>
++OK, I can see that I will have to ask WG21; I will file an appropriate issue
++with the Library subgroup. In the meantime, I will mark this testcase as "DISPUTED"
++so that it is not required for conformance testing, until we get a definitive opinion.
++</p>
++</blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++There appears to be a real need for clarification in the standard, and
++implementations differ in their current interpretation. This will need
++some research by implementers and a proposed resolution before further
++discussion is likely to be fruitful.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2116"></a>2116. <tt>std::swap noexcept(what?)</tt></h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2011-12-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++IMO if we specified <tt>is_[nothrow_]constructible</tt> in terms of a variable
++declaration whose validity requires destructibility, it is clearly a bug
++in our specification and a failure to realize the actual original
++intent. The specification should have been in terms of placement-new.
++<p/>
++Daniel:<br/>
++At the time of the specification this was intended and the solution is
++<em>not</em> done by removing the destruction semantics of <tt>is_constructible</tt>.
++<p/>
++The design of <tt>is_constructible</tt> was also impacted by the previous
++<tt>Constructible</tt> concept that <em>explicitly</em> contained destruction semantics,
++because during conceptification of the library it turned out to simplify
++the constraints in the library because you did not need to add
++<tt>Destructible</tt> all the time. It often was implied but never spoken out
++in C++03.
++<p/>
++Pure construction semantics was considered as useful as well, so <tt>HasConstructor</tt>
++did also exist and would surely be useful as trait as well.
++<p/>
++Another example that is often overlooked: This also affects wrapper types like <tt>pair</tt>,
++<tt>tuple</tt>, <tt>array</tt> that contain potentially more than one type:
++This is easy to understand if you think of <tt>T1</tt> having a deleted destructor
++and <tt>T2</tt> having a constructor that may throw: Obviously the compiler has
++potentially need to use the <tt>destructor</tt> of <tt>T1</tt> in the <em>constructor</em>
++of <tt>std::pair&lt;T1, T2&gt;</tt> to ensure that the core language requirements
++are satisfied (All previous fully constructed sub-objects must be destructed).
++<p/>
++The core language also honors this fact in 12.8 [class.copy] p11:
++</p>
++<blockquote><p>
++A defaulted copy&#47;move constructor for a class <tt>X</tt> is defined as deleted (8.4.3 [dcl.fct.def.delete])
++if <tt>X</tt> has:<br/>
++[&hellip;]<br/>
++&mdash; any direct or virtual base class or non-static data member of a type with a destructor that is deleted
++or inaccessible from the defaulted constructor,<br/>
++[&hellip;]
++</p></blockquote>
++<p>
++Dave:<br/>
++This is about <tt>is_nothrow_constructible</tt> in particular. The fact that it is
++foiled by not having a <tt>noexcept</tt> dtor is a defect.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++<tt>is_nothrow_constructible</tt> is defined in terms of <tt>is_constructible</tt>, which is defined
++by looking at a hypothetical variable and asking whether the variable definition is known not to
++throw exceptions. The issue claims that this also examines the type's destructor, given the context,
++and thus will return <tt>false</tt> if the destructor can potentially throw. At least one
++implementation (Howard's) does return <tt>false</tt> if the constructor is <tt>noexcept(true)</tt>
++and the destructor is <tt>noexcept(false)</tt>. So that's not a strained interpretation.
++The issue is asking for this to be defined in terms of placement <tt>new</tt>, instead of in terms
++of a temporary object, to make it clearer that <tt>is_nothrow_constructible</tt> looks at the
++<tt>noexcept</tt> status of only the constructor, and not the destructor.
++</p>
++<p>
++Sketch of what the wording would look like:
++</p>
++<p>
++require <tt>is_constructible</tt>, and then also require that a placement <tt>new</tt> operation
++does not throw. (Remembering the title of this issue... What does this imply for <tt>swap</tt>?
++</p>
++<p>
++If we accept this resolution, do we need any changes to <tt>swap</tt>?
++</p>
++<p> STL argues: no, because you are already forbidden from passing anything with a throwing
++desturctor to <tt>swap</tt>.
++</p>
++<p>
++Dietmar argues: no, not true. Maybe statically the destructor can conceivably throw for some
++values, but maybe there are some values known not to throw. In that case, it's correct to
++pass those values to <tt>swap</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2117"></a>2117. <tt>ios_base</tt> manipulators should have <tt>showgrouping&#47;noshowgrouping</tt></h3>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals], 27.5.3.1.2 [ios::fmtflags], 27.5.6.1 [fmtflags.manip] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Benjamin Kosnik <b>Opened:</b> 2011-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Iostreams should include a manipulator to toggle grouping on&#47;off for
++locales that support grouped digits. This has come up repeatedly and
++been deferred. See LWG <a href="lwg-closed.html#826">826</a> for the previous attempt.
++<p/>
++If one is using a locale that supports grouped digits, then output
++will always include the generated grouping characters. However, very
++plausible scenarios exist where one might want to output the number,
++un-grouped. This is similar to existing manipulators that toggle
++on&#47;off the decimal point, numeric base, or positive sign.
++<p/>
++See some user commentary <a href="http://www.tablix.org/~avian/blog/archives/2008/01/c_streams_suck/">here</a>.
++</p>
++
++
++<p><i>[21012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++This is a feature request.
++</p>
++<p>
++Walter is slightly uncomfortable with processing feature requests through the issues lists.
++</p>
++<p>
++Alisdair says this is far from the first feature request that has come in from the issues list.
++</p>
++<p>
++STL: The fact that you can turn off grouping on hex output is compelling.
++</p>
++<p>
++Marshall: if we add this flag, we'll need to update tables 87-91 as well.
++</p>
++<p>
++STL: If it has been implemented somewhere, and it works, we'd be glad to add it.
++</p>
++<p>
++Howard: We need to say what the default is.
++</p>
++<p>
++Alisdair sumarizes:
++</p>
++<p>
++(1) We want clear wording that says what the effect is of turning the flag off;
++</p>
++<p>
++(2) what the default values are, and
++</p>
++<p>
++(3) how this fits into tables 87-90. (and 128)
++</p>
++
++<p><i>[Issaquah 2014-02-10-12: Move to LEWG]</i></p>
++
++<p>
++Since this issue was filed, we have grown a new working group that is better placed to handle feature requests.
++</p>
++<p>
++We will track such issues with an LEWG status until we get feedback from the Library Evolution Working Group.
++</p>
++
++<p><i>[Issaquah 2014-02-12: LEWG discussion]</i></p>
++
++
++<table>
++ <caption>Do we think this feature should exist?</caption>
++ <tr><td>SF</td><td>F</td><td>N</td><td>A</td><td>SA</td></tr>
++ <tr><td>2</td> <td>4</td><td>1</td><td>0</td><td>0</td></tr>
++</table>
++
++<p>Think about the ABI break for adding a flag. But this could be
++mitigated by putting the data into an iword instead of a flag.</p>
++
++<p>This needs to change Stage 2 in [facet.num.put.virtuals].</p>
++
++<p>Previous resolution, which needs the above corrections:</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li>
++<p>Insert in 22.4.2.2.2 [facet.num.put.virtuals] paragraph 5:</p>
++
++<blockquote><p>
++<strong>Stage 1</strong>: The first action of stage 1 is to determine a conversion specifier. The tables that describe
++this determination use the following local variables
++</p>
++<pre>
++fmtflags flags = str.flags() ;
++fmtflags basefield = (flags &amp; (ios_base::basefield));
++fmtflags uppercase = (flags &amp; (ios_base::uppercase));
++fmtflags floatfield = (flags &amp; (ios_base::floatfield));
++fmtflags showpos = (flags &amp; (ios_base::showpos));
++fmtflags showbase = (flags &amp; (ios_base::showbase));
++<ins>fmtflags showgrouping = (flags &amp; (ios_base::showgrouping));</ins>
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change header <tt>&lt;ios&gt;</tt> synopsis, 27.5.1 [iostreams.base.overview] as indicated:</p>
++
++<blockquote><pre>
++#include &lt;iosfwd&gt;
++
++namespace std {
++ [&hellip;]
++ <i>// 27.5.6, manipulators:</i>
++ [&hellip;]
++ ios_base&amp; showpoint (ios_base&amp; str);
++ ios_base&amp; noshowpoint (ios_base&amp; str);
++ <ins>ios_base&amp; showgrouping (ios_base&amp; str);</ins>
++ <ins>ios_base&amp; noshowgrouping(ios_base&amp; str);</ins>
++ ios_base&amp; showpos (ios_base&amp; str);
++ ios_base&amp; noshowpos (ios_base&amp; str);
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change class <tt>ios_base</tt> synopsis, 27.5.3 [ios.base] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ class ios_base {
++ public:
++ class failure;
++ <i>// 27.5.3.1.2 fmtflags</i>
++ typedef <i>T1</i> fmtflags;
++ [&hellip;]
++ static constexpr fmtflags showpoint = <i>unspecified</i> ;
++ <ins>static constexpr fmtflags showgrouping = <i>unspecified</i> ;</ins>
++ static constexpr fmtflags showpos = <i>unspecified</i> ;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Add a new entry to Table 122 &mdash; "<tt>fmtflags</tt> effects" as indicated:</p>
++
++<table border="1">
++<caption>Table 122 &mdash; <tt>fmtflags</tt> effects</caption>
++<tr align="center">
++<th>Element</th>
++<th>Effect(s) if set</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>showpoint</tt>
++</td>
++<td>
++generates a decimal-point character unconditionally in generated floatingpoint output
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>showgrouping</tt></ins>
++</td>
++<td>
++<ins>generates grouping characters unconditionally in generated output</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>After 27.5.3.1.2 [ios::fmtflags] p12 insert the following:</p>
++<blockquote><pre>
++<ins>ios_base&amp; showgrouping(ios_base&amp; str);</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Effects</i>: Calls <tt>str.setf(ios_base::showgrouping)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: <tt>str</tt>.</ins>
++</p>
++</blockquote>
++<pre>
++<ins>ios_base&amp; noshowgrouping(ios_base&amp; str);</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Effects</i>: Calls <tt>str.unsetf(ios_base::showgrouping)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: <tt>str</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2119"></a>2119. Missing <tt>hash</tt> specializations for extended integer types</h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-12-16 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to the header <tt>&lt;functional&gt;</tt> synopsis 20.9 [function.objects]
++and to the explicit description in 20.9.13 [unord.hash] class template
++<tt>hash</tt> specializations shall be provided for all arithmetic types that are
++not extended integer types. This is not explicitly mentioned, but neither the list
++nor any normative wording does include them, so it follows by implication.
++<p/>
++What are the reasons that extended integer types are excluded? E.g. for
++<tt>numeric_limits</tt> corresponding specializations are required. I would
++expect that an <tt>unordered_map</tt> with key type <tt>std::uintmax_t</tt> would
++just work, but that depends now on whether this type is an extended integer type
++or not.
++<p/>
++This issue is <em>not</em> asking for also providing specializations for the
++<i>cv</i>-qualified arithmetic types. While this is surely a nice-to-have feature,
++I consider that restriction as a more secondary problem in practice.
++<p/>
++The proposed resolution also fixes a problem mentioned in <a href="lwg-defects.html#2109">2109</a> in regard
++to confusing requirements on user-defined types and those on implementations.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++Agreed that it's a real issue and that the proposed wording fixes it. However, the wording
++change is not minimal and isn't consistent with the way we fixed hash wording elsewhere.
++</p>
++<p>Alisdair will provide updated wording.
++</p>
++
++<p><i>[2014-05-06 Geoffrey Romer suggests alternative wording]</i></p>
++
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 20.9.13 [unord.hash] p2 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;bool&gt;;
++template &lt;&gt; struct hash&lt;char&gt;;
++[&hellip;]
++template &lt;&gt; struct hash&lt;long double&gt;;
++template &lt;class T&gt; struct hash&lt;T*&gt;;
++</pre><blockquote>
++<p>
++-2- <del><i>Requires</i>: the template specializations shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;functional&gt;</tt> provides definitions for specializations of the
++<tt>hash</tt> class template for each <i>cv</i>-unqualified arithmetic type. This
++header also provides a definition for a partial specialization of the <tt>hash</tt>
++class template for any pointer type. The requirements for the members of these
++specializations are given in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: the new PR is very simple and could resolve that nicely<br/>
++MC: the older PR is rather longish
++</p>
++<ul>
++<li><p>anybody have any objections to this approach?</p></li>
++<li><p>what people want to have as a status?</p></li>
++</ul>
++<p>
++STL: I want to have Ready<br/>
++MC: move to ready: in favor: 13, opposed: 0, abstain: 4
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<p>Change 20.9.13 [unord.hash] p1 as indicated:</p>
++
++<blockquote><p>
++The unordered associative containers defined in 23.5 use specializations of the class template <tt>hash</tt> as the
++default hash function. For all object types <tt>Key</tt> for which there exists a specialization <tt>hash&lt;Key&gt;</tt>,
++and for all <ins>integral and</ins> enumeration types (7.2) <tt>Key</tt>, the instantiation <tt>hash&lt;Key&gt;</tt> shall: [&hellip;]
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2121"></a>2121. <tt>app</tt> for string streams</h3>
++<p><b>Section:</b> 27.8.5.1 [stringstream.cons] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2012-01-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++This issue was raised while discussing issue <a href="lwg-defects.html#1448">1448</a>.
++<p/>
++Note the following program:
++</p>
++<blockquote><pre>
++string s("s1: 123456789");
++ostringstream s1(s, ios_base::out|ios_base::app);
++s1 &lt;&lt; "hello";
++cout &lt;&lt; s1.str() &lt;&lt; endl;
++</pre></blockquote>
++<p>
++With g++4.x it prints:
++</p>
++<blockquote><pre>
++s1: 123456789hello
++</pre></blockquote>
++<p>
++With VisualC++10 it prints:
++</p>
++<blockquote><pre>
++hello23456789
++</pre></blockquote>
++<p>
++From my intuitive understanding the flag "app" should result in the output of g++4.x.
++I also would read that from 27.5.3.1.4 [ios::openmode] claiming:
++</p>
++<blockquote><p>
++<tt>app</tt>&nbsp;&nbsp;&nbsp;seek to end before each write
++</p></blockquote>
++<p>
++However in issue <a href="lwg-defects.html#1448">1448</a> P.J.Plauger comments:
++</p>
++<blockquote><p>
++I think we should say nothing special about <tt>app</tt> at construction time (thus leaving the write pointer at the beginning of the buffer).
++Leave implementers wiggle room to ensure subsequent append writes as they see fit, but don't change existing rules for initial seek
++position.
++</p></blockquote>
++<p>
++Note that the flag <tt>ate</tt> on both platforms appends "hello" to <tt>s</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2127"></a>2127. Move-construction with <tt>raw_storage_iterator</tt></h3>
++<p><b>Section:</b> 20.7.10 [storage.iterator] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-01-23 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#storage.iterator">issues</a> in [storage.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Aliaksandr Valialkin pointed out that <tt>raw_storage_iterator</tt> only supports constructing
++a new object from lvalues so cannot be used to construct move-only types:
++</p>
++<blockquote><pre>
++template &lt;typename InputIterator, typename T&gt;
++void move_to_raw_buffer(InputIterator first, InputIterator last, T *raw_buffer)
++{
++ std::move(first, last, std::raw_storage_iterator&lt;T *, T&gt;(raw_buffer));
++}
++</pre></blockquote>
++<p>
++This could easily be solved by overloading <tt>operator=</tt> for rvalues.
++<p/>
++Dave Abrahams:
++<p/>
++<tt>raw_storage_iterator</tt> causes exception-safety problems when used with any
++generic algorithm. I suggest leaving it alone and not encouraging its use.
++</p>
++
++<p><i>[2014-11-11, Jonathan provides improved wording]</i></p>
++
++<p>
++In Urbana LWG decided to explicitly say the value is constructed from an rvalue.
++</p>
++
++<strong>Previous resolution from Jonathan [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf">N3337</a>.</p>
++
++<ol>
++<li><p>Add a new signature to the synopsis in 20.7.10 [storage.iterator] p1:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class OutputIterator, class T&gt;
++ class raw_storage_iterator
++ : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
++ public:
++ explicit raw_storage_iterator(OutputIterator x);
++
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
++ <ins>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(T&amp;&amp; element);</ins>
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();
++ raw_storage_iterator&lt;OutputIterator,T&gt; operator++(int);
++};
++}
++</pre></blockquote>
++</li>
++
++<li><p>Insert the new signature and a new paragraph before p4:</p>
++
++<blockquote><pre>
++raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
++<ins>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(T&amp;&amp; element);</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Requires</i>: For the first signature <tt>T</tt> shall be <tt>CopyConstructible</tt>. For
++the second signature <tt>T</tt> shall be <tt>MoveConstructible</tt>.</ins>
++<p/>
++-4- <i>Effects</i>: Constructs a value from <tt>element</tt> at the location to which the iterator points.
++<p/>
++-5- <i>Returns</i>: A reference to the iterator.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: Suggestion to move it to Ready for incorporation on Friday<br/>
++MC: move to ready: in favor: 12, opposed: 0, abstain: 3
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/prot/14882fdis/n4140.pdf">N4140</a>.</p>
++
++<ol>
++<li><p>Add a new signature to the synopsis in 20.7.10 [storage.iterator] p1:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class OutputIterator, class T&gt;
++ class raw_storage_iterator
++ : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
++ public:
++ explicit raw_storage_iterator(OutputIterator x);
++
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
++ <ins>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(T&amp;&amp; element);</ins>
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();
++ raw_storage_iterator&lt;OutputIterator,T&gt; operator++(int);
++};
++}
++</pre></blockquote>
++</li>
++
++<li><p>Insert a new paragraph before p4:</p>
++
++<blockquote><pre>
++raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
++</pre><blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>T</tt> shall be <tt>CopyConstructible</tt>.</ins>
++<p/>
++-4- <i>Effects</i>: Constructs a value from <tt>element</tt> at the location to which the iterator points.
++<p/>
++-5- <i>Returns</i>: A reference to the iterator.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Insert the new signature and a new paragraph after p5:</p>
++
++<blockquote><pre>
++<ins>raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(T&amp;&amp; element);</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveConstructible</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects</i>: Constructs a value from <tt>std::move(element)</tt> at the
++location to which the iterator points.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: A reference to the iterator.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2133"></a>2133. Attitude to overloaded comma for iterators</h3>
++<p><b>Section:</b> 17.6.5.4 [global.functions] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Yakov Galka <b>Opened:</b> 2012-01-25 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#global.functions">issues</a> in [global.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++17.6.5.4 [global.functions] says
++</p>
++<blockquote><p>
++Unless otherwise specified, global and non-member functions in the standard library
++shall not use functions from another namespace which are found through argument-dependent
++name lookup (3.4.2).
++</p></blockquote>
++<p>
++This sounds clear enough. There are just two problems:
++</p>
++<ol>
++<li><p>
++Both implementations I tested (VS2005 and GCC 3.4.3) do unqualified
++calls to the comma operator in some parts of the library with operands
++of user-defined types.
++</p></li>
++<li>
++<p>
++The standard itself does this in the description of some algorithms. E.g. <tt>uninitialized_copy</tt>
++is defined as:
++</p>
++<blockquote><p>
++<i>Effects</i>:
++</p><blockquote>
++<pre>
++for (; first != last; <span style="color:#C80000;font-weight:bold">++result, ++first</span>)
++ ::new (static_cast&lt;void*&gt;(&amp;*result))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++</pre>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++<p>
++If understood literally, it is required to call <tt>operator,(ForwardIterator, InputIterator)</tt>.
++<p/>
++For detailed discussion with code samples see
++<a href="http://stackoverflow.com/questions/8719829/should-the-implementation-guard-itself-against-comma-overloading">here</a>.
++<p/>
++Proposal:
++</p>
++<ol>
++<li>
++Add an exception to the rule in 17.6.5.4 [global.functions] by permitting
++the implementation to call the comma operator as much as it wants to. I doubt we want this. or
++</li>
++<li>
++Fix the description of the said algorithms and perhaps add a note to 17.6.5.4 [global.functions]
++that brings attention of the implementers to avoid this pitfall.
++</li>
++</ol>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++There are real questions here, that may require a paper to explore and answer properly.
++</p>
++
++<p><i>[2014-05-18, Daniel comments and suggests concrete wording]</i></p>
++
++
++<p>
++Other issues, such as <a href="lwg-active.html#2114">2114</a> already follow a similar spirit as the one suggested by bullet 2 of the
++issue submitter. I assert that consideration of possible user-provided overloads of the comma-operator were not intended
++by the original wording and doing so afterwards would unnecessarily complicate a future conceptualization of the library
++and would needlessly restrict implementations.
++<p/>
++I don't think that a paper is needed to solve this issue, there is a simply way to ensure that the code-semantics
++excludes consideration of user-provided comma operators. The provided wording below clarifies this by explicitly
++casting the first argument of the operator to <tt>void</tt>.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++DK: is putting it in the middle the right place for it?<br/>
++STL: either works, but visually putting it in the middle is clearer, and for "++it1, ++i2, ++it3" it needs to be
++done after the second comma, so "++it1, (void) ++i2, (void) ++it3" is better than "(void) ++it1, ++i2, (void) ++it3"<br/>
++ZY: for <tt><i>INVOKE</i></tt> yesterday we used <tt>static_cast&lt;void&gt;</tt> but here we're using C-style cast, why?<br/>
++STL: for <tt><i>INVOKE</i></tt> I want to draw attention that there's an intentional coercion to <tt>void</tt> because that's
++the desired type. Here we only do it because that's the best way to prevent the problem, not because we specifically want a
++<tt>void</tt> type.<br/>
++Move to Ready: 9 in favor, none opposed, 1 abstention
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.7.12.2 [uninitialized.copy] as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class InputIterator, class ForwardIterator&gt;
++ ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
++ ForwardIterator result);
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; first != last; ++result, <ins>(void)</ins> ++first)
++ ::new (static_cast&lt;void*&gt;(&amp;*result))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++</pre>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++template &lt;class InputIterator, class Size,class ForwardIterator&gt;
++ ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
++ ForwardIterator result);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; n &gt; 0; ++result, <ins>(void)</ins> ++first, --n)
++ ::new (static_cast&lt;void*&gt;(&amp;*result))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++</pre>
++</blockquote>
++</blockquote>
++
++</blockquote>
++</li>
++
++<li><p>Change 25.4.8 [alg.lex.comparison] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++template&lt;class InputIterator1, class InputIterator2&gt;
++ bool
++ lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
++ InputIterator2 first2, InputIterator2 last2);
++template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
++ bool
++ lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
++ InputIterator2 first2, InputIterator2 last2,
++ Compare comp);
++</pre>
++<blockquote>
++<p>
++-3- <i>Remarks</i>: [&hellip;]
++</p>
++<blockquote>
++<pre>
++for ( ; first1 != last1 &amp;&amp; first2 != last2 ; ++first1, <ins>(void)</ins> ++first2) {
++ if (*first1 &lt; *first2) return true;
++ if (*first2 &lt; *first1) return false;
++}
++return first1 == last1 &amp;&amp; first2 != last2;
++</pre>
++</blockquote>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2136"></a>2136. Postconditions vs. exceptions</h3>
++<p><b>Section:</b> 17.5.1 [structure] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2012-03-08 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The front matter in clause 17 should clarify that postconditions will not hold if a
++standard library function exits via an exception. Postconditions or guarantees that
++apply when an exception is thrown (beyond the basic guarantee) are described in an
++"Exception safety" section.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Open
++]</i></p>
++
++
++<p>
++Consensus that we do not clearly say this, and that we probably should. A likely
++location to describe the guarantees of <i>postconditions</i> could well be a new
++sub-clause following 17.6.4.11 [res.on.required] which serves the same purpose
++for <i>requires</i> clauses. However, we need such wording before we can make
++progress.
++</p>
++
++<p>
++Also, see <a href="lwg-active.html#2137">2137</a> for a suggestion that we want to see a paper resolving
++both issues together.
++</p>
++
++<p><i>[2015-05-06 Lenexa: EirkWF to write paper addressing 2136 and 2137]</i></p>
++
++<p>MC: Idea is to replace all such "If no exception" postconditions with "Exception safety" sections.</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2137"></a>2137. Misleadingly constrained post-condition in the presence of exceptions</h3>
++<p><b>Section:</b> 28.8.3 [re.regex.assign] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-03-08 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex.assign">issues</a> in [re.regex.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The post-conditions of <tt>basic_regex&lt;&gt;::assign</tt> 28.8.3 [re.regex.assign] p16 say:
++</p>
++<blockquote><p>
++<span style="color:#C80000;font-weight:bold">If no exception is thrown,</span> <tt>flags()</tt> returns
++<tt>f</tt> and <tt>mark_count()</tt> returns the number of marked sub-expressions within the expression.
++</p></blockquote>
++<p>
++The default expectation in the library is that post-conditions only hold, if there is no failure
++(see also <a href="lwg-active.html#2136">2136</a>), therefore the initial condition should be removed to prevent any
++misunderstanding.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Open
++]</i></p>
++
++
++<p>
++A favorable resolution clearly depends on a favorable resolution to <a href="lwg-active.html#2136">2136</a>.
++There is also a concern that this is just one example of where we would want to apply
++such a wording clean-up, and which is really needed to resolve both this issue and
++<a href="lwg-active.html#2136">2136</a> is a paper providing the clause 17 wording that gives the guarantee
++for <i>postcondition</i> paragaraphs, and then reviews clauses 18-30 to apply that
++guarantee consistently. We do not want to pick up these issues piecemeal, as we risk
++openning many issues in an ongoing process.
++</p>
++
++<p><i>[2015-05-06 Lenexa: EirkWF to write paper addressing 2136 and 2137]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<blockquote><pre>
++template &lt;class string_traits, class A&gt;
++ basic_regex&amp; assign(const basic_string&lt;charT, string_traits, A&gt;&amp; s,
++ flag_type f = regex_constants::ECMAScript);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-15- <i>Effects</i>: Assigns the regular expression contained in the string <tt>s</tt>, interpreted according
++the flags specified in <tt>f</tt>. If an exception is thrown, <tt>*this</tt> is unchanged.
++<p/>
++-16- <i>Postconditions</i>: <del>If no exception is thrown,</del> <tt>flags()</tt> returns <tt>f</tt> and
++<tt>mark_count()</tt> returns the number of marked sub-expressions within the expression.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2139"></a>2139. What is a <em>user-defined</em> type?</h3>
++<p><b>Section:</b> 17.6.4.2.1 [namespace.std], 19.5 [syserr], 20.7.7.1 [allocator.uses.trait], 20.9.10.1 [func.bind.isbind], 20.9.10.2 [func.bind.isplace], 20.9.13 [unord.hash], 20.10.7.6 [meta.trans.other], 22.3.1 [locale], 22.4.1.4 [locale.codecvt], 28.12.1.4 [re.regiter.incr] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Lo&iuml;c Joly <b>Opened:</b> 2012-03-08 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#namespace.std">issues</a> in [namespace.std].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The expression "user-defined type" is used in several places in the standard, but I'm not sure what
++it means. More specifically, is a type defined in the standard library a user-defined type?
++<p/>
++From my understanding of English, it is not. From most of the uses of this term in the standard, it
++seem to be considered as user defined. In some places, I'm hesitant, e.g. 17.6.4.2.1 [namespace.std] p1:
++</p>
++<blockquote><p>
++A program may add a template specialization for any standard library template to namespace <tt>std</tt>
++only if the declaration depends on a user-defined type and the specialization meets the standard library
++requirements for the original template and is not explicitly prohibited.
++</p></blockquote>
++<p>
++Does it mean we are allowed to add in the namespace <tt>std</tt> a specialization for
++<tt>std::vector&lt;std::pair&lt;T, U&gt;&gt;</tt>, for instance?
++<p/>
++Additional remarks from the reflector discussion: The traditional meaning of user-defined types refers
++to class types and enum types, but the library actually means here user-defined types that are not
++(purely) library-provided. Presumably a new term - like <em>user-provided type</em> - should be introduced
++and properly defined.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Deferred
++]</i></p>
++
++
++<p>
++The issue is real, in that we never define this term and rely on a "know it when I see it"
++intuition. However, there is a fear that any attempt to pin down a definition is more
++likely to introduce bugs than solve them - getting the wording for this precisely correct
++is likely far more work than we are able to give it.
++</p>
++
++<p>
++There is unease at simple closing as NAD, but not real enthusiasm to provide wording either.
++Move to Deferred as we are not opposed to some motivated individual coming back with full
++wording to review, but do not want to go out of our way to encourage someone to work on this
++in preference to other issues.
++</p>
++
++<p><i>[2014-02-20 Re-open Deferred issues as Priority 4]</i></p>
++
++
++<p><i>[2015-03-05 Jonathan suggests wording]</i></p>
++
++<p>
++I dislike the suggestion to change to "user-provided" type because I already find the
++difference between user-declared / user-provided confusing for special member functions,
++so I think it would be better to use a completely different term. The core language
++uses "user-defined conversion sequence" and "user-defined literal" and
++similar terms for things which the library provides, so I think we
++should not refer to "user" at all to distinguish entities defined
++outside the implementation from things provided by the implementation.
++<p/>
++I propose "program-defined type" (and "program-defined specialization"), defined below.
++The P/R below demonstrates the scope of the changes required, even if this name isn't adopted.
++I haven't proposed a change for "User-defined facets" in [locale].
++</p>
++
++<p><i>[Lenexa 2015-05-06]</i></p>
++
++<p>RS, HT: The core language uses "user-defined" in a specific way, including library things but excluding core language things, let's use a different term.</p>
++<p>MC: Agree.</p>
++<p>RS: "which" should be "that", x2</p>
++<p>RS: Is std::vector&lt;MyType&gt; a "program-defined type"?</p>
++<p>MC: I think it should be.</p>
++<p>TK: std::vector&lt;int&gt; seems to take the same path.</p>
++<p>JW: std::vector&lt;MyType&gt; isn't program-defined, we don't need it to be, anything that depends on that also depends on =MyType.</p>
++<p>TK: The type defined by an "explicit template specialization" should be a program-defined type.</p>
++<p>RS: An implicit instantiation of a "program-defined partial specialization" should also be a program-defined type.</p>
++<p>JY: This definition formatting is horrible and ugly, can we do better?</p>
++<p>RS: Checking ISO directives.</p>
++<p>RS: Define "program-defined type" and "program-defined specialization" instead, to get rid of the angle brackets.</p>
++<p>JW redrafting.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Add a new sub-clause to 17.3 [definitions]:</p>
++
++<p><ins><b>17.3.? [defns.program.defined]</b></ins></p>
++<p>
++<ins><b>program-defined</b></ins>
++<p/>
++<ins>&lt;type&gt; a class type or enumeration type which is not part of the C++
++standard library and not defined by the implementation. [<i>Note</i>: Types
++defined by the implementation include extensions (1.4 [intro.compliance])
++and internal types used by the library. &mdash; <i>end note</i>]</ins>
++</p>
++<p>
++<ins><b>program-defined</b></ins>
++<p/>
++<ins>&lt;specialization&gt; an explicit template specialization or partial
++specialization which is not part of the C++ standard library and not
++defined by the implementation.</ins>
++</p>
++</li>
++
++<li><p>Change 17.6.4.2.1 [namespace.std] paragraph 1+2:</p>
++
++<p>
++-1- The behavior of a C++ program is undefined if it adds declarations or definitions to namespace <tt>std</tt> or to a
++namespace within namespace <tt>std</tt> unless otherwise specified. A program may add a template specialization
++for any standard library template to namespace <tt>std</tt> only if the declaration depends on a
++<del>user</del><ins>program</ins>-defined type and the specialization meets the standard library requirements for the
++original template and is not explicitly prohibited.
++<p/>
++-2- The behavior of a C++ program is undefined if it declares
++<p/>
++[&hellip;]
++<p/>
++A program may explicitly instantiate a template defined in the standard library only if the declaration
++depends on the name of a <del>user</del><ins>program</ins>-defined type and the instantiation meets the standard
++library requirements for the original template.
++</p>
++</li>
++
++<li><p>Change 19.5 [syserr] paragraph 4:</p>
++
++<p>
++-4- The <tt>is_error_code_enum</tt> and <tt>is_error_condition_enum</tt> may be specialized for
++<del>user</del><ins>program</ins>-defined types to indicate that such types are eligible for class <tt>error_code</tt>
++and class <tt>error_condition</tt> automatic conversions, respectively.
++</p>
++</li>
++
++<li><p>Change 20.7.7.1 [allocator.uses.trait] paragraph 1:</p>
++
++<p>
++-1- <i>Remarks</i>: automatically detects [&hellip;]. A program may specialize this template to derive from
++<tt>true_type</tt> for a <del>user</del><ins>program</ins>-defined type <tt>T</tt> that does not have a nested
++<tt>allocator_type</tt> but nonetheless can be constructed with an allocator where either: [&hellip;]
++</p>
++</li>
++
++<li><p>Change 20.9.10.1 [func.bind.isbind] paragraph 2:</p>
++
++<p>
++-2- Instantiations of the <tt>is_bind_expression</tt> template [&hellip;]. A program may specialize
++this template for a <del>user</del><ins>program</ins>-defined type <tt>T</tt> to have a <tt>BaseCharacteristic</tt>
++of <tt>true_type</tt> to indicate that <tt>T</tt> should be treated as a subexpression in a <tt>bind</tt> call.
++</p>
++</li>
++
++<li><p>Change 20.9.10.2 [func.bind.isplace] paragraph 2:</p>
++
++<p>
++-2- Instantiations of the <tt>is_placeholder</tt> template [&hellip;]. A program may specialize this template for a
++<del>user</del><ins>program</ins>-defined type <tt>T</tt> to have a <tt>BaseCharacteristic</tt> of
++<tt>integral_constant&lt;int, <i>N</i>&gt;</tt> with <tt><i>N</i> &gt; 0</tt> to indicate that <tt>T</tt> should be
++treated as a placeholder type.
++</p>
++</li>
++
++<li><p>Change 20.9.13 [unord.hash] paragraph 1:</p>
++
++<p>
++The unordered associative containers defined in 23.5 use specializations of the class template <tt>hash</tt> [&hellip;],
++the instantiation <tt>hash&lt;Key&gt;</tt> shall:
++</p>
++<ul>
++<li><p>[&hellip;]</p></li>
++<li><p>[&hellip;]</p></li>
++<li><p>[&hellip;]</p></li>
++<li><p>[&hellip;]</p></li>
++<li><p>satisfy the requirement that the expression <tt>h(k)</tt>, where <tt>h</tt> is an object of type
++<tt>hash&lt;Key&gt;</tt> and <tt>k</tt> is an object of type <tt>Key</tt>, shall not throw an exception unless
++<tt>hash&lt;Key&gt;</tt> is a <del>user</del><ins>program</ins>-defined specialization that depends on at least one
++<del>user</del><ins>program</ins>-defined type.</p></li>
++</ul>
++</li>
++
++<li><p>Change 20.10.7.5 [meta.trans.ptr] Table 57 (<tt>common_type</tt> row):</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 57 &mdash; Other transformations</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class... T&gt;<br/>
++struct common_type;</tt>
++</td>
++
++<td align="center">
++&nbsp;
++</td>
++
++<td>
++The member typedef <tt>type</tt> shall be<br/>
++defined or omitted as specified below.<br/>
++[&hellip;]. A program may<br/>
++specialize this trait if at least one<br/>
++template parameter in the<br/>
++specialization is a <del>user</del><ins>program</ins>-defined type.<br/>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Change 22.4.1.4 [locale.codecvt] paragraph 3:</p>
++
++<p>
++-3- The specializations required in Table 81 (22.3.1.1.1) [&hellip;]. Other encodings can be converted
++by specializing on a <del>user</del><ins>program</ins>-defined <tt>stateT</tt> type.[&hellip;]
++</p>
++</li>
++
++<li><p>Change 28.12.1.4 [re.regiter.incr] paragraph 8:</p>
++
++<p>
++-8- [<i>Note</i>: This means that a compiler may call an implementation-specific search function, in which case
++a <del>user</del><ins>program</ins>-defined specialization of <tt>regex_search</tt> will not be called. &mdash;
++<i>end note</i>]
++</p>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2146"></a>2146. Are reference types <tt>Copy</tt>&#47;<tt>Move-Constructible</tt>&#47;<tt>Assignable</tt> or <tt>Destructible</tt>?</h3>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2012-03-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 17.6.3.1 [utility.arg.requirements] p1
++</p>
++<blockquote><p>
++The template definitions in the C++ standard library refer to various named requirements whose details are set out in
++tables 17-24. In these tables, <tt>T</tt> is an object or reference type to be supplied by a C++ program instantiating
++a template; <tt>a</tt>, <tt>b</tt>, and <tt>c</tt> are values of type (possibly <tt>const</tt>) <tt>T</tt>; <tt>s</tt>
++and <tt>t</tt> are modifiable lvalues of type <tt>T</tt>; <tt>u</tt> denotes an identifier; <tt>rv</tt> is an rvalue of
++type <tt>T</tt>; and <tt>v</tt> is an lvalue of type (possibly <tt>const</tt>) <tt>T</tt> or an rvalue of type <tt>const T</tt>.
++</p></blockquote>
++<p>
++Is it really intended that <tt>T</tt> may be a reference type? If so, what should <tt>a</tt>, <tt>b</tt>, <tt>c</tt>,
++<tt>s</tt>, <tt>t</tt>, <tt>u</tt>, <tt>rv</tt>, and <tt>v</tt> mean? For example, are "<tt>int &amp;</tt>" and
++"<tt>int &amp;&amp;</tt>" <tt>MoveConstructible</tt>?
++<p/>
++As far as I understand, we can explicitly specify template arguments for <tt>std::swap</tt> and <tt>std::for_each</tt>.
++Can we use reference types there?
++</p>
++<ol>
++<li>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;utility&gt;
++
++int main()
++{
++ int x = 1;
++ int y = 2;
++ std::swap&lt;<span style="color:#C80000;font-weight:bold">int &amp;&amp;</span>&gt;(x, y); // <em>undefined?</em>
++ std::cout &lt;&lt; x &lt;&lt; " " &lt;&lt; y &lt;&lt; std::endl;
++}
++</pre></blockquote>
++</li>
++<li>
++<blockquote><pre>
++#include &lt;algorithm&gt;
++#include &lt;iostream&gt;
++#include &lt;iterator&gt;
++#include &lt;utility&gt;
++
++struct F
++{
++ void operator()(int n)
++ {
++ std::cout &lt;&lt; n &lt;&lt; std::endl;
++ ++count;
++ }
++ int count;
++} f;
++
++int main()
++{
++ int arr[] = { 1, 2, 3 };
++ auto&amp;&amp; result = std::for_each&lt;int *, <span style="color:#C80000;font-weight:bold">F &amp;&amp;</span>&gt;( // <em>undefined?</em>
++ std::begin(arr),
++ std::end(arr),
++ std::move(f));
++ std::cout &lt;&lt; "count: " &lt;&lt; result.count &lt;&lt; std::endl;
++}
++</pre></blockquote>
++</li>
++</ol>
++<p>
++Are these forms of usage well-defined?
++<p/>
++Let's also consider the following constructor of <tt>std::thread</tt>:
++</p>
++<blockquote><pre>
++template &lt;class F, class ...Args&gt;
++explicit thread(F&amp;&amp; f, Args&amp;&amp;... args);
++</pre><blockquote>
++<p>
++<i>Requires</i>: <tt>F</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall satisfy the <tt>MoveConstructible</tt> requirements.
++</p>
++</blockquote></blockquote>
++<p>
++When the first argument of this constructor is an lvalue (e.g. a name of a global function), template argument for <tt>F</tt>
++is deduced to be lvalue reference type. What should "<tt>MoveConstructible</tt>" mean with regard to an lvalue reference
++type? Maybe the wording should say that <tt>std::decay&lt;F&gt;::type</tt> and each <tt>std::decay&lt;Ti&gt;::type</tt> (where
++<tt>Ti</tt> is an arbitrary item in <tt>Args</tt>) shall satisfy the <tt>MoveConstructible</tt> requirements?
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++The questions raised by the issue are real, and should have a clear answer.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2151"></a>2151. <tt>basic_string&lt;&gt;::swap</tt> semantics ignore allocators</h3>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Robert Shearer <b>Opened:</b> 2012-04-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In C++11, <tt>basic_string</tt> is not described as a "container", and is not governed by the allocator-aware
++container semantics described in sub-clause 23.2 [container.requirements]; as a result, and
++requirements or contracts for the <tt>basic_string</tt> interface must be documented in Clause
++21 [strings].
++<p/>
++Sub-clause 21.4.6.8 [string::swap] defines the <tt>swap</tt> member function with no requirements, and
++with guarantees to execute in constant time without throwing. Fulfilling such a contract is not reasonable
++in the presence of unequal non-propagating allocators.
++<p/>
++In contrast, 23.2.1 [container.requirements.general] p7 declares the behavior of member <tt>swap</tt>
++for containers with unequal non-propagating allocators to be undefined.
++<p/>
++Resolution proposal:
++<p/>
++Additional language from Clause 23 [containers] should probably be copied to Clause
++21 [strings]. I will refrain from an exactly recommendation, however, as I am raising further
++issues related to the language in Clause 23 [containers].
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Alisdair has offered to provide wording.
++</p>
++<p>
++Telecon notes that 23.2.1 [container.requirements.general]p13 says that <tt>string</tt> is an
++allocator-aware container.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2152"></a>2152. Instances of standard container types are not swappable</h3>
++<p><b>Section:</b> 17.6.3.2 [swappable.requirements], 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Robert Shearer <b>Opened:</b> 2012-04-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#swappable.requirements">issues</a> in [swappable.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Sub-clause 17.6.3.2 [swappable.requirements] defines two notions of swappability: a binary version defining
++when two objects are <em>swappable with</em> one another, and a unary notion defining whether an object is
++<em>swappable</em> (without qualification), with the latter definition requiring that the object satisfy the
++former with respect to all values of the same type.
++<p/>
++Let <tt>T</tt> be a container type based on a non-propagating allocator whose instances do not necessarily
++compare equal. Then sub-clause 23.2.1 [container.requirements.general] p7 implies that no object <tt>t</tt>
++of type <tt>T</tt> is swappable (by the unary definition).
++<p/>
++Throughout the standard it is the unary definition of "swappable" that is listed as a requirement (with the
++exceptions of 20.2.2 [utility.swap] p4, 20.3.2 [pairs.pair] p31, 20.4.2.3 [tuple.swap] p2,
++25.3.3 [alg.swap] p2, and 25.3.3 [alg.swap] p6, which use the binary definition). This renders
++many of the mutating sequence algorithms of sub-clause 25.3 [alg.modifying.operations], for example,
++inapplicable to sequences of standard container types, even where every element of the sequence is swappable
++with every other.
++<p/>
++Note that this concern extends beyond standard containers to all future allocator-based types.
++<p/>
++Resolution proposal:
++<p/>
++I see two distinct straightforward solutions:
++</p>
++<ol style="list-style-type:lower-roman">
++<li>Modify the requirements of algorithms from sub-clause 25.3 [alg.modifying.operations], and all other
++places that reference the unary "swappable" definition, to instead use the binary "swappable with" definition
++(over a domain appropriate to the context). The unary definition of "swappable" could then be removed from the
++standard.
++</li>
++<li>Modify sub-clause 23.2.1 [container.requirements.general] such that objects of standard container types
++are "swappable" by the unary definition.
++</li>
++</ol>
++<p>
++I favor the latter solution, for reasons detailed in the following issue.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Open
++]</i></p>
++
++
++<p>
++The issue is broader than containers with stateful allocotors, although they are the most obvious
++example contained within the standard itself. The basic problem is that once you have a stateful
++allocator, that does not <tt>propagate_on_swap</tt>, then whether two objects of this type can be
++swapped with well defined behavior is a run-time property (the allocators compare equal) rather
++than a simple compile-time property that can be deduced from the type. Strictly speaking, any
++type where the nature of swap is a runtime property does not meet the <tt>swappable</tt>
++requirements of C++11, although typical sequences of such types are going to have elements that
++are all <tt>swappable with</tt> any other element in the sequence (using our other term of art
++for specifying requirements) as the common case is a container of elements who all share the
++same allocator.
++</p>
++
++<p>
++The heart of the problem is that the <tt>swappable</tt> requirments demand that any two objects
++of the same type be <tt>swappable with</tt> each other, so if any two such objects would not
++be <tt>swappable with</tt> each other, then the whole type is never <tt>swappable</tt>. Many
++algorithms in clause 25 are specified in terms of <tt>swappable</tt> which is essentially an
++overspecification as all they actually need is that any element in the sequence is <tt>swappable
++with</tt> any other element in the sequence.
++</p>
++
++<p>
++At this point Howard joins the discussion and points out that the intent of introducing the
++two swap-related terms was to support <tt>vector&lt;bool&gt;::reference</tt> types, and we are
++reading something into the wording that was never intended. Consuses is that regardless of
++the intent, that is what the words today say.
++</p>
++
++<p>
++There is some support to see a paper reviewing the whole of clause 25 for this issue, and
++other select clauses as may be necessary.
++</p>
++
++<p>
++There was some consideration to introducing a note into the front of clause 25 to indicate
++<tt>swappable</tt> requirements in the clause should be interpreted to allow such awkward
++types, but ultimately no real enthusiasm for introducing a <tt>swappable for clause 25</tt>
++requirement term, especially if it confusingly had the same name as a term used with a
++subtly different meaning through the rest of the standard.
++</p>
++
++<p>
++There was no enthusiasm for the alternate resolution of requiring containers with unequal
++allocators that do not propagate provide a well-defined swap behavior, as it is not
++believed to be possible without giving <tt>swap</tt> linear complexity for such values,
++and even then would require adding the constraint that the container element types are
++CopyConstructible.
++</p>
++
++<p>
++Final conclusion: move to open pending a paper from a party with a strong interest in
++stateful allocators.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2153"></a>2153. Narrowing of the non-member <tt>swap</tt> contract</h3>
++<p><b>Section:</b> 20.2.2 [utility.swap], 17.6.3.2 [swappable.requirements], 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Robert Shearer <b>Opened:</b> 2012-04-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Sub-clause 20.2.2 [utility.swap] defines a non-member 'swap' function with defined behavior for
++all <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> types. It does not guarantee
++constant-time complexity or <tt>noexcept</tt> in general, however this definition does
++render all objects of <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> type swappable
++(by the unary definition of sub-clause 17.6.3.2 [swappable.requirements]) in the absence of
++specializations or overloads.
++<p/>
++The overload of the non-member <tt>swap</tt> function defined in Table 96, however,
++defines semantics incompatible with the generic non-member <tt>swap</tt> function,
++since it is defined to call a member <tt>swap</tt> function whose semantics are
++undefined for some values of <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> types.
++<p/>
++The obvious (perhaps naive) interpretation of sub-clause 17.6.3.2 [swappable.requirements] is as a guide to
++the "right" semantics to provide for a non-member <tt>swap</tt> function (called in
++the context defined by 17.6.3.2 [swappable.requirements] p3) in order to provide interoperable
++user-defined types for generic programming. The standard container types don't follow these guidelines.
++<p/>
++More generally, the design in the standard represents a classic example of "contract narrowing". It
++is entirely reasonable for the contract of a particular <tt>swap</tt> overload to provide <em>more</em>
++guarantees, such as constant-time execution and <tt>noexcept</tt>, than are provided by the <tt>swap</tt>
++that is provided for any <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> types, but it is <em>not</em>
++reasonable for such an overload to fail to live up to the guarantees it provides for general types when
++it is applied to more specific types. Such an overload or specialization in generic programming is akin
++to an override of an inherited virtual function in OO programming: violating a superclass contract in a
++subclass may be legal from the point of view of the language, but it is poor design and can easily lead
++to errors. While we cannot prevent user code from providing overloads that violate the more general
++<tt>swap</tt> contract, we can avoid doing so within the library itself.
++<p/>
++My proposed resolution is to draw a sharp distinction between member <tt>swap</tt> functions, which provide
++optimal performance but idiosyncratic contracts, and non-member <tt>swap</tt> functions, which should always
++fulfill at least the contract of 20.2.2 [utility.swap] and thus render objects swappable. The member
++<tt>swap</tt> for containers with non-propagating allocators, for example, would offer constant-time
++guarantees and <tt>noexcept</tt> but would only offer defined behavior for values with allocators that compare
++equal; non-member <tt>swap</tt> would test allocator equality and then dispatch to either member <tt>swap</tt> or
++<tt>std::swap</tt> depending on the result, providing defined behavior for all values (and rendering the type
++"swappable"), but offering neither the constant-time nor the <tt>noexcept</tt> guarantees.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++This topic deserves more attention than can be given in the telocon, and there is no proposed resolution.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2154"></a>2154. What exactly does compile-time complexity imply?</h3>
++<p><b>Section:</b> 26.5.1.3 [rand.req.urng] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> John Salmon <b>Opened:</b> 2012-04-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.urng">issues</a> in [rand.req.urng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The expressions <tt>G::min()</tt> and <tt>G::max()</tt> in Table 116 in 26.5.1.3 [rand.req.urng] are specified
++as having "compile-time" complexity.
++<p/>
++It is not clear what, exactly, this requirement implies. If a URNG has a method:
++</p>
++<blockquote><pre>
++static int min();
++</pre></blockquote>
++<p>
++then is the method required to have a <tt>constexpr</tt> qualifier? I believe the standard would benefit from
++clarification of this point.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2155"></a>2155. Macro <tt>__bool_true_false_are_defined</tt> should be removed</h3>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2012-04-30 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Since C99, the C standard describes a macro named <tt>__bool_true_false_are_defined</tt>.
++<p/>
++In the process of harmonizing C++11 with C99, this name became part of the C++ standard.
++<p/>
++I propose that all mention of this name should be removed from the C and C++ standards.
++<p/>
++Here's the problem: The name was originally proposed as a transition tool, so that the headers for a
++project could contain lines like the following.
++</p>
++<blockquote><pre>
++#if !defined(__bool_true_false_are_defined)
++#define bool int /* or whatever */
++#define true 1
++#define false 0
++#endif
++</pre></blockquote>
++<p>
++Then when the project was compiled by a "new" compiler that implemented <tt>bool</tt> as defined by the
++evolving C++98 or C99 standards, those lines would be skipped; but when compiled by an "old" compiler that
++didn't yet provide <tt>bool</tt>, <tt>true</tt>, and <tt>false</tt>, then the <tt>#define</tt>'s would provide a
++simulation that worked for most purposes.
++<p/>
++It turns out that there is an unfortunate ambiguity in the name. One interpretation is as shown above, but
++a different reading says "bool, true, and false are #define'd", i.e. that the meaning of the macro is to
++assert that these names are macros (not built-in) ... which is true in C, but not in C++.
++<p/>
++In C++11, the name appears in parentheses followed by a stray period, so
++some editorial change is needed in any event:
++<p/>
++18.10 [support.runtime] para 1:
++</p>
++<blockquote><p>
++Headers <tt>&lt;csetjmp&gt;</tt> (nonlocal jumps), <tt>&lt;csignal&gt;</tt> (signal handling), <tt>&lt;cstdalign&gt;</tt>
++(alignment), <tt>&lt;cstdarg&gt;</tt> (variable arguments), <tt>&lt;cstdbool&gt;</tt> (<tt>__bool_true_false_are_defined</tt>).
++<tt>&lt;cstdlib&gt;</tt> (runtime environment <tt>getenv()</tt>, <tt>system()</tt>), and <tt>&lt;ctime&gt;</tt>
++(system clock <tt>clock()</tt>, <tt>time()</tt>) provide further compatibility with C code.
++</p></blockquote>
++<p>
++However, para 2 says
++</p>
++<blockquote><p>
++"The contents of these headers are the same as the Standard C library headers <tt>&lt;setjmp.h&gt;</tt>,
++<tt>&lt;signal.h&gt;</tt>, <tt>&lt;stdalign.h&gt;</tt>, <tt>&lt;stdarg.h&gt;</tt>, <tt>&lt;stdbool.h&gt;</tt>,
++<tt>&lt;stdlib.h&gt;</tt>, and <tt>&lt;time.h&gt;</tt>, respectively, with the following
++changes:",
++</p></blockquote>
++<p>
++and para 8 says
++</p>
++<blockquote><p>
++"The header <tt>&lt;cstdbool&gt;</tt> and the header <tt>&lt;stdbool.h&gt;</tt> shall
++not define macros named <tt>bool</tt>, <tt>true</tt>, or <tt>false</tt>."
++</p></blockquote>
++<p>
++Thus para 8 doesn't exempt the C++ implementation from the arguably clear requirement of the C standard, to
++provide a macro named <tt>__bool_true_false_are_defined</tt> defined to be 1.
++<p/>
++Real implementations of the C++ library differ, so the user cannot count upon any consistency; furthermore, the
++usefulness of the transition tool has faded long ago.
++<p/>
++That's why my suggestion is that both C and C++ standards should eliminate any mention of
++<tt>__bool_true_false_are_defined</tt>. In that case, the name belongs to implementers to provide, or not, as
++they choose.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++While not strictly necessary, the clean-up look good.
++</p>
++<p>
++We would like to hear from our C liaison before moving on this issue though.
++</p>
++
++<p><i>[2015-05 Lenexa]</i></p>
++
++<p>
++LWG agrees. Jonathan provides wording.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li>
++<p>Edit the footnote on 17.6.1.2 [headers] p7:</p>
++<blockquote>
++<p>
++176) In particular, including <ins>any of</ins> the standard header<ins>s <tt>&lt;stdbool.h&gt;</tt>, <tt>&lt;cstdbool&gt;</tt>,</ins> <tt>&lt;iso646.h&gt;</tt> or <tt>&lt;ciso646&gt;</tt> has no effect.
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>Edit 18.10 [support.runtime] p1 as indicated (and remove the index entry for <tt>__bool_true_false_are_defined</tt>):</p>
++
++<blockquote>
++<p>
++-1- Headers <tt>&lt;csetjmp&gt;</tt> (nonlocal jumps), <tt>&lt;csignal&gt;</tt> (signal handling), <tt>&lt;cstdalign&gt;</tt> (alignment), <tt>&lt;cstdarg&gt;</tt> (variable arguments), <tt>&lt;cstdbool&gt;</tt><ins>,</ins><del> (<tt>__bool_true_false_are_defined</tt>).</del> <tt>&lt;cstdlib&gt;</tt> (runtime environment <tt>getenv()</tt>, <tt>system()</tt>), and <tt>&lt;ctime&gt;</tt> (system clock <tt>clock()</tt>, <tt>time()</tt>) provide further compatibility with C code.
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>Remove Table 38 &mdash; Header <tt>&lt;cstdbool&gt;</tt> synopsis [tab:support.hdr.cstdbool] from 18.10 [support.runtime] </p>
++<blockquote>
++<table border="1">
++<caption> Table 38 &mdash; Header <tt>&lt;cstdbool&gt;</tt> synopsis </caption>
++<tr><td><b>Type</b></td><td><b>Name(s)</b></td></tr>
++<tr><td><b>Macro:</b></td><td><tt>__bool_true_false_are_defined</tt></td></tr>
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2156"></a>2156. Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel James <b>Opened:</b> 2012-05-07 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++I think that unordered containers' <tt>reserve</tt> doesn't quite do what it should. I'd expect after calling
++<tt>x.reserve(n)</tt> to be able to insert <tt>n</tt> elements without invalidating iterators. But as
++the standard is written (I'm looking at n3376), I think the guarantee only holds for <tt>n-1</tt> elements.
++<p/>
++For a container with <tt>max_load_factor</tt> of <tt>1</tt>, <tt>reserve(n)</tt> is equivalent to
++<tt>rehash(ceil(n/1))</tt>, ie. <tt>rehash(n)</tt>. <tt>rehash(n)</tt> requires that the bucket
++count is <tt>&gt;= n</tt>, so it can be <tt>n</tt> (Table 103). The rule is that <tt>insert</tt>
++shall not affect the validity of iterators if <tt>(N + n) &lt; z * B</tt> (23.2.5 [unord.req] p15).
++But for this case the two sides of the equation are equal, so <tt>insert</tt> can affect the validity of iterators.
++</p>
++
++<p><i>[2013-03-16 Howard comments and provides wording]</i></p>
++
++
++<p>
++Given the following:
++</p>
++
++<blockquote><pre>
++LF := load_factor()
++MLF := max_load_factor()
++S := size()
++B := bucket_count()
++
++LF == S/B
++</pre></blockquote>
++
++<p>
++The container has an invariant:
++</p>
++
++<blockquote><pre>
++LF &lt;= MLF
++</pre></blockquote>
++
++<p>
++Therefore:
++</p>
++
++<blockquote><pre>
++MLF &gt;= S/B
++S &lt;= MLF * B
++B &gt;= S/MLF
++</pre></blockquote>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Howard to provide rationale and potentally revised wording.
++</p>
++
++
++<p><i>[2012-02-12 Issaquah : recategorize as P3]</i></p>
++
++<p>
++Jonathon Wakely: submitter is Boost.Hash maintainer. Think it's right.
++</p>
++
++<p>
++Marshall Clow: even if wrong it's more right than what we have now
++</p>
++
++<p>
++Geoffrey Romer: issue is saying rehash should not leave container in such a state that a notional insertion of zero elements should not trigger a rehash
++</p>
++
++<p>
++AJM: e.g. if you do a range insert from an empty range
++</p>
++
++<p>
++AJM: we don't have enough brainpower to do this now, so not priority zero
++</p>
++
++<p>
++Recategorised as P3
++</p>
++
++<p><i>[Lenexa 2015-05-06: Move to Ready]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li>
++<p>
++In 23.2.5 [unord.req] Table 103 &mdash; Unordered associative container requirements, change the post-condition
++in the row for <code>a.rehash(n)</code> to:
++</p>
++<blockquote>
++Post: <code>a.bucket_count() &gt;<ins>=</ins> a.size() / a.max_load_factor()</code> and <code>a.bucket_count() &gt;= n</code>.
++</blockquote>
++</li>
++
++<li>
++<p>
++In 23.2.5 [unord.req]/p15 change
++</p>
++<blockquote>
++The <code>insert</code> and <code>emplace</code> members shall not affect the validity of iterators if
++<code>(N+n) &lt;<ins>=</ins> z * B</code>, where <code>N</code> is the number of elements in the container
++prior to the insert operation, <code>n</code> is the number of elements inserted, <code>B</code> is the container's
++bucket count, and <code>z</code> is the container's maximum load factor.
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2157"></a>2157. How does <tt>std::array&lt;T,0&gt;</tt> initialization work when <tt>T</tt> is not default-constructible?</h3>
++<p><b>Section:</b> 23.3.2.8 [array.zero] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daryle Walker <b>Opened:</b> 2012-05-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#array.zero">issues</a> in [array.zero].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Objects of <tt>std::array&lt;T,N&gt;</tt> are supposed to be initialized with aggregate initialization (when
++not the destination of a copy or move). This clearly works when <tt>N</tt> is positive. What happens when <tt>N</tt>
++is zero? To continue using an (inner) set of braces for initialization, a <tt>std::array&lt;T,0&gt;</tt> implementation
++must have an array member of at least one element, and let default initialization take care of those secret elements.
++This cannot work when <tt>T</tt> has a set of constructors and the default constructor is deleted from that set.
++Solution: Add a new paragraph in 23.3.2.8 [array.zero]:
++</p>
++<blockquote><p>
++The unspecified internal structure of array for this case shall allow initializations like:
++</p>
++<blockquote><pre>
++array&lt;T, 0&gt; a = { };
++</pre></blockquote>
++<p>
++and said initializations must be valid even when <tt>T</tt> is not default-constructible.
++</p></blockquote>
++
++<p><i>[2012, Portland: Move to Open]</i></p>
++
++<p>
++Some discussion to understand the issue, which is that implementations currently have freedom to implement
++an empty <tt>array</tt> by holding a dummy element, and so might not support value initialization, which is
++surprising when trying to construct an empty container. However, this is not mandated, it is an unspecified
++implementation detail.
++</p>
++
++<p>
++Jeffrey points out that the implication of 23.3.2.1 [array.overview] is that this initialization syntax
++must be supported by empty <tt>array</tt> objects already. This is a surprising inference that was not
++obvious to the room, but consensus is that the reading is accurate, so the proposed resolution is not necessary,
++although the increased clarity may be useful.
++</p>
++
++<p>
++Further observation is that the same clause effectively implies that <tt>T</tt> must always be DefaultConstructible,
++regardless of <tt>N</tt> for the same reasons - as an <i>initializer-list</i> may not supply enough values, and the
++remaining elements must all be value initialized.
++</p>
++
++<p>
++Concern that we are dancing angels on the head of pin, and that relying on such subtle implications in wording is
++not helpful. We need a clarification of the text in this area, and await wording.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++DK: What was the outcome of Portland? AM: Initially we thought we already had the intended behaviour.
++We concluded that <tt>T</tt> must always be <tt>DefaultConstructible</tt>, but I'm not sure why. GR: It's p2 in
++<tt>std::array</tt>, "up to <tt>N</tt>". AM: That wording already implies that "<tt>{}</tt>" has to work when <tt>N</tt>
++is zero. But the wording of p2 needs to be fixed to make clear that it does <em>not</em> imply that <tt>T</tt> must be
++<tt>DefaultConstructible</tt>.
++<p/>
++Conclusion: Update wording, revisit later.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<p>Add the following new paragraph between the current 23.3.2.8 [array.zero] p1 and p2:</p>
++
++<blockquote><p>
++-1- <tt>array</tt> shall provide support for the special case <tt>N == 0</tt>.
++<p/>
++<ins>-?- The unspecified internal structure of <tt>array</tt> for this case shall allow initializations like:</ins>
++</p>
++<blockquote><pre>
++<ins>array&lt;T, 0&gt; a = { };</ins>
++</pre></blockquote>
++<p>
++<ins>and said initializations must be valid even when <tt>T</tt> is not default-constructible.</ins>
++<p/>
++-2- In the case that <tt>N == 0</tt>, <tt>begin() == end() ==</tt> unique value. The return value of
++<tt>data()</tt> is unspecified.
++<p/>
++-3- The effect of calling <tt>front()</tt> or <tt>back()</tt> for a zero-sized array is undefined.
++<p/>
++-4- Member function <tt>swap()</tt> shall have a <em>noexcept-specification</em> which is equivalent to
++<tt>noexcept(true)</tt>.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2158"></a>2158. Conditional copy&#47;move in <tt>std::vector</tt></h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2012-05-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++There are various operations on <tt>std::vector</tt> that can cause elements of the vector to be
++moved from one location to another. A move operation can use either rvalue or const lvalue as
++argument; the choice depends on the value of <tt>!is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp;
++is_copy_constructible&lt;T&gt;::value</tt>, where <tt>T</tt> is the element type. Thus, some operations
++on <tt>std::vector</tt> (e.g. 'resize' with single parameter, 'reserve', 'emplace_back') should have
++conditional requirements. For example, let's consider the requirement for 'reserve' in N3376 &ndash;
++23.3.6.3 [vector.capacity]&#47;2:
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++</p></blockquote>
++<p>
++This requirement is not sufficient if an implementation is free to select copy constructor when
++<tt>!is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; is_copy_constructible&lt;T&gt;::value</tt>
++evaluates to true. Unfortunately, <tt>is_copy_constructible</tt> cannot reliably determine whether
++<tt>T</tt> is really copy-constructible. A class may contain public non-deleted copy constructor whose
++definition does not exist or cannot be instantiated successfully (e.g.,
++<tt>std::vector&lt;std::unique_ptr&lt;int&gt;&gt;</tt> has copy constructor, but this type is not
++copy-constructible). Thus, the actual requirements should be:
++</p>
++<ul>
++<li><p>
++if <tt>!is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; is_copy_constructible&lt;T&gt;::value</tt>
++then <tt>T</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>;
++</p></li>
++<li><p>
++otherwise <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++</p></li>
++</ul>
++<p>
++Maybe it would be useful to introduce a new name for such conditional requirement (in addition to
++"<tt>CopyInsertable</tt>" and "<tt>MoveInsertable</tt>").
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2161"></a>2161. <tt>const</tt> equivalence of <tt>std::map</tt></h3>
++<p><b>Section:</b> 23.4 [associative], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Bjarne Stroustrup <b>Opened:</b> 2012-06-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative">active issues</a> in [associative].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative">issues</a> in [associative].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++As described in the reflector discussion c++std-core-21860 consider the following example:
++</p>
++<blockquote><pre>
++map&lt;const int, int&gt; mci{};
++map&lt;int, int&gt; mi = mci; // ??
++mci[1] = 2;
++mi[1] = 2;
++</pre></blockquote>
++<p>
++Should it be required that the marked initialization is well-formed? As a possible solution
++this could be realized by an alias template:
++</p>
++<blockquote><pre>
++template &lt;class K, class T&gt;
++struct OriginalMap { [&hellip;] };
++
++template &lt;class K, class T&gt;
++using ImprovedMap = OriginalMap&lt;const K, T&gt;;
++</pre></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2164"></a>2164. What are the semantics of <tt>vector.emplace(vector.begin(), vector.back())</tt>?</h3>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers], 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2012-07-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Nikolay Ivchenkov recently brought the following example on the
++<a href="https://groups.google.com/a/isocpp.org/d/topic/std-discussion/dhy23mDFXj4/discussion">std-discussion</a>
++newsgroup, asking whether the following program well-defined:
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;vector&gt;
++
++int main()
++{
++ std::vector&lt;int&gt; v;
++ v.reserve(4);
++ v = { 1, 2, 3 };
++ v.emplace(v.begin(), v.back());
++ for (int x : v)
++ std::cout &lt;&lt; x &lt;&lt; std::endl;
++}
++</pre></blockquote>
++<p>
++Nikolay Ivchenkov:
++<p/>
++I think that an implementation of <tt>vector</tt>'s 'emplace' should initialize an intermediate object with
++<tt>v.back()</tt> before any shifts take place, then perform all necessary shifts and finally replace the
++value pointed to by <tt>v.begin()</tt> with the value of the intermediate object. So, I would expect the
++following output:
++</p>
++<blockquote><pre>
++3
++1
++2
++3
++</pre></blockquote>
++<p>
++GNU C++ 4.7.1 and GNU C++ 4.8.0 produce other results:
++</p>
++<blockquote><pre>
++2
++1
++2
++3
++</pre></blockquote>
++<p>
++Howard Hinnant:
++<p/>
++I believe Nikolay is correct that vector should initialize an intermediate object with <tt>v.back()</tt>
++before any shifts take place. As Nikolay pointed out in another email, this appears to be the only way to
++satisfy the strong exception guarantee when an exception is not thrown by <tt>T</tt>'s copy constructor,
++move constructor, copy assignment operator, or move assignment operator as specified by
++23.3.6.5 [vector.modifiers]/p1. I.e. if the emplace construction throws, the vector must remain unaltered.
++<p/>
++That leads to an implementation that tolerates objects bound to the function parameter pack of the <tt>emplace</tt>
++member function may be elements or sub-objects of elements of the container.
++<p/>
++My position is that the standard is correct as written, but needs a clarification in this area. Self-referencing
++<tt>emplace</tt> should be legal and give the result Nikolay expects. The proposed resolution of LWG <a href="lwg-active.html#760">760</a>
++is not correct.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++LWG agrees with the analysis including the assessment of LWG <a href="lwg-active.html#760">760</a> and would appreciate a concrete wording proposal.
++</p>
++
++<p><i>[2015-04-07 dyp comments]</i></p>
++
++<p>
++The Standard currently does not require that creation of such
++intermediate objects is legal. 23.2.3 [sequence.reqmts] Table 100
++&mdash; "Sequence container requirements" currently specifies:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 100 &mdash; Sequence container requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.emplace(p, args);</tt>
++</td>
++<td>
++<tt>iterator</tt>
++</td>
++<td>
++<i>Requires</i>: <tt>T</tt> is <tt>EmplaceConstructible</tt> into
++<tt>X</tt> from <tt>args</tt>. For <tt>vector</tt> and <tt>deque</tt>,
++<tt>T</tt> is also <tt>MoveInsertable</tt> into <tt>X</tt> and
++<tt>MoveAssignable</tt>. [&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++<p>
++The <tt>EmplaceConstructible</tt> concept is defined via
++<tt>allocator_traits&lt;A&gt;::construct</tt> in 23.2.1 [container.requirements.general] p15.5 That's surprising to me
++since the related concepts use the suffix <tt>Insertable</tt> if they
++refer to the allocator. An additional requirement such as
++<tt>std::is_constructible&lt;T, Args...&gt;</tt> is necessary to allow
++creation of intermediate objects.
++</p>
++
++<p>
++The creation of intermediate objects also affects other functions, such
++as <tt>vector.insert</tt>. Since aliasing the vector is only allowed for
++the single-element forms of <tt>insert</tt> and <tt>emplace</tt> (see
++<a href="lwg-closed.html#526">526</a>), the range-forms are not affected. Similarly,
++aliasing is not allowed for the rvalue-reference overload. See also LWG
++<a href="lwg-defects.html#2266">2266</a>.
++</p>
++
++<p>
++There might be a problem with a requirement of
++<tt>std::is_constructible&lt;T, Args...&gt;</tt> related to the issues
++described in LWG <a href="lwg-active.html#2461">2461</a>. For example, a scoped allocator
++adapter passes additional arguments to the constructor of the value
++type. This is currently not done in recent implementations of libstdc++
++and libc++ when creating the intermediate objects, they simply create
++the intermediate object by perfectly forwarding the arguments. If such
++an intermediate object is then moved to its final destination in the
++vector, a change of the allocator instance might be required &mdash;
++potentially leading to an expensive copy. One can also imagine worse
++problems, such as run-time errors (allocators not comparing equal at
++run-time) or compile-time errors (if the value type cannot be created
++without the additional arguments). I have not looked in detail into this
++issue, but I'd be reluctant adding a requirement such as
++<tt>std::is_constructible&lt;T, Args...&gt;</tt> without further
++investigation.
++</p>
++
++<p>
++It should be noted that the creation of intermediate objects currently
++is inconsistent in libstdc++ vs libc++. For example, libstdc++ creates
++an intermediate object for <tt>vector.insert</tt>, but not
++<tt>vector.emplace</tt>, whereas libc++ does the exact opposite in this
++respect.
++</p>
++
++<p>
++A live demo of the inconsistent creation of intermediate objects can be
++found <a href="http://coliru.stacked-crooked.com/a/449253d3d329ef4c">here</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2165"></a>2165. <tt>std::atomic&lt;X&gt;</tt> requires <tt>X</tt> to be nothrow default constructible</h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic], 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Core">Core</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-07-19 <b>Last modified:</b> 2015-04-09</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Core">Core</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++As raised in c++std-lib-32781, this fails to compile even though the default constructor is not used:
++</p>
++<blockquote><pre>
++#include &lt;atomic&gt;
++
++struct X {
++ X() noexcept(false) {}
++ X(int) { }
++};
++
++std::atomic&lt;X&gt; x(3);
++</pre></blockquote>
++<p>This is because <tt>atomic&lt;T&gt;</tt>'s default constructor is declared to be non-throwing and
++is explicitly-defaulted on its first declaration:
++</p>
++<blockquote><pre>
++atomic() noexcept = default;
++</pre></blockquote>
++<p>
++This is ill-formed if the implicitly-declared default constructor would not be non-throwing.
++<p/>
++Possible solutions:
++</p>
++<ol>
++<li>
++Add nothrow default constructible to requirements for template argument of the generic <tt>atomic&lt;T&gt;</tt>
++</li>
++<li>
++Remove <tt>atomic&lt;T&gt;::atomic()</tt> from the overload set if <tt>T</tt> is not nothrow default constructible.
++</li>
++<li>
++Remove <tt>noexcept</tt> from <tt>atomic&lt;T&gt;::atomic()</tt>, allowing it to be
++deduced (but the default constructor is intended to be always noexcept)
++</li>
++<li>
++Do not default <tt>atomic&lt;T&gt;::atomic()</tt> on its first declaration (but makes the default constructor
++user-provided and so prevents <tt>atomic&lt;T&gt;</tt> being trivial)
++</li>
++<li>
++A core change to allow the mismatched exception specification if the default constructor isn't used
++(see c++std-core-21990)
++</li>
++</ol>
++
++<p><i>[2012, Portland: move to Core]</i></p>
++
++<p>
++Recommend referring to core to see if the constructor <tt>noexcept</tt> mismatch
++can be resolved there. The issue is not specific to concurrency.
++</p>
++
++<p><i>[2015-04-09 Daniel comments]</i></p>
++
++<p>
++CWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1778">1778</a>, which had
++been created in behalf of this LWG issue, has been resolved as a defect.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2166"></a>2166. Heap property underspecified?</h3>
++<p><b>Section:</b> 25.4.6 [alg.heap.operations] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Peter Sommerlad <b>Opened:</b> 2012-07-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.heap.operations">issues</a> in [alg.heap.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Another similar issue to the <tt>operator&lt;</tt> vs greater in <tt>nth_element</tt> but not as direct occurs
++in 25.4.6 [alg.heap.operations]:
++</p>
++<blockquote><p>
++-1- A <em>heap</em> is a particular organization of elements in a range between two random access iterators
++<tt>[a,b)</tt>. Its two key properties are:
++</p>
++<ol>
++<li>There is no element greater than <tt>*a</tt> in the range and
++</li>
++<li><tt>*a</tt> may be removed by <tt>pop_heap()</tt>, or a new element added by <tt>push_heap()</tt>, in
++O(log(<tt>N</tt>)) time.
++</li>
++</ol>
++</blockquote>
++<p>
++As noted by Richard Smith, it seems that the first bullet should read:
++</p>
++<blockquote><p>
++<tt>*a</tt> is not less than any element in the range
++</p></blockquote>
++<p>
++Even better the heap condition could be stated here directly, instead of leaving it unspecified, i.e.,
++</p>
++<blockquote><p>
++Each element at <tt>(a+2*i+1)</tt> and <tt>(a+2*i+2)</tt> is less than the element at <tt>(a+i)</tt>,
++if those elements exist, for <tt>i&gt;=0</tt>.
++</p></blockquote>
++<p>
++But may be that was may be intentional to allow other heap organizations?
++<p/>
++See also follow-up discussion of c++std-lib-32780.
++<p/>
++
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2173"></a>2173. The meaning of operator + in the description of the algorithms</h3>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2012-08-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 25.1 [algorithms.general]/12,
++</p>
++<blockquote><p>
++In the description of the algorithms operators <tt>+</tt> and <tt>-</tt> are used for some of the iterator categories
++for which they do not have to be defined. In these cases the semantics of <tt>a+n</tt> is the same as that of
++</p>
++<blockquote><pre>
++X tmp = a;
++advance(tmp, n);
++return tmp;
++</pre></blockquote>
++</blockquote>
++<p>
++There are several places where such operator <tt>+</tt> is applied to an output iterator &mdash; for example, see the
++description of <tt>std::copy</tt>:
++</p>
++<blockquote><pre>
++template&lt;class InputIterator, class OutputIterator&gt;
++OutputIterator copy(InputIterator first, InputIterator last,
++ OutputIterator result);
++</pre>
++<blockquote><p>
++-1- <i>Effects</i>: Copies elements in the range <tt>[first,last)</tt> into the range <tt>[result,result + (last -
++first))</tt> starting from <tt>first</tt> and proceeding to <tt>last</tt>. For each non-negative integer
++<tt>n &lt; (last - first)</tt>, performs <tt>*(result + n) = *(first + n)</tt>.
++</p></blockquote></blockquote>
++<p>
++<tt>std::advance</tt> is not supposed to be applicable to output iterators, so we need a different method of description.
++<p/>
++See also message <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32908">c++std-lib-32908</a>.
++</p>
++
++<p><i>[2014-06-07 Daniel comments and provides wording]</i></p>
++
++<p>
++The specification for output iterators is somewhat tricky, because here a sequence of increments is required to
++be combined with intervening <em>assignments</em> to the dereferenced iterator. I tried to respect this
++fact by using a conceptual assignment operation as part of the specification.
++<p/>
++Another problem in the provided as-if-code is the question which requirements are imposed on <tt>n</tt>. Unfortunately,
++the corresponding function <tt>advance</tt> is completely underspecified in this regard, so I couldn't borrow wording
++from it. We cannot even assume here that <tt>n</tt> is the difference type of the iterator, because for output iterators there is
++no requirements for this associated type to be defined. The presented wording attempts to minimize assumptions, but still
++can be considered as controversial.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 25.1 [algorithms.general] around p12 as indicated:</p>
++
++<blockquote>
++<p>
++-12- In the description of the algorithms operators <tt>+</tt> and <tt>-</tt> are used for some of the iterator categories for which
++they do not have to be defined. In these cases the semantics of <tt>a+n</tt> is the same as that of
++</p>
++<blockquote>
++<pre>
++X tmp = a;
++advance(tmp, n);
++return tmp;
++</pre>
++</blockquote>
++<p>
++<ins>when <tt>X</tt> meets the input iterator requirements (24.2.3 [input.iterators]), otherwise it is the same as that of</ins>
++</p>
++<blockquote>
++<pre>
++<ins>X tmp = a;
++for (auto i = n; i; ++tmp, (void) --i)
++ *tmp = <i>Expr</i>(i);
++return tmp;</ins>
++</pre>
++</blockquote>
++<p>
++<ins>where <tt><i>Expr</i>(i)</tt> denotes the <tt>n-i</tt>-th expression that is assigned to for the corresponding algorithm;</ins>
++and that of <tt>b-a</tt> is the same as of
++</p>
++<blockquote>
++<pre>
++return distance(a, b);
++</pre>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2178"></a>2178. <tt>Allocator</tt> requirement changes not mentioned Annex C</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], C.5 [diff.library] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Nevin Liber <b>Opened:</b> 2012-08-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Given that a number of things were removed from the allocator requirements (<tt>reference</tt>, <tt>const_reference</tt>,
++<tt>address()</tt> in 17.6.3.5 [allocator.requirements]), it seems that these incompatible changes should be
++mentioned in Annex C.5 [diff.library], more specifically in [diff.cpp03].
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Open
++]</i></p>
++
++
++<p>
++It was clearly pointed out by Bill during the C++11 process that our change to allocator requirements
++potentially broke 3rd party user containers written to expect C++03 allocators, or rather, an
++allocator written to the minimal requirements of C++11 might not be guaranteed to work with a container
++written to the previous rules. This was a trade-off in making allocaters easier to write by use of
++the <tt>allocator_traits</tt> framework.
++</p>
++
++<p>
++This probably does merit a write-up in Annex C, and we look forward to seeing wording. Until then,
++the best we can do is move the issue to Open.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2179"></a>2179. <tt>enable_shared_from_this</tt> and construction from raw pointers</h3>
++<p><b>Section:</b> 20.8.2.5 [util.smartptr.enab], 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-08-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++On reflector message <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32927">c++std-lib-32927</a>,
++Matt Austern asked whether the following example should be well-defined or not
++</p>
++<blockquote><pre>
++struct X : public enable_shared_from_this&lt;X&gt; { };
++auto xraw = new X;
++shared_ptr&lt;X&gt; xp1(xraw);
++shared_ptr&lt;X&gt; xp2(xraw);
++</pre></blockquote>
++<p>
++pointing out that 20.8.2.2.1 [util.smartptr.shared.const] does not seem to allow it, since
++<tt>xp1</tt> and <tt>xp2</tt> aren't allowed to share ownership, because each of them is required to have
++<tt>use_count() == 1</tt>. Despite this wording it might be reasonable (and technical possible)
++to implement that request.
++<p/>
++On the other hand, there is the non-normative note in 20.8.2.5 [util.smartptr.enab] p11 (already part of TR1):
++</p>
++<blockquote><p>
++The <tt>shared_ptr</tt> constructors that <span style="color:#C80000;font-weight:bold">create unique pointers</span>
++can detect the presence of an <tt>enable_shared_from_this</tt> base and assign the newly created <tt>shared_ptr</tt>
++to its <tt>__weak_this member</tt>.
++</p></blockquote>
++<p>
++Now according to the specification in 20.8.2.2.1 [util.smartptr.shared.const] p3-7:
++</p>
++<blockquote><pre>
++template&lt;class Y&gt; explicit shared_ptr(Y* p);
++</pre></blockquote>
++<p>
++the notion of <em>creating unique pointers</em> can be read to be included by this note, because the post-condition
++of this constructor is <tt>unique() == true</tt>. Evidence for this interpretation seems to be weak, though.
++<p/>
++Howard Hinnant presented the counter argument, that actually the following is an "anti-idiom" and it seems questionable
++to teach it to be well-defined in any case:
++</p>
++<blockquote><pre>
++auto xraw = new X;
++shared_ptr&lt;X&gt; xp1(xraw);
++shared_ptr&lt;X&gt; xp2(xraw);
++</pre></blockquote>
++<p>
++He also pointed out that the current post-conditions of the affected <tt>shared_ptr</tt> constructor
++would need to be reworded.
++<p/>
++It needs to be decided, which direction to follow. If this idiom seems too much broken to be supported,
++the note could be improved. If it should be supported, the constructors in
++20.8.2.2.1 [util.smartptr.shared.const] need a careful analysis to ensure that post-conditions
++are correct.
++<p/>
++Several library implementations currently do not support this example, instead they typically
++cause a crash. Matt points out that there are currently no explicit requirements imposed on
++<tt>shared_ptr</tt> objects to prevent them from owning the same underlying object without sharing the
++ownership. It might be useful to add such a requirement.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++More discussion is needed to pick a direction to guide a proposed resolution.
++</p>
++
++<p><i>[2013-05-09 Jonathan comments]</i></p>
++
++<p>
++The note says the newly created <tt>shared_ptr</tt> is assigned to the <tt>weak_ptr</tt> member. It doesn't
++say before doing that the <tt>shared_ptr</tt> should check if the <tt>weak_ptr</tt> is non-empty and possibly
++share ownership with some other pre-existing <tt>shared_ptr</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2181"></a>2181. Exceptions from <em>seed sequence</em> operations</h3>
++<p><b>Section:</b> 26.5.1.2 [rand.req.seedseq], 26.5.3 [rand.eng], 26.5.4 [rand.adapt] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-08-18 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.seedseq">issues</a> in [rand.req.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++LWG issue <a href="lwg-defects.html#2180">2180</a> points out some deficiences in regard to the specification of the library-provided
++type <tt>std::seed_seq</tt> regarding exceptions, but there is another specification problem
++in regard to general types satisfying the <em>seed sequence</em> constraints (named <tt>SSeq</tt>) as described in
++26.5.1.2 [rand.req.seedseq].
++<p/>
++26.5.3 [rand.eng] p3 and 26.5.4.1 [rand.adapt.general] p3 say upfront:
++</p>
++<blockquote><p>
++Except where specified otherwise, no function described in this section
++26.5.3 [rand.eng]/26.5.4 [rand.adapt] throws an exception.
++</p></blockquote>
++<p>
++This constraint causes problems, because the described templates in these sub-clauses depend on operations of
++<tt>SSeq::generate()</tt> which is a function template, that depends both on operations provided by the
++implementor of <tt>SSeq</tt> (e.g. of <tt>std::seed_seq</tt>), and those of the random access iterator type
++provided by the caller. With class template <tt>linear_congruential_engine</tt> we have just one example for a user
++of <tt>SSeq::generate()</tt> via:
++</p>
++<blockquote><pre>
++template&lt;class Sseq&gt;
++linear_congruential_engine&lt;&gt;::linear_congruential_engine(Sseq&amp; q);
++
++template&lt;class Sseq&gt;
++void linear_congruential_engine&lt;&gt;::seed(Sseq&amp; q);
++</pre></blockquote>
++<p>
++None of these operations has an exclusion rule for exceptions.
++<p/>
++As described in <a href="lwg-defects.html#2180">2180</a> the wording for <tt>std::seed_seq</tt> should and can be fixed to ensure that
++operations of <tt>seed_seq::generate()</tt> won't throw except from operations of the provided iterator range,
++but there is no corresponding "safety belt" for user-provided <tt>SSeq</tt> types, since 26.5.1.2 [rand.req.seedseq]
++does not impose no-throw requirements onto operations of <em>seed sequences</em>.
++</p>
++
++<ol style="list-style-type:upper-roman">
++
++<li><p>
++A quite radical step to fix this problem would be to impose general no-throw requirements on the expression
++<tt>q.generate(rb,re)</tt> from Table 115, but this is not as simple as it looks initially, because this
++function again depends on general types that are mutable random access iterators. Typically, we do not
++impose no-throw requirements on iterator operations and this would restrict general seed sequences where
++exceptions are not a problem. Furthermore, we do not impose comparable constraints for other expressions,
++like that of the expression <tt>g()</tt> in Table 116 for good reasons, e.g. <tt>random_device::operator()</tt>
++explicitly states when it throws exceptions.
++</p></li>
++
++<li><p>
++A less radical variant of the previous suggestion would be to add a normative requirement on the expression
++<tt>q.generate(rb,re)</tt> from Table 115 that says: "Throws nothing if operations of <tt>rb</tt> and <tt>re</tt>
++do not throw exceptions". Nevertheless we typically do not describe <em>conditional</em> Throws elements in proper
++requirement sets elsewhere (Container requirements excluded, they just describe the containers from Clause 23)
++and this may exclude resonable implementations of seed sequences that could throw exceptions under rare
++situations.
++</p></li>
++
++<li><p>
++The iterator arguments provided to <tt>SSeq::generate()</tt> for operations in templates of 26.5.3 [rand.eng] and
++26.5.4 [rand.adapt] are under control of implementations, so we could impose stricter exceptions requirements
++on <tt>SSeq::generate()</tt> for <tt>SSeq</tt> types that are used to instantiate member templates in 26.5.3 [rand.eng]
++and 26.5.4 [rand.adapt] solely.
++</p></li>
++
++<li><p>
++We simply add extra wording to the introductive parts of 26.5.3 [rand.eng] and 26.5.4 [rand.adapt]
++that specify that operations of the engine (adaptor) templates that depend on a template parameter <tt>SSeq</tt>
++throw no exception unless <tt>SSeq::generate()</tt> throws an exception.
++</p></li>
++</ol>
++
++<p>
++Given these options I would suggest to apply the variant described in the fourth bullet.
++<p/>
++The proposed resolution attempts to reduce a lot of the redundancies of requirements in the introductory paragraphs of
++26.5.3 [rand.eng] and 26.5.4 [rand.adapt] by introducing a new intermediate sub-clause
++"Engine and engine adaptor class templates" following sub-clause 26.5.2 [rand.synopsis]. This approach also
++solves the problem that currently 26.5.3 [rand.eng] also describes requirements that apply for
++26.5.4 [rand.adapt] (Constrained templates involving the <tt>Sseq</tt> parameters).
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Remove the first bullet point:
++</p>
++<blockquote><p>
++?- Throughout this sub-clause general requirements and conventions are described that apply to every class
++template specified in sub-clause 26.5.3 [rand.eng] and 26.5.4 [rand.adapt]. Phrases of the form "in those
++sub-clauses" shall be interpreted as equivalent to "in sub-clauses 26.5.3 [rand.eng] and 26.5.4 [rand.adapt]".
++</p></blockquote>
++<p>
++Replace "in those sub-clauses" with "in sub-clauses 26.5.3 [rand.eng] and 26.5.4 [rand.adapt]".
++<p/>
++Find another place for the wording.
++<p/>
++Daniel: These are requirements on the implementation not on the types. I'm not comfortable in moving it to another place
++without double checking.
++<p/>
++Improve the text (there are 4 "for"s): <em>for</em> copy constructors, <em>for</em> copy assignment operators,
++<em>for</em> streaming operators, and <em>for</em> equality and inequality operators are not shown in the synopses.
++<p/>
++Move the information of this paragraph to the paragraphs it refers to:
++</p>
++<blockquote><p>
++"-?- Descriptions are provided in those sub-clauses only for engine operations that are not described in
++26.5.1.4 [rand.req.eng], for adaptor operations that are not described in 26.5.1.5 [rand.req.adapt], or for
++operations where there is additional semantic information. In particular, declarations for copy constructors, for
++copy assignment operators, for streaming operators, and for equality and inequality operators are not shown in the synopses."
++</p></blockquote>
++<p>
++Alisdair: I prefer duplication here than consolidation/reference to these paragraphs.
++<p/>
++The room showed weakly favjust or for duplication.
++</p>
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Add a new sub-clause titled "Engine and engine adaptor class templates" following sub-clause
++26.5.2 [rand.synopsis] (but at the same level) and add one further sub-clause "General" as
++child of the new sub-clause as follows:
++<p/>
++<ins>Engine and engine adaptor class templates [rand.engadapt]</ins>
++<p/>
++<ins>General [rand.engadapt.general]</ins>
++</p>
++<blockquote><p>
++<ins>-?- Throughout this sub-clause general requirements and conventions are described that apply to every class
++template specified in sub-clause 26.5.3 [rand.eng] and 26.5.4 [rand.adapt]. Phrases of the
++form "in those sub-clauses" shall be interpreted as equivalent to "in sub-clauses 26.5.3 [rand.eng] and
++26.5.4 [rand.adapt]".
++</ins>
++<p/>
++<ins>-?- Except where specified otherwise, the complexity of each function specified in those sub-clauses is constant.</ins>
++<p/>
++<ins>-?- Except where specified otherwise, no function described in those sub-clauses throws an exception.</ins>
++<p/>
++<ins>-?- Every function described in those sub-clauses that has a function parameter <tt>q</tt> of type
++<tt>SSeq&amp;</tt> for a template type parameter named <tt>SSeq</tt> that is different from type <tt>std::seed_seq</tt>
++throws what and when the invocation of <tt>q.generate</tt> throws.</ins>
++<p/>
++<ins>-?- Descriptions are provided in those sub-clauses only for engine operations that are not described in
++26.5.1.4 [rand.req.eng], for adaptor operations that are not described in 26.5.1.5 [rand.req.adapt],
++or for operations where there is additional semantic information. In particular, declarations for copy constructors,
++for copy assignment operators, for streaming operators, and for equality and inequality operators
++are not shown in the synopses.</ins>
++<p/>
++<ins>-?- Each template specified in those sub-clauses requires one or more relationships, involving the value(s) of
++its non-type template parameter(s), to hold. A program instantiating any of these templates is ill-formed if
++any such required relationship fails to hold.</ins>
++<p/>
++<ins>-?- For every random number engine and for every random number engine adaptor <tt>X</tt> defined in those
++sub-clauses:</ins>
++</p>
++<ul>
++<li><p>
++<ins>if the constructor</ins>
++</p>
++<blockquote><pre>
++<ins>template &lt;class Sseq&gt; explicit X(Sseq&amp; q);</ins>
++</pre></blockquote>
++<p>
++<ins>is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this constructor shall not
++participate in overload resolution;</ins>
++</p>
++</li>
++
++<li><p>
++<ins>if the member function</ins>
++</p>
++<blockquote><pre>
++<ins>template &lt;class Sseq&gt; void seed(Sseq&amp; q);</ins>
++</pre></blockquote>
++<p>
++<ins>is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this function shall not
++participate in overload resolution;</ins>
++</p>
++</li>
++</ul>
++<p>
++<ins>The extent to which an implementation determines that a type cannot be a seed sequence is unspecified,
++except that as a minimum a type shall not qualify as a seed sequence if it is implicitly convertible to
++<tt>X::result_type</tt>.</ins>
++</p>
++</blockquote>
++
++</li>
++
++<li><p>Edit the contents of sub-clause 26.5.3 [rand.eng] as indicated:</p>
++
++<blockquote><p>
++-1- Each type instantiated from a class template specified in this section 26.5.3 [rand.eng] satisfies the
++requirements of a random number engine (26.5.1.4 [rand.req.eng]) type <ins>and the general implementation
++requirements specified in sub-clause [rand.engadapt.general]</ins>.
++<p/>
++<del>-2- Except where specified otherwise, the complexity of each function specified in this section 26.5.3 [rand.eng]
++is constant.</del>
++<p/>
++<del>-3- Except where specified otherwise, no function described in this section 26.5.3 [rand.eng] throws an exception.</del>
++<p/>
++<del>-4- Descriptions are provided in this section 26.5.3 [rand.eng] only for engine operations that are not
++described in 26.5.1.4 [rand.req.eng] [&hellip;]</del>
++<p/>
++<del>-5- Each template specified in this section 26.5.3 [rand.eng] requires one or more relationships,
++involving the value(s) of its non-type template parameter(s), to hold. [&hellip;]</del>
++<p/>
++<del>-6- For every random number engine and for every random number engine adaptor <tt>X</tt> defined in this subclause
++(26.5.3 [rand.eng]) and in sub-clause 26.5.3 [rand.eng]: [&hellip;]</del>
++</p></blockquote>
++
++</li>
++
++<li><p>Edit the contents of sub-clause 26.5.4.1 [rand.adapt.general] as indicated:</p>
++
++<blockquote><p>
++-1- Each type instantiated from a class template specified in this section <del>26.5.3 [rand.eng]</del><ins>26.5.4 [rand.adapt]</ins> satisfies the
++requirements of a random number engine adaptor (26.5.1.5 [rand.req.adapt]) type <ins>and the general
++implementation requirements specified in sub-clause [rand.engadapt.general]</ins>.
++<p/>
++<del>-2- Except where specified otherwise, the complexity of each function specified in this section 26.5.4 [rand.adapt]
++is constant.</del>
++<p/>
++<del>-3- Except where specified otherwise, no function described in this section 26.5.4 [rand.adapt] throws an exception.</del>
++<p/>
++<del>-4- Descriptions are provided in this section 26.5.4 [rand.adapt] only for engine operations that are not
++described in 26.5.1.5 [rand.req.adapt] [&hellip;]</del>
++<p/>
++<del>-5- Each template specified in this section 26.5.4 [rand.adapt] requires one or more relationships, involving
++the value(s) of its non-type template parameter(s), to hold. [&hellip;]</del>
++</p></blockquote>
++
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2014-02-09, Daniel provides alternative resolution]</i></p>
++
++
++<p><i>[Lenexa 2015-05-07: Move to Ready]</i></p>
++
++<p>LWG 2181 exceptions from seed sequence operations</p>
++<p>STL: Daniel explained that I was confused. I said, oh, seed_seq says it can throw if the RanIt throws. Daniel says the RanIts are provided by the engine. Therefore if you give a seed_seq to an engine, it cannot throw, as implied by the current normative text. So what Daniel has in the PR is correct, if slightly unnecessary. It's okay to have explicitly non-overlapping Standardese even if overlapping would be okay.</p>
++<p>Marshall: And this is a case where the std:: on seed_seq is a good thing.</p>
++<p>STL: Meh.</p>
++<p>STL: And that was my only concern with this PR. I like the latest PR much better than the previous.</p>
++<p>Marshall: Yes. There's a drive-by fix for referencing the wrong section. Other than that, the two are the same.</p>
++<p>STL: Alisdair wanted the repetition instead of centralization, and I agree.</p>
++<p>Marshall: Any other opinions?</p>
++<p>Jonathan: I'll buy it.</p>
++<p>STL: For a dollar?</p>
++<p>Hwrd: I'll buy that for a nickel.</p>
++<p>Marshall: Any objections to Ready? I don't see a point in Immediate.</p>
++<p>Jonathan: Absolutely agree.</p>
++<p>Marshall: 7 for ready, 0 opposed, 0 abstain.</p>
++
++<p><i>[2014-05-22, Daniel syncs with recent WP]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit the contents of sub-clause 26.5.3 [rand.eng] as indicated:</p>
++
++<blockquote><p>
++-1- Each type instantiated from a class template specified in this section 26.5.3 [rand.eng] satisfies the
++requirements of a random number engine (26.5.1.4 [rand.req.eng]) type.
++<p/>
++-2- Except where specified otherwise, the complexity of each function specified in this section 26.5.3 [rand.eng]
++is constant.
++<p/>
++-3- Except where specified otherwise, no function described in this section 26.5.3 [rand.eng] throws an exception.
++<p/>
++<ins>-?- Every function described in this section 26.5.3 [rand.eng] that has a function parameter <tt>q</tt> of
++type <tt>Sseq&amp;</tt> for a template type parameter named <tt>Sseq</tt> that is different from type <tt>std::seed_seq</tt>
++throws what and when the invocation of <tt>q.generate</tt> throws.</ins>
++<p/>
++-4- Descriptions are provided in this section 26.5.3 [rand.eng] only for engine operations that are not
++described in 26.5.1.4 [rand.req.eng] or for operations where there is additional semantic information. In particular,
++declarations for copy constructors, <del>for</del> copy assignment operators, <del>for</del> streaming operators, <del>and
++for</del> equality <ins>operators,</ins> and inequality operators are not shown in the synopses.
++<p/>
++-5- Each template specified in this section 26.5.3 [rand.eng] requires one or more relationships,
++involving the value(s) of its non-type template parameter(s), to hold. A program instantiating any of these templates is
++ill-formed if any such required relationship fails to hold.
++<p/>
++-6- For every random number engine and for every random number engine adaptor <tt>X</tt> defined in this subclause
++(26.5.3 [rand.eng]) and in sub-clause 26.5.4 [rand.adapt]:
++</p>
++<ul>
++<li><p>
++if the constructor
++</p>
++<blockquote><pre>
++template &lt;class Sseq&gt; explicit X(Sseq&amp; q);
++</pre></blockquote>
++<p>
++is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this constructor shall not
++participate in overload resolution;
++</p>
++</li>
++<li><p>
++if the member function
++</p>
++<blockquote><pre>
++template &lt;class Sseq&gt; void seed(Sseq&amp; q);
++</pre></blockquote>
++<p>
++is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this function shall not
++participate in overload resolution;
++</p>
++</li>
++</ul>
++<p>
++The extent to which an implementation determines that a type cannot be a seed sequence is unspecified,
++except that as a minimum a type shall not qualify as a seed sequence if it is implicitly convertible to
++<tt>X::result_type</tt>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit the contents of sub-clause 26.5.4.1 [rand.adapt.general] as indicated:</p>
++
++<blockquote><p>
++-1- Each type instantiated from a class template specified in this section
++<del>26.5.3 [rand.eng]</del><ins>26.5.4 [rand.adapt]</ins> satisfies the requirements of a
++random number engine adaptor (26.5.1.5 [rand.req.adapt]) type.
++<p/>
++-2- Except where specified otherwise, the complexity of each function specified in this section 26.5.4 [rand.adapt]
++is constant.
++<p/>
++-3- Except where specified otherwise, no function described in this section 26.5.4 [rand.adapt] throws an exception.
++<p/>
++<ins>-?- Every function described in this section 26.5.4 [rand.adapt] that has a function parameter <tt>q</tt> of
++type <tt>Sseq&amp;</tt> for a template type parameter named <tt>Sseq</tt> that is different from type <tt>std::seed_seq</tt>
++throws what and when the invocation of <tt>q.generate</tt> throws.</ins>
++<p/>
++-4- Descriptions are provided in this section 26.5.4 [rand.adapt] only for adaptor operations that are not
++described in section 26.5.1.5 [rand.req.adapt] or for operations where there is additional semantic information. In particular,
++declarations for copy constructors, <del>for</del> copy assignment operators, <del>for</del> streaming operators, <del>and for</del>
++equality <ins>operators,</ins> and inequality operators are not shown in the synopses.
++<p/>
++-5- Each template specified in this section 26.5.4 [rand.adapt] requires one or more relationships, involving
++the value(s) of its non-type template parameter(s), to hold. A program instantiating any of these templates is ill-formed if
++any such required relationship fails to hold.
++</p></blockquote>
++</li>
++
++<li><p>Edit the contents of sub-clause 26.5.8.1 [rand.dist.general] p2 as indicated: [<i>Drafting note</i>: These
++editorial changes are just for consistency with those applied to 26.5.3 [rand.eng] and
++26.5.4.1 [rand.adapt.general] &mdash; <i>end drafting note</i>]</p>
++
++<blockquote><p>
++-2- Descriptions are provided in this section 26.5.8 [rand.dist] only for distribution operations that are not
++described in 26.5.1.6 [rand.req.dist] or for operations where there is additional semantic information. In particular,
++declarations for copy constructors, <del>for</del> copy assignment operators, <del>for</del> streaming operators, <del>and for</del>
++equality <ins>operators,</ins> and inequality operators are not shown in the synopses.
++</p></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2183"></a>2183. Muddled allocator requirements for <tt>match_results</tt> constructors</h3>
++<p><b>Section:</b> 28.10.1 [re.results.const], 28.10.6 [re.results.all] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.results.const">active issues</a> in [re.results.const].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.const">issues</a> in [re.results.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++28.10.1 [re.results.const] p1 says:
++</p>
++<blockquote><p>
++In all <tt>match_results</tt> constructors, a copy of the <tt>Allocator</tt> argument shall be used for any memory
++allocation performed by the constructor or member functions during the lifetime of the object.
++</p></blockquote>
++<p>
++There are three constructors:
++</p>
++<blockquote><pre>
++match_results(const Allocator&amp; = Allocator());
++match_results(const match_results&amp; m);
++match_results(match_results&amp;&amp; m) noexcept;
++</pre></blockquote>
++<p>
++The second and third constructors do no have an <tt>Allocator</tt> argument, so despite the "all <tt>match_results</tt>
++constructors", it is not possible to use "the <tt>Allocator</tt> argument" for the second and third constructors.
++<p/>
++The requirements for those two constructors also does not give any guidance. The second constructor has no language
++about allocators, and the third states that the stored <tt>Allocator</tt> value is move constructed from
++<tt>m.get_allocator()</tt>, but doesn't require using that allocator to allocate memory.
++<p/>
++The same basic problem recurs in 28.10.6 [re.results.all], which gives the required return value for
++<tt>get_allocator()</tt>:
++</p>
++<blockquote><p>
++<i>Returns</i>: A copy of the <tt>Allocator</tt> that was passed to the object's constructor or, if that allocator
++has been replaced, a copy of the most recent replacement.
++</p></blockquote>
++<p>
++Again, the second and third constructors do not take an <tt>Allocator</tt>, so there is nothing that meets this
++requirement when those constructors are used.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2184"></a>2184. Muddled allocator requirements for <tt>match_results</tt> assignments</h3>
++<p><b>Section:</b> 28.10.1 [re.results.const], 28.10.6 [re.results.all] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.results.const">active issues</a> in [re.results.const].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.const">issues</a> in [re.results.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The effects of the two assignment operators are specified in Table 141. Table 141 makes no mention of allocators,
++so, presumably, they don't touch the target object's allocator. That's okay, but it leaves the question:
++<tt>match_results::get_allocator()</tt> is supposed to return "A copy of the Allocator that was passed to the
++object's constructor or, if that allocator has been replaced, a copy of the most recent replacement"; if assignment
++doesn't replace the allocator, how can the allocator be replaced?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2189"></a>2189. Throwing <tt>swap</tt> breaks unordered containers' state</h3>
++<p><b>Section:</b> 23.2.5.1 [unord.req.except] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-09-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The hash functor and key-comparison functor of unordered containers are allowed to throw on <tt>swap</tt>.
++</p>
++<p>
++23.2.5.1 [unord.req.except]p3 "For unordered associative containers, no <tt>swap</tt> function throws
++an exception unless that exception is thrown by the swap of the container's Hash or Pred object (if any)."
++</p>
++<p>
++In such a case we must offer the basic exception safety guarantee, where both objects are left in valid
++but unspecified states, and no resources are leaked. This yields a corrupt, un-usable container if the
++first <tt>swap</tt> succeeds, but the second fails by throwing, as the functors form a matched pair.
++</p>
++<p>
++So our basic scenario is first, swap the allocators if the allocators propagate on swap, according to
++<tt>allocator_traits</tt>. Next we swap the pointers to our internal hash table data structures, so that
++they match the allocators that allocated them. (Typically, this operation cannot throw). Now our containers
++are back in a safely destructible state if an exception follows.
++</p>
++<p>
++Next, let's say we swap the hash functor, and that throws. We have a corrupt data structure, in that the
++buckets are not correctly indexed by the correct functors, lookups will give unpredicatable results etc.
++We can safely restore a usable state by forcibly clearing each container - which does not leak resources
++and leaves us with two (empty but) usable containers.
++</p>
++<p>
++Now let us assume that the hasher swap succeeds. Next we swap the equality comparator functor, and this
++too could throw. The important point to bear in mind is that these two functors form an important pairing
++- two objects that compare equal by the equality functor must also hash to the same value. If we swap
++one without the other, we most likely leave the container in an unusable state, even if we clear out all
++elements.
++</p>
++<p>
++1. A colleague pointed out that the solution for this is to dynamically allocate the two functors, and then
++we need only swap pointers, which is not a throwing operation. And if we don't want to allocate on default
++construction (a common QoI request), we might consider moving to a dynamically allocated functors whenever
++<tt>swap</tt> is called, or on first insertion. Of course, allocating memory in <tt>swap</tt> is a whole
++new can of worms, but this does not really sound like the design we had intended.
++</p>
++
++<p>
++2. The simplest option is to say that we do not support hasher or equality functors that throw on ADL
++<tt>swap</tt>. Note that the requirement is simply to not throw, rather than to be explicitly
++marked as <tt>noexcept</tt>. Throwing functors are allowed, so long as we never use values that
++would actually manifest a throw when used in an unordered container.
++</p>
++
++<p>
++Pablo went on to give me several more options, to be sure we have a full set to consider:
++</p>
++<p>
++3. Disallow one or the other functor from throwing. In that case, the
++possibly-throwing functor must be swapped first, then the other functor,
++the allocator, and the data pointer(s) afterwards (in any order -- there
++was a TC that allocator assignment and swap may not throw if the
++corresponding propagation trait is true.). Of course, the question
++becomes: which functor is allowed to throw and which one is not?
++</p>
++<p>
++4. Require that any successful functor <tt>swap</tt> be reliably reversible.
++This is very inventive. I know of no other place in the standard where
++such a requirement is stated, though I have occasionally wanted such a
++guarantee.
++</p>
++<p>
++5. Allow a failed swap to leave the containers in a state where future
++insertions may fail for reasons other than is currently allowed.
++Specifically, if the hash and equality functors are out of sync, all
++insertions will fail. Presumably some "incompletely swapped" exception
++would be thrown. This is "slightly" inventive, although people have been
++discussing "radioactive" states for a while.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2191"></a>2191. Incorrect specification of <tt>match_results(match_results&amp;&amp;)</tt></h3>
++<p><b>Section:</b> 28.10.1 [re.results.const] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-10-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.results.const">active issues</a> in [re.results.const].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.const">issues</a> in [re.results.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++28.10.1 [re.results.const]/3: "Move-constructs an object of class <tt>match_results</tt> satisfying the same
++postconditions as Table 141."
++</p>
++<p>
++Table 141 lists various member functions and says that their results should be the results of the corresponding member
++function calls on <tt>m</tt>. But <tt>m</tt> has been moved from, so the actual requirement ought to be based on the
++value that <tt>m</tt> had <em>before</em> the move construction, not on <tt>m</tt> itself.
++</p>
++<p>
++In addition to that, the requirements for the copy constructor should refer to Table 141.
++<p/>
++<u>Ganesh</u>:
++<p/>
++Also, the requirements for move-assignment should refer to Table 141. Further it seems as if in Table 141 all phrases of
++"for all integers <tt>n &lt; m.size()</tt>" should be replaced by "for all <em>unsigned</em> integers
++<tt>n &lt; m.size()</tt>".
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2192"></a>2192. Validity and return type of <tt>std::abs(0u)</tt> is unclear</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-10-02 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In C++03 the following two programs are invalid:
++</p>
++<ol style="list-style-type:upper-alpha"><li>
++<blockquote><pre>
++#include &lt;cmath&gt;
++
++int main() {
++ std::abs(0u);
++}
++</pre></blockquote>
++</li>
++<li>
++<blockquote><pre>
++#include &lt;cstdlib&gt;
++
++int main() {
++ std::abs(0u);
++}
++</pre></blockquote>
++</li>
++</ol>
++<p>
++because none of the <tt>std::abs()</tt> overloads is a best match.
++</p>
++<p>
++In C++11 the additional "sufficient overload" rule from 26.8 [c.math] p11 (see also LWG
++<a href="lwg-defects.html#2086">2086</a>) can be read to be applicable to the <tt>std::abs()</tt> overloads as well, which
++can lead to the following possible conclusions:
++<p/>
++<ol>
++<li><p>The program</p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++#include &lt;cmath&gt;
++
++static_assert(std::is_same&lt;decltype(std::abs(0u)), double&gt;(), "Oops");
++
++int main() {
++ std::abs(0u); // Calls std::abs(double)
++}
++</pre></blockquote>
++<p>
++is required to be well-formed, because of sub-bullet 2 ("[..] or an integer type [..]") of
++26.8 [c.math] p11 (Note that the current resolution of LWG <a href="lwg-defects.html#2086">2086</a> doesn't
++fix this problem).
++</p>
++</li>
++<li><p>Any translation unit including both <tt>&lt;cmath&gt;</tt> and <tt>&lt;cstdlib&gt;</tt>
++might be ill-formed because of two conflicting requirements for the return type of the overload
++<tt>std::abs(int)</tt>.
++</p>
++</li>
++</ol>
++</p>
++
++<p>
++It seems to me that at least the second outcome is not intended, personally I think that both
++are unfortunate: In contrast to all other floating-point functions explicitly listed in sub-clause
++26.8 [c.math], the <tt>abs</tt> overloads have a special and well-defined meaning for
++signed integers and thus have explicit overloads returning a signed integral type. I also believe that
++there is no problem accepting that <tt>std::fabs(0u)</tt> is well-defined with return type <tt>double</tt>,
++because the leading 'f' clearly signals that we have a floating point function here. But the expected
++return type of <tt>std::abs(0u)</tt> seems less than clear to me. A very reasonable answer could be that
++this has the same type as its argument type, alternatively it could be a reasonably chosen signed
++integer type, or a floating point type. It should also be noted, that the corresponding
++"generic type function" rule set from C99/C1x in 7.25 p2+3 is restricted to the floating-point functions
++from <tt>&lt;math.h&gt;</tt> and <tt>&lt;complex.h&gt;</tt>, so cannot be applied to the <tt>abs</tt>
++functions (but to the <tt>fabs</tt> functions!).
++<p/>
++Selecting a signed integer return type for unsigned input values can also problematic: The directly
++corresponding signed integer type would give half of the possible argument values an implementation-defined
++result value. Choosing the first signed integer value that can represent all positive values would solve this
++problem for <tt>unsigned int</tt>, but there would be no clear answer for the input type <tt>std::uintmax_t</tt>.
++</p>
++<p>
++Based on this it seems to me that the C++03 state in regard to unsigned integer values was the better
++situation, alerting the user that this code is ambigious at the moment (This might be change with different core-language
++rules as described in N3387).
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Resolution: leave as new and bring it back in Chicago.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++This issue also relates to LWG <a href="lwg-active.html#2294">2294</a>
++<p/>
++STL: these two issues should be bundled
++<p/>
++Stefanus: do what Pete says, and add overloads for unsigned to return directly
++<p/>
++STL: agree Consensus that this is an issue
++<p/>
++Walter: motion to move to Open
++<p/>
++STL: no wording for <a href="lwg-active.html#2294">2294</a>
++<p/>
++Stefanus: move to open and note the 2 issues are related and should be moved together
++<p/>
++Stefanus: add and define unsigned versions of <tt>abs()</tt>
++</p>
++
++<p><i>[2014-02-03 Howard comments]</i></p>
++
++<p>
++Defining <tt>abs()</tt> for unsigned integers is a bad idea. Doing so would turn compile time errors into run time errors,
++especially in C++ where we have templates, and the types involved are not always apparent to the programmer at design time.
++For example, consider:
++</p>
++<blockquote><pre>
++template &lt;class Int&gt;
++Int
++analyze(Int x, Int y)
++{
++ // ...
++ if (std::abs(<span style="color:#C80000;font-weight:bolder">x - y</span>) &lt; threshold)
++ {
++ // ...
++ }
++ // ...
++}
++</pre></blockquote>
++<p>
++<tt>std::abs(<i>expr</i>)</tt> is often used to ask: Are these two numbers sufficiently close? When the assumption is that
++the two numbers are signed (either signed integral, or floating point), the logic is sound. But when the same logic is
++accidentally used with an arithmetic type not capable of representing negative numbers, and especially if unsigned overflow
++will silently happen, then the logic is no longer correct:
++</p>
++<blockquote><pre>
++auto i = analyze(20u, 21u); // Today a compile time error
++ // But with <tt>abs(unsigned)</tt> becomes a run time error
++</pre></blockquote>
++<p>
++This is not idle speculation. Search the net for "<tt>abs unsigned</tt>"
++<a href="http://www.avrfreaks.net/index.php?name=PNphpBB2&amp;file=printview&amp;t=35514&amp;start=0">here</a> or
++<a href="http://fischerlaender.de/mysql/surprising-mysql-behaviour-using-unsigned-int">here</a>.
++<p/>
++In C++11, <tt>chrono</tt> <tt>duration</tt>s and <tt>time_point</tt>s are allowed to be based on unsigned integers. Taking the
++absolute value of the difference of two such <tt>time_point</tt>s would be easy to accidentally do (say in code templated on
++<tt>time_point</tt>s), and would certainly be a logic bug, caught at compile time unless we provide the error prone <tt>abs(unsigned)</tt>.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++GR: Do we want to make the changes to both <tt>&lt;cmath&gt;</tt> and <tt>&lt;cstdlib&gt;</tt>?<br/>
++AM: I think so; we should provide consistent overloads.<br/>
++GR: Then we're imposing restrictions on what users put in the global namespace.<br/>
++AM: I'm not so worried about that. Users already know not to use C library names.<br/>
++VV: So what are we going to do about unsigned integers? AM: We will say that they are ill-formed.<br/>
++AM: Does anyone volunteer to send updated wording to Daniel? GR, can you do it? GR: Sure.<br/>
++GR: To clarify: we want to make unsigned types ill-formed?<br/>
++AM: With promotion rank at least <tt>unsigned int</tt>.<br/>
++GR: And NL suggests to just list those types.
++<p/>
++Conclusion: Merge the resolution into a single issue.
++</p>
++
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++<blockquote class = "note">
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 26.8 [c.math] p11 as indicated:</p>
++<blockquote><p>
++-11- Moreover<ins>, except for the <tt>abs</tt> functions</ins>, there shall be additional overloads sufficient to ensure:
++<p/>
++[&hellip;]
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-03-03, Geoffrey Romer provides improved wording]</i></p>
++
++<p>
++In the following I've drafted combined wording to resolve LWG <a href="lwg-active.html#2192">2192</a> and <a href="lwg-active.html#2294">2294</a>. Note that the first
++two paragraphs are taken verbatim from the P/R of LWG <a href="lwg-active.html#2294">2294</a>, but the third is newly drafted:
++</p>
++
++<p><i>[2015-05-05 Lenexa: Howard to draft updated wording]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Insert the following new paragraphs after 26.8 [c.math] p7:</p>
++<blockquote>
++<p>
++-6- In addition to the <tt>int</tt> versions of certain math functions in <tt>&lt;cstdlib&gt;</tt>, C++ adds <tt>long</tt>
++and <tt>long long</tt> overloaded versions of these functions, with the same semantics.
++<p/>
++-7- The added signatures are:
++</p>
++<blockquote>
++<pre>
++long abs(long); <i>// labs()</i>
++long long abs(long long); <i>// llabs()</i>
++ldiv_t div(long, long); <i>// ldiv()</i>
++lldiv_t div(long long, long long); <i>// lldiv()</i>
++</pre>
++</blockquote>
++<p>
++<ins>-?- To avoid ambiguities, C++ also adds the following overloads of <tt>abs()</tt> to <tt>&lt;cstdlib&gt;</tt>,
++with the semantics defined in <tt>&lt;cmath&gt;</tt>:</ins>
++</p>
++<blockquote>
++<pre>
++<ins>float abs(float);
++double abs(double);
++long double abs(long double);</ins>
++</pre>
++</blockquote>
++<p>
++<ins>-?- To avoid ambiguities, C++ also adds the following overloads of <tt>abs()</tt> to <tt>&lt;cmath&gt;</tt>,
++with the semantics defined in <tt>&lt;cstdlib&gt;</tt>:</ins>
++</p>
++<blockquote>
++<pre>
++<ins>int abs(int);
++long abs(long);
++long long abs(long long);</ins>
++</pre>
++</blockquote>
++<p>
++<ins>-?- If <tt>abs()</tt> is called with an argument of unsigned integral type that cannot be converted to <tt>int</tt>
++by integral promotion (4.5 [conv.prom]), the program is ill-formed. [<i>Note</i>: arguments that can be promoted
++to <tt>int</tt> are permitted for compatibility with C. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2195"></a>2195. Missing constructors for <tt>match_results</tt></h3>
++<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-10-06 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results">issues</a> in [re.results].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The requirement expressed in 28.10 [re.results] p2
++</p>
++<blockquote><p>
++The class template <tt>match_results</tt> shall satisfy the requirements of an allocator-aware container and of a
++sequence container, as specified in 23.2.3 [sequence.reqmts], except that only operations defined for
++const-qualified sequence containers are supported.
++</p></blockquote>
++<p>
++can be read to require the existence of the described constructors from as well, but they do not exist in the
++synopsis.
++<p/>
++The missing sequence constructors are:
++</p>
++<blockquote><pre>
++match_results(initializer_list&lt;value_type&gt;);
++match_results(size_type, const value_type&amp;);
++template&lt;class InputIterator&gt; match_results(InputIterator, InputIterator);
++</pre></blockquote>
++<p>
++The missing allocator-aware container constructors are:
++</p>
++<blockquote><pre>
++match_results(const match_results&amp;, const Allocator&amp;);
++match_results(match_results&amp;&amp;, const Allocator&amp;);
++</pre></blockquote>
++<p>
++It should be clarified, whether (a) constructors are an exception of above mentioned operations or (b) whether
++at least some of them (like those accepting a <tt>match_results</tt> value and an allocator) should be added.
++<p/>
++As visible in several places of the standard (including the core language), constructors seem usually to be considered
++as "operations" and they certainly can be invoked for const-qualified objects.
++<p/>
++The below given proposed resolution applies only the minimum necessary fix, i.e. it excludes constructors from
++above requirement.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Check current implementations to see what they do and, possibly, write a paper.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Ask Daniel to update the proposed wording to include the allocator copy and move constructors.
++</p>
++
++<p><i>[2014-01-18 Daniel changes proposed resolution]</i></p>
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++
++<blockquote class="note">
++<ol>
++<li><p>Change 28.10 [re.results] p2 as indicated:</p>
++<blockquote><p>
++The class template <tt>match_results</tt> shall satisfy the requirements of an allocator-aware container and of a
++sequence container, as specified in 23.2.3 [sequence.reqmts], except that only operations defined for
++const-qualified sequence containers <ins>that are not constructors</ins> are supported.
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05-06 Lenexa]</i></p>
++
++<p>MC passes important knowledge to EF.</p>
++<p>VV, RP: Looks good.</p>
++<p>TK: Second form should be conditionally noexcept</p>
++<p>JY: Sequence constructors are not here, but mentioned in the issue writeup. Why?</p>
++<p>TK: That would have been fixed by the superseded wording.</p>
++<p>JW: How does this interact with Mike Spertus' allocator-aware regexes? [...] Perhaps it doesn't.</p>
++<p>JW: Can't create match_results, want both old and new resolution.</p>
++<p>JY: It's problematic that users can't create these, but not this issue.</p>
++<p>VV: Why conditional noexcept?</p>
++<p>MC: Allocator move might throw.</p>
++<p>JW: Update superseded wording to "only non-constructor operations that are"?</p>
++<p>MC: Only keep superseded, but append "and the means of constructing match_results are limited to [...]"?</p>
++<p>JY: Bullet 4 paragraph 2 needs to address the allocator constructor.</p>
++<p>Assigned to JW for drafting.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 28.10 [re.results] p4, class template <tt>match_results</tt> synopsis, as indicated:</p>
++<blockquote><pre>
++[&hellip;]
++// 28.10.1, construct/copy/destroy:
++explicit match_results(const Allocator&amp; a = Allocator());
++match_results(const match_results&amp; m);
++<ins>match_results(const match_results&amp; m, const Allocator&amp; a);</ins>
++match_results(match_results&amp;&amp; m) noexcept;
++<ins>match_results(match_results&amp;&amp; m, const Allocator&amp; a) noexcept;</ins>
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Change 28.10.1 [re.results.const] as indicated: [<i>Drafting note:</i> Paragraph 6 as currently written,
++makes not much sense, because the <tt>noexcept</tt> does not allow any exception to propagate. Further-on, the allocator requirements
++do not allow for throwing move constructors. Deleting it seems to be near to editorial &mdash; <i>end drafting note</i>]</p>
++<blockquote>
++
++<pre>
++match_results(const match_results&amp; m);
++<ins>match_results(const match_results&amp; m, const Allocator&amp; a);</ins>
++</pre>
++<blockquote>
++<p>
++-4- <i>Effects:</i> Constructs an object of class <tt>match_results</tt>, as a copy of <tt>m</tt>.
++</p>
++</blockquote>
++
++<pre>
++match_results(match_results&amp;&amp; m) noexcept;
++<ins>match_results(match_results&amp;&amp; m, const Allocator&amp; a) noexcept;</ins>
++</pre>
++<blockquote>
++<p>
++-5- <i>Effects:</i> Move-constructs an object of class <tt>match_results</tt> from <tt>m</tt> satisfying the same postconditions
++as Table 142. <del>Additionally</del><ins>For the first form</ins>, the stored <tt>Allocator</tt> value is move constructed
++from <tt>m.get_allocator()</tt>.
++<p/>
++<del>-6- <i>Throws:</i> Nothing if the allocator's move constructor throws nothing.</del>
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2198"></a>2198. <tt>max_load_factor(z)</tt> makes no strong guarantees, but bans useful behavior</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The user cannot specify a <tt>max_load_factor</tt> for their unordered container
++at construction, it must be supplied after the event, when the container is
++potentially not empty. The contract for this method is deliberately vague, not
++guaranteeing to use the value supplied by the user, and any value actually used
++will be used as a ceiling that the container will <i>attempt</i> to respect.
++</p>
++<p>
++The only guarantee we have is that, if user requests a <tt>max_load_factor</tt>
++that is less than the current <tt>load_factor</tt>, then the operation will take
++constant time, thus outlawing an implementation that chooses to rehash and so
++preserve as a class invariant that <tt>load_factor &lt; max_load_factor</tt>.
++</p>
++<p>
++Reasonable options conforming to the standard include ignoring the user's request
++if the requested value is too low, or deferring the rehash to the next <tt>insert</tt>
++operation and allowing the container to have a strange state (wrt <tt>max_load_factor</tt>)
++until then - and there is still the question of rehashing if the next <tt>insert</tt>
++is for a duplicate key in a unique container.
++</p>
++<p>
++Given the deliberate vagueness of the current wording, to support a range of reasonable
++(but not <i>perfect</i>) behaviors, it is not clear why the equally reasonable rehash
++to restore the constraint should be outlawed. It is not thought that this is a performance
++critical operation, where users will be repeatedly setting low load factors on populated
++containers, in a tight or (less unlikely) an instant response scenario.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Alisdair to provide wording.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2199"></a>2199. unordered containers are required to have an initial max load factor of 1.0</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The default constructor, allocator-aware constructor, and range-based constructors
++for the unordered containers do not offer a means to control the initial
++<tt>max_load_factor</tt>, so the standard mandates the value 1.0. This seems overly
++restrictive, as there is plenty of research suggesting a value between 0.5 and 1.0
++is more often optimal for unique-key containers, and perhaps a slightly higher
++value might be appropriate for multi-containers.
++</p>
++<p>
++Rather than guess at the appropriate <tt>max_load_factor</tt>, it seems reasonable
++that the standard should allow vendors to pick a value at their discretion, with
++perhaps a note of advice. It is less clear whether the default value should be
++implementation-defined or unspecified, given the ease of a user determining this
++by querying this attribute immediately after construction.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Alisdair to provide wording.
++</p>
++<p>
++Marshall: It seems to me that what you really want is to be able to pass a max load factor in the
++constructor, but that's a different issue.
++</p>
++<p>
++Alisdair agrees in principle, but concerned with adding yet more constructors to these classes.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2201"></a>2201. Missing macro entries from C standard library</h3>
++<p><b>Section:</b> C.5 [diff.library] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Kevin McCarty <b>Opened:</b> 2012-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#diff.library">issues</a> in [diff.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++It seems that in C.5 [diff.library], Table 150 the following macros from 18.3.3 [c.limits], Table 31
++are missing:
++</p>
++<blockquote><pre>
++LLONG_MIN
++LLONG_MAX
++ULLONG_MAX
++</pre></blockquote>
++<p>
++In addition in C.5 [diff.library], Table 150 the following macros from 18.3.3 [c.limits], Table 32
++are missing:
++</p>
++<blockquote><pre>
++DECIMAL_DIG
++FLT_EVAL_METHOD
++</pre></blockquote>
++<p>
++Furtheron it seems that in C.5 [diff.library], Table 149/150 further macros are missing as well, e.g.
++<tt>HUGE_VALF</tt>, <tt>INFINITY</tt>, etc.
++</p>
++
++<p><i>[2014-02 Issaquah:]</i></p>
++
++<p>
++This is an issue, all of C has not been updated for C99, C99 functions are missing, whole section needs to be overhauled.
++<p/>
++The issue needs to be updated for functions and other missing items and when that happens the issue title is wrong and
++needs to be adapted.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2202"></a>2202. Missing allocator support by <tt>async</tt></h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#Deferred">Deferred</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2012-10-19 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>promise</tt>, <tt>packaged_task</tt>, and <tt>async</tt> are the only
++places where a shared state is actually supposed to be allocated. Accordingly,
++<tt>promise</tt> and <tt>packaged_task</tt> are "allocator-aware". But
++function template <tt>async</tt> provides no way to provide an allocator.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Matt: deprecate async
++<p/>
++Nico: read my paper
++<p/>
++Alisdair: defer issues to wait for polymorphic allocators
++<p/>
++Alisdair: defer, active topic of research Deferred
++</p>
++
++<p><i>[2014-02-20 Re-open Deferred issues as Priority 4]</i></p>
++
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++We want whatever status approximates: "will not fix; we're working on a replacement facility and don't want to add features to a broken one"
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2206"></a>2206. Inaccuracy in <tt>initializer_list</tt> constructor requirements</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts], 23.2.4 [associative.reqmts], 23.2.5 [unord.req], 26.5.1.2 [rand.req.seedseq] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2012-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In 23.2.3 [sequence.reqmts] p3, we have "<tt>il</tt> designates an object of type
++<tt>initializer_list&lt;value_type&gt;</tt>", and then several functions that take
++'<tt>il</tt>' as an argument. However, an expression like <tt>{1, 2, 'a'}</tt> is <em>not</em>
++an object of type <tt>initializer_list&lt;int&gt;</tt> unless it's used to initialize
++an explicitly-typed variable of that type. I believe we want:
++</p>
++<blockquote><pre>
++std::vector&lt;int&gt; v;
++v = {1, 2, 'a'};
++</pre></blockquote>
++<p>
++to compile portably, so we should say something different when defining '<tt>il</tt>'. The
++same phrasing happens in 23.2.4 [associative.reqmts], 23.2.5 [unord.req], and
++26.5.1.2 [rand.req.seedseq].
++<p/>
++This may just be an editorial issue because the actual class synopses declare the functions
++to take <tt>initializer_list&lt;exact_type&gt;</tt>.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++This is definitely not NAD
++</p>
++<p>
++Should copy the suggested wording as the proposed resolution.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2208"></a>2208. <tt>std::reverse_iterator</tt> should be a literal type</h3>
++<p><b>Section:</b> 24.5.1 [reverse.iterators] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2012-10-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iterators">issues</a> in [reverse.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>std::reverse_iterator::reverse_iterator(Iterator)</tt> should be constexpr
++so that other constexpr functions can return <tt>reverse_iterator</tt>s. Of the
++other methods, the other constructors, <tt>base()</tt>, <tt>operator+</tt>, <tt>operator-</tt>,
++<tt>operator[]</tt>, and the non-member operators can probably also be
++<tt>constexpr</tt>.
++<p/>
++<tt>operator*</tt> cannot be constexpr because it involves an assignment to a
++member variable. Discussion starting with c++std-lib-33282 indicated
++that it would be useful to make reverse_iterator a literal type
++despite this restriction on its use at compile time.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2214"></a>2214. Clarify <tt>basic_ios::init</tt> call restrictions</h3>
++<p><b>Section:</b> 27.5.5.2 [basic.ios.cons] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Andrey Semashev <b>Opened:</b> 2012-11-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++There is an ambiguity in how <tt>std::basic_ios::init</tt> method (27.5.5.2 [basic.ios.cons])
++can be used in the derived class. The Standard only specify the state of the <tt>basic_ios</tt>
++object after the call completes. However, in <tt>basic_ios</tt> default constructor description
++(27.5.5.2 [basic.ios.cons]) there is this sentence:
++</p>
++<blockquote><p>
++<i>Effects</i>: Constructs an object of class <tt>basic_ios</tt> (27.5.3.7 [ios.base.cons])
++leaving its member objects uninitialized. The object shall be initialized by calling <tt>basic_ios::init</tt>
++before its first use or before it is destroyed, whichever comes first; otherwise the behavior is undefined.
++</p></blockquote>
++<p>
++This restriction hints that <tt>basic_ios::init</tt> should be called exactly
++once before the object can be used or destroyed, because <tt>basic_ios::init</tt>
++may not know whether it was called before or not (i.e. whether its members are actually
++uninitialized or are initialized by the previous call to <tt>basic_ios::init</tt>). There
++is no such restriction in the <tt>basic_ios::init</tt> preconditions so it is not clear whether it is
++allowed to call <tt>basic_ios::init</tt> multiple times or not.
++<p/>
++This problem has already affected publicly available implementations.
++For example, Microsoft Visual C++ STL introduces a memory leak if
++<tt>basic_ios::init</tt> is called multiple times, while GCC 4.7 and STLPort
++reinitialize the <tt>basic_ios</tt> object correctly without memory leak or any
++other undesired effects. There was a discussion of this issue on Boost
++<a href="http://article.gmane.org/gmane.comp.lib.boost.devel/235659">developers mailing list</a>,
++and there is a <a href="https://sourceforge.net/apps/trac/boost-log/ticket/2#comment:4">test case
++that reproduces the problem</a>. The test case is actually a bug report for my Boost.Log library,
++which attempts to cache <tt>basic_ostream</tt>-derived objects internally to avoid expensive construction
++and destruction. My stream objects allowed resetting the stream buffer pointers the stream
++is attached to, without requiring to destroy and construct the stream.
++<p/>
++My personal view of the problem and proposed resolution follows.
++<p/>
++While apparently the intent of <tt>basic_ios::init</tt> is to provide a way to
++initialize <tt>basic_ios</tt> after default construction, I see no reason to
++forbid it from being called multiple times to reinitialize the stream.
++Furthermore, it is possible to implement a conforming <tt>basic_ios</tt> that
++does not have this restriction.
++<p/>
++The quoted above section of the Standard that describes the effects of
++the default constructor is misleading. The Standard does not mandate
++any data members of <tt>basic_ios</tt> or <tt>ios_base</tt> (27.5.3 [ios.base]), which
++it derives from. This means that the implementation is allowed to use
++non-POD data members with default constructors that initialize the
++members with particular default values. For example, in the case of
++Microsoft Visual C++ STL the leaked memory is an <tt>std::locale</tt> instance
++that is dynamically allocated during <tt>basic_ios::init</tt>, a raw pointer to
++which is stored within ios_base. It is possible to store e.g. an
++<tt>unique_ptr</tt> instead of a raw pointer as a member of <tt>ios_base</tt>, the smart
++pointer will default initialize the underlying raw pointer on default
++construction and automatically destroy the allocated object upon being
++reset or destroyed, which would eliminate the leak and allow
++<tt>basic_ios::init</tt> to be called multiple times. This leads to conclusion
++that the default constructor of <tt>basic_ios</tt> cannot leave "its member
++objects uninitialized" but instead performs default initialization of
++the member objects, which would mean the same thing in case of POD types.
++<p/>
++However, I feel that restricting <tt>ios_base</tt> and <tt>basic_ios</tt> members to
++non-POD types is not acceptable. Since multiple calls to <tt>basic_ios::init</tt> are
++not forbidden by the Standard, I propose to correct the <tt>basic_ios</tt> default
++constructor description so that it is allowed to destroy <tt>basic_ios</tt> object
++without calling <tt>basic_ios::init</tt>. This would imply that any raw members of
++<tt>basic_ios</tt> and <tt>ios_base</tt> should be initialized to values suitable for
++destruction (essentially, this means only initializing raw pointers to NULL). The new
++wording could look like this:
++</p>
++<blockquote><p>
++<i>Effects</i>: Constructs an object of class <tt>basic_ios</tt> (27.5.3.7 [ios.base.cons])
++initializing its member objects to unspecified state, only suitable for <tt>basic_ios</tt> destruction.
++The object shall be initialized by calling <tt>basic_ios::init</tt> before its first use; otherwise
++the behavior is undefined.
++</p></blockquote>
++<p>
++This would remove the hint that <tt>basic_ios::init</tt> must be called exactly
++once. Also, this would remove the requirement for <tt>basic_ios::init</tt> to
++be called at all before the destruction. This is also an important issue because
++the derived stream constructor may throw an exception before it manages to call
++<tt>basic_ios::init</tt> (for example, if the streambuf constructor throws), and
++in this case the <tt>basic_ios</tt> destructor has undefined behavior.
++<p/>
++To my mind, the described modification is sufficient to resolve the issue. But to
++emphasize the possibility to call <tt>basic_ios::init</tt> multiple times, a remark
++or a footnote for <tt>basic_ios::init</tt> postconditions could be added to explicitly
++state the semantics of calling it multiple times. The note could read as follows:
++</p>
++<blockquote><p>
++The function can be called multiple times during the object lifetime. Each subsequent
++call reinitializes the object to the described in postconditions initial state.
++</p></blockquote>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Alisdair: The current wording is unclear but the proposed resolution is wrong
++<p/>
++Solution: Clarify that <tt>init</tt> must be called once and only once. Move then to review.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 27.5.5.2 [basic.ios.cons] as indicated:</p>
++<blockquote><pre>
++basic_ios();
++</pre>
++<blockquote>
++<p>
++-2- <i>Effects</i>: Constructs an object of class <tt>basic_ios</tt> (27.5.3.7 [ios.base.cons])
++<del>leaving its member objects uninitialized</del><ins>initializing its member objects to unspecified state,
++only suitable for <tt>basic_ios</tt> destruction</ins>. The object shall be initialized by calling
++<tt>basic_ios::init</tt> before its first use <del>or before it is destroyed, whichever comes first</del>;
++otherwise the behavior is undefined.
++</p>
++</blockquote>
++<pre>
++void init(basic_streambuf&lt;charT,traits&gt;* sb);
++</pre><blockquote>
++<p>
++<i>Postconditions</i>: The postconditions of this function are indicated in Table 128.
++<p/>
++<ins>-?- <i>Remarks</i>: The function can be called multiple times during the object lifetime. Each subsequent
++call reinitializes the object to the described in postconditions initial state.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2215"></a>2215. (unordered) associative container functors should be <tt>CopyConstructible</tt></h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-11-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The requirements on the functors used to arrange elements in the various associative and
++unordered containers are given by a set of expressions in tables 102 &mdash; Associative container
++requirements, and 103 &mdash; Unordered associative container requirements. In keeping with Library
++convention these expressions make the minimal requirements necessary on their types. For
++example, we have the following 3 row extracts for the unordered containers:
++</p>
++<table>
++<tr>
++ <td>
++ <b>Expression</b>
++ </td>
++ <td>
++ <b>Assertion/note pre-/post-condition</b>
++ </td>
++</tr>
++
++<tr>
++ <td>
++<pre>
++<tt>X(n, hf, eq)</tt>
++<tt>X a(n, hf, eq)</tt>
++</pre>
++ </td>
++ <td>
++ <i>Requires:</i> <tt>hasher</tt> and <tt>key_equal</tt> are <tt>CopyConstructible</tt>.
++ </td>
++</tr>
++
++<tr>
++ <td>
++<pre>
++<tt>X(n, hf)</tt>
++<tt>X a(n, hf)</tt>
++</pre>
++ </td>
++ <td>
++ <i>Requires:</i> <tt>hasher</tt> is <tt>CopyConstructible</tt> and
++ <tt>key_equal</tt> is <tt>DefaultConstructible</tt>.
++ </td>
++</tr>
++
++<tr>
++ <td>
++<pre>
++<tt>X(n)</tt>
++<tt>X a(n)</tt>
++</pre>
++ </td>
++ <td>
++ <i>Requires:</i> <tt>hasher</tt> and <tt>key_equal</tt> are <tt>DefaultConstructible</tt>.
++ </td>
++</tr>
++</table>
++
++<p>
++However, the signature for each class template requires that the functors must effectively be
++<tt>CopyConstructible</tt> for each of these expressions:
++</p>
++
++<blockquote><pre>
++template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key>,
++ class Pred = std::equal_to&lt;Key>,
++ class Allocator = std::allocator&lt;std::pair&lt;const Key, T> > >
++class unordered_map
++{
++ <i>...</i>
++
++ <i>// construct/destroy/copy</i>
++ explicit unordered_map(size_type n = <i>see below</i>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++
++ <i>...</i>
++}
++</pre></blockquote>
++
++<p>
++The letter of the standard can be honored as long as implementors recognize
++their freedom to split this one signature into multiple overloads, so that
++the documented default arguments (requiring a <tt>CopyConstructible</tt> functor)
++are not actually passed as default arguments.
++</p>
++<p>
++As we look into the requirements for the copy constructor and copy-assignment
++operator, the requirements are even more vague, as the explicit requirements on
++the functors are not called out, other than saying that the functors are copied.
++</p>
++<p>
++Must the functors be <tt>CopyAssignable</tt>? Or is <tt>CopyConstructible</tt>
++sufficient in this case? Do we require that the functors be <tt>Swappable</tt>
++so that the copy-swap idiom can be deployed here? Note that a type that is both
++<tt>CopyConstructible</tt> and <tt>CopyAssignable</tt> is still not guaranteed to
++be <tt>Swappable</tt> as the user may delete the <tt>swap</tt> function for their
++type in their own namespace, which would be found via ADL.
++</p>
++<p>
++Some clean-up of the requirements table looks necessary, to at least document the
++assignment behavior. In addition, we should have clear guidance on whether these
++functors should always be <tt>CopyConstructible</tt>, as suggested by the class
++template definitions, or if the requirement tables are correct and we should
++explicitly split up the constructors in the (unordered) associative containers
++to no longer use default (function) arguments to obtain their defaulted functors.
++</p>
++<p>
++I recommend the simplest solution would be to always require that the functors
++for (unordered) associative containers be <tt>CopyConstructible</tt>, above the
++requirements tables themselves, so that the issue need not be addressed within
++the tables. I suggest that the assignment operators for these containers add
++the requirement that the functors be <tt>Swappable</tt>, rather than forwarding
++the corresponding <tt>Assignable</tt> requirement.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Alisdair to propose wording.
++</p>
++
++<p><i>[2014-06-08, Daniel comments]</i></p>
++
++<p>
++The area of this issue partially overlaps what LWG <a href="lwg-active.html#2227">2227</a> addresses.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2216"></a>2216. <tt>regex_replace(basic_string)</tt> allocator handling</h3>
++<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2012-11-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<blockquote><pre>
++template &lt;class traits, class charT, class ST, class SA&gt;
++ basic_string&lt;charT, ST, SA&gt;
++ regex_replace(const basic_string&lt;charT, ST, SA&gt;&amp; s,
++ const basic_regex&lt;charT, traits&gt;&amp; e,
++ const charT* fmt,
++ regex_constants::match_flag_type flags =
++ regex_constants::match_default);
++</pre></blockquote>
++<p>
++and friends are documented as
++</p>
++<blockquote><p>
++Constructs an empty string result of type <tt>basic_string&lt;charT, ST, SA&gt;</tt>
++and calls <tt>regex_replace(back_inserter(result), s.begin(), s.end(), e, fmt, flags)</tt>.
++</p></blockquote>
++<p>
++This appears to require the result to have a default-constructed
++allocator, which isn't even possible for all allocator types. I
++suspect the allocator should be copied from 's' instead. Possibly
++there should be an additional defaulted argument to override the
++allocator of the result.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2218"></a>2218. Unclear how containers use <tt>allocator_traits::construct()</tt></h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-11-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Firstly, 23.2.1 [container.requirements.general]/7 says a container's
++allocator is used to obtain memory, but it isn't stated explicitly that the same
++allocator is used to construct and destroy elements, as opposed to a value-initialized
++allocator of the same type.
++</p>
++<p>
++Secondly, 23.2.1 [container.requirements.general]/3 says elements "shall be
++constructed using the <tt>allocator_traits&lt;allocator_type&gt;::construct</tt>
++function and destroyed using the <tt>allocator_traits&lt;allocator_type&gt;::destroy</tt> function" and
++23.2.1 [container.requirements.general]/13 defines <tt>CopyInsertable</tt> etc. in
++terms of an allocator <tt>A</tt> which is identical to the container's <tt>allocator_type</tt>.
++</p>
++<p>
++The intent of making <tt>construct()</tt> and <tt>destroy()</tt> function templates was
++that containers would be permitted to use <tt>allocator_traits&lt;A&gt;::construct()</tt> instead of
++<tt>allocator_traits&lt;allocator_type&gt;::construct()</tt>, where <tt>A</tt> is
++<tt>allocator_traits&lt;allocator_type&gt;::rebind_alloc&lt;U&gt;</tt> for some other type
++<tt>U</tt>. This allows node-based containers to store an allocator of the right type for
++allocating nodes and to use the same object to construct elements in aligned storage within
++those nodes, avoiding rebinding and copying the stored allocator every time an element needs
++to be constructed.
++<p/>
++It should be made clear that a possibly-rebound copy of the container's allocator is used for object
++construction.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Jonathan: point 2 in the proposed resolution is definitely needed.
++</p>
++
++<p><i>[2014-11-28, Jonathan improves wording]</i></p>
++
++<p>
++In the first set of edits to paragraph 3 both pieces inserting "<tt>rebind_alloc&lt;U&gt;::</tt>"
++should be replaced by "<tt>rebind_traits&lt;U&gt;::</tt>"
++<p/>
++Otherwise it implies using the allocator's functions directly, but they might not exist and
++it should be through the rebound traits type.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: You want to permit but not require rebinding?<br/>
++Wakely: The current wording forces me to use the original allocator, not the rebound one.<br/>
++STL: Oh, I see. Yeah, we immediately rebind.<br/>
++Wakely: The edits clarify that we don't use some other allocator. The third diff is because the definitions of
++EmplaceConstructible/etc. happen with the same types. The diff to the note is because it doesn't require the value
++of the allocator was the one passed in.<br/>
++STL: After looking at this, I think I'm comfortable with the edits. The previous Standardese was nonsense so it's
++pretty easy to improve upon.<br/>
++Marshall: Any other opinions?<br/>
++Marshall: Any objections to moving it to Ready? Review? Ready in Kona?<br/>
++Wakely: My preference would be Ready. We all know this is what we're doing anyways.<br/>
++Nevin: The intent won't change.<br/>
++STL: I think this is the right fix.<br/>
++Hwrd: I third Ready. Even if Jonathan retracts his.<br/>
++Marshall: Ready!
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 23.2.1 [container.requirements.general] paragraph 3:</p>
++<blockquote><p>
++For the components affected by this subclause that declare an <tt>allocator_type</tt>, objects stored in these
++components shall be constructed using the <tt>allocator_traits&lt;allocator_type&gt;::<ins>rebind_traits&lt;U&gt;::</ins>construct</tt>
++function and destroyed using the <tt>allocator_traits&lt;allocator_type&gt;::<ins>rebind_traits&lt;U&gt;::</ins>destroy</tt>
++function (20.7.8.2 [allocator.traits.members])<ins>, where <tt>U</tt> is either <tt>allocator_type::value_type</tt>
++or an internal type used by the container</ins>. These functions are called only for the container's element type,
++not for internal types used by the container. [ <i>Note</i>: This means, for example, that a node-based container
++might need to construct nodes containing aligned buffers and call construct to place the element into the buffer.
++&mdash; <i>end note</i> ]
++</p></blockquote>
++</li>
++
++<li><p>Edit 23.2.1 [container.requirements.general] paragraph 7:</p>
++<blockquote><p>
++[&hellip;] A copy of this allocator is used for any memory allocation <ins>and element construction</ins> performed,
++by these constructors and by all member functions, during the lifetime of each container object or until the allocator
++is replaced. [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>Edit 23.2.1 [container.requirements.general] paragraph 13:</p>
++<blockquote><p>
++[&hellip;] Given <ins>an allocator type <tt>A</tt> and given</ins> a container type <tt>X</tt> having <del>an
++<tt>allocator_type</tt> identical to <tt>A</tt> and</del> a <tt>value_type</tt> identical to <tt>T</tt>
++<ins>and an <tt>allocator_type</tt> identical to <tt>allocator_traits&lt;A&gt;::rebind_alloc&lt;T&gt;</tt></ins>
++and given an lvalue <tt>m</tt> of type <tt>A</tt>, a pointer <tt>p</tt>
++of type <tt>T*</tt>, an expression <tt>v</tt> of type (possibly <tt>const</tt>) <tt>T</tt>, and an rvalue <tt>rv</tt>
++of type <tt>T</tt>, the following terms are defined.
++<p/>
++[&hellip;]
++<p/>
++[ <i>Note</i>: A container calls <tt>allocator_traits&lt;A&gt;::construct(m, p, args)</tt> to construct an element
++at <tt>p</tt> using <tt>args</tt><ins>, with <tt>m == get_allocator()</tt></ins>. The default <tt>construct</tt> in
++<tt>std::allocator</tt> will call <tt>::new((void*)p) T(args)</tt>, but specialized allocators may choose a
++different definition. &mdash; <i>end note</i> ]
++</p></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2219"></a>2219. <tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</h3>
++<p><b>Section:</b> 20.9.2 [func.require] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-11-28 <b>Last modified:</b> 2015-05-06</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The standard currently requires this to be invalid:
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
++
++struct X { int i; } x;
++auto f = &amp;X::i;
++auto t1 = std::ref(x);
++int i = std::mem_fn(f)(t1);
++</pre></blockquote>
++<p>
++The call expression on the last line is equivalent to <tt><i>INVOKE</i>(f, std::ref(x))</tt>
++which according to 20.9.2 [func.require]p1 results in the invalid expression <tt>(*t1).*f</tt>
++because <tt>reference_wrapper&lt;X&gt;</tt> is neither an object of type <tt>X</tt> nor a reference
++to an object of type <tt>X</tt> nor a reference to an object of a type derived from <tt>X</tt>.
++</p>
++<p>
++The same argument applies to pointers to member functions, and if they don't work with <tt>INVOKE</tt>
++it becomes harder to do all sorts of things such as:
++</p>
++<blockquote><p>
++<tt>call_once(o, &amp;std::thread::join, std::ref(thr))</tt>
++</p></blockquote>
++<p>
++or
++</p>
++<blockquote><p>
++<tt>async(&amp;std::list&lt;int&gt;::sort, std::ref(list));</tt>
++</p></blockquote>
++<p>
++The definition of <tt><i>INVOKE</i></tt> should be extended to handle reference wrappers.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++The wording seems accurate, but verbose. If possible, we would like to define the kind of thing being
++specified so carefully as one of a number of potential language constructs in a single place. It is
++also possible that this clause <i>is</i> that single place.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Jonathan comments:</p>
++
++<p>In the proposed resolution in the first bullet <tt>(t1.*f)</tt> is not valid if <tt>t1</tt> is a
++<tt>reference_wrapper</tt>, so we probably need a separate bullet to handle the
++<tt>reference_wrapper</tt> case.</p>
++
++<p><i>[2014-02-14, Issaquah, Mike Spertus supplies wording]</i></p>
++
++
++<p><strong>Previous resolution from Jonathan [SUPERSEDED]:</strong></p>
++
++<blockquote class="note">
++
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 20.9.2 [func.require]:</p>
++<blockquote><p>
++Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++</p>
++<ul>
++<li><p>
++<tt>(t1.*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>t1</tt> is an object of type <tt>T</tt> or a reference to an object of type <del><tt>T</tt> or a reference
++to an object of a type derived from <tt>T</tt></del> <ins><tt>U</tt> or an object of type <tt>reference_wrapper&lt;U&gt;</tt>
++or a reference to an object of type <tt>reference_wrapper&lt;U&gt;</tt> where <tt>U</tt> is either the type
++<tt>T</tt> or a type derived from <tt>T</tt></ins>;
++</p>
++</li>
++
++<li><p>
++<tt>((*t1).*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>t1</tt> is not one of the types described in the previous item;
++</p></li>
++
++<li><p>
++<tt>t1.*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <tt>t1</tt>
++is an object of type <tt>T</tt> or a reference to an object of type <del><tt>T</tt> or a reference to an object of a
++type derived from <tt>T</tt></del> <ins><tt>U</tt> or an object of type <tt>reference_wrapper&lt;U&gt;</tt>
++or a reference to an object of type <tt>reference_wrapper&lt;U&gt;</tt> where <tt>U</tt> is either the type
++<tt>T</tt> or a type derived from <tt>T</tt></ins>;
++</p></li>
++
++<li><p>
++<tt>(*t1).*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <tt>t1</tt>
++is not one of the types described in the previous item;
++</p></li>
++
++<li><p>
++<tt>f(t1, t2, ..., tN)</tt> in all other cases.
++</p></li>
++</ul>
++
++</blockquote>
++
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[2014-10-01, STL adds discussion and provides an improved resolution]</i></p>
++
++<p>
++Because neither <tt>t1.*f</tt> nor <tt>(*t1).*f</tt> will compile when <tt>t1</tt> is <tt>reference_wrapper&lt;U&gt;</tt>
++for any <tt>U</tt>, we don't need to inspect <tt>U</tt> carefully. We can bluntly detect all <tt>reference_wrapper</tt>s
++and use <tt>get()</tt> for them.
++<p/>
++We would have to be more careful if we had to deal with pointers to members of <tt>reference_wrapper</tt> itself.
++Fortunately, we don't. First, it doesn't have user-visible data members. Second, users technically can't take the
++addresses of its member functions (this is a consequence of 17.6.5.5 [member.functions], the Implementer's Best Friend).
++<p/>
++While we're in the neighborhood, I recommend simplifying and clarifying the wording used to detect base/derived objects.
++</p>
++
++<p><strong>Previous resolution from Mike Spertus [SUPERSEDED]:</strong></p>
++
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 20.9.2 [func.require]:</p>
++<blockquote><p>
++Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++</p>
++<ul>
++<li><p>
++<tt>(t1.*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>t1</tt> is an object of type <tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference
++to an object of a type derived from <tt>T</tt>;
++</p>
++</li>
++
++<li><p>
++<ins>
++<tt>(t1.get().*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function
++of class <tt>T</tt>
++and <tt>t1</tt> is an object of type <tt>reference_wrapper&lt;U&gt;</tt> where <tt>U</tt>
++is either the type <tt>T</tt> or a type derived from <tt>T</tt>.
++</ins>
++</p>
++</li>
++
++<li><p>
++<tt>((*t1).*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>t1</tt> is not one of the types described in the previous item;
++</p></li>
++
++
++
++<li><p>
++<tt>t1.*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <tt>t1</tt>
++is an object of type <tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference to an object of a
++type derived from <tt>T</tt>;
++</p></li>
++
++<li><p>
++<ins>
++<tt>t1.get().*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a
++class <tt>T</tt> and <tt>t1</tt> is an object of type <tt>reference_wrapper&lt;U&gt;</tt>
++where <tt>U</tt> is either the type <tt>T</tt> or a type derived from <tt>T</tt>.
++</ins>
++</p></li>
++
++<li><p>
++<tt>(*t1).*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <tt>t1</tt>
++is not one of the types described in the previous item;
++</p></li>
++
++<li><p>
++<tt>f(t1, t2, ..., tN)</tt> in all other cases.
++</p></li>
++</ul>
++
++</blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++Waiting for implementation experience.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: latest note from Cologne, waiting for implementation experience<br/>
++STL: don't think this is harder than anything else we do<br/>
++MC: it does involve <tt>mem_fn</tt> and invoke<br/>
++STL: my simplication was not to attempt fine-grained<br/>
++STL: can ignore pmf<br/>
++STL: can't invoke pmf to reference wrapper<br/>
++STL: wording dated back to TR1 when there was no <tt>decltype</tt><br/>
++MC: should <tt>decay_t&lt;decltype(t1)&gt;</tt> be pulled out since it is in multiple places<br/>
++STL: it could be handled editorially<br/>
++STL: we fix function, bind, invoke<br/>
++STL: have not implemented this but believe it is fine<br/>
++MC: Eric F, you have worked in invoke<br/>
++EF: yes, looks ok<br/>
++MC: consensus move to ready
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.9.2 [func.require] p1 as depicted:</p>
++<blockquote><p>
++Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++</p>
++<ul>
++<li><p>
++<tt>(t1.*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<del><tt>t1</tt> is an object of type <tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference
++to an object of a type derived from <tt>T</tt></del><ins><tt>is_base_of&lt;T, decay_t&lt;decltype(t1)&gt;&gt;::value</tt>
++is true</ins>;
++</p>
++</li>
++
++<li><p>
++<ins><tt>(t1.get().*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>decay_t&lt;decltype(t1)&gt;</tt> is a specialization of <tt>reference_wrapper</tt>;</ins>
++</p></li>
++
++<li><p>
++<tt>((*t1).*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function of a class <tt>T</tt> and
++<tt>t1</tt> <del>is not one of the types described in the previous item</del><ins>does not satisfy the previous two
++items</ins>;
++</p></li>
++
++<li><p>
++<tt>t1.*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <del><tt>t1</tt>
++is an object of type <tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference to an object of a
++type derived from <tt>T</tt></del><ins><tt>is_base_of&lt;T, decay_t&lt;decltype(t1)&gt;&gt;::value</tt>
++is true</ins>;
++</p></li>
++
++<li><p>
++<ins><tt>t1.get().*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and
++<tt>decay_t&lt;decltype(t1)&gt;</tt> is a specialization of <tt>reference_wrapper</tt>;</ins>
++</p></li>
++
++<li><p>
++<tt>(*t1).*f</tt> when <tt>N == 1</tt> and <tt>f</tt> is a pointer to member data of a class <tt>T</tt> and <tt>t1</tt>
++<del>is not one of the types described in the previous item</del><ins>does not satisfy the previous two items</ins>;
++</p></li>
++
++<li><p>
++<tt>f(t1, t2, ..., tN)</tt> in all other cases.
++</p></li>
++</ul>
++
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2220"></a>2220. Under-specification of <tt>operator==</tt> for <tt>regex_token_iterator</tt></h3>
++<p><b>Section:</b> 28.12.2.2 [re.tokiter.comp] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-11-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Consider the following example:
++</p>
++<blockquote><pre>
++std::string str0("x");
++std::regex rg0("a");
++std::regex_token_iterator it0(str0.begin(), str0.end(), rg0, -1); // points at "x" in str0
++std::string str1("x");
++std::regex rg1("b");
++std::regex_token_iterator it1(str1.begin(), str1.end(), rg1, -1); // points at "x" in str1
++</pre></blockquote>
++<p>
++28.12.2.2 [re.tokiter.comp] p1 says that <tt>it0.operator==(it1)</tt> returns true "if
++<tt>*this</tt> and <tt>right</tt> are both suffix iterators and <tt>suffix == right.suffix</tt>"; both
++conditions are satisfied in this example. It does not say that they must both be iterators
++into the same sequence, nor does it say (as general iterator requirements do) that they must
++both be in the domain of <tt>==</tt> in order for the comparison to be meaningful. It's a
++simple statement: they're equal if the strings they point at compare equal. Given this being
++a valid comparison, the obtained result of "true" looks odd.
++<p/>
++The problem is that for iterator values prior to the suffix iterator, equality means the same
++regular expression and the same matched sequence (both uses of "same" refer to identity, not equality);
++for the suffix iterator, equality means that the matched sequences compare equal.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2221"></a>2221. No formatted output operator for <tt>nullptr</tt></h3>
++<p><b>Section:</b> 27.7.3 [output.streams] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2012-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++When I write
++</p>
++<blockquote><pre>
++std::cout &lt;&lt; nullptr &lt;&lt; std::endl;
++</pre></blockquote>
++<p>
++I get a compilation error, "ambiguous overload for '<tt>operator&lt;&lt;</tt>' in '<tt>std::cout &lt;&lt; nullptr</tt>'".
++As far as I can tell, the compiler is right to issue that error. There are inserters for <tt>const void*</tt>,
++<tt>const char*</tt>, <tt>const signed char*</tt>, and <tt>const unsigned char*</tt>, and none for
++<tt>nullptr_t</tt>, so the expression really is ambiguous.
++<p/>
++<em>Proposed wording</em>:
++<p/>
++The obvious library solution is to add a <tt>nullptr_t</tt> overload, which would be defined something like
++</p>
++<blockquote><pre>
++template&lt;class C, class T&gt;
++basic_ostream&lt;C, T&gt;&amp; operator&lt;&lt;(basic_ostream&lt;C, T&gt;&amp; os, nullptr_t)
++{
++ return os &lt;&lt; (void*) nullptr;
++}
++</pre></blockquote>
++<p>
++We might also consider addressing this at a core level: add a special-case language rule that addresses all
++cases where you write <tt>f(nullptr)</tt> and <tt>f</tt> is overloaded on multiple pointer types. (Perhaps
++a tiebreaker saying that <tt>void*</tt> is preferred in such cases.)
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2223"></a>2223. <tt>shrink_to_fit</tt> effect on iterator validity</h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2012-12-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++After the additions by <a href="lwg-defects.html#2033">2033</a>, it appears clear that the intended effect includes a reallocation and
++thus the potential effect on iterators should be explicitly added to the text in order to not contradict
++23.2.1 [container.requirements.general]/11, or at the very least, explicitly state that a reallocation may
++happen.
++<p/>
++Taking consistency with "reserve" into consideration, I propose:
++</p>
++<ul>
++<li><p>
++that the current "Remarks" are made its "Effect" instead, inserting "Reallocation happens at this point if and only
++if the function effectively reduces the capacity." after the note on non-bindingness.
++</p>
++</li>
++<li><p>
++adding a "Remarks" paragraph, similar to that of reserve: "Reallocation invalidates all the references, pointers,
++and iterators referring to the elements in the sequence."
++</p></li>
++</ul>
++<p>
++BTW, while we are at it, I believe the effect on iterators should also be explicitly stated in the other instance
++a reallocation may happen: 23.3.6.5 [vector.modifiers]/1 &mdash; even if obvious, it only contradicts
++23.2.1 [container.requirements.general]/11 implicitly.
++<p/>
++I propose to also insert "Reallocation invalidates all the references, pointers, and iterators referring to the
++elements in the sequence." at the appropriate location in its "Remarks".
++</p>
++
++<p><i>[2012-12-19: Jonathan Wakely comments]</i></p>
++
++
++<p>
++The described problem also affects <tt>std::basic_string</tt> and <tt>std::deque</tt>.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Daniel extends the P/R.</p>
++
++<p>Rationale:</p>
++
++<p>The wording in 21.4.4 [string.capacity] combined with 21.4.1 [string.require]
++seems to say the necessary things. We cannot impose all requirements as we do for <tt>vector</tt>, because
++we want to allow the short-string-optimization.</p>
++
++
++<p><i>[2014-02-15 post-Issaquah session]</i></p>
++
++<p>
++STL: I think that <tt>shrink_to_fit</tt> should be a no-op when called twice.
++</p>
++<p>
++STL: Do we ever define reallocation for <tt>deque</tt>? Nope, all mentions of "reallocation" are in <tt>vector</tt>.
++ We define what it means in <tt>vector::reserve()</tt>, but not for <tt>deque</tt>.
++</p>
++<p>
++STL: Oh duh, they define reallocate in the PR. But I think we can do better here.
++</p>
++<p>
++STL: Optimally, deque shrinking just allocates a new map of pointers, and drops empty blocks, but preserves pointers/references to elements.
++</p>
++<p>
++Alisdair: That's like unordered containers, invalidating only iterators.
++</p>
++<p>
++Pablo: It doesn't make sense to reduce <tt>capacity()</tt> to <tt>size()</tt>, because <tt>deque</tt> doesn't have capacity!
++</p>
++<p>
++STL: For <tt>vector</tt>, "effectively reduces the capacity" is unnecessary, the capacity there is observable.
++</p>
++<p>
++STL: There is a strong reason to provide an optimal shrink to fit for <tt>deque</tt>, since only the library implementer can do this.
++</p>
++<p>
++STL: The other thing I don't like the repeated definition of reallocation for <tt>vector</tt>, we define it once and use it in a bunch of places.
++ At most we can lift it up to the <tt>vector</tt> synopsis.
++</p>
++<p>
++STL: I'll write new wording.
++</p>
++
++<p><i>[2014-10-01, STL adds discussion and provides new wording]</i></p>
++
++<p>
++Compared to the previous proposed resolution:
++</p>
++<ul>
++<li><p>
++I'm changing <tt>basic_string</tt>'s wording because (1) we should guarantee that capacity won't increase, (2) we should mention
++that it's linear complexity, and (3) we can provide a better invalidation guarantee than 21.4.1 [string.require]/5.
++(As previously noted, we already have the strong exception guarantee.) This introduces the term "reallocation" into
++<tt>basic_string</tt>, but immediately explains what it means for iterator validity. As far as I can tell, the Small String
++Optimization doesn't complicate the wording here; it's a reason why an implementation might not honor the request, but if
++the capacity is reduced, we are definitely reallocating buffers and will invalidate everything (including when the destination
++is the small buffer).
++</p></li>
++<li><p>
++Between N3485 and N3936, <tt>deque</tt>'s wording was updated to avoid talking about <tt>capacity()</tt> which it doesn't have.
++Since the container's capacity is unobservable, I'm saying that invalidation is unconditional.
++</p></li>
++<li><p>
++In <tt>vector</tt>'s wording, I'm also guaranteeing that capacity won't increase, and that iterators/etc. remain valid if the
++capacity is unchanged.
++</p></li>
++</ul>
++<p>
++My wording doesn't directly say that <tt>shrink_to_fit()</tt> should be a no-op when called twice in a row. (Indirectly,
++if the first call reduces <tt>capacity()</tt> to <tt>size()</tt>, the second call must preserve iterators/etc.) I considered
++rewording the complexity to say "linear if reallocation happens", but that's potentially problematic (what if we copy almost
++all <tt>N</tt> elements, then one throws and we have to unwind? There are no effects, so reallocation didn't happen, yet we
++took longer than constant time). Implementers can always do better than the stated complexity bounds.
++<p/>
++I chose not to modify <tt>deque</tt>'s requirements, so implementations remain free to reallocate the elements themselves.
++<p/>
++I didn't attempt to centralize vector's reallocation wording. That can be done editorially, if someone is sufficiently motivated.
++</p>
++
++<p><strong>Previous resolution from Juan Soulie/Daniel [SUPERSEDED]:</strong></p>
++
++<blockquote class="note">
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Keep 21.4.4 [string.capacity] around p14 <em>unchanged</em>, because we don't speak about
++reallocations and we give the strong exception guarantee in 21.4.1 [string.require] (Invalidation
++specification also at that place):</p>
++<blockquote><pre>
++void shrink_to_fit();
++</pre>
++<p>
++-14- <i>Remarks</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to
++<tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i> ].
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.3.3 [deque.capacity] around p7 as indicated:</p>
++<blockquote><pre>
++void shrink_to_fit();
++</pre>
++<p>
++-5- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Effects</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to
++<tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i> ] Reallocation happens at this point if and only
++if the function effectively reduces the capacity. If an exception is thrown other than by the move constructor
++of a non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</ins>
++<p/>
++-6- <i>Complexity</i>: Linear in the size of the sequence.
++<p/>
++-7- <i>Remarks</i>: <del><tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to
++<tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i> ] If an exception is thrown other than by the move constructor
++of a non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</del><ins>Reallocation invalidates all
++the references, pointers, and iterators referring to the elements in the sequence.</ins>
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.6.3 [vector.capacity] around p7 as indicated:</p>
++<blockquote><pre>
++void shrink_to_fit();
++</pre>
++<p>
++-7- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Effects</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to
++<tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i> ] Reallocation happens at this point if and only
++if the function effectively reduces the capacity. If an exception is thrown other than by the move constructor
++of a non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</ins>
++<p/>
++-8- <i>Complexity</i>: Linear in the size of the sequence.
++<p/>
++-9- <i>Remarks</i>: <del><tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to
++<tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i> ] If an exception is thrown other than by the move constructor
++of a non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</del><ins>Reallocation invalidates all
++the references, pointers, and iterators referring to the elements in the sequence.</ins>
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.6.5 [vector.modifiers] p1 as indicated:</p>
++<blockquote><pre>
++iterator insert(const_iterator position, const T&amp; x);
++iterator insert(const_iterator position, T&amp;&amp; x);
++iterator insert(const_iterator position, size_type n, const T&amp; x);
++template &lt;class InputIterator&gt;
++iterator insert(const_iterator position, InputIterator first, InputIterator last);
++iterator insert(const_iterator position, initializer_list&lt;T&gt;);
++template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
++void push_back(const T&amp; x);
++void push_back(T&amp;&amp; x);
++</pre>
++<p>
++-1- <i>Remarks</i>: Causes reallocation if the new size is greater than the old capacity. <ins>Reallocation
++invalidates all the references, pointers, and iterators referring to the elements in the sequence.</ins> If
++no reallocation happens, all the iterators and references before the insertion point remain valid. If an
++exception is thrown other than by the copy constructor, move constructor, assignment operator, or move
++assignment operator of <tt>T</tt> or by any <tt>InputIterator</tt> operation there are no effects. If an
++exception is thrown by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</p>
++</blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++GR: I'm concerned that <tt>shrink_to_fit</tt> may cause reallocation without changing the capacity. [&hellip;]
++It's about correctness. The statement about invalidation is useless if I cannot detect whether reallocation has happened?
++<p/>
++AM: It seems like the logic goes the other way round: It's the capacity change that causes reallocation, so if
++there's no capacity change, there's no reallocation. But that's not quite how I'd like to say it... maybe this, :
++"If capacity does not change, no reallocation occurs."
++<p/>
++GR: Where does it actually say that <tt>reserve()</tt> invalidates? AM: It should say that in the container requirements.
++VV: vector specifies in <tt>reserve</tt> that there's reallocation if and only if the capacity changes. GR: I can't find
++anything in the container requirements about <tt>reserve</tt>. DK: No, it's specified for every container separately.
++GR: It isn't specified for string.
++<p/>
++GR: I'm noticing that the issue touches on <tt>shrink_to_fit</tt> for a bunch of containers. Anyway, I think the
++reserve issue [re string] is in scope for this issue. This change is touching on a lot of members.
++<p/>
++AM: Landing this change will provide clarity for what we should do with <tt>basic_string</tt>. GR: We're already asking
++for changes; we should fix string as well. AM: If one of the changes is ready before the other, I'd like to land the
++finished part first, but if both are ready for Lenexa, I'm equally happy to fix them in one go.
++<p/>
++DK will reword this.
++<p/>
++<b>Conclusion</b>: Update wording, revisit in Lenexa.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 21.4.4 [string.capacity] p14 as depicted:</p>
++
++<blockquote>
++<pre>
++void shrink_to_fit();
++</pre>
++<blockquote>
++<p>
++-14- <i><del>Remarks</del><ins>Effects</ins></i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce
++<tt>capacity()</tt> to <tt>size()</tt>. [<i>Note</i>: The request is non-binding to allow latitude for
++implementation-specific optimizations. &mdash; <i>end note</i>] <ins>It does not increase <tt>capacity()</tt>,
++but may reduce <tt>capacity()</tt> by causing reallocation.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: Linear in the size of the sequence.</ins>
++<p/>
++<ins>-?- <i>Remarks</i>: Reallocation invalidates all the references, pointers, and iterators referring to the
++elements in the sequence. If no reallocation happens, they remain valid.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.3.3 [deque.capacity] p5-p7 as depicted:</p>
++<blockquote>
++<pre>
++void shrink_to_fit();
++</pre>
++<blockquote>
++<p>
++-5- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Effects</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce memory use but does not change
++the size of the sequence. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i>] If an exception is thrown other than by the move constructor of a
++non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</ins>
++<p/>
++-6- <i>Complexity</i>: Linear in the size of the sequence.
++<p/>
++-7- <i>Remarks</i>: <del><tt>shrink_to_fit</tt> is a non-binding request to reduce memory use but does not change the
++size of the sequence. [<i>Note</i>: The request is non-binding to allow latitude for implementation-specific
++optimizations. &mdash; <i>end note</i>]</del><ins><tt>shrink_to_fit</tt> invalidates all the references, pointers,
++and iterators referring to the elements in the sequence.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.3 [vector.capacity] p7-p9 as depicted:</p>
++<blockquote>
++<pre>
++void shrink_to_fit();
++</pre>
++<blockquote>
++<p>
++-7- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Effects</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to <tt>size()</tt>.
++[<i>Note</i>: The request is non-binding to allow latitude for implementation-specific optimizations. &mdash; <i>end note</i>]
++It does not increase <tt>capacity()</tt>, but may reduce <tt>capacity()</tt> by causing reallocation. If an exception is
++thrown other than by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.</ins>
++<p/>
++-8- <i>Complexity</i>: Linear in the size of the sequence.
++<p/>
++-9- <i>Remarks</i>: <del><tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to <tt>size()</tt>.
++[<i>Note</i>: The request is non-binding to allow latitude for implementation-specific optimizations. &mdash; <i>end
++note</i>] If an exception is thrown other than by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt> there
++are no effects.</del><ins>Reallocation invalidates all the references, pointers, and iterators referring to the elements
++in the sequence. If no reallocation happens, they remain valid.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.5 [vector.modifiers] p1 as depicted:</p>
++
++<blockquote>
++<p>
++-1- <i>Remarks</i>: Causes reallocation if the new size is greater than the old capacity. <ins>Reallocation invalidates all
++the references, pointers, and iterators referring to the elements in the sequence.</ins> If no reallocation happens,
++all the iterators and references before the insertion point remain valid. [&hellip;]
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2224"></a>2224. Ambiguous status of access to non-live objects</h3>
++<p><b>Section:</b> 17.6.4.10 [res.on.objects] <b>Status:</b> <a href="lwg-active.html#Ready">Tentatively Ready</a>
++ <b>Submitter:</b> Geoffrey Romer <b>Opened:</b> 2012-12-17 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.objects">issues</a> in [res.on.objects].</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The standard currently does not discuss when library objects may be accessed, except in a non-normative
++note pertaining to synchronization in [res.on.objects], leaving it ambiguous whether single-threaded
++code can access a library object during its construction or destruction. For example, there is a
++reasonable question as to what happens if the deleter supplied to a <tt>unique_ptr</tt> transitively
++accesses the <tt>unique_ptr</tt> itself during <tt>unique_ptr</tt>'s destruction; a straightforward
++reading suggests that this is permitted, and that the deleter will see the <tt>unique_ptr</tt> still
++holding the originally stored pointer, but consensus on the LWG reflector indicates this was not the
++intent (see discussion beginning with
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=33362">c++std-lib-33362</a>).
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Geoffrey will provide an example that clearly highlights the issue.
++</p>
++
++<p><i>[2013-03-19 Geoffrey provides revised resolution and an example]</i></p>
++
++
++<p>
++I contend that the most straightforward reading of the current standard requires the following example code to print
++"good" (because <tt>~unique_ptr</tt> is not specified to modify the state of the internal pointer), but the consensus
++on the reflector was that its behavior should be undefined.
++<p/>
++This example also shows that, contrary to a comment in the telecon, the PR is not tautological. 12.7 [class.cdtor]/p4
++explicitly permits member function calls during destruction, so the behavior of this code is well-defined as far as
++the core language is concerned, despite the fact that it accesses a library object after the end of the object's
++lifetime. If we want this code to have undefined behavior, we need to specify that at the library level.
++</p>
++
++<blockquote><pre>
++#include &lt;memory&gt;
++#include &lt;iostream&gt;
++
++class A;
++
++struct B {
++ std::unique_ptr&lt;A&gt; a;
++};
++
++struct A {
++ B* b;
++ ~A() {
++ if (b-&gt;a.get() == this) {
++ std::cout &lt;&lt; "good" &lt;&lt; std::endl;
++ }
++ }
++};
++
++int main() {
++ B b;
++ b.a.reset(new A);
++ b.a-&gt;b = &amp;b;
++}
++</pre></blockquote>
++
++<p>
++Previous resolution:
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Change the title of sub-clause 17.6.4.10 [res.on.objects] as indicated:</p>
++<p><del>Shared objects and the library</del><ins>Library object access</ins> [res.on.objects]</p>
++</li>
++
++<li><p>Edit 17.6.4.10 [res.on.objects] p2 as indicated:</p>
++<p>-2- <del>[<i>Note</i>: In particular, the program is required to ensure that completion of the constructor
++of any object of a class type defined in the standard library happens before any other member function
++invocation on that object and, unless otherwise specified, to ensure that completion of any member function
++invocation other than destruction on such an object happens before destruction of that object. This applies
++even to objects such as mutexes intended for thread synchronization. &mdash; <i>end note</i>]</del>
++<ins>If an object of a standard library type is accessed outside of the object's lifetime (3.8 [basic.life]),
++the behavior is undefined unless otherwise specified.</ins></p>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014 Urbana]</i></p>
++
++<p>
++STL: is this resolved by our change to the reeentrancy rules? [LWG <a href="lwg-active.html#2414">2414</a>]<br/>
++GR: don't think that solves the multi-threaded case<br/>
++MC: I like changing the note to normative text<br/>
++GR: uses the magic "happens before" words, and "access" is magic too<br/>
++JW: I like this. strict improvement, uses the right wording we have to say this properly<br/>
++STL: I like the last sentence of the note, could we add that as a new note at the end?<br/>
++So add "[Note: This applies even to objects such as mutexes intended for thread synchronization.]" to the end and move to Ready
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Change the title of sub-clause 17.6.4.10 [res.on.objects] as indicated:</p>
++<p><del>Shared objects and the library</del><ins>Library object access</ins> [res.on.objects]</p>
++</li>
++
++<li><p>Edit 17.6.4.10 [res.on.objects] p2 as indicated: <em>[<i>Editorial remark:</i> The motivation, is to
++be more precise about the meaning of "outside the object's lifetime" in the presence of threads &mdash; <i>end editorial
++remark</i>]</em></p>
++<p>-2- <del>[<i>Note</i>: In particular, the program is required to ensure that completion of the constructor
++of any object of a class type defined in the standard library happens before any other member function
++invocation on that object and, unless otherwise specified, to ensure that completion of any member function
++invocation other than destruction on such an object happens before destruction of that object. This applies
++even to objects such as mutexes intended for thread synchronization. &mdash; <i>end note</i>]</del>
++<ins>If an object of a standard library type is accessed, and the beginning of the object's lifetime
++(3.8 [basic.life]) does not happen before the access, or the access does not happen before the end
++of the object's lifetime, the behavior is undefined unless otherwise specified. [<i>Note</i>: This applies even to
++objects such as mutexes intended for thread synchronization. &mdash; <i>end note</i>]</ins></p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2226"></a>2226. <tt>wstring_convert</tt> methods do not take allocator instance</h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Glen Fernandes <b>Opened:</b> 2012-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The <tt>wstring_convert</tt> class template, described in 22.3.3.2.2 [conversions.string], does not
++support custom stateful allocators. It only supports custom stateless allocators.
++<p/>
++The <tt>to_bytes</tt> member function returns <tt>basic_string&lt;char, char_traits&lt;char&gt;, Byte_alloc&gt;</tt>
++but it does not take an instance of <tt>Byte_alloc</tt> to pass to the constructor of the <tt>basic_string</tt>.
++<p/>
++Similarly the <tt>from_bytes</tt> member function returns <tt>basic_string&lt;Elem, char_traits&lt;Elem&gt;, Wide_alloc&gt;</tt>
++but it does not take an instance of <tt>Wide_alloc</tt> to pass to the constructor of the <tt>basic_string</tt>.
++<p/>
++This makes these two member functions and the <tt>wstring_convert</tt> class template not usable when <tt>Wide_alloc</tt>
++or <tt>Byte_alloc</tt> are stateful allocators.
++</p>
++
++<p><i>[2013-01-22, Glen provides wording]</i></p>
++
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to NAD Future.
++</p>
++<p>
++This is clearly an extension that the LEWG may want to take a look at, once we have more experience
++with appropriate use of allocators with the C++11 model.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>In 22.3.3.2.2 [conversions.string]/2 and /6 "Class template <tt>wstring_convert</tt> synopsis" change the overloads
++of the member function <tt>from_bytes()</tt> so that all four overloads take an additional parameter
++which is an instance of <tt>Wide_alloc</tt>:</p>
++
++<blockquote><pre>
++wide_string from_bytes(char byte<ins>, const Wide_alloc&amp; alloc = Wide_alloc()</ins>);
++wide_string from_bytes(const char *ptr<ins>, const Wide_alloc&amp; alloc = Wide_alloc()</ins>);
++wide_string from_bytes(const byte_string&amp; str<ins>, const Wide_alloc&amp; alloc = Wide_alloc()</ins>);
++wide_string from_bytes(const char *first, const char *last<ins>, const Wide_alloc&amp; alloc = Wide_alloc()</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>In 22.3.3.2.2 [conversions.string] /8 specify that this <tt>Wide_alloc</tt> allocator parameter is used to
++construct the <tt>wide_string</tt> object returned from the function:</p>
++
++<p>
++-7- <i>Effects</i>: The first member function shall convert the single-element sequence <tt>byte</tt> to a wide string.
++The second member function shall convert the null-terminated sequence beginning at <tt>ptr</tt> to a wide
++string. The third member function shall convert the sequence stored in <tt>str</tt> to a wide string. The fourth
++member function shall convert the sequence defined by the range <tt>[first, last)</tt> to a wide string.
++<p/>
++-8- In all cases:
++</p>
++<ul>
++<li><p>If the <tt>cvtstate</tt> object was not constructed with an explicit value, it shall be set to its default value
++(the initial conversion state) before the conversion begins. Otherwise it shall be left unchanged.</p></li>
++
++<li><p>The number of input elements successfully converted shall be stored in <tt>cvtcount</tt>.</p></li>
++
++<li><p><ins>The <tt>Wide_alloc</tt> allocator parameter is used to construct the <tt>wide_string</tt> object returned
++from the function.</ins></p></li>
++</ul>
++</li>
++
++<li><p>In 22.3.3.2.2 [conversions.string]/2 and /12 "Class template <tt>wstring_convert</tt> synopsis" change the overloads
++of the member function <tt>to_bytes()</tt> so that all four overloads take an additional parameter
++which is an instance of <tt>Byte_alloc</tt>:</p>
++
++<blockquote><pre>
++byte_string to_bytes(Elem wchar<ins>, const Byte_alloc&amp; alloc = Byte_alloc()</ins>);
++byte_string to_bytes(const Elem *wptr<ins>, const Byte_alloc&amp; alloc = Byte_alloc()</ins>);
++byte_string to_bytes(const wide_string&amp; wstr<ins>, const Byte_alloc&amp; alloc = Byte_alloc()</ins>);
++byte_string to_bytes(const Elem *first, const Elem *last<ins>, const Byte_alloc&amp; alloc = Byte_alloc()</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>In 22.3.3.2.2 [conversions.string] /13 specify that this <tt>Byte_alloc</tt> allocator parameter is used to
++construct the <tt>byte_string</tt> object returned from the function:</p>
++
++<p>
++-12- <i>Effects</i>: The first member function shall convert the single-element sequence <tt>wchar</tt> to a byte string.
++The second member function shall convert the null-terminated sequence beginning at <tt>wptr</tt> to a byte
++string. The third member function shall convert the sequence stored in <tt>wstr</tt> to a byte string. The
++fourth member function shall convert the sequence defined by the range <tt>[first, last)</tt> to a byte string.
++<p/>
++-13- In all cases:
++</p>
++<ul>
++<li><p>If the <tt>cvtstate</tt> object was not constructed with an explicit value, it shall be set to its default value
++(the initial conversion state) before the conversion begins. Otherwise it shall be left unchanged.</p></li>
++
++<li><p>The number of input elements successfully converted shall be stored in <tt>cvtcount</tt>.</p></li>
++
++<li><p><ins>The <tt>Byte_alloc</tt> allocator parameter is used to construct the <tt>byte_string</tt> object returned
++from the function.</ins></p></li>
++</ul>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2227"></a>2227. Stateful comparison objects in associative containers</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2012-12-19 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Table 102 in 23.2.4 [associative.reqmts]/8 states on expression <tt>a.key_comp()</tt> that it
++"returns the comparison object out of which a was constructed". At the same time,
++23.2.1 [container.requirements.general]/8 states (starting in the third line) that
++"...Any <tt>Compare</tt>, <tt>Pred</tt>, or <tt>Hash</tt> objects belonging to <tt>a</tt> and <tt>b</tt>
++shall be swappable and <em>shall be exchanged</em> by unqualified calls to non-member swap...". This is
++problematic for any compliant implementation, since once swapped the container cannot return the comparison
++object out of which it was constructed unless incurring in storing an otherwise needless object.
++<p/>
++The simple solution is to correct that statement in Table 102, but I believe this is part of a larger problem
++of underspecified behavior: The new standard has made an effort in regards to allocators and now fully
++specifies what happens to stateful allocator objects. It has even specified what happens to stateful <tt>hasher</tt>
++and <tt>key_equal</tt> members of unordered containers (they propagate), but it says nothing about stateful
++comparison objects of (ordered) associative containers, except for the statement in
++23.2.1 [container.requirements.general]/8 referred above and only related to <tt>swap</tt>.
++<p/>
++For example, it is unclear to me what is specified to happen on an assignment: should the comparison object
++be copied/moved along with the elements, or should the left-hand side object keep its own?
++Maybe this has been intentionally left unspecified with the purpose of compatibility with C++98, which I
++understand it specified that comparison objects were kept for the entire life of the container (like allocators)
++&mdash; an unfortunate choice. But anyway, the segment of 23.2.1 [container.requirements.general] quoted
++above seems to break any possible backwards compatibility with C++98 in this regard.
++<p/>
++Therefore, taking into consideration consistency with how this is dealed with for unordered associative
++containers, I propose that Table 102 is modified as follows:
++</p>
++<ul>
++<li>
++<p>
++The row for expression <tt>a.key_comp()</tt> is changed so that its "assertion/note pre-/post-condition" reads
++"Returns <tt>a</tt>'s comparison object."
++</p>
++</li>
++
++<li>
++<p>
++A new row is added at the appropriate location (which I believe would be after "X(il)" row), with:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td>
++<tt>X(b)<br/>
++X a(b)</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++Copy constructor. In addition to<br/>
++the requirements of Table 96, copies<br/>
++the comparison object.
++</td>
++<td>
++Linear in <tt>b.size()</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a = b</tt>
++</td>
++<td>
++<tt>X&amp;</tt>
++</td>
++<td>
++Copy assignment operator. In addition to<br/>
++the requirements of Table 96, copies the<br/>
++comparison object.
++</td>
++<td>
++Linear in <tt>a.size()</tt> and <tt>b.size()</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ul>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++<p>
++STL: can't believe we don't specify this already. this is totally necessary
++<p/>
++Alisdair: how does it do this? copy construction? assignment?
++<p/>
++Also need it for move.
++<p/>
++STL: we already specify this for constructing from a comparator, not during copy construction though.
++<p/>
++Jonathan: don't like wording, should say "<tt>key_compare</tt> is <tt>CopyConstructible</tt>. Uses <tt>b.key_comp()</tt>
++as a comparison object."
++<p/>
++STL: we get it right for unordered!
++<p/>
++Jonathan: can't wordsmith this now, but I think implementations do the right thing.
++<p/>
++Alisdair: not sure what right thing is for moves. Also we say nothing about propagating allocators to functors.
++</p>
++<p>
++Moved to Open.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++TK: There's no need for fine-grained propagate/not-propagate control. If you don't want to propagate the predicate, you can
++simply construct or insert from an iterator range.
++<p/>
++VV: libstdc++ already implements the resolution of this issue.
++<p/>
++GR: There are a couple of other problems. We don't specify move constructor and move assignment for maps. Those are just general.
++<p/>
++TK: General container requirements already describe the semantics for {copy,move}-{construction,assignment}, so it doesn't
++seem that there's room for choice in <tt>std::map</tt> assignments. <tt>unordered_map</tt> is different, though.
++<p/>
++[Note: Check what general container requirements say about container equality.]
++<p/>
++DK will draft wording. The decision is to unambiguously make all {copy,move}-{construction,assignment} operations endow the
++LHS with the exact state of the RHS, including all predicates and hash function states.
++<p/>
++Conclusion: Update wording, revisit later.
++</p>
++
++<p><i>[2015-05-06 Lenexa: Waiting for updated wording]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Change Table 102 as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(il)</tt>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++Same as <tt>X(il.begin(), il.end())</tt>.
++</td>
++<td>
++same as <tt>X(il.begin(), il.end())</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X(b)<br/>
++X a(b)</tt></ins>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++<ins>Copy constructor. In addition to<br/>
++the requirements of Table 96, copies<br/>
++the comparison object.</ins>
++</td>
++<td>
++<ins>Linear in <tt>b.size()</tt></ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>a = b</tt></ins>
++</td>
++<td>
++<ins><tt>X&amp;</tt></ins>
++</td>
++<td>
++<ins>Copy assignment operator. In addition to<br/>
++the requirements of Table 96, copies the<br/>
++comparison object.</ins>
++</td>
++<td>
++<ins>Linear in <tt>a.size()</tt> and <tt>b.size()</tt></ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.key_comp()</tt>
++</td>
++<td>
++<tt>X::key_compare</tt>
++</td>
++<td>
++<del>r</del><ins>R</ins>eturns <del>the</del><ins><tt>a</tt>'s</ins> comparison object<br/>
++<del>out of which a was constructed.</del>
++</td>
++<td>
++constant
++</td>
++</tr>
++
++
++</table>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2232"></a>2232. [CD] The <tt>char_traits</tt> specializations should declare their <tt>length()</tt>, <tt>compare()</tt>, and
++<tt>find()</tt> members constexpr</h3>
++<p><b>Section:</b> 21.2.3 [char.traits.specializations] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2012-12-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits.specializations">issues</a> in [char.traits.specializations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses ES 14, US 19</b></p>
++
++<p>
++These functions have easy recursive constexpr implementations that, unfortunately, aren't efficient at runtime.
++EWG is still figuring out how to solve this problem in general (e.g.,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3444.html">N3444</a> isn't sufficient to avoid
++stack overflows in debug builds or to get the optimal assembly-based implementations at runtime), so users can't
++portably solve this problem for themselves, but implementations can use compiler-specific techniques to choose
++the right implementation inside their standard libraries.
++</p>
++
++<p>
++The LWG is still undecided about whether individual implementations can add constexpr to these functions, so we
++need to add <tt>constexpr</tt> to the standard here for implementations to be able to improve this.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++There are a number of people who have a strong interest in this issue not available for the telecon.
++</p>
++<p>
++It also plays at the heart of a discussion about library freedoms for <tt>constexpr</tt> and specifying
++a library that may depend on unspecified compiler intrinsics to be implementable.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Moved to NAD Future.
++</p>
++<p>
++While it is clear that this feature can be implemented using only C++14 <tt>constexpr</tt> features,
++there is real concern that we cannot call the efficient, highly optimized, C implementations of these
++functions under a C++14 <tt>constexpr</tt> implementation, nor implement similar ourselves as this
++typically involves use of inline <tt>asm</tt> instructions.
++</p>
++<p>
++Clang and libc++ have some experience of using intrinsics to try to address the performance issue, but
++the current intrinsics are not general enough to support <tt>char_traits</tt>. The intrinsics support
++only operations on character string literals, and the string literal is no longer visible <i>as</i> a
++literal after passing as a <tt>const char *</tt> to the <tt>char_traits</tt> functions.
++</p>
++<p>
++Additional concern was raised that these operations are unlikely to be useful anyway, as the only client
++is <tt>basic_string</tt> which relies on dynamic memory allocation, and so cannot effectively be made a
++literal type. Jeffrey then pointed out the pending <tt>string_view</tt> library that will also use
++<tt>char_traits</tt> and would most certainly benefit from being a literal type.
++</p>
++
++<p>
++Given the choice of giving up performance on a critical library component, or requiring a compiler
++intrinsic with only unsuccessful implementation experience, the consensus is to not reject this, unless
++compelling implementation experience is demonstrated. NAD Future seems the appropriate resolution.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 21.2.3.1 [char.traits.specializations.char], 21.2.3.2 [char.traits.specializations.char16_t],
++21.2.3.3 [char.traits.specializations.char32_t], and 21.2.3.4 [char.traits.specializations.wchar.t]:</p>
++<blockquote><pre>
++static <ins>constexpr</ins> int compare(const char_type* s1, const char_type* s2, size_t n);
++static <ins>constexpr</ins> size_t length(const char_type* s);
++static <ins>constexpr</ins> const char_type* find(const char_type* s, size_t n, const char_type&amp; a);
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2234"></a>2234. <tt>assert()</tt> should allow usage in constant expressions</h3>
++<p><b>Section:</b> 19.3 [assertions] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-01-12 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#assertions">active issues</a> in [assertions].</p>
++<p><b>View all other</b> <a href="lwg-index.html#assertions">issues</a> in [assertions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++It is unclear from the current specification whether <tt>assert()</tt> expressions can be used in
++(potential) constant expressions. As an example consider the implementation of a <tt>constexpr</tt>
++function:
++</p>
++
++<blockquote><pre>
++#include &lt;cassert&gt;
++
++template&lt;class T, unsigned N&gt;
++struct array {
++ T data[N];
++ constexpr const T&amp; operator[](unsigned i) const {
++ return assert(i &lt; N), data[i];
++ }
++};
++
++int main() {
++ constexpr array&lt;int, 3&gt; ai = {1, 2, 3};
++ constexpr int i = ai[0];
++ int j = ai[0];
++ // constexpr int k = ai[5];
++}
++</pre></blockquote>
++
++<p>
++The first question is whether this program is guaranteed well-formed? A second question is whether is would guaranteed to be
++ill-formed, if we uncomment the last code line in <tt>main()</tt>?
++</p>
++
++<p>
++The wording in 19.3 [assertions] doesn't add anything significant to the C99 wording. From the C99 specification
++(7.2 p1 and 7.2.1.1 p2) we get already some valuable guarantees:
++</p>
++
++<ul>
++<li><p>
++The expression <tt>assert(e)</tt> is a <tt>void</tt> expression for all expressions <tt>e</tt> independent of
++the definition of <tt>NDEBUG</tt>.
++</p></li>
++<li><p>
++If <tt>NDEBUG</tt> is defined, <tt>assert(e)</tt> is equivalent to the expression <tt>void()</tt>
++(or anything that cannot be distinguished from that).
++</p></li>
++</ul>
++
++<p>
++The current wording does not yet <em>guarantee</em> that <tt>assert</tt> expressions can be used in constant expressions,
++but all tested implementations (gcc, MSVC) would already support this use-case. It seems to me that this should be possible
++without giving <tt>assert</tt> a special meaning for the core language.
++<p/>
++As a related comment it should be added, that there is a core language
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3444.html">proposal</a>
++that intents to relax some current constraints for <tt>constexpr</tt> functions and <tt>literal</tt> types. The most
++interesting one (making <tt>void</tt> a literal types and allowing for expression-statements) would simplify the motivating
++example implementation of <tt>operator[]</tt> to:
++</p>
++<blockquote><pre>
++constexpr const T&amp; operator[](unsigned i) const {
++ assert(i &lt; N);
++ return data[i];
++};
++</pre></blockquote>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++We are still gaining experience with <tt>constexpr</tt> as a language feature, and there may
++be work in Evolution that would help address some of these concerns. Defer discussion until
++we have a group familiar with any evolutionary direction.
++</p>
++
++<p><i>[2014-06-08, Daniel comments and suggests wording]</i></p>
++
++<p>
++After approval of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3652.html"/>N3652<a/>,
++<tt>void</tt> is now a literal type and <tt>constexpr</tt> functions can contain multiple statements, so
++this makes the guarantee that <tt>assert</tt> expressions are per-se <tt>constexpr</tt>-friendly even more
++relevant. A possible wording form could be along the lines of:
++</p>
++<blockquote>
++<p>
++For every core constant expression <em>e</em> of scalar type that evaluates to <tt>true</tt> after being contextually
++converted to <tt>bool</tt>, the expression <tt>assert(<em>e</em>)</tt> shall be a prvalue core constant expression of type
++<tt>void</tt>.
++</p>
++</blockquote>
++<p>
++Richard Smith pointed out some weaknesses of this wording form, for example it would not guarantee to require
++the following example to work:
++</p>
++<blockquote><pre>
++constexpr void check(bool b) { assert(b); }
++</pre></blockquote>
++<p>
++because <tt>b</tt> is not a core constant expression in this context.
++<p/>
++He suggested improvements that lead to the wording form presented below (any defects mine).
++</p>
++
++<p><i>[Lenexa 2015-05-05]</i></p>
++
++<p>MC : ran into this</p>
++<p>Z : Is it guaranteed to be an expression?</p>
++<p>MC : clarifies that assert runs at runtime, not sure what it does at compile time</p>
++<p>STL : c standard guarantees its an expression and not a whole statement, so comma chaining it is ok</p>
++<p>HH : Some implementations work as author wants it to</p>
++<p>STL : also doing this as constexpr</p>
++<p>DK/STL : discussing how this can actually work</p>
++<p>HH : GCC 5 also implements it. We have implementor convergence</p>
++<p>MC : Wants to do this without giving assert a special meaning</p>
++<p>STL : NDEBUG being defined where assert appears is not how assert works. This is bug in wording. Should be "when assert is defined" or something like that. ... is a constant subexpression if NDEBUG is defined at the point where assert is last defined or redefined."</p>
++<p>Would like to strike the "either" because ok if both debug or assertion is true. We want inclusive-or here</p>
++<p>MC : is redefined needed?</p>
++<p>STL : my mental model is its defined once and then redefined</p>
++<p>HH : wants to up to P2</p>
++<p>Z/STL : discussing how wording takes care of how/when assert is defined/redefefined</p>
++<p>STL/WB : discussing whether to move to ready or review. -> Want to move it to ready.</p>
++<p>ask for updated wording</p>
++<p>p3 -> p2</p>
++<p>plan to go to ready after checking wording</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Introduce the following new definition to the existing list in 17.3 [definitions]: [<i>Drafting note</i>:
++If LWG <a href="lwg-active.html#2296">2296</a> is accepted before this issue, the accepted wording for the new definition should be used instead
++&mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<p>
++<strong>constant subexpression</strong> [defns.const.subexpr]
++<p/>
++an expression whose evaluation as subexpression of a <em>conditional-expression</em> <em>CE</em> (5.16 [expr.cond])
++would not prevent <em>CE</em> from being a core constant expression (5.20 [expr.const]).
++</p>
++</blockquote>
++</li>
++
++<li><p>Insert a new paragraph following 19.3 [assertions] p1 as indicated:</p>
++
++<blockquote>
++<p>
++<ins>-?- An expression <tt>assert(<em>E</em>)</tt> is a constant subexpression ( [defns.const.subexpr]), if either</ins>
++</p>
++<ul>
++<li><p><ins><tt>NDEBUG</tt> is defined at the point where <tt>assert(<em>E</em>)</tt> appears, or</ins></p></li>
++<li><p><ins><tt><em>E</em></tt> contextually converted to <tt>bool</tt> (4 [conv]), is a constant subexpression
++that evaluates to the value <tt>true</tt>.</ins></p></li>
++</ul>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2236"></a>2236. <tt>kill_dependency</tt> unconditionally noexcept</h3>
++<p><b>Section:</b> 29.2 [atomics.syn], 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#SG1">SG1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-01-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.syn">issues</a> in [atomics.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#SG1">SG1</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The "magic" <tt>kill_dependency</tt> function is a function without any constraints on the template parameter <tt>T</tt>
++and is specified as
++</p>
++
++<blockquote><pre>
++template &lt;class T&gt;
++T kill_dependency(T y) noexcept;
++</pre><blockquote>
++<p>
++-14- <i>Effects</i>: The argument does not carry a dependency to the return value (1.10).
++<p/>
++-15- <i>Returns</i>: <tt>y</tt>.
++</p>
++</blockquote></blockquote>
++
++<p>
++I wonder whether the unconditional <tt>noexcept</tt> is really intended here:
++Assume we have some type <tt>U</tt> that has a potentially throwing move
++constructor (or it has a potentially throwing copy constructor and no
++move constructor), for any "normal" function template with the same
++signature and the same effects (modulo the dependency magic) this
++would mean that it cannot safely be declared <tt>noexcept</tt> because of the
++return statement being part of the complete function call affected by
++<tt>noexcept</tt> (The by-value function argument is irrelevant in this
++context). In other words it seems that a function call such as
++</p>
++
++<blockquote><pre>
++struct S {
++ ...
++ S(const S&amp; r) { if(<em>some condition</em>) throw Something(); }
++ ...
++};
++
++int main() {
++ S s1 = ...;
++ S s2 = std::kill_dependency(s1);
++}
++</pre></blockquote>
++
++<p>
++would be required to call <tt>std::terminate</tt> if the copy constructor of <tt>S</tt> throws during the return
++of <tt>std::kill_dependency</tt>.
++<p/>
++To require copy elision for this already magic function would look like a low-hanging fruit to solve this problem,
++but this case is not covered by current copy elision rules see 12.8 p31 b1:
++<p/>
++"&mdash; in a return statement in a function with a class return type, when the expression is the name of a non-volatile
++automatic object (other than a function or catch-clause parameter) with the same <em>cv</em>-unqualified type as the
++function return type, the copy/move operation can be omitted by constructing the automatic object directly into the
++function's return value".
++<p/>
++Some options come into my mind:
++</p>
++<ol>
++<li><p>
++Make the exception-specification a constrained one in regard via <tt>std::is_nothrow_move_constructible</tt>:
++</p>
++
++<blockquote><pre>
++template &lt;class T&gt;
++T kill_dependency(T y) noexcept(<em>see below</em>);
++</pre></blockquote>
++
++<p>
++This is similar to the approach taken for function templates such as <tt>std::swap</tt>.
++</p>
++</li>
++
++<li><p>
++Use perfect forwarding (This needs further wording to correct the effects):
++</p>
++
++<blockquote><pre>
++template &lt;class T&gt;
++T&amp;&amp; kill_dependency(T&amp;&amp; y) noexcept;
++</pre></blockquote>
++</li>
++
++<li><p>
++Impose constraints on the template arguments in regard to throwing exceptions while copying/moving.
++</p></li>
++
++<li><p>
++Keep the state as it is but possibly add a note about a call of <tt>std::terminate</tt> in above scenario.
++</p></li>
++</ol>
++
++<p>
++A second problem is that the current wording is not clear whether it is well-defined to call the function with
++types that are reference types, such as in the following example:
++</p>
++
++<blockquote><pre>
++#include &lt;atomic&gt;
++
++int main()
++{
++ int a = 12;
++ int&amp; b = std::kill_dependency&lt;int&amp;&gt;(a);
++}
++</pre></blockquote>
++
++<p>
++It is unclear what kind of dependency is killed here. This is presumably a core language problem, but could
++affect the possible resolutions of the problem.
++</p>
++
++<p><i>[2014-11 Urbana]</i></p>
++
++<p>
++Recommend using a revised example:
++</p>
++<blockquote><pre>
++int lookup(class D* p)
++{
++ class E* q = p-&gt;a.load(memory_order_consume);
++ int y = std::kill_dependency(q-&gt;y);
++}
++</pre></blockquote>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2237"></a>2237. <tt>&lt;cuchar&gt;</tt> macros</h3>
++<p><b>Section:</b> 21.8 [c.strings] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jason Merrill <b>Opened:</b> 2013-01-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.strings">active issues</a> in [c.strings].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.strings">issues</a> in [c.strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Apparently C1X changes <tt>__STDC_UTF_16__</tt> and <tt>__STDC_UTF_32__</tt> from macros
++defined in <tt>uchar.h</tt> (and reflected in C++ by Table 79) to be predefined by the compiler.
++Do we want to do the same?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2238"></a>2238. Problematic iterator-pair constructor of containers</h3>
++<p><b>Section:</b> 21.8 [c.strings] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Johannes Schaub <b>Opened:</b> 2013-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.strings">active issues</a> in [c.strings].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.strings">issues</a> in [c.strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The non-explicit nature of the iterator-pair constructor of containers, such a
++</p>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++vector(InputIterator first, InputIterator last, const Allocator&amp; = Allocator());
++</pre></blockquote>
++
++<p>
++can be selected in unexpected situations, leading to a hard runtime error, as demonstrated by the following example:
++</p>
++
++<blockquote><pre>
++#include &lt;vector&gt;
++
++void f(std::vector&lt;char&gt; v){ /* ... */}
++
++int main() {
++ f({"A", "B"});
++}
++</pre></blockquote>
++
++<p>
++The actually intended initializer-list constructor isn't feasible here, so the best match is the constructor template
++</p>
++
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++vector(InputIterator first, InputIterator last, const Allocator&amp; = Allocator());
++</pre></blockquote>
++
++<p>
++This compiles, but will result in code running amok. The potential trap (that cannot be easily detected by the
++library implementation) could be reduced by making this constructor explicit. It would still have the effect to
++be selected here, but the code would be ill-formed, so the programmer gets a clear meassage here.
++</p>
++
++<p><i>[2014-06 Rapperswil]</i></p>
++
++<p>
++JW: can't fix this, don't want to touch this, Do The Right Thing clause has been a source of tricky issues.
++only really happens with string literals, that's the only way to create an array that isn't obviously an array
++<p/>
++GR: want to see paper
++<p/>
++AM: is it only string literals, or also UDLs?
++<p/>
++STL: maybe, but we don't need to deal with that. This is only a problem in a very specific case
++<p/>
++Leave as Open.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2241"></a>2241. <tt>&lt;cstdalign&gt;</tt> and <tt>#define</tt> of <tt>alignof</tt></h3>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2013-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to 18.10 [support.runtime] p2:
++</p>
++
++<blockquote><p>
++The contents of these headers are the same as the Standard C library headers [..], <tt>&lt;stdalign.h&gt;</tt>, [..]
++</p></blockquote>
++
++<p>
++Since our base C standard is C99, which doesn't have a <tt>&lt;stdalign.h&gt;</tt>, the reference to a non-existing
++C header is irritating (In this context <tt>&lt;stdalign.h&gt;</tt> doesn't refer to the deprecated C++ header
++<tt>&lt;stdalign.h&gt;</tt> described in D.5 [depr.c.headers]).
++<p/>
++Furthermore, it would be also important that it doesn not define a macro named <tt>alignof</tt>, which C11 also defines
++in this header.
++<p/>
++Currently we only have the following guarantee as part of 18.10 [support.runtime] p7:
++</p>
++
++<blockquote><p>
++The header <tt>&lt;cstdalign&gt;</tt> and the header <tt>&lt;stdalign.h&gt;</tt> shall not define a macro named
++<tt>alignas</tt>.
++</p></blockquote>
++
++<p>
++It is unclear what the better strategy is: Striking the reference to <tt>&lt;stdalign.h&gt;</tt> in
++18.10 [support.runtime] p2 or upgrading to C11 as new base C standard.
++</p>
++
++<p><i>[2014-02-15 Issaquah]</i></p>
++
++<p>
++STL: related to earlier issue on C4, <a href="lwg-active.html#2201">2201</a>, and now we get a C11 header
++</p>
++<p>
++JY: find _Alignof as keyword C11 FDIS has four defines in stdalign.h
++</p>
++<p>
++AM: need paper for C11 as base library we should really do that
++</p>
++<p>
++STL: really need vendor input
++</p>
++<p>
++STL: don't think we need to do anything right now not P1
++</p>
++<p>
++AM: any objections to downscale to P2 (no objections)
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2242"></a>2242. <tt>[uninitialized_]copy_n()</tt> defect</h3>
++<p><b>Section:</b> 25.3.1 [alg.copy], 20.7.12.2 [uninitialized.copy] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Sean Parent <b>Opened:</b> 2013-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#alg.copy">active issues</a> in [alg.copy].</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.copy">issues</a> in [alg.copy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>copy_n()</tt> and <tt>uninitialized_copy_n()</tt> only return the output iterator, and not the input iterator.
++Likely the interface was simply copied from the original STL. Unfortunately the interface in the original STL contains a bug.
++<p/>
++<tt>copy_n()</tt> and <tt>uninitialized_copy_n()</tt> must return the resulting input iterator as well as the output
++iterator (I would suggest returning a pair). Without this, there is no way to continue reading from an actual input
++iterator &mdash; and if it is really a forward iterator, it will cost <tt>n</tt> increments to get back to where you were.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2243"></a>2243. <tt>istream::putback</tt> problem</h3>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-03-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 27.7.2.3 [istream.unformatted] / 34, when describing <tt>putback</tt>, it says that "<tt>rdbuf-&gt;sputbackc()</tt>"
++is called. The problem are not the obvious typos in the expression, but the fact that it may lead to different
++interpretations, since nowhere is specified what the required argument to <tt>sputbackc</tt> is.
++<p/>
++It can be guessed to be "<tt>rdbuf()-&gt;sputbackc(c)</tt>", but "<tt>rdbuf()-&gt;sputbackc(char_type())</tt>" or
++just anything would be as conforming (or non-confoming) as the first guess.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2244"></a>2244. Issue on <tt>basic_istream::seekg</tt></h3>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-03-04 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++When issue <a href="lwg-defects.html#1445">1445</a> was resolved by adopting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">N3168</a>, it exposed the need to
++modify both overloads of <tt>basic_istream::seekg</tt> (by inserting "the function clears eofbit," after "except that"),
++but the fix applied to the text apparently forgets the second overload at 27.7.2.3 [istream.unformatted] p43.
++</p>
++
++<p><i>[2013-10-17: Daniel provides concrete wording]</i></p>
++
++
++<p>
++It seems that the tiny sentence "SIMILARLY for 27.7.1.3/43 (<tt>seekg</tt>)." had been overlooked. I agree that the wording needs to be
++applied here as well.
++</p>
++
++<p><i>[2015-05-06 Lenexa: Move to Ready]</i></p>
++
++<p>MC: This was just missed when we added "the function first clears eofbit" to the other overload, Daniel agrees. Editing mistake.</p>
++<p>Move to Ready, consensus.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 27.7.2.3 [istream.unformatted] p43 as indicated:</p>
++
++<blockquote><pre>
++basic_istream&lt;charT,traits&gt;&amp; seekg(off_type off, ios_base::seekdir dir);
++</pre><blockquote>
++<p>
++-43- <i>Effects:</i> Behaves as an unformatted input function (as described in 27.7.2.3, paragraph 1), except
++that <ins>the function first clears <tt>eofbit</tt>,</ins> it does not count the number of characters extracted<ins>,</ins>
++and does not affect the value returned by subsequent calls to <tt>gcount()</tt>. [&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2245"></a>2245. <tt>packaged_task::reset()</tt> memory allocation</h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-03-05 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The effects of <tt>packaged_task::reset()</tt> result in memory allocation, but
++don't allow a user to provide an allocator.
++<p/>
++<tt>packaged_task::reset()</tt> needs to be overloaded like so:
++</p>
++
++<blockquote><pre>
++template&lt;class Alloc&gt;
++void reset(const Alloc&amp;);
++</pre></blockquote>
++
++<p>
++Alternatively, the effects of <tt>reset()</tt> need to require the same allocator is used
++as at construction, which would require the constructor to store the allocator for later use.
++<p/>
++I like to remark that GCC at the moment uses the second option, i.e. the allocator passed to the constructor
++(if any) is used to create the new shared state, because this didn't require any change to the
++interface.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++No strong opinions in SG1, and this is really an LWG issue. Back to you.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2248"></a>2248. <tt>numeric_limits::is_iec559</tt> misnamed</h3>
++<p><b>Section:</b> 18.3.2 [limits] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2013-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#limits">issues</a> in [limits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++This member should probably be named "is_ieee754". Or at least the standard should explain that IEC-559 no longer exists,
++and that it's been superseded by IEEE-754.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2250"></a>2250. Follow-up On Library Issue 2207</h3>
++<p><b>Section:</b> 20.6.1 [bitset.cons], 20.6.2 [bitset.members], 21.4.2 [string.cons], 21.4.6 [string.modifiers], 21.4.7 [string.ops] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Frank Birbacher <b>Opened:</b> 2013-04-18 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Similar to LWG <a href="lwg-defects.html#2207">2207</a> there are several other places where the "Requires" clause precludes the "Throws" condition.
++Searching for the <tt>out_of_range</tt> exception to be thrown, the following have been found (based on the working draft
++N3485):
++</p>
++
++<ol>
++<li><p>20.6.1 [bitset.cons] p3+4</p></li>
++<li><p>20.6.2 [bitset.members] p13+14 (<tt>set</tt>)</p></li>
++<li><p>20.6.2 [bitset.members] p19+20 (<tt>reset</tt>)</p></li>
++<li><p>20.6.2 [bitset.members] p27+28 (<tt>flip</tt>)</p></li>
++<li><p>20.6.2 [bitset.members] p41+42 (<tt>test</tt>)</p></li>
++<li><p>21.4.2 [string.cons] p3+4</p></li>
++<li><p>21.4.6.2 [string::append] p3+4</p></li>
++<li><p>21.4.6.3 [string::assign] p4+5</p></li>
++<li><p>21.4.6.4 [string::insert] p1+2, p5+6, p9+10 (partially)</p></li>
++<li><p>21.4.6.5 [string::erase] p1+2</p></li>
++<li><p>21.4.6.6 [string::replace] p1+2, p5+6, p9+10 (partially)</p></li>
++<li><p>21.4.6.7 [string::copy] p1+2</p></li>
++<li><p>21.4.7.8 [string::substr] p1+2</p></li>
++</ol>
++
++<p><i>[2013-10-15: Daniel provides wording]</i></p>
++
++
++<p>
++In addition to the examples mentioned in the discussion, a similar defect exists for <tt>thread</tt>'s <tt>join()</tt>
++and <tt>detach</tt> functions (see 30.3.1.5 [thread.thread.member]). The suggested wording applies a similar fix for these
++as well.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL : likes it<br/>
++DK : does it change behavior?<br/>
++Multiple : no<br/>
++Move to ready? Unanimous
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Modify 20.6.1 [bitset.cons] as indicated: <em>[Editorial comment: The wording form used to ammend the
++<i>Throws</i> element is borrowed from a similar style used in 21.4.6.6 [string::replace] p10]</em></p>
++
++<blockquote><pre>
++template &lt;class charT, class traits, class Allocator&gt;
++explicit
++bitset(const basic_string&lt;charT, traits, Allocator&gt;&amp; str,
++ typename basic_string&lt;charT, traits, Allocator&gt;::size_type pos = 0,
++ typename basic_string&lt;charT, traits, Allocator&gt;::size_type n =
++ basic_string&lt;charT, traits, Allocator&gt;::npos,
++ charT zero = charT('0'), charT one = charT('1'));
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires:</i> <tt>pos &lt;= str.size()</tt>.</del>
++<p/>
++-4- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; str.size()</tt> <ins>or <tt>invalid_argument</tt> if an
++invalid character is found (see below)</ins>.
++<p/>
++-5- <i>Effects:</i> Determines the effective length <tt>rlen</tt> of the initializing string as the smaller of <tt>n</tt> and
++<tt>str.size() - pos</tt>.
++<p/>
++The function then throws <tt>invalid_argument</tt> if any of the <tt>rlen</tt> characters in <tt>str</tt> beginning at position
++<tt>pos</tt> is other than <tt>zero</tt> or <tt>one</tt>. The function uses <tt>traits::eq()</tt> to compare the character values.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 20.6.2 [bitset.members] as indicated:</p>
++
++<blockquote><pre>
++bitset&lt;N&gt;&amp; set(size_t pos, bool val = true);
++</pre><blockquote>
++<p>
++<del>-13- <i>Requires:</i> <tt>pos</tt> is valid</del>
++<p/>
++-14- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit position.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++bitset&lt;N&gt;&amp; reset(size_t pos);
++</pre><blockquote>
++<p>
++<del>-19- <i>Requires:</i> <tt>pos</tt> is valid</del>
++<p/>
++-20- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit position.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++bitset&lt;N&gt;&amp; flip(size_t pos);
++</pre><blockquote>
++<p>
++<del>-27- <i>Requires:</i> <tt>pos</tt> is valid</del>
++<p/>
++-28- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit position.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++bool test(size_t pos) const;
++</pre><blockquote>
++<p>
++<del>-41- <i>Requires:</i> <tt>pos</tt> is valid</del>
++<p/>
++-42- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit position.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.2 [string.cons] as indicated:</p>
++
++<blockquote><pre>
++basic_string(const basic_string&amp; str,
++ size_type pos, size_type n = npos,
++ const Allocator&amp; a = Allocator());
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires:</i> <tt>pos &lt;= str.size()</tt></del>
++<p/>
++-4- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; str.size()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.4 [string.capacity] as indicated:</p>
++
++<blockquote><pre>
++void resize(size_type n, charT c);
++</pre><blockquote>
++<p>
++<del>-6- <i>Requires:</i> <tt>n &lt;= max_size()</tt></del>
++<p/>
++-7- <i>Throws:</i> <tt>length_error</tt> if <tt>n &gt; max_size()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.6.2 [string::append] as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp;
++ append(const basic_string&amp; str, size_type pos, size_type n = npos);
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires:</i> <tt>pos &lt;= str.size()</tt></del>
++<p/>
++-4- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; str.size()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.6.3 [string::assign] as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp;
++ assign(const basic_string&amp; str, size_type pos,
++ size_type n = npos);
++</pre><blockquote>
++<p>
++<del>-5- <i>Requires:</i> <tt>pos &lt;= str.size()</tt></del>
++<p/>
++-6- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; str.size()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.6.4 [string::insert] as indicated: <em>[Editorial note: The first change suggestion is also a bug fix
++of the current wording, because (a) the function has parameter <tt>pos1</tt> but the semantics refers to <tt>pos</tt> and (b)
++it is possible that this function can throw <tt>length_error</tt>, see p10]</em></p>
++
++<blockquote><pre>
++basic_string&amp;
++ insert(size_type pos<del>1</del>, const basic_string&amp; str);
++</pre><blockquote>
++<p>
++<del>-1- <i>Requires:</i> <tt>pos &lt;= size()</tt>.</del>
++<p/>
++<del>-2- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; size()</tt>.</del>
++<p/>
++-3- <i>Effects:</i> <del>Calls</del><ins>Equivalent to:</ins> <tt><ins>return</ins> insert(pos, str.data(), str.size())<ins>;</ins></tt><del>.</del>
++<p/>
++<del>-4- <i>Returns:</i> <tt>*this</tt>.</del>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ insert(size_type pos1, const basic_string&amp; str,
++ size_type pos2, size_type n = npos);
++</pre><blockquote>
++<p>
++<del>-5- <i>Requires:</i> <tt>pos1 &lt;= size()</tt> and <tt>pos2 &lt;= str.size()</tt>.</del>
++<p/>
++-6- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos1 &gt; size()</tt> or <tt>pos2 &gt; str.size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ insert(size_type pos, const charT* s, size_type n);
++</pre><blockquote>
++<p>
++-9- <i>Requires:</i> <tt>s</tt> points to an array of at least <tt>n</tt> elements of <tt>charT</tt> <del>and
++<tt>pos &lt;= size()</tt></del>.
++<p/>
++-10- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; size()</tt> or <tt>length_error</tt> if <tt>size() + n &gt; max_size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ insert(size_type pos, const charT* s);
++</pre><blockquote>
++<p>
++-13- <i>Requires:</i> <del><tt>pos &lt;= size()</tt> and</del> <tt>s</tt> points to an array of at least
++<tt>traits::length(s) + 1</tt> elements of <tt>charT</tt>.
++<p/>
++-14- <i>Effects:</i> Equivalent to <tt><ins>return</ins> insert(pos, s, traits::length(s))<ins>;</ins></tt><del>.</del>
++<p/>
++<del>-15- <i>Returns:</i> <tt>*this</tt>.</del>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.6.5 [string::erase] as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; erase(size_type pos = 0, size_type n = npos);
++</pre><blockquote>
++<p>
++<del>-1- <i>Requires:</i> <tt>pos &lt;= size()</tt></del>
++<p/>
++-2- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.6.6 [string::replace] as indicated: <em>[Editorial note: The first change suggestion is also a bug fix
++of the current wording, because it is possible that this function can throw <tt>length_error</tt>, see p10]</em></p>
++
++<blockquote><pre>
++basic_string&amp;
++ replace(size_type pos1, size_type n1,
++ const basic_string&amp; str);
++</pre><blockquote>
++<p>
++<del>-1- <i>Requires:</i> <tt>pos1 &lt;= size()</tt>.</del>
++<p/>
++<del>-2- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos1 &gt; size()</tt>.</del>
++<p/>
++-3- <i>Effects:</i> <del>Calls</del><ins>Equivalent to</ins> <tt><ins>return</ins> replace(pos1, n1, str.data(), str.size())<ins>;</ins></tt><del>.</del>
++<p/>
++<del>-4- <i>Returns:</i> <tt>*this</tt>.</del>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ replace(size_type pos1, size_type n1,
++ const basic_string&amp; str,
++ size_type pos2, size_type n = npos);
++</pre><blockquote>
++<p>
++<del>-5- <i>Requires:</i> <tt>pos1 &lt;= size()</tt> and <tt>pos2 &lt;= str.size()</tt>.</del>
++<p/>
++-6- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos1 &gt; size()</tt> or <tt>pos2 &gt; str.size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ replace(size_type pos1, size_type n1, const charT* s, size_type n2);
++</pre><blockquote>
++<p>
++-9- <i>Requires:</i> <del><tt>pos1 &lt;= size()</tt> and</del> <tt>s</tt> points to an array of at least <tt>n2</tt> elements
++of <tt>charT</tt>.
++<p/>
++-10- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos1 &gt; size()</tt> or <tt>length_error</tt> if the length of the resulting
++string would exceed <tt>max_size()</tt> (see below).
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++basic_string&amp;
++ replace(size_type pos, size_type n, const charT* s);
++</pre><blockquote>
++<p>
++-13- <i>Requires:</i> <del><tt>pos &lt;= size()</tt> and</del> <tt>s</tt> points to an array of at least
++<tt>traits::length(s) + 1</tt> elements of <tt>charT</tt>.
++<p/>
++-14- <i>Effects:</i> Equivalent to <tt><ins>return</ins> replace(pos, n, s, traits::length(s))<ins>;</ins></tt><del>.</del>
++<p/>
++<del>-15- <i>Returns:</i> <tt>*this</tt>.</del>
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.6.7 [string::copy] as indicated:</p>
++
++<blockquote><pre>
++size_type copy(charT* s, size_type n, size_type pos = 0) const;
++</pre><blockquote>
++<p>
++<del>-1- <i>Requires:</i> <tt>pos &lt;= size()</tt></del>
++<p/>
++-2- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 21.4.7.8 [string::substr] as indicated:</p>
++
++<blockquote><pre>
++basic_string substr(size_type pos = 0, size_type n = npos) const;
++</pre><blockquote>
++<p>
++<del>-1- <i>Requires:</i> <tt>pos &lt;= size()</tt></del>
++<p/>
++-2- <i>Throws:</i> <tt>out_of_range</tt> if <tt>pos &gt; size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Modify 30.3.1.5 [thread.thread.member] as indicated:</p>
++
++<blockquote><pre>
++void join();
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires:</i> <tt>joinable()</tt> is true.</del>
++<p/>
++[&hellip;]
++<p/>
++-7- <i>Throws:</i> <tt>system_error</tt> when an exception is required (30.2.2).
++<p/>
++-8- <i>Error conditions:</i>
++</p>
++<ul>
++<li><p>[&hellip;]</p></li>
++<li><p><tt>invalid_argument</tt> &mdash; if the thread is not joinable.</p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote><pre>
++void detach();
++</pre><blockquote>
++<p>
++<del>-9- <i>Requires:</i> <tt>joinable()</tt> is true.</del>
++<p/>
++[&hellip;]
++<p/>
++-12- <i>Throws:</i> <tt>system_error</tt> when an exception is required (30.2.2).
++<p/>
++-13- <i>Error conditions:</i>
++</p>
++<ul>
++<li><p>[&hellip;]</p></li>
++<li><p><tt>invalid_argument</tt> &mdash; if the thread is not joinable.</p></li>
++</ul>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2253"></a>2253. [arrays.ts] <tt>dynarray</tt> should state which container requirements aren't met</h3>
++<p><b>Section:</b> X [dynarray.overview] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: arrays.ts</b></p>
++
++<p>
++X [dynarray.overview] p2 says:
++</p>
++<blockquote>
++<p>
++"Unless otherwise specified, all <tt>dynarray</tt> operations have the same requirements and semantics as specified in
++23.2 [container.requirements]."
++</p>
++</blockquote>
++<p>
++Some differences from 23.2 [container.requirements] are not explicitly specified, including at
++least the lack of a default constructor, copy assignment and <tt>swap</tt> member.
++<p/>
++The wording could be similar to 23.3.2.1 [array.overview] which says "An array satisfies all of the requirements
++of a container and of a reversible container (23.2 [container.requirements]), except that a default constructed
++array object is not empty and that <tt>swap</tt> does not have constant complexity."
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswil]</i></p>
++
++<p>
++This issue has been reopened as arrays-ts.
++</p>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++<p><i>[2014/11 Urbana]</i></p>
++
++<p>
++Held at Ready status, pending clarification of Arrays TS
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Add to X [dynarray.overview] p2:</p>
++<p>
++-2- <ins>A <tt>dynarray</tt> satisfies all of the requirements of a container and of a reversible container
++(23.2 [container.requirements]), except for default construction, assignment and <tt>swap</tt>.</ins> Unless
++otherwise specified, all <tt>dynarray</tt> operations have the same requirements and semantics as specified in
++23.2 [container.requirements].
++</p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2254"></a>2254. [arrays.ts] Is <tt>dynarray</tt> an allocator-aware container?</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: arrays.ts</b></p>
++
++<p>
++23.2.1 [container.requirements.general] p3 says:
++</p>
++<blockquote>
++<p>
++"All of the containers defined in this Clause and in (21.4) except <tt>array</tt> meet the additional requirements
++of an allocator-aware container, as described in Table 99."
++</p>
++</blockquote>
++<p>
++Is this true of <tt>dynarray</tt>? I believe the answer must be no because <tt>dynarray</tt> has no <tt>allocator_type</tt>,
++and morally should be no, so that operations are defined in terms of <tt>std::allocator&lt;T&gt;</tt>, which p13 says
++doesn't actually need to be used (which allows the elements to be default-initialized as is intended, rather than
++"default-inserted into the container" using an allocator.)
++<p/>
++The requirement that "each element is constructed with uses-allocator construction" provides roughly equivalent behaviour
++to the "<em>CopyInsertable into <tt>X</tt></em>" requirements for allocator-aware containers, allowing an allocator to
++control construction of the <tt>dynarray</tt> elements.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as arrays-ts.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Change to 23.2.1 [container.requirements.general] p13:</p>
++<p>
++-13- All of the containers defined in this Clause and in (21.4) except <tt>array</tt> <ins>and <tt>dynarray</tt></ins>
++meet the additional requirements of an allocator-aware container, as described in Table 99.
++</p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2255"></a>2255. [arrays.ts] <tt>dynarray</tt> constructor ambiguity</h3>
++<p><b>Section:</b> X [dynarray.cons] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: arrays.ts</b></p>
++
++<p>
++These constructors can interact badly::
++</p>
++<blockquote><pre>
++template&lt;class Alloc&gt;
++ dynarray(size_type c, const Alloc&amp; alloc);
++dynarray(size_type c, const T&amp; v);
++</pre></blockquote>
++<p>
++Unless the second argument is a value of exactly the type <tt>T</tt> you will get the first constructor, i.e.
++all of these will fail to compile:
++</p>
++<blockquote><pre>
++dynarray&lt;long&gt; dlong(1, 1); // 1 is not long
++dynarray&lt;float&gt; dflt(1, 1.0); // 1.0 is not float
++dynarray&lt;int*&gt; dptr(1, nullptr); // nullptr is not int*
++dynarray&lt;void*&gt; doh(1, 0); // 0 is not void*
++</pre></blockquote>
++<p>
++The <tt>nullptr</tt> case is particularly annoying, a user trying to do the right thing by saying <tt>nullptr</tt>
++instead of <tt>NULL</tt> still gets the wrong result.
++<p/>
++The constructor taking an allocator requires that "<tt>Alloc</tt> shall meet the requirements for an Allocator"
++but doesn't actually say "shall not participate in overload resolution unless ..."
++<p/>
++I believe we have no precedent for using SFINAE to check "the requirements for an Allocator" because it's
++a pretty complicated set of requirements. We could say it shall not participate in overload resolution if <tt>Alloc</tt>
++is implicitly convertible to <tt>value_type</tt>.
++<p/>
++Alternatively, we could follow the same approach used by other types that can be constructed with an unconstrained
++allocator type and use <tt>std::allocator_arg_t</tt> as the first argument instead of adding an allocator after the
++other arguments.
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswil]</i></p>
++
++<p>
++This issue has been reopened as arrays-ts.
++</p>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready for alternative A
++</p>
++
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<ol style="list-style-type:upper-alpha">
++<li>
++<p>
++<em>Either</em> use the correct way to unambiguously call a constructor taking any type of allocator, i.e. change the
++constructors to take <tt>dynarray(std::allocator_arg_t, const Alloc&amp;, ...)</tt> by modifying both the synopsis
++X [dynarray.overview] p2 and X [dynarray.cons] before p9 like so:</p>
++
++<blockquote><pre>
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>size_type c<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>size_type c, const T&amp; v<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>const dynarray&amp; d<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>initializer_list&lt;T&gt;<del>, const Alloc&amp; alloc</del>);
++</pre></blockquote>
++
++</li>
++
++<li><p><em>or</em> constrain the problematic constructor by adding a new paragraph to X [dynarray.cons]:</p>
++<blockquote><pre>
++template &lt;class Alloc&gt;
++ dynarray(size_type c, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++ dynarray(size_type c, const T&amp; v, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++ dynarray(const dynarray&amp; d, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++ dynarray(initializer_list&lt;T&gt;, const Alloc&amp; alloc);
++</pre><blockquote>
++<p>
++-9- <i>Requires</i>: <tt>Alloc</tt> shall meet the requirements for an Allocator (17.6.3.5 [allocator.requirements]).
++<p/>
++-10- <i>Effects</i>: Equivalent to the preceding constructors except that each element is constructed with uses-allocator
++construction (20.7.7.2 [allocator.uses.construction]).
++<p/>
++<ins>-?- <i>Remarks</i>: The first constructor shall not participate in overload resolution unless <tt>Alloc</tt> is not
++implicitly convertible to <tt>T</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014/11 Urbana]</i></p>
++
++<p>
++Held at Ready status, pending clarification of Arrays TS
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li>
++<p>
++Use the correct way to unambiguously call a constructor taking any type of allocator, i.e. change the
++constructors to take <tt>dynarray(std::allocator_arg_t, const Alloc&amp;, ...)</tt> by modifying both the synopsis
++X [dynarray.overview] p2 and X [dynarray.cons] before p9 like so:</p>
++
++<blockquote><pre>
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>size_type c<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>size_type c, const T&amp; v<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>const dynarray&amp; d<del>, const Alloc&amp; alloc</del>);
++template &lt;class Alloc&gt;
++ dynarray(<ins>allocator_arg_t, const Alloc&amp; a, </ins>initializer_list&lt;T&gt;<del>, const Alloc&amp; alloc</del>);
++</pre></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2256"></a>2256. On <tt>vector</tt> iterator invalidation</h3>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-04-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++23.3.6.5 [vector.modifiers]/p3 says:
++</p>
++<blockquote><pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: Invalidates iterators and references at or after the point of the erase.
++</p>
++</blockquote></blockquote>
++<p>
++Consider this example:
++</p>
++<blockquote><pre>
++#include &lt;vector&gt;
++#include &lt;cassert&gt;
++
++int main()
++{
++ typedef std::vector&lt;int&gt; C;
++ C c = {1, 2, 3, 4};
++ C::iterator i = c.begin() + 1;
++ C::iterator j = c.end() - 1;
++ assert(*i == 2);
++ assert(*j == 4);
++ c.erase(c.begin());
++ <span style="color:#C80000;font-weight:bold">assert(*i == 3); // Why is this not perfectly fine?!</span>
++}
++</pre></blockquote>
++<p>
++Why has the iterator <tt>i</tt> been invalidated? It still refers to a perfectly reasonable, fully constructed object.
++If <tt>vector::iterator</tt> were to be implemented as a pointer (which is legal), it is not possible for that last
++line to do anything but run fine.
++<p/>
++The iterator <tt>j</tt> on the other hand now points at end, and any iterators that may now point beyond <tt>end()</tt>,
++into uninitialized memory, are clearly invalid.
++<p/>
++But why do we say that an iterator that <em>must</em> point to a valid object is invalid? This looks to me like we
++simply got sloppy in our specification.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2259"></a>2259. Issues in 17.6.5.5 rules for member functions</h3>
++<p><b>Section:</b> 17.6.5.5 [member.functions] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2013-05-12 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#member.functions">issues</a> in [member.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++17.6.5.5 [member.functions] p2 says:
++</p>
++
++<blockquote><p>
++&quot;An implementation may declare additional non-virtual member function signatures within a class:
++</p>
++<ul>
++<p>by adding arguments with default values to a member function signature; [Footnote: Hence, the address of a member
++function of a class in the C++ standard library has an unspecified type.] [<i>Note</i>: An implementation
++may not add arguments with default values to virtual, global, or non-member functions. &mdash; <i>end note</i>]</p>
++<p>by replacing a member function signature with default values by two or more member function signatures
++with equivalent behavior; and</p>
++<p>by adding a member function signature for a member function name.&quot;</p>
++</ul>
++</blockquote>
++
++<ol>
++<li>
++<p>
++This wording is not using the correct terminology. "by adding arguments with default values" presumably means
++"by adding parameters with default arguments", and likewise throughout.
++</p>
++</li>
++<li>
++<p>
++This paragraph only allows an implementation to declare "additional" signatures, but the first bullet is talking
++about replacing a standard signature with one with additional parameters.
++</p>
++</li>
++<li>
++<p>
++None of these bullets allows a member function with no <i>ref</i>-qualifier to be replaced by signatures with <i>ref</i>-qualifiers
++(a situation which was just discussed on std-proposals), and likewise for <i>cv</i>-qualifiers. Presumably that is
++not intentional, and such changes should be permissible.
++</p>
++</li>
++</ol>
++
++<p>
++I think the first two items are probably editorial, since the intent is clear.
++</p>
++
++<p><i>[2013-12-11 Richard provides concrete wording]</i></p>
++
++<p>
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++JW: I don't like that this loses the footnote about the address of member functions having an unspecified type,
++the footnote is good to be able to point to as an explicit clarification of one consequence of the normative wording.<br/>
++MC: so we want to keep the footnote<br/>
++STL: doesn't need to be a footnote, can be an inline Note<br/>
++JW: does this have any impact on our ability to add totally different functions with unrelated names, not described in
++the standard?<br/>
++MC: no, the old wording didn't refer to such functions anyway<br/>
++Move to Ready and include in motion on Friday?<br/>
++9 in favor, 0 opposed, 2 abstention
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Merge 17.6.5.5 [member.functions]p2+3 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <del>An implementation may declare additional non-virtual member function signatures within a class:</del>
++</p>
++<ul>
++<li><p>
++<del>by adding arguments with default values to a member function signature;188 [<i>Note:</i> An implementation
++may not add arguments with default values to virtual, global, or non-member functions. &mdash; <i>end note</i>]</del>
++</p></li>
++<li><p>
++<del>by replacing a member function signature with default values by two or more member function signatures
++with equivalent behavior; and</del>
++</p></li>
++<li><p>
++<del>by adding a member function signature for a member function name.</del>
++</p></li>
++</ul>
++<p>
++<del>-3- A call to a member function signature described in the C++ standard library behaves as if the implementation
++declares no additional member function signatures.[Footnote: A valid C++ program always calls the expected library
++member function, or one with equivalent behavior. An implementation may also define additional member functions
++that would otherwise not be called by a valid C++ program.]</del> <ins>For a non-virtual member function described
++in the C++ standard library, an implementation may declare a different set of member function signatures, provided
++that any call to the member function that would select an overload from the set of declarations described in this
++standard behaves as if that overload were selected. [<i>Note:</i> For instance, an implementation may add parameters
++with default values, or replace a member function with default arguments with two or more member functions with
++equivalent behavior, or add additional signatures for a member function name. &mdash; <i>end note</i>]</ins>
++</p>
++
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2260"></a>2260. Missing requirement for <tt>Allocator::pointer</tt></h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++For an allocator <tt>A&lt;T&gt;</tt> which defines <tt>A&lt;T&gt;::pointer</tt> to a class type,
++i.e. not <tt>T*</tt>, I see no requirement that <tt>A&lt;T&gt;::pointer</tt> is convertible to
++<tt>A&lt;U&gt;::pointer</tt>, even if <tt>T*</tt> is convertible to <tt>U*</tt>. Such conversions are
++needed in containers to convert from e.g. <tt>ListNodeBase*</tt> to <tt>ListNode&lt;T&gt;*</tt>.
++</p>
++
++<p>The obvious way to do such conversions appears to be
++<tt>pointer_traits::pointer_to()</tt>, but that's ill-formed if the static
++member function <tt>A&lt;T&gt;::pointer::pointer_to()</tt> doesn't exist and the
++allocator requirements don't mention that function, so you need to
++cast <tt>A&lt;T&gt;::pointer</tt> to <tt>A&lt;T&gt;::void_pointer</tt> then cast that to
++<tt>A&lt;U&gt;::pointer</tt>.
++</p>
++
++<p>
++Is converting via <tt>void_pointer</tt> really intended, or are we missing a requirement that
++<tt>pointer_traits&lt;A&lt;T&gt;::pointer&gt;::pointer_to()</tt> be well-formed?
++</p>
++
++<p>Proposed resolution:</p>
++
++<p>Add to the Allocator requirements table the following requirement:</p>
++
++<blockquote>
++<p>
++The expression <tt>pointer_traits&lt;XX::pointer&gt;::pointer_to(r)</tt> is well-defined.
++</p>
++</blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Pablo to come back with Proposed Wording
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>
++Edit Table 28 as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>static_cast&lt;X::const_pointer&gt;(z)</tt>
++</td>
++<td>
++<tt>X::const_pointer</tt>
++</td>
++<td>
++<tt>static_cast&lt;X::const_pointer&gt;(z) == q</tt>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>pointer_traits&lt;X::pointer&gt;::pointer_to(r)</tt></ins>
++</td>
++<td>
++<ins><tt>X::pointer</tt></ins>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2261"></a>2261. Are containers required to use their '<tt>pointer</tt>' type internally?</h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Is a container <tt>C</tt> only supposed to refer to allocated memory (blocks of
++contiguous storage, nodes, etc.) through objects of type <tt>C::pointer</tt>
++rather than <tt>C::value_type*</tt>?
++</p>
++
++<p>
++I don't see anything explicitly requiring this, so a container could
++immediately convert the result of <tt>get_allocator().allocate(1)</tt> to a
++built-in pointer of type <tt>value_type*</tt> and only deal with the built-in
++pointer until it needs to deallocate it again, but that removes most
++of the benefit of allowing allocators to use custom pointer types.
++</p>
++
++<p><i>[2014-06-12, Jonathan comments]</i></p>
++
++<p>
++This issue is basically the same issue as LWG <a href="lwg-active.html#1521">1521</a>, which agrees it's an issue,
++to be dealt with in the future, so I request that <a href="lwg-active.html#2261">2261</a> not be closed as a dup
++unless we reopen <a href="lwg-active.html#1521">1521</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2262"></a>2262. Requirement for <tt>unique_ptr&lt;T&gt;::get_deleter()(p)</tt> to be able to destroy the <tt>unique_ptr</tt></h3>
++<p><b>Section:</b> 20.8.1.2 [unique.ptr.single] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Rob Desbois <b>Opened:</b> 2013-05-15 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++N3337 20.8.1.2.5 [unique.ptr.single.modifiers] contains 2 non-normative notes stating:
++</p>
++
++<blockquote>
++<p>
++[para 4]: &quot;The order of these operations is significant because the call to <tt>get_deleter()</tt>
++may destroy <tt>*this</tt>.&quot;
++</p>
++<p>
++[para 5]: &quot;The postcondition does not hold if the call to <tt>get_deleter()</tt> destroys <tt>*this</tt> since
++<tt>this->get()</tt> is no longer a valid expression.&quot;
++</p>
++</blockquote>
++
++<p>
++It seems this wording was created to resolve <a href="lwg-defects.html#998">998</a> due to the possibility that a <tt>unique_ptr</tt> may be
++destroyed through deletion of its stored pointer where that directly or indirectly refers to the same <tt>unique_ptr</tt>.
++If <tt>unique_ptr</tt> is required to support circular references then it seems this must be normative text: an implementation
++is currently allowed to operate on <tt>*this</tt> after the assignment and deletion specified in para 4, since this is only
++'disallowed' by the non-normative note.
++</p>
++
++<p>I propose the following draft rewording:</p>
++
++<p>
++[para 4]: <i>Effects</i>: assigns <tt>p</tt> to the stored pointer, and then if the old value of the stored pointer, <tt>old_p</tt>, was not
++equal to <tt>nullptr</tt>, calls <tt>get_deleter()(old_p)</tt>. <ins>No operation shall be performed after the call to
++<tt>get_deleter()(old_p)</tt> that requires <tt>*this</tt> to be valid, because the deletion may destroy <tt>*this</tt> if it is
++referred to directly or indirectly by the stored pointer.</ins> <del>[<i>Note:</i> The order of these operations is significant
++because the call to <tt>get_deleter()</tt> may destroy <tt>*this</tt>. &mdash; <i>end note</i>]</del>
++<p/>
++[para 5]: <i>Postconditions</i>: <ins>If the call <tt>get_deleter()(old_p)</tt> destroyed <tt>*this</tt>, none. Otherwise,</ins>
++<tt>get() == p</tt>. <del>[<i>Note:</i> The postcondition does not hold if the call to <tt>get_deleter()</tt>
++destroys <tt>*this</tt> since <tt>this->get()</tt> is no longer a valid expression. &mdash; <i>end note</i>]</del>
++</p>
++
++<p>
++I expect it will also be necessary to amend the requirements for a deleter, so in addition:
++</p>
++
++<p>
++20.8.1.2 [unique.ptr.single] [para 1]: The default type for the template parameter <tt>D</tt> is <tt>default_delete</tt>.
++A client-supplied template argument <tt>D</tt> shall be a function object type (20.10), lvalue-reference to function, or
++lvalue-reference to function object type for which, given a value <tt>d</tt> of type <tt>D</tt> and a value <tt>ptr</tt> of type
++<tt>unique_ptr&lt;T, D&gt;::pointer</tt>, the expression <tt>d(ptr)</tt> is valid and has the effect of disposing of the pointer
++as appropriate for that deleter. <ins>Where <tt>D</tt> is not an lvalue reference type, <tt>d(ptr)</tt> shall be valid if <tt>ptr</tt>
++refers directly or indirectly to the invoking <tt>unique_ptr</tt> object.</ins>
++</p>
++
++<p><i>[2013-10-05, Stephan T. Lavavej comments and provides alternative wording]</i></p>
++
++<p>
++In Chicago, we determined that the original proposed change to 20.8.1.2 [unique.ptr.single]/1 was insufficient, because
++<tt>d</tt> might be a reference to a deleter functor that's destroyed during self-destruction.
++<p/>
++We believed that 20.8.1.2.5 [unique.ptr.single.modifiers]/4 was already sufficiently clear. The Standard occasionally prevents
++implementations of <tt>X</tt> from doing various things, through the principle of "nothing allows <tt>X</tt> to fail in that situation".
++For example, <tt>v.push_back(v[0])</tt> is required to work for non-empty vectors because nothing allows that to fail. In this case,
++the intent to allow self-destruction is already clear.
++<p/>
++Additionally, we did not believe that 20.8.1.2.5 [unique.ptr.single.modifiers]/5 had to be changed. The current note is slightly
++squirrely but it does not lead to confusion for implementers or users.
++</p>
++
++<p>
++Previous resolution from Rob Desbois:
++</p>
++<blockquote class="note">
++<ol>
++<li>
++<p>
++Edit 20.8.1.2 [unique.ptr.single] p1 as indicated:
++</p>
++<blockquote><p>
++The default type for the template parameter <tt>D</tt> is <tt>default_delete</tt>.
++A client-supplied template argument <tt>D</tt> shall be a function object type (20.10), lvalue-reference to function, or
++lvalue-reference to function object type for which, given a value <tt>d</tt> of type <tt>D</tt> and a value <tt>ptr</tt> of type
++<tt>unique_ptr&lt;T, D&gt;::pointer</tt>, the expression <tt>d(ptr)</tt> is valid and has the effect of disposing of the pointer
++as appropriate for that deleter. <ins>Where <tt>D</tt> is not an lvalue reference type, <tt>d(ptr)</tt> shall be valid if <tt>ptr</tt>
++refers directly or indirectly to the invoking <tt>unique_ptr</tt> object.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Edit 20.8.1.2.5 [unique.ptr.single.modifiers] p4+5 as indicated:
++</p>
++<blockquote><pre>
++void reset(pointer p = pointer()) noexcept;
++</pre><blockquote>
++<p>
++-3- <i>Requires:</i> The expression <tt>get_deleter()(get())</tt> shall be well formed, shall have well-defined behavior,
++and shall not throw exceptions.
++<p/>
++-4- <i>Effects:</i> assigns <tt>p</tt> to the stored pointer, and then if the old value of the stored pointer, <tt>old_p</tt>, was not
++equal to <tt>nullptr</tt>, calls <tt>get_deleter()(old_p)</tt>. <ins>No operation shall be performed after the call to
++<tt>get_deleter()(old_p)</tt> that requires <tt>*this</tt> to be valid, because the deletion may destroy <tt>*this</tt> if it is
++referred to directly or indirectly by the stored pointer.</ins> <del>[<i>Note:</i> The order of these operations is significant
++because the call to <tt>get_deleter()</tt> may destroy <tt>*this</tt>. &mdash; <i>end note</i>]</del>
++<p/>
++-5- <i>Postconditions:</i> <ins>If the call <tt>get_deleter()(old_p)</tt> destroyed <tt>*this</tt>, none. Otherwise,</ins>
++<tt>get() == p</tt>. <del>[<i>Note:</i> The postcondition does not hold if the call to <tt>get_deleter()</tt>
++destroys <tt>*this</tt> since <tt>this->get()</tt> is no longer a valid expression. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li>
++<p>
++Edit 20.8.1.2 [unique.ptr.single] p1 as indicated:
++</p>
++<blockquote><p>
++The default type for the template parameter <tt>D</tt> is <tt>default_delete</tt>.
++A client-supplied template argument <tt>D</tt> shall be a function object type (20.10), lvalue-reference to function, or
++lvalue-reference to function object type for which, given a value <tt>d</tt> of type <tt>D</tt> and a value <tt>ptr</tt> of type
++<tt>unique_ptr&lt;T, D&gt;::pointer</tt>, the expression <tt>d(ptr)</tt> is valid and has the effect of disposing of the pointer
++as appropriate for that deleter. <ins><tt>d(ptr)</tt> shall be valid even if it triggers the destruction of <tt>d</tt> or (if
++<tt>D</tt> is an lvalue reference to function object type) the function object that <tt>d</tt> refers to.</ins>
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++After some discussion in Lenexa there was some wavering on if the added sentence is necessary. Here is example code that
++demonstrates why the extra sentence is necessary. In this example the call to <tt>d(ptr)</tt> is valid, however the deleter
++references <tt>*this</tt> after destructing its element:
++</p>
++<blockquote><pre>
++#include &lt;cassert&gt;
++#include &lt;memory&gt;
++#include &lt;iostream&gt;
++
++class Deleter
++{
++ int state_ = 0;
++
++ enum
++ {
++ destructed = -4,
++ self_move_assigned = -3,
++ move_assigned_from = -2,
++ move_constructed_from = -1
++ };
++public:
++ ~Deleter() {state_ = destructed;}
++
++ Deleter() = default;
++ Deleter(Deleter const&amp;) = default;
++ Deleter&amp; operator=(Deleter const&amp;) = default;
++
++ Deleter(Deleter&amp;&amp; a) noexcept
++ : state_(a.state_)
++ {a.state_ = move_constructed_from;}
++
++ Deleter&amp; operator=(Deleter&amp;&amp; a) noexcept
++ {
++ if (this == &amp;a)
++ state_ = self_move_assigned;
++ else
++ {
++ state_ = a.state_;
++ a.state_ = move_assigned_from;
++ }
++ return *this;
++ }
++
++ Deleter(int state)
++ : state_(state)
++ {
++ assert(state &gt;= 0);
++ }
++
++ template &lt;class T&gt;
++ void
++ operator()(T* t) const
++ {
++ std::cout &lt;&lt; "Deleter beginning operator()(T*)\n";
++ std::cout &lt;&lt; "The deleter = " &lt;&lt; *this &lt;&lt; '\n';
++ std::cout &lt;&lt; "Deleter about to destruct the X.\n";
++ delete t;
++ std::cout &lt;&lt; "Deleter has destructed the X.\n";
++ std::cout &lt;&lt; "The deleter = " &lt;&lt; *this &lt;&lt; '\n';
++ std::cout &lt;&lt; "Deleter ending operator()(T*)\n";
++ }
++
++ friend
++ std::ostream&amp;
++ operator&lt;&lt;(std::ostream&amp; os, const Deleter&amp; a)
++ {
++ switch (a.state_)
++ {
++ case destructed:
++ os &lt;&lt; "**destructed**";
++ break;
++ case self_move_assigned:
++ os &lt;&lt; "self_move_assigned";
++ break;
++ case move_assigned_from:
++ os &lt;&lt; "move_assigned_from";
++ break;
++ case move_constructed_from:
++ os &lt;&lt; "move_constructed_from";
++ break;
++ default:
++ os &lt;&lt; a.state_;
++ break;
++ }
++ return os;
++ }
++};
++
++struct X
++{
++ Deleter deleter_{1};
++};
++
++int main()
++{
++ auto xp = new X;
++ {
++ std::unique_ptr&lt;X, Deleter&amp;&gt; p(xp, xp-&gt;deleter_);
++ std::cout &lt;&lt; "unique_ptr is constructed.\n";
++ std::cout &lt;&lt; "The deleter = " &lt;&lt; p.get_deleter() &lt;&lt; '\n';
++ std::cout &lt;&lt; "Destructing unique_ptr...\n";
++ }
++ std::cout &lt;&lt; "unique_ptr is destructed.\n";
++}
++</pre></blockquote>
++<p>
++Which outputs:
++</p>
++<blockquote>
++<pre>
++unique_ptr is constructed.
++The deleter = 1
++Destructing unique_ptr...
++Deleter beginning operator()(T*)
++The deleter = 1
++Deleter about to destruct the X.
++Deleter has destructed the X.
++The deleter = **destructed**
++Deleter ending operator()(T*)
++unique_ptr is destructed.
++</pre>
++</blockquote>
++<p>
++The line "<tt>The deleter = **destructed**</tt>" represents the deleter referencing itself after it has been destructed by the
++<tt>d(ptr)</tt> expression, but prior to that call returning.
++<p/>
++Suggested alternative to the current proposed wording:
++</p>
++<blockquote>
++<p>
++The expression <tt>d(ptr)</tt> shall not refer to the object <tt>d</tt> after it executes <tt>ptr-&gt;~T()</tt>.
++</p>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<ol>
++<li>
++<p>
++Edit 20.8.1.2 [unique.ptr.single] p1 as indicated:
++</p>
++<blockquote><p>
++The default type for the template parameter <tt>D</tt> is <tt>default_delete</tt>.
++A client-supplied template argument <tt>D</tt> shall be a function object type (20.9), lvalue-reference to function, or
++lvalue-reference to function object type for which, given a value <tt>d</tt> of type <tt>D</tt> and a value <tt>ptr</tt> of type
++<tt>unique_ptr&lt;T, D&gt;::pointer</tt>, the expression <tt>d(ptr)</tt> is valid and has the effect of disposing of the pointer
++as appropriate for that deleter. <ins>The expression <tt>d(ptr)</tt> shall not refer to the object <tt>d</tt> after it executes
++<tt>ptr-&gt;~T()</tt>.</ins>
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2264"></a>2264. [arrays.ts] <tt>std::dynarray</tt> defines its initializer-list constructor in terms of a non-existent constructor</h3>
++<p><b>Section:</b> X [dynarray], 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Povilas Kanapickas <b>Opened:</b> 2013-05-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: arrays.ts</b></p>
++
++<p>
++<tt>std::dynarray</tt> member listing at X [dynarray.overview] includes this constructor:
++</p>
++
++<blockquote><pre>
++dynarray(initializer_list&lt;T&gt;);
++</pre></blockquote>
++
++<p>
++Also, X [dynarray.overview] p. 2 says:
++</p>
++
++<blockquote><p>
++Unless otherwise specified, all <tt>dynarray</tt> operations have the same requirements and semantics as specified in 23.2.
++</p></blockquote>
++
++<p>
++The constructor in question isn't mentioned in X [dynarray.cons] or anywhere else. This means requirements from
++23.2 [container.requirements] apply. However, Table 100 in 23.2.3 [sequence.reqmts] says:
++</p>
++
++<blockquote><p>
++<tt>X(il)</tt> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Equivalent to <tt>X(il.begin(), il.end())</tt>
++</p></blockquote>
++
++<p>
++<tt>std::dynarray</tt> does not provide this constructor.
++</p>
++
++<p>
++The proposed resolution below adds the missing constructor and a complementary constructor with an allocator parameter.
++The new constructors, differently from the rest of containers, accept iterators that have forward iterator category. This
++is needed because the size requirements must be known in order to allocate appropriately-sized storage.
++<p/>
++An alternative resolution could be to properly specify the initializer-list constructor.
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as arrays-ts.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Add the following to the <tt>std::dynarray</tt> synopsis at X [dynarray.overview]:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt;
++ class dynarray {
++ [&hellip;]
++ <i>// 23.3.4.2 construct/copy/destroy:</i>
++ [&hellip;]
++ <ins>template &lt;class ForwardIterator&gt;</ins>
++ <ins>dynarray(ForwardIterator first, ForwardIterator last);</ins>
++ <ins>template &lt;class ForwardIterator, class Alloc&gt;</ins>
++ <ins>dynarray(ForwardIterator first, ForwardIterator last, const Alloc&amp; alloc);</ins>
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Add the following to X [dynarray.cons] after p. 8:</p>
++
++<blockquote><pre>
++<ins>template &lt;class ForwardIterator&gt;
++dynarray(ForwardIterator first, ForwardIterator last);</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Requires:</i> <tt>T</tt> shall meet the <tt>CopyConstructible</tt> requirements.</ins>
++<p/>
++<ins>-?- <i>Effects:</i> Allocates storage for <tt>distance(first, last)</tt> elements.
++The <tt>distance(first, last)</tt> elements of the dynarray are direct-initialized (8.5 [dcl.init]) with the
++corresponding elements from the range <tt>[first,last)</tt>. May or may not invoke the global <tt>operator new</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity:</i> <tt>distance(first, last)</tt>.</ins>
++<p/>
++<ins>-?- <i>Throws:</i> <tt>std::bad_array_length</tt> when the size requested is larger than implementable, <tt>std::bad_alloc</tt>
++when there is insufficient memory.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Add the following to the list of constructors at X [dynarray.cons] before p. 9:</p>
++</li>
++
++<blockquote><pre>
++template &lt;class Alloc&gt;
++dynarray(size_type c, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++dynarray(size_type c, const T&amp; v, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++dynarray(const dynarray&amp; d, const Alloc&amp; alloc);
++template &lt;class Alloc&gt;
++dynarray(initializer_list&lt;T&gt;, const Alloc&amp; alloc);
++<ins>template &lt;class ForwardIterator, class Alloc&gt;
++dynarray(ForwardIterator first, ForwardIterator last, const Alloc&amp; alloc);</ins>
++</pre></blockquote>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2265"></a>2265. 29.3p9 appears to rule out some acceptable executions</h3>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Brian Demsky <b>Opened:</b> 2013-06-17 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I believe that the following variation on IRIW should admit executions in
++which <tt>c1 = d1 = 5</tt> and <tt>c2 = d2 = 0</tt>. If this is allowed, then what is sequence of
++program evaluations for 29.3 [atomics.order] p9 that justifies the store to <tt>z</tt>? It seems that
++29.3 [atomics.order] p9 should not allow this execution because one of the stores to <tt>x</tt> or <tt>y</tt> has
++to appear earlier in the sequence, each of the <tt>fetch_adds</tt> reads the previous load in the thread (and thus must
++appear later in the sequence), and 29.3 [atomics.order] p9 states that each load must read from the last prior
++assignment in the sequence.
++</p>
++
++<blockquote><pre>
++atomic_int x;
++atomic_int y;
++atomic_int z;
++int c1, c2, d1, d2;
++
++static void a(void* obj)
++{
++ atomic_store_explicit(&amp;x, 5, memory_order_relaxed);
++}
++
++static void b(void* obj)
++{
++ atomic_store_explicit(&amp;y, 5, memory_order_relaxed);
++}
++
++static void c(void* obj)
++{
++ c1 = atomic_load_explicit(&amp;x, memory_order_relaxed);
++ // this could also be an atomic load if the address depends on c1:
++ c2 = atomic_fetch_add_explicit(&amp;y, c1, memory_order_relaxed);
++}
++
++static void d(void* obj)
++{
++ d1 = atomic_load_explicit(&amp;y, memory_order_relaxed);
++ d2 = atomic_fetch_add_explicit(&amp;x, d1, memory_order_relaxed);
++}
++
++int user_main(int argc, char** argv)
++{
++ thrd_t t1, t2, t3, t4;
++
++ atomic_init(&amp;x, 0);
++ atomic_init(&amp;y, 0);
++
++ printf("Main thread: creating 4 threads\n");
++ thrd_create(&amp;t1, (thrd_start_t)&amp;a, NULL);
++ thrd_create(&amp;t2, (thrd_start_t)&amp;b, NULL);
++ thrd_create(&amp;t3, (thrd_start_t)&amp;c, NULL);
++ thrd_create(&amp;t4, (thrd_start_t)&amp;d, NULL);
++
++ thrd_join(t1);
++ thrd_join(t2);
++ thrd_join(t3);
++ thrd_join(t4);
++ printf("c1=%d c2=%d\n",c1,c2);
++ printf("d1=%d d2=%d\n",d1,d2);
++
++ // Can this store write 1000 (i.e., c1=d1=5, c2=d2=0)?
++ atomic_store(&amp;z, (c1+d1)*100+c2+d2);
++
++ printf("Main thread is finished\n");
++
++ return 0;
++}
++</pre></blockquote>
++
++<p>
++It seems that the easiest fix is to allow a load in 29.3 [atomics.order] p9 to read from any prior
++store in the evaluation order.
++<p/>
++That said, I would personally advocate the following:
++It seems to me that C/C++ atomics are in a bit of different situation than Java
++because:
++</p>
++<ol>
++<li><p>People are expected to use relaxed C++ atomics in potentially racy
++situations, so it isn't clear that semantics as complicated as the JMM's
++causality would be sane.
++</p></li>
++<li><p>People who use C/C++ atomics are likely to be experts and use them in a
++very controlled fashion. I would be really surprised if compilers would find
++any real wins by optimizing the use of atomics.
++</p></li>
++</ol>
++<p>
++Why not do something like:
++<p/>
++There is satisfaction DAG of all program evaluations. Each evaluation
++observes the values of variables as computed by some prior assignment in
++the DAG.
++<p/>
++There is an edge <tt>x-&gt;y</tt> between two evaluations <tt>x</tt> and <tt>y</tt> if:
++</p>
++<ol>
++<li><p>the evaluation <tt>y</tt> observes a value computed by the evaluation <tt>x</tt> or
++</p></li>
++<li><p>the evaluation <tt>y</tt> is an atomic store, the evaluation <tt>x</tt> is an atomic load, and
++there is a condition branch c that may depend (intrathread dependence) on <tt>x</tt>
++and <tt>x-sb-&gt;c</tt> and <tt>c-sb-&gt;y</tt>.
++</p></li>
++</ol>
++<p>
++This seems to allow reordering of relaxed atomics that processors do without
++extra fence instructions, allows most reorderings by the compiler, and gets
++rid of satisfaction cycles.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++This was partially addressed (weasel-worded) in C++14 (See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3786.htm">N3786</a>).
++The remainder is an open research problem. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3710.html">N3710</a> outlines a "solution" that doesn't have a consensus behind it because it costs performance. We have no better solution at the moment.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2267"></a>2267. <tt>partial_sort_copy</tt> underspecified for ranges of two different types</h3>
++<p><b>Section:</b> 25.4.1.4 [partial.sort.copy] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2013-06-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The signature of this function is:
++</p>
++
++<blockquote><pre>
++template&lt;class InputIterator, class RandomAccessIterator&gt;
++RandomAccessIterator
++partial_sort_copy(InputIterator first, InputIterator last,
++ RandomAccessIterator result_first,
++ RandomAccessIterator result_last);
++
++</pre></blockquote>
++
++<p>
++(and the usual overload for an explicitly provided comparison function). The standard says nothing about requirements
++in the case where the input type (<tt>iterator_traits&lt;InputIterator&gt;::value_type</tt>) and the output type
++(<tt>iterator_traits&lt;RandomAccessIterator&gt;::value_type</tt>) are different.
++<p/>
++Presumably the input type must be convertible to the output type. What's less clear is what the requirements are on
++the comparison operator. Does the algorithm only perform comparisons on two values of the output type, or does it also
++perform comparisons on values of the input type, or might it even perform heterogeneous comparisons?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2269"></a>2269. Container iterators and argument-dependent lookup</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2013-06-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider the following code snippet:
++</p>
++
++<blockquote><pre>
++#include &lt;vector&gt;
++#include &lt;algorithm&gt;
++
++int main() {
++ std::vector&lt;int&gt; v1(100, 3);
++ std::vector&lt;int&gt; v2(100);
++ copy(v1.begin(), v1.end(), v2.begin());
++}
++</pre></blockquote>
++
++<p>
++It compiles without error on my desktop. Is it required to? I can't find evidence from the standard that it is.
++In my test <tt>std::copy</tt> was found by argument-dependent lookup because the implementation I used made
++<tt>std::vector&lt;int&gt;::iterator</tt> a user-defined type defined in namespace <tt>std</tt>. But the standard
++only requires <tt>std::vector&lt;int&gt;::iterator</tt> to be an implementation specified random access iterator
++type. I can't find anything requiring it to be a user-defined type at all (and in fact there are reasonable implementation
++where it isn't), let alone a user defined type defined in a specific namespace.
++</p>
++
++<p>
++Since the defining namespace of container iterators is visible to users, should the standard say anything about what
++that namespace is?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2273"></a>2273. <tt>regex_match</tt> ambiguity</h3>
++<p><b>Section:</b> 28.11.2 [re.alg.match] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.match">issues</a> in [re.alg.match].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++28.11.2 [re.alg.match] p2 in describing regex_match says:
++</p>
++<blockquote>
++<p>
++-2- <i>Effects:</i> Determines whether there is a match between the regular expression <tt>e</tt>, and all of
++the character sequence <tt>[first,last)</tt>. The parameter <tt>flags</tt> is used to control how the expression
++is matched against the character sequence. Returns true if such a match exists, false otherwise.
++</p>
++</blockquote>
++
++<p>
++It has come to my attention that different people are interpreting the first sentence of p2 in different ways:
++</p>
++
++<ol>
++<li><p>
++If a search of the input string using the regular expression <tt>e</tt> matches the entire input string,
++<tt>regex_match</tt> should return true.
++</p></li>
++<li><p>
++Search the input string using the regular expression <tt>e</tt>. Reject all matches that do not match the
++entire input string. If a such a match is found, return true.
++</p></li>
++</ol>
++
++<p>
++The difference between these two subtly different interpretations is found using the following ECMAScript example:
++</p>
++
++<blockquote><pre>
++std::regex re("Get|GetValue");
++</pre></blockquote>
++
++<p>
++Using <tt>regex_search</tt>, this <tt>re</tt> can never match the input string <tt>"GetValue"</tt>, because ECMA
++specifies that alternations are ordered, not greedy. As soon as <tt>"Get"</tt> is matched in the left alternation,
++the matching algorithm stops.
++<p/>
++Using definition 1, <tt>regex_match</tt> would return false for an input string of <tt>"GetValue"</tt>.
++<p/>
++However definition 2 alters the grammar and appears equivalent to augmenting the regex with a trailing <tt>'$'</tt>,
++which is an anchor that specifies, reject any matches which do not come at the end of the input sequence.
++So, using definition 2, <tt>regex_match</tt> would return true for an input string of <tt>"GetValue"</tt>.
++<p/>
++My opinion is that it would be strange to have <tt>regex_match</tt> return true for a <tt>string/regex</tt>
++pair that <tt>regex_search</tt> could never find. I.e. I favor definition 1.
++<p/>
++John Maddock writes:
++<p/>
++The intention was always that <tt>regex_match</tt> would reject any match candidate which didn't match the entire
++input string. So it would find <tt>GetValue</tt> in this case because the <tt>"Get"</tt> alternative had already
++been rejected as not matching. Note that the comparison with ECMA script is somewhat moot, as ECMAScript defines
++the regex grammar (the bit we've imported), it does not define anything like <tt>regex_match</tt>, nor do we import
++from ECMAScript the behaviour of that function. So IMO the function should behave consistently regardless of the
++regex dialect chosen. Saying "use awk regexes" doesn't cut it, because that changes the grammar in other ways.
++<p/>
++(John favors definition 2).
++<p/>
++We need to clarify 28.11.2 [re.alg.match]/p2 in one of these two directions.
++</p>
++
++<p><i>[2014-06-21, Rapperswil]</i></p>
++
++<p>
++AM: I think there's a clear direction and consensus we agree with John Maddock's position, and if noone else
++thinks we need the other function I won't ask for it.
++<p/>
++Marshall Clow and STL to draft.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2276"></a>2276. Missing requirement on <tt>std::promise::set_exception</tt></h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-07-30 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The standard does not specify the behaviour of this program:
++</p>
++
++<blockquote><pre>
++#include &lt;future&gt;
++#include &lt;cassert&gt;
++
++struct NonTrivial
++{
++ NonTrivial() : init(true) { }
++ ~NonTrivial() { assert(init); }
++ bool init;
++};
++
++int main()
++{
++ std::promise&lt;NonTrivial&gt; p;
++ auto f = p.get_future();
++ p.set_exception(std::exception_ptr());
++ f.get();
++}
++</pre></blockquote>
++
++<p>
++The standard doesn't forbid making the state ready with a null
++<tt>exception_ptr</tt>, so what should <tt>get()</tt> return? There's no stored
++exception to throw, but it can't return a value because none was initialized.
++<p/>
++A careful reading of the standard shows 30.6.4 [futures.state] p8 says
++"A shared state is <em>ready</em> only if it holds a value or an exception
++ready for retrieval." One can infer from the fact that <tt>set_exception()</tt>
++makes the state ready that it must store a value or exception, so
++cannot store "nothing", but that isn't explicit.
++<p/>
++The <tt>promise::set_exception()</tt> and <tt>promise::set_exception_at_thread_exit()</tt>
++members should require <tt>p != nullptr</tt> or should state the type of exception thrown
++if <tt>p</tt> is null.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++SG1 provides P/R and requests move to SG1-OK status: Add Requires clauses for promise (30.6.5 [futures.promise]) set_exception (before p18) and set_exception_at_thread_exit (before p24): Requires: p is not null.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N4431.
++</p>
++Add Requires clauses for promise (30.6.5 [futures.promise]) <tt>set_exception</tt> (before p18) and
++<tt>set_exception_at_thread_exit</tt> (before p24): <i>Requires</i>: <tt>p</tt> is not null.
++
++<ol>
++<li><p>Change 30.6.5 [futures.promise] as depicted:</p>
++
++<blockquote>
++<pre>
++void set_exception(exception_ptr p);
++</pre>
++<blockquote>
++<p>
++<ins>-??- <i>Requires:</i> <tt>p</tt> is not null. </ins>
++</p>
++<p>
++-18- <i>Effects:</i> atomically stores the exception pointer <tt>p</tt> in the shared state and makes that state ready (30.6.4).
++</p>
++</blockquote>
++</blockquote>
++
++<blockquote>
++<pre>
++void set_exception_at_thread_exit(exception_ptr p);
++</pre>
++<blockquote>
++<p>
++<ins>-??- <i>Requires:</i> <tt>p</tt> is not null. </ins>
++</p>
++<p>
++-24- <i>Effects:</i> Stores the exception pointer <tt>p</tt> in the shared state without making that state ready immediately. [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li></ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2277"></a>2277. [arrays.ts] <tt>&lt;dynarray&gt;</tt> is missing in 24.7/1</h3>
++<p><b>Section:</b> 24.7 [iterator.range] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Cassio Neri <b>Opened:</b> 2013-07-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#iterator.range">active issues</a> in [iterator.range].</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.range">issues</a> in [iterator.range].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: arrays.ts</b></p>
++
++<p>
++Section 24.7 [iterator.range] p1 specifies header files that, in addition to
++<tt>&lt;iterator&gt;</tt>, make available the function templates in 24.7
++(<tt>begin</tt>, <tt>end</tt>, etc.) but it fails to mention
++<tt>&lt;dynarray&gt;</tt>. This seems to be just an oversight.
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as arrays-ts.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Modify 24.7 [iterator.range] p1 as indicated:</p>
++
++<blockquote><p>
++-1- In addition to being available via inclusion of the <tt>&lt;iterator&gt;</tt> header, the function templates in 24.7 are
++available when any of the following headers are included: <tt>&lt;array&gt;</tt>, <tt>&lt;deque&gt;</tt>,
++<ins><tt>&lt;dynarray&gt;</tt>,</ins>
++<tt>&lt;forward_list&gt;</tt>, <tt>&lt;list&gt;</tt>, <tt>&lt;map&gt;</tt>, <tt>&lt;regex&gt;</tt>,
++<tt>&lt;set&gt;</tt>, <tt>&lt;string&gt;</tt>, <tt>&lt;unordered_map&gt;</tt>, <tt>&lt;unordered_set&gt;</tt>,
++and <tt>&lt;vector&gt;</tt>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2286"></a>2286. <tt>stringbuf::underflow()</tt> underspecified</h3>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Sergey Zubkov <b>Opened:</b> 2013-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 27.8.2.4 [stringbuf.virtuals]/1, <tt>basic_stringbuf::underflow()</tt> is specified to unconditionally
++return <tt>traits::eof()</tt> when a read position is not available.
++<p/>
++The semantics of <tt>basic_stringbuf</tt> require, and existing libraries implement it so that this function makes
++a read position available if possible to do so, e.g. if some characters were inserted into the stream since the
++last call to <tt>overflow()</tt>, resulting in <tt>pptr() &gt; egptr()</tt>. Compare to the conceptually similar
++D.7.1.3 [depr.strstreambuf.virtuals]/15.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++
++<li><p>Change 27.8.2.4 [stringbuf.virtuals] as indicated:</p>
++
++<blockquote>
++<pre>
++int_type underflow();
++</pre><blockquote>
++<p>
++-1- <i>Returns:</i> If the input sequence has a read position available <ins>or the function makes a read position available
++(as described below)</ins>, returns <tt>traits::to_int_type(*gptr())</tt>. Otherwise, returns <tt>traits::eof()</tt>. Any
++character in the underlying buffer which has been initialized is considered to be part of the input sequence.
++<p/>
++<ins>-?- The function can make a read position available only if <tt>(mode &amp; ios_base::in) != 0</tt> and if the write
++next pointer <tt>pptr()</tt> is not null and is greater than the current read end pointer <tt>egptr()</tt>. To make a read
++position available, the function alters the read end pointer <tt>egptr()</tt> to equal <tt>pptr()</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2289"></a>2289. <tt>constexpr</tt> guarantees of defaulted functions still insufficient</h3>
++<p><b>Section:</b> 20.3.2 [pairs.pair], 20.4.2.1 [tuple.cnstr], 20.12.5 [time.duration] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-09 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++During the acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">N3471</a> and
++some similar <tt>constexpr</tt> papers, specific wording was added to <tt>pair</tt>, <tt>tuple</tt>, and other templates
++that were intended to impose implementation constraints that ensure that the observable <tt>constexpr</tt> "character"
++of a defaulted function template is solely determined by the required expressions of the user-provided types when instantiated,
++for example:
++</p>
++
++<blockquote><p>
++The defaulted move and copy constructor, respectively, of pair shall be a <tt>constexpr</tt> function if and only if
++all required element-wise initializations for copy and move, respectively, would satisfy the requirements for
++a <tt>constexpr</tt> function.
++</p></blockquote>
++
++<p>
++This wording doesn't require enough, especially since the core language via CWG 1358 does now support <tt>constexpr</tt>
++function template instantiations, even if such function cannot appear in a constant expression (as specified in 5.20 [expr.const])
++or as a constant initializer of that object (as specified in 3.6.2 [basic.start.init]). The wording should be
++improved and should require valid uses in constant expressions and as constant initializers instead.
++</p>
++
++<p><i>[Lenexa 2015-05-05]</i></p>
++
++<p>STL : notice order of move/copy and copy/move with "respectively".</p>
++<p>General word-smithing; ask for updated wording</p>
++<p>Are we happy with this with changes we are suggesting?</p>
++<p>unanimous</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 20.3.2 [pairs.pair] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <del>The defaulted move and copy constructor, respectively, of pair shall be a <tt>constexpr</tt> function if and only if
++all required element-wise initializations for copy and move, respectively, would satisfy the requirements for
++a <tt>constexpr</tt> function</del><ins>An invocation of the move or copy constructor of <tt>pair</tt> shall be a constant expression
++(5.20 [expr.const]) if all required element-wise initializations would be constant expressions. An invocation of the
++move or copy constructor of <tt>pair</tt> shall be a constant initializer for that <tt>pair</tt> object (3.6.2 [basic.start.init])
++if all required element-wise initializations would be constant initializers for the respective subobjects</ins>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.1 [tuple.cnstr] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <del>The defaulted move and copy constructor, respectively, of <tt>tuple</tt> shall be a <tt>constexpr</tt> function if
++and only if all required element-wise initializations for copy and move, respectively, would satisfy the requirements for
++a <tt>constexpr</tt> function. The defaulted move and copy constructor of <tt>tuple&lt;&gt;</tt> shall be <tt>constexpr</tt>
++functions</del><ins>An invocation of the move or copy constructor of <tt>tuple</tt> shall be a constant expression (5.20 [expr.const])
++if all required element-wise initializations would be constant expressions. An invocation of the move or copy constructor of
++<tt>tuple</tt> shall be a constant initializer for that <tt>tuple</tt> object (3.6.2 [basic.start.init]) if all
++required element-wise initializations would be constant initializers for the respective subobjects. An invocation of the
++move or copy constructor of <tt>tuple&lt;&gt;</tt> shall be a constant expression, or a constant initializer for that
++<tt>tuple&lt;&gt;</tt> object, respectively, if the function argument would be constant expression</ins>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 20.12.5 [time.duration] p7 as indicated:</p>
++
++<blockquote>
++<p>
++-7- <i>Remarks:</i> <del>The defaulted copy constructor of duration shall be a <tt>constexpr</tt> function if and only if
++the required initialization of the member <tt>rep_</tt> for copy and move, respectively, would satisfy the
++requirements for a <tt>constexpr</tt> function.</del><ins>An invocation of the copy constructor of <tt>duration</tt> shall
++be a constant expression (5.20 [expr.const]) if the required initialization of the member <tt>rep_</tt> would be a constant expression.
++An invocation of the copy constructor of <tt>duration</tt> shall be a constant initializer for that <tt>duration</tt> object
++(3.6.2 [basic.start.init]) if the required initialization of the member <tt>rep_</tt> would be constant initializers
++for this subobject</ins>.
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2290"></a>2290. Top-level "SFINAE"-based constraints should get a separate definition in Clause 17</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-02 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The current library specification uses at several places wording that is intended to refer to
++core language template deduction failure at the top-level of expressions (aka "SFINAE"), for example:
++</p>
++
++<blockquote><p>
++The expression <tt>declval&lt;T&gt;() = declval&lt;U&gt;()</tt> is well-formed when treated as an unevaluated operand (Clause 5).
++Access checking is performed as if in a context unrelated to <tt>T</tt> and <tt>U</tt>. Only the validity of the immediate context
++of the assignment expression is considered. [<i>Note:</i> The compilation of the expression can result in side effects
++such as the instantiation of class template specializations and function template specializations, the generation of
++implicitly-defined functions, and so on. Such side effects are not in the "immediate context" and can result in the program
++being ill-formed. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>
++Similar wording can be found in the specification of <tt>result_of</tt>, <tt>is_constructible</tt>, and <tt>is_convertible</tt>,
++being added to resolve an NB comment by LWG <a href="lwg-defects.html#1390">1390</a> and <a href="lwg-defects.html#1391">1391</a> through
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">N3142</a>.
++<p/>
++This wording is necessary to limit speculative compilations needed to implement these traits, but it is also lengthy and repetitive.
++</p>
++
++<p><i>[2014-05-19, Daniel suggests a descriptive term]</i></p>
++
++<p>
++<b>constrictedly well-formed expression</b>:
++<p/>
++An expression <em>e</em> depending on a set of types <tt>A1</tt>, ..., <tt>An</tt> which is well-formed when treated as
++an unevaluated operand (Clause 5). Access checking is performed as if in a context unrelated to <tt>A1</tt>, ...,
++<tt>An</tt>. Only the validity of the immediate context of <em>e</em> is considered. [<i>Note:</i> The compilation of
++the expression can result in side effects such as the instantiation of class template specializations and function
++template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the
++"immediate context" and can result in the program being ill-formed. &mdash; <i>end note</i>]
++</p>
++
++<p><i>[2014-05-20, Richard and Jonathan suggest better terms]</i></p>
++
++<p>
++Richard suggested "locally well-formed"
++<p/>
++Jonathan suggested "contextually well-formed" and then "The expression ... is valid in a contrived argument
++deduction context"
++</p>
++
++<p><i>[2014-06-07, Daniel comments and improves wording]</i></p>
++
++<p>
++The 2014-05-19 suggestion did only apply to expressions, but there are two important examples that are not expressions, but instead
++are involving an <em>object definition</em> (<tt>std::is_constructible</tt>) and a <em>function definition</em>
++(<tt>std::is_convertible</tt>), respectively, instead. Therefore I suggest to rephrase the usage of "expression" into "program
++construct" in the definition of Jonathan's suggestion of "valid in a contrived argument deduction context".
++<p/>
++I would like to point out that given the new definition of "valid in a contrived argument deduction context", there are several other
++places of the Library specification that could take advantage of this wording to improve the existing specification, such as
++20.9.12.2 [func.wrap.func] p2, most functions in 20.7.8.2 [allocator.traits.members], and the <tt>**Insertable</tt>,
++<tt>EmplaceConstructible</tt>, and <tt>Erasable</tt> definitions in 23.2.1 [container.requirements.general], but given that
++these are not fully described in terms of the aforementioned wording <em>yet</em>, I would recommend to fix them by a separate issue
++once the committee has agreed on following the suggestion presented by this issue.
++</p>
++
++<p><i>[2015-05-05 Lenexa: Move to Open]</i></p>
++
++<p>...</p>
++<p>MC: I think we like the direction but it isn't quite right: it needs some work</p>
++<p>JW: I'm prepared to volunteer to move that further, hopefully with the help of Daniel</p>
++<p>Roger Orr: should this be Core wording because it doesn't really have anything to do with libraries - the term could then just be used here</p>
++<p>AM: Core has nothing to deal with that, though</p>
++<p>HT: it seems there is nothing to imply that allows dropping out with an error - maybe that's a separate issue</p>
++<p>MC: I'm not getting what you are getting at: could you write an issue? - any objection to move to Open?</p>
++<p>...</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Add the following new definition to 17.3 [definitions] as indicated:</p>
++
++<p>
++<ins><b>valid in a contrived argument deduction context</b> [defns.valid.contr.context]</ins>
++<p/>
++<ins>A program construct <em>c</em> depending on a set of types <tt>A1</tt>, ..., <tt>An</tt>, and treated as
++an unevaluated operand (Clause 5) when <em>c</em> is an expression, which is well-formed.
++Access checking is performed as if in a context unrelated to <tt>A1</tt>, ..., <tt>An</tt>.
++Only the validity of the immediate context (14.8.2 [temp.deduct]) of <em>c</em> is considered.
++[<i>Note:</i> The compilation of <em>c</em> can result in side effects such as the instantiation of class template
++specializations and function template specializations, the generation of implicitly-defined functions, and so on.
++Such side effects are not in the "immediate context" and can result in the program being ill-formed. &mdash;
++<i>end note</i>].</ins>
++</p>
++</li>
++
++<li><p>Change Table 49 ("Type property predicates") as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 49 &mdash; Type property predicates</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Preconditions</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T, class U&gt;<br/>
++struct is_assignable;</tt>
++</td>
++
++<td>
++The expression
++<tt>declval&lt;T&gt;() =<br/>
++declval&lt;U&gt;()</tt> is <ins>valid in a<br/>
++contrived argument deduction context<br/>
++([defns.valid.contr.context]) for types<br/>
++<tt>T</tt> and <tt>U</tt>.</ins>
++<del>well-formed when treated<br/>
++as an unevaluated operand<br/>
++(Clause 5). Access<br/>
++checking is performed as if<br/>
++in a context unrelated to <tt>T</tt><br/>
++and <tt>U</tt>. Only the validity of<br/>
++the immediate context of<br/>
++the assignment expression<br/>
++is considered. [<i>Note</i>: The<br/>
++compilation of the<br/>
++expression can result in<br/>
++side effects such as the<br/>
++instantiation of class<br/>
++template specializations<br/>
++and function template<br/>
++specializations, the<br/>
++generation of<br/>
++implicitly-defined<br/>
++functions, and so on. Such<br/>
++side effects are not in the<br/>
++"immediate context" and<br/>
++can result in the program<br/>
++being ill-formed. &mdash; end<br/>
++note]</del>
++</td>
++
++<td align="center">
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Change 20.10.4.3 [meta.unary.prop] p7 as indicated:</p>
++
++<blockquote><p>
++-7- Given the following function prototype:
++</p>
++<blockquote><pre>
++template &lt;class T&gt;
++ add_rvalue_reference_t&lt;T&gt; create() noexcept;
++</pre></blockquote>
++<p>
++the predicate condition for a template specialization <tt>is_constructible&lt;T, Args...&gt;</tt> shall be satisfied
++if and only if the following variable definition <del>would be well-formed</del> for some invented
++variable <tt>t</tt> <ins>would be valid in a contrived argument deduction context ([defns.valid.contr.context]) for
++types <tt>T</tt> and <tt>Args...</tt></ins>:
++</p>
++<blockquote><pre>
++T t(create&lt;Args&gt;()...);
++</pre></blockquote>
++<p>
++[<i>Note</i>: These tokens are never interpreted as a function declaration. &mdash; <i>end note</i>] <del>Access checking is
++performed as if in a context unrelated to <tt>T</tt> and any of the <tt>Args</tt>. Only the validity of the immediate context
++of the variable initialization is considered. [<i>Note</i>: The evaluation of the initialization can result in side
++effects such as the instantiation of class template specializations and function template specializations, the
++generation of implicitly-defined functions, and so on. Such side effects are not in the "immediate context"
++and can result in the program being ill-formed. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote>
++</li>
++
++<li><p>Change Table 57 ("Other transformations") as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 57 &mdash; Other transformations</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class Fn, class... ArgTypes&gt;<br/>
++struct result_of&lt;Fn(ArgTypes...)&gt;;</tt>
++</td>
++
++<td align="center">
++[&hellip;]
++</td>
++
++<td>
++If the expression<br/>
++<tt><i>INVOKE</i>(declval&lt;Fn&gt;(),<br/>
++declval&lt;ArgTypes&gt;()...)</tt> is<br/>
++<ins>valid in a contrived argument deduction<br/>
++context ([defns.valid.contr.context]) for types<br/>
++<tt>Fn</tt> and <tt>ArgTypes...</tt></ins>
++<del>well<br/>
++formed when treated as an<br/>
++unevaluated operand (Clause 5)</del>, the<br/>
++member typedef type shall name the<br/>
++type<br/>
++<tt>decltype(<i>INVOKE</i>(declval&lt;Fn&gt;(),<br/>
++declval&lt;ArgTypes&gt;()...))</tt>;<br/>
++otherwise, there shall be no member<br/>
++type. <del>Access checking is performed as<br/>
++if in a context unrelated to <tt>Fn</tt> and<br/>
++<tt>ArgTypes</tt>. Only the validity of the<br/>
++immediate context of the expression is<br/>
++considered. [<i>Note</i>: The compilation of<br/>
++the expression can result in side<br/>
++effects such as the instantiation of<br/>
++class template specializations and<br/>
++function template specializations, the<br/>
++generation of implicitly-defined<br/>
++functions, and so on. Such side effects<br/>
++are not in the "immediate context"<br/>
++and can result in the program being<br/>
++ill-formed. &mdash; <i>end note</i>]</del>
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li><p>Change 20.10.6 [meta.rel] p4 as indicated:</p>
++
++<blockquote><p>
++-4- Given the following function prototype:
++</p>
++<blockquote><pre>
++template &lt;class T&gt;
++ add_rvalue_reference_t&lt;T&gt; create() noexcept;
++</pre></blockquote>
++<p>
++the predicate condition for a template specialization <tt>is_convertible&lt;From, To&gt;</tt> shall be satisfied if and
++only if the return expression in the following code would be <del>well-formed</del><ins>valid in a contrived argument
++deduction context ([defns.valid.contr.context]) for types <tt>To</tt> and <tt>From</tt></ins>, including any implicit conversions
++to the return type of the function:
++</p>
++<blockquote><pre>
++To test() {
++ return create&lt;From&gt;();
++}
++</pre></blockquote>
++<p>
++[<i>Note</i>: This requirement gives well defined results for reference types, <tt>void</tt> types, array types, and
++function types. &mdash; <i>end note</i>] <del>Access checking is performed as if in a context unrelated to <tt>To</tt>
++and <tt>From</tt>. Only the validity of the immediate context of the expression of the return-statement (including conversions to
++the return type) is considered. [<i>Note</i>: The evaluation of the conversion can result in side effects such as
++the instantiation of class template specializations and function template specializations, the generation of
++implicitly-defined functions, and so on. Such side effects are not in the "immediate context" and can result
++in the program being ill-formed. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2292"></a>2292. Find a better phrasing for "shall not participate in overload resolution"</h3>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2013-09-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The C++14 CD has 25 sections including the phrase "X shall not
++participate in overload resolution ...". Most of these uses are double
++negatives, which are hard to interpret. "shall not ... unless" tends
++to be the easiest to read, since the condition is true when the
++function is available, but we also have a lot of "if X is not Y, then
++Z shall not participate", which actually means "You can call Z if X is
++Y." The current wording is also clumsy and long-winded. We should find
++a better and more concise phrasing.
++<p/>
++As an initial proposal, I'd suggest using "X is enabled if and only if Y" in prose
++and adding an "<i>Enabled If:</i> ..." element to 17.5.1.4 [structure.specifications].
++<p/>
++Daniel:
++<p/>
++I suggest to name this new specification element for 17.5.1.4 [structure.specifications]
++as "<i>Template Constraints:</i>" instead, because the mentioned wording form was intentionally provided
++starting with LWG <a href="lwg-defects.html#1237">1237</a> to give implementations more freedom to realize the
++concrete constraints. Instead of the original <tt>std::enable_if</tt>-based specifications
++we can use better forms of "SFINAE" constraints today and it eases the path to possible language-based
++constraints in the future.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2294"></a>2294. <tt>&lt;cstdlib&gt;</tt> should declare <tt>abs(double)</tt></h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2013-09-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++&hellip; and <tt>abs(float)</tt> and <tt>abs(long double)</tt>. And <tt>&lt;cmath&gt;</tt> should declare
++<tt>abs(int)</tt>, <tt>abs(long)</tt>, and <tt>abs(long long)</tt>.
++<p/>
++As things currently stand, this program is illegal:
++</p>
++<blockquote><pre>
++#include &lt;cstdlib&gt;
++
++int main() {
++ double d = -1.23;
++ double dd = std::abs(d);
++ return 0;
++}
++</pre></blockquote>
++<p>
++The call is ambiguous because of the various integer overloads, that's because <tt>&lt;cstdlib&gt;</tt> provides
++<tt>abs(int)</tt> but not <tt>abs(double)</tt>.
++<p/>
++This lead one commenter on Stackoverflow to state that <tt>abs</tt> is dangerous, and to recommend using <tt>fabs</tt> instead.
++<p/>
++In general, it makes sense to declare overloaded functions that take user-defined types in the same header as the
++definition of the user-defined types; it isn't necessary to declare all of the overloads in the same place. But
++here we're not dealing with any user-defined types; we're dealing with builtin types, which are always defined;
++all of the overloads should be defined in the same place, to avoid mysterious problems like the one in the code above.
++<p/>
++The standard library has six overloads for <tt>abs</tt>:
++</p>
++<blockquote><pre>
++int abs(int); // &lt;cstdlib&gt;
++long abs(long); // &lt;cstdlib&gt;
++long long abs(long long); // &lt;cstdlib&gt;
++
++float abs(float); // &lt;cmath&gt;
++double abs(double); // &lt;cmath&gt;
++long double abs(long double); // &lt;cmath&gt;
++</pre></blockquote>
++<p>
++These should all be declared in both headers.
++<p/>
++I have no opinion on <tt>&lt;stdlib.h&gt;</tt> and <tt>&lt;math.h&gt;</tt>.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++This issue is related to LWG <a href="lwg-active.html#2192">2192</a>
++<p/>
++Move to open
++</p>
++
++<p><i>[2014-02-13 Issaquah &mdash; Nicolai Josuttis suggest wording]</i></p>
++
++
++<p><i>[2015-03-03, Geoffrey Romer provides improved wording]</i></p>
++
++<p>
++See proposed resolution of LWG <a href="lwg-active.html#2192">2192</a>.
++</p>
++
++<strong>Previous resolution from Nicolai [SUPERSEDED]:</strong>
++<blockquote class = "note">
++<ol>
++<li><p>Edit 26.8 [c.math] after p7 as indicated:</p>
++
++<blockquote><p>
++-6- In addition to the <tt>int</tt> versions of certain math functions in <tt>&lt;cstdlib&gt;</tt>, C++ adds <tt>long</tt> and <tt>long long</tt>
++overloaded versions of these functions, with the same semantics.
++<p/>
++-7- The added signatures are:
++</p>
++<blockquote><pre>
++long abs(long); <i>// labs()</i>
++long long abs(long long); <i>// llabs()</i>
++ldiv_t div(long, long); <i>// ldiv()</i>
++lldiv_t div(long long, long long); <i>// lldiv()</i>
++</pre></blockquote>
++<p>
++<ins>-?- To avoid ambiguities, C++ also adds the following overloads of <tt>abs()</tt> to <tt>&lt;cstdlib&gt;</tt>,
++with the semantics defined in <tt>&lt;cmath&gt;</tt>:</ins>
++</p>
++<blockquote><pre>
++<ins>float abs(float);
++double abs(double);
++long double abs(long double);</ins>
++</pre></blockquote>
++<p>
++<ins>-?- To avoid ambiguities, C++ also adds the following overloads of <tt>abs()</tt> to <tt>&lt;cmath&gt;</tt>,
++with the semantics defined in <tt>&lt;cstdlib&gt;</tt>:</ins>
++</p>
++<blockquote><pre>
++<ins>int abs(int);
++long abs(long);
++long long abs(long long);</ins>
++</pre></blockquote>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++See proposed resolution of LWG <a href="lwg-active.html#2192">2192</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2295"></a>2295. Locale name when the provided <tt>Facet</tt> is a <tt>nullptr</tt></h3>
++<p><b>Section:</b> 22.3.1.2 [locale.cons] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-09-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++22.3.1.2 [locale.cons] p14 ends with:
++</p>
++<blockquote><p>
++"[&hellip;] If <tt>f</tt> is null, the resulting object is a copy of <tt>other</tt>."
++</p></blockquote>
++<p>
++but the next line p15 says:
++</p>
++<blockquote><p>
++"<i>Remarks:</i> The resulting locale has no name."
++</p></blockquote>
++<p>
++But both can't be true when <tt>other</tt> has a name and <tt>f</tt> is null.
++<p/>
++I've tried it on two implementations (MSVC,GCC) and they are inconsistent with each other on this.
++</p>
++<p>
++Daniel Kr&uuml;gler:
++<p/>
++As currently written, the <i>Remarks</i> element applies unconditionally for all cases and thus should
++"win". The question arises whether the introduction of this element by LWG <a href="lwg-closed.html#424">424</a> had actually intended
++to change the previous <i>Note</i> to a <i>Remarks</i> element. In either case the wording should be improved
++to clarify this special case.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2296"></a>2296. <tt>std::addressof</tt> should be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 20.7.12.1 [specialized.addressof] <b>Status:</b> <a href="lwg-active.html#Review">Review</a>
++ <b>Submitter:</b> Daryle Walker <b>Opened:</b> 2013-09-08 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.addressof">issues</a> in [specialized.addressof].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Review">Review</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I'm writing a function that needs to be <tt>constexpr</tt> and I wanted to take the address of its input. I was
++thinking of using <tt>std::addressof</tt> to be safe, but it isn't currently <tt>constexpr</tt>. A
++<a href="http://en.cppreference.com/w/cpp/memory/addressof">sample implementation</a>
++couldn't be <tt>constexpr</tt> under the C++11 rules, though.
++<p/>
++Daniel Kr&uuml;gler:
++<p/>
++Indeed the core language clarified by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1312">CWG 1312</a>
++and by <a href="www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1384">CWG 1384</a>, that such emulations of <tt>std::addressof</tt>
++implementations are not valid in constant expressions, therefore it seems more like a defect than a feature request to ask for
++the guarantee that <tt>std::addressof</tt> is a <tt>constexpr</tt> function. It should be added that a similar requirement
++already exists for <tt>offsetof</tt> indirectly via the C99 standard as of 7.17 p3:
++</p>
++<blockquote>
++<p>
++The macros are [&hellip;]
++</p>
++<blockquote><pre>
++offsetof(type, member-designator)
++</pre></blockquote>
++<p>
++which expands to an integer constant expression that has type <tt>size_t</tt> [&hellip;]
++</p>
++</blockquote>
++
++<p>
++combined with the noted property in C++11 that:
++</p>
++
++<blockquote><p>
++"<tt>offsetof</tt> is required to work as specified even if unary <tt>operator&amp;</tt>
++is overloaded for any of the types involved"
++</p></blockquote>
++
++<p>
++Therefore implementations should already be able without heroic efforts to realize this functionality by
++some intrinsic. The wording needs at least to ensure that for any lvalue core constant expression <tt><em>e</em></tt>
++the expression <tt>std::addressof(<em>e</em>)</tt> is a core constant expression.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++</p>
++
++<p><i>[2014-06-08, Daniel improves wording]</i></p>
++
++<p>
++It has been ensured that the wording is in sync with the recent working paper and the usage of "any" has been
++improved to say "every" instead (the fix is similar to that applied by LWG <a href="lwg-defects.html#2150">2150</a>).
++</p>
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Change header <tt>&lt;memory&gt;</tt> synopsis, 20.7.2 [memory.syn] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 20.7.12 [specialized.algorithms], specialized algorithms:</i>
++ template &lt;class T&gt; <ins>constexpr</ins> T* addressof(T&amp; r) noexcept;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 20.7.12.1 [specialized.addressof] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class T&gt; <ins>constexpr</ins> T* addressof(T&amp; r) noexcept;
++</pre><blockquote>
++<p>
++-1- <i>Returns:</i> The actual address of the object or function referenced by <tt>r</tt>, even in the presence of an
++overloaded <tt>operator&amp;</tt>.
++<p/>
++<ins>-?- <i>Remarks:</i> For every lvalue core constant expression <tt><em>e</em></tt> (5.20 [expr.const]), the expression
++<tt>std::addressof(<em>e</em>)</tt> is a core constant expression.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-06-09, further improvements]</i></p>
++
++<p>
++A new wording form is now used similar to the approach used by LWG <a href="lwg-active.html#2234">2234</a>, which
++is a stricter way to impose the necessary implementation requirements.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++ STL: the intent of this change is good; I think the wording is good<br/>
++- I'm a bit worried about asking for a compiler hook<br/>
++- if every implementer says: yes they can do it we should be good<br/>
++EB: there is missing the word "a" before "subexpression" (in multiple places)<br/>
++MC: the editor should do - we rely on our editors<br/>
++MC: move to Review with a note stating that we wait for implementation experience first<br/>
++- in favor: 13, opposed: 0, abstain: 2
++HB: N4430 will bring something which is addressing this issue<br/>
++MC: good we didn't go to ready then
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Introduce the following new definition to the existing list in 17.3 [definitions]: [<i>Drafting note</i>:
++If LWG <a href="lwg-active.html#2234">2234</a> is accepted before this issue, the accepted wording for the new definition should be used instead
++&mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<p>
++<strong>constant subexpression</strong> [defns.const.subexpr]
++<p/>
++an expression whose evaluation as subexpression of a <em>conditional-expression</em> <em>CE</em> (5.16 [expr.cond])
++would not prevent <em>CE</em> from being a core constant expression (5.20 [expr.const]).
++</p>
++</blockquote>
++</li>
++
++<li><p>Change header <tt>&lt;memory&gt;</tt> synopsis, 20.7.2 [memory.syn] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 20.7.12 [specialized.algorithms], specialized algorithms:</i>
++ template &lt;class T&gt; <ins>constexpr</ins> T* addressof(T&amp; r) noexcept;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 20.7.12.1 [specialized.addressof] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class T&gt; <ins>constexpr</ins> T* addressof(T&amp; r) noexcept;
++</pre><blockquote>
++<p>
++-1- <i>Returns:</i> The actual address of the object or function referenced by <tt>r</tt>, even in the presence of an
++overloaded <tt>operator&amp;</tt>.
++<p/>
++<ins>-?- <i>Remarks:</i> An expression <tt>std::addressof(<em>E</em>)</tt> is a constant subexpression ( [defns.const.subexpr]),
++if <tt><em>E</em></tt> is an lvalue constant subexpression.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2303"></a>2303. Explicit instantiation of <tt>std::vector&lt;UserType&gt;</tt> broken?</h3>
++<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The library gives explicit permission in 17.6.4.2.1 [namespace.std] p2 that user code may explicitly instantiate
++a library template provided that the instantiations depend on at least one user-defined type:
++</p>
++
++<blockquote><p>
++A program may explicitly instantiate a template defined in the standard library only if the declaration
++depends on the name of a user-defined type and the instantiation meets the standard library requirements
++for the original template.
++</p></blockquote>
++
++<p>
++But it seems that the C++11 library is not specified in a way that guarantees such an instantiation to be well-formed
++if the minimum requirements of the library is not satisfied.
++<p/>
++For example, in general, the first template parameter of <tt>std::vector</tt> is not required to be
++<tt>DefaultConstructible</tt> in general, but due to the split of the single C++03 member function
++with default argument
++</p>
++<blockquote><pre>
++void resize(size_type sz, T c = T());
++</pre></blockquote>
++<p>
++into
++</p>
++<blockquote><pre>
++void resize(size_type sz);
++void resize(size_type sz, const T&amp; c);
++</pre></blockquote>
++<p>
++the effect is now that for a type <tt>ND</tt> that is not <tt>DefaultConstructible</tt>, such as
++</p>
++<blockquote><pre>
++struct NP {
++ NP(int);
++};
++</pre></blockquote>
++<p>
++the explicit instantiation of <tt>std::vector&lt;ND&gt;</tt> is no longer well-formed, because the attempt to
++instantiate the single-argument overload of <tt>resize</tt> cannot not succeed, because this function imposes
++the <tt>DefaultInsertable</tt> requirements and given the default allocator this effectively requires
++<tt>DefaultConstructible</tt>.
++</p>
++<p>
++But <tt>DefaultConstructible</tt> is not the only point, what about <tt>CopyConstructible</tt> versus
++<tt>MoveConstructible</tt> alone? It turns out that currently the second <tt>resize</tt> overload
++would fail during an explicit instantiation for a type like
++</p>
++<blockquote><pre>
++struct MO {
++ MO() = default;
++ MO(MO&amp;&amp;) = default;
++};
++</pre></blockquote>
++<p>
++because it imposes <tt>CopyInsertable</tt> requirements that end up being equivalent to the <tt>CopyConstructible</tt>
++requirements for the default allocator.
++<p/>
++Technically a library can solve these issues: For special member functions by defining them in some base class, for others
++by transforming them effectively into a function template due to the great feature of default template arguments for
++function templates (At the very moment the validity of the latter approach depends on a resolution of core language issue
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1635">CWG 1635</a>, though). E.g. the here mentioned
++<tt>resize</tt> functions of <tt>std::vector</tt> could be prevented from instantiation by defining them like this
++with an implementation:
++</p>
++<blockquote><pre>
++template&lt;class = void&gt;
++void resize(size_type sz) { [&hellip;] }
++template&lt;class = void&gt;
++void resize(size_type sz, const T&amp; c) { [&hellip;] }
++</pre></blockquote>
++<p>
++In this case, these functions could also be defined in a base class, but the latter approach won't work in all cases.
++<p/>
++Basically such an implementation is required to constrain all member functions that are not covered by the general
++requirements imposed on the actual library template parameters. I tested three different C++11 library implementations
++and but none could instantiate for example <tt>std::list</tt>, <tt>std::vector</tt>, or <tt>std::deque</tt> with
++value types that are not <tt>DefaultConstructible</tt> or only <tt>MoveConstructible</tt>.
++<p/>
++
++<p/>
++This issue is raised to clarify the current situation in regard to the actual requirements imposed on user-provided
++types that are used to explicitly instantiate Library-provided templates. For example, the current Container requirements
++impose very little requirements on the actual value type and it is unclear to which extend library implementations have
++to respect that.
++<p/>
++The minimum solution of this issue should be to at least realize that there is no fundamental requirement on
++<tt>DefaultConstructible</tt> for value types of library containers, because we have since C++03 the general
++statement of 17.6.3.1 [utility.arg.requirements] ("In general, a default constructor is not required.").
++It is unclear whether <tt>CopyConstructible</tt> should be required for an explicit instantiation request, but
++given the careful introduction of move operations in the library it would seem astonishing that a
++<tt>MoveConstructible</tt> type wouldn't suffice for value types of the container types.
++<p/>
++In any case I can envision at least two approaches to solve this issue:
++</p>
++<ol>
++<li>
++<p>
++As indicated in LWG <a href="lwg-active.html#2292">2292</a>, those function could get an explicit "<i>Template Constraints:</i>"
++element, albeit this promises more than needed to solve this issue.
++</p>
++</li>
++<li>
++<p>
++The library could introduce a completely new element form, such as "<i>Instantiation Constraints:</i>" that
++would handle this situation for explicit instantiation situations. This would allow for simpler techniques
++to solve the issue when explicit instantiation is required compared to the first bullet, because it would not
++(necessarily) guarantee SFINAE-friendly expression-wellformedness, such as inspecting the expression
++<tt>std::declval&lt;std::vector&lt;ND&gt;&amp;&gt;.resize(0)</tt> in an unevaluated context.
++</p>
++</li>
++</ol>
++
++<p>
++It should be noted that the 2013-08-27 comment to LWG <a href="lwg-defects.html#2193">2193</a> could be resolved by a similar solution
++as indicated in this issue here.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2307"></a>2307. Should the Standard Library use <tt>explicit</tt> only when necessary?</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2013-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++LWG <a href="lwg-defects.html#2193">2193</a> yields <tt>explicit</tt> for default ctors to allow <tt>{}</tt>, but not for
++all cases of uniform initialization. For example:
++</p>
++<blockquote><pre>
++explicit vector(size_type count, const Allocator&amp; alloc = Allocator());
++</pre></blockquote>
++<p>
++This prevents <tt>{n, alloc()}</tt>. Although this use is relatively rare,
++but the behavior is inconsistent with that of
++</p>
++<blockquote><pre>
++vector(size_type count, const T&amp; value, const Allocator&amp; alloc = Allocator());
++</pre></blockquote>
++
++<p><i>[Urbana 2014-11-07: Move to Open]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2309"></a>2309. <tt>mutex::lock()</tt> should not throw <tt>device_or_resource_busy</tt></h3>
++<p><b>Section:</b> 30.4.1.2 [thread.mutex.requirements.mutex] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2013-09-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements.mutex">issues</a> in [thread.mutex.requirements.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As discussed during the Chicago meeting in
++<a href="http://wiki.edg.com/twiki/bin/view/Wg21chicago2013/ThursdayMorningMinutes#LWG_2135_revisited">SG1</a>
++the only reasonable reasons for throwing <tt>device_or_resource_busy</tt> seem to be:
++</p>
++<ul>
++<li><p>
++The thread currently already holds the mutex, the mutex is not recursive, and the implementation detects this.
++In this case <tt>resource_deadlock_would_occur</tt> should be thrown.
++</p></li>
++<li><p>
++Priority reasons. At least <tt>std::mutex</tt> (and possibly all standard mutex types)
++should not be setup this way, otherwise we have real problems with <tt>condition_variable::wait()</tt>.
++</p></li>
++</ul>
++
++<p><i>[2014-06-17 Rapperswil]</i></p>
++
++<p>
++Detlef provides wording
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++We believe we were already done with it. Should be in SG1-OK status.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 30.4.1.2 [thread.mutex.requirements.mutex] as indicated:</p>
++
++<blockquote><p>
++-13- <i>Error conditions</i>:
++</p>
++<ul>
++<li><p><tt>operation_not_permitted</tt> &mdash; if the thread does not have the privilege to perform the operation.</p></li>
++<li><p><tt>resource_deadlock_would_occur</tt> &mdash; if the implementation detects that a deadlock would occur.</p></li>
++<li><p><del><tt>device_or_resource_busy</tt> &mdash; if the mutex is already locked and blocking is not possible.</del></p></li>
++</ul>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2310"></a>2310. Public <em>exposition only</em> member in <tt>std::array</tt></h3>
++<p><b>Section:</b> 23.3.2.1 [array.overview] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++23.3.2.1 [array.overview] shows <tt>std::array</tt> with an "exposition only" data member, <tt>elems</tt>.
++<p/>
++The wording in 17.5.2.3 [objects.within.classes] that defines how
++"exposition only" is used says it applies to private members, but
++<tt>std::array::elems</tt> (or its equivalent) must be public in order for
++<tt>std::array</tt> to be an aggregate.
++<p/>
++If the intention is that <tt>std::array::elems</tt> places requirements on the
++implementation to provide "equivalent external behavior" to a public
++array member, then 17.5.2.3 [objects.within.classes] needs to cover public
++members too, or some other form should be used in 23.3.2.1 [array.overview].
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Open]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2312"></a>2312. <tt>tuple</tt>'s constructor constraints need to be phrased more precisely</h3>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-05-06</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider the following code:
++</p>
++<blockquote><pre>
++void meow(tuple&lt;long, long&gt;) { puts("Two"); }
++
++void meow(tuple&lt;long, long, long&gt;) { puts("Three"); }
++
++tuple&lt;int, int, int&gt; t(0, 0, 0);
++
++meow(t);
++</pre></blockquote>
++<p>
++This should compile and print "Three" because <tt>tuple&lt;long, long&gt;</tt>'s constructor from
++<tt>const tuple&lt;int, int, int&gt;&amp;</tt> should remove itself from overload resolution.
++Implementations sensibly do this, but the Standard doesn't actually say it!
++<p/>
++In this case, <tt>Types</tt> is "<tt>long, long</tt>" and <tt>UTypes</tt> is "<tt>int, int, int</tt>". 20.4.2.1 [tuple.cnstr]/3
++says "let <tt>i</tt> be in the range <tt>[0,sizeof...(Types))</tt> in order", which is <tt>[0, 2)</tt>. Then /17 says
++"<i>Remark:</i> This constructor shall not participate in overload resolution unless <tt>const Ui&amp;</tt> is implicitly
++convertible to <tt>Ti</tt> for all <tt>i</tt>." Interpreted literally, this is true! /15 says
++"<i>Requires:</i> <tt>sizeof...(Types) == sizeof...(UTypes)</tt>." but requiring the sizes to be identical doesn't help.
++Only the special phrase "shall not participate in overload resolution unless" mandates SFINAE/<tt>enable_if</tt> machinery.
++<p/>
++The wording that we need is almost available in the <i>Requires</i> paragraphs, except that the <i>Requires</i> paragraphs say
++"<tt>is_constructible</tt>" while the Remark paragraphs say "is implicitly convertible", which is the correct thing for the SFINAE
++constraints to check. My proposed resolution is to unify the <i>Requires</i> and <i>Remark</i> paragraphs, after which there
++will be no need for <i>Requires</i> (when a constructor participates in overload resolution if and only if <tt>X</tt> is true,
++then there's no need for it to <i>Require</i> that <tt>X</tt> is true).
++<p/>
++Note: 20.10.4.3 [meta.unary.prop]/6 specifies <tt>is_constructible&lt;To, From&gt;</tt> and 20.10.6 [meta.rel]/4 specifies
++<tt>is_convertible&lt;From, To&gt;</tt>. Both are specified in terms of
++"<tt>template &lt;class T&gt; typename add_rvalue_reference&lt;T&gt;::type create();</tt>".
++Therefore, passing <tt>From</tt> and <tt>From&amp;&amp;</tt> is equivalent, regardless of whether <tt>From</tt> is an object type,
++an lvalue reference, or an rvalue reference.
++<p/>
++Also note that 20.4.2.1 [tuple.cnstr]/3 defines <tt>T0</tt> and <tt>T1</tt> so we don't need to repeat their definitions.
++</p>
++
++<p><i>[2014-10-05, Daniel comments]</i></p>
++
++<p>
++This issue is closely related to LWG <a href="lwg-active.html#2419">2419</a>.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++AM: Howard wants to do something in this space and I want to wait for him to get a paper in.
++<p/>
++Postponed.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: handled by Daniel's tuple paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387.html">N4387</a><br/>
++STL: look at status after N4387 applied.
++</p>
++<p><i>[2015-05-05, Daniel comments]</i></p>
++
++<p>
++N4387 doesn't touch these area intentionally. I agree with Howard that a different option exists that would introduce
++a TupleLike concept. Some implementations currently take advantage of this choice and this P/R would forbid them, which seems
++unfortunate to me.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 20.4.2.1 [tuple.cnstr] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class... UTypes&gt;
++ explicit constexpr tuple(UTypes&amp;&amp;... u);
++</pre><blockquote>
++<p>
++<del>-8- <i>Requires:</i> <tt>sizeof...(Types) == sizeof...(UTypes)</tt>. <tt>is_constructible&lt;Ti, Ui&amp;&amp;&gt;::value</tt> is true
++for all <i>i</i>.</del>
++<p/>
++[&hellip;]
++<p/>
++-10- <i>Remark:</i> This constructor shall not participate in overload resolution unless <del>each type in <tt>UTypes</tt> is
++implicitly convertible to its corresponding type in <tt>Types</tt></del><ins><tt>sizeof...(Types) == sizeof...(UTypes)</tt> and
++both <tt>is_constructible&lt;Ti, Ui&gt;::value</tt> and <tt>is_convertible&lt;Ui, Ti&gt;::value</tt> are true for all <i>i</i></ins>.
++</p>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++<blockquote><pre>
++template &lt;class... UTypes&gt;
++ constexpr tuple(const tuple&lt;UTypes...&gt;&amp; u);
++</pre><blockquote>
++<p>
++<del>-15- <i>Requires:</i> <tt>sizeof...(Types) == sizeof...(UTypes)</tt>. <tt>is_constructible&lt;Ti, const Ui&amp;&gt;::value</tt> is true
++for all <i>i</i>.</del>
++<p/>
++[&hellip;]
++<p/>
++-17- <i>Remark:</i> This constructor shall not participate in overload resolution unless <del><tt>const Ui&amp;</tt> is implicitly
++convertible to <tt>Ti</tt></del><ins><tt>sizeof...(Types) == sizeof...(UTypes)</tt> and
++both <tt>is_constructible&lt;Ti, const Ui&amp;&gt;::value</tt> and <tt>is_convertible&lt;const Ui&amp;, Ti&gt;::value</tt> are
++true</ins> for all <i>i</i>.
++</p>
++</blockquote>
++</blockquote>
++<blockquote><pre>
++template &lt;class... UTypes&gt;
++ constexpr tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);
++</pre><blockquote>
++<p>
++<del>-18- <i>Requires:</i> <tt>sizeof...(Types) == sizeof...(UTypes)</tt>. <tt>is_constructible&lt;Ti, Ui&amp;&amp;&gt;::value</tt> is true
++for all <i>i</i>.</del>
++<p/>
++[&hellip;]
++<p/>
++-20- <i>Remark:</i> This constructor shall not participate in overload resolution unless <del>each type in <tt>UTypes</tt> is
++implicitly convertible to its corresponding type in <tt>Types</tt></del><ins><tt>sizeof...(Types) == sizeof...(UTypes)</tt> and
++both <tt>is_constructible&lt;Ti, Ui&gt;::value</tt> and <tt>is_convertible&lt;Ui, Ti&gt;::value</tt> are true for all <i>i</i></ins>.
++</p>
++</blockquote>
++</blockquote>
++<blockquote><pre>
++template &lt;class U1, class U2&gt; constexpr tuple(const pair&lt;U1, U2&gt;&amp; u);
++</pre><blockquote>
++<p>
++<del>-21- <i>Requires:</i> <tt>sizeof...(Types) == 2</tt>. <tt>is_constructible&lt;T0, const U1&amp;&gt;::value</tt> is true for the first
++type <tt>T0</tt> in Types and <tt>is_constructible&lt;T1, const U2&amp;&gt;::value</tt> is true for the second type <tt>T1</tt> in
++<tt>Types</tt>.</del>
++<p/>
++[&hellip;]
++<p/>
++-23- <i>Remark:</i> This constructor shall not participate in overload resolution unless <del><tt>const U1&amp;</tt> is implicitly
++convertible to <tt>T0</tt> and <tt>const U2&amp;</tt> is implicitly convertible to <tt>T1</tt></del><ins><tt>sizeof...(Types) == 2
++&amp;&amp; is_constructible&lt;T0, const U1&amp;&gt;::value &amp;&amp; is_constructible&lt;T1, const U2&amp;&gt;::value &amp;&amp;
++is_convertible&lt;const U1&amp;, T0&gt;::value &amp;&amp; is_convertible&lt;const U2&amp;, T1&gt;::value</tt> is true</ins>.
++</p>
++</blockquote>
++</blockquote>
++<blockquote><pre>
++template &lt;class U1, class U2&gt; constexpr tuple(pair&lt;U1, U2&gt;&amp;&amp; u);
++</pre><blockquote>
++<p>
++<del>-24- <i>Requires:</i> <tt>sizeof...(Types) == 2</tt>. <tt>is_constructible&lt;T0, U1&amp;&amp;&gt;::value</tt> is true for the first
++type <tt>T0</tt> in Types and <tt>is_constructible&lt;T1, U2&amp;&amp;&gt;::value</tt> is true for the second type <tt>T1</tt> in
++<tt>Types</tt>.</del>
++<p/>
++[&hellip;]
++<p/>
++-26- <i>Remark:</i> This constructor shall not participate in overload resolution unless <del><tt>U1</tt> is implicitly convertible
++to <tt>T0</tt> and <tt>U2</tt> is implicitly convertible to <tt>T1</tt></del><ins><tt>sizeof...(Types) == 2
++&amp;&amp; is_constructible&lt;T0, U1&gt;::value &amp;&amp; is_constructible&lt;T1, U2&gt;::value &amp;&amp;
++is_convertible&lt;U1, T0&gt;::value &amp;&amp; is_convertible&lt;U2, T1&gt;::value</tt> is true</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2318"></a>2318. <tt>basic_string</tt>'s wording has confusing relics from the copy-on-write era</h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++21.4.4 [string.capacity]/8 specifies <tt>basic_string::resize(n, c)</tt> with:
++</p>
++<blockquote><p>
++<i>Effects:</i> Alters the length of the string designated by <tt>*this</tt> as follows:
++</p>
++<ul>
++<li><p>
++If <tt>n &lt;= size()</tt>, the function replaces the string designated by <tt>*this</tt> with a string of length <tt>n</tt> whose
++elements are a copy of the initial elements of the original string designated by <tt>*this</tt>.
++</p>
++</li>
++<li><p>
++If <tt>n &gt; size()</tt>, the function replaces the string designated by <tt>*this</tt> with a string of length <tt>n</tt> whose
++first <tt>size()</tt> elements are a copy of the original string designated by <tt>*this</tt>, and whose remaining elements are all
++initialized to <tt>c</tt>.
++</p>
++</li>
++</ul>
++</blockquote>
++<p>
++This wording is a relic of the copy-on-write era. In addition to being extremely confusing, it has undesirable implications.
++Saying "replaces the string designated by <tt>*this</tt> with a string of length <tt>n</tt> whose elements are a copy" suggests
++that the trimming case can reallocate. Reallocation during trimming should be forbidden, like <tt>vector</tt>.
++<p/>
++At least 7 paragraphs are affected: 21.4.4 [string.capacity]/8, 21.4.6.2 [string::append]/9,
++21.4.6.3 [string::assign]/3 and /10, 21.4.6.4 [string::insert]/11, 21.4.6.5 [string::erase]/4, and
++21.4.6.6 [string::replace]/11 say "replaces the string [designated/controlled] by <tt>*this</tt>". (21.4.6.7 [string::copy]/3
++is different &mdash; it "replaces the string designated by <tt>s</tt>".)
++<p/>
++Of the affected paragraphs, <tt>resize()</tt> and <tt>erase()</tt> are the most important to fix because they should forbid
++reallocation during trimming.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2321"></a>2321. Moving containers should (usually) be required to preserve iterators</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++23.2.1 [container.requirements.general]/10 says that unless otherwise specified, "no <tt>swap()</tt> function invalidates
++any references, pointers, or iterators referring to the elements of the containers being swapped. [<i>Note:</i> The <tt>end()</tt>
++iterator does not refer to any element, so it may be invalidated. &mdash; <i>end note</i>]". However, move constructors and move
++assignment operators aren't given similar invalidation guarantees. The guarantees need several exceptions, so I do not believe
++that blanket language like /11 "Unless otherwise specified (either explicitly or by defining a function in terms of other functions),
++invoking a container member function or passing a container as an argument to a library function shall not invalidate iterators to,
++or change the values of, objects within that container." is applicable.
++</p>
++
++<p><i>[2014-02-13 Issaquah]</i></p>
++
++<p>
++General agreeement on intent, several wording nits and additional paragraphs to hit.
++</p>
++<p>
++STL to provide updated wording. Move to Open.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++AM: in the proposed wording, I'd like to mention that the iterators now refer to elements of a different container.
++I think we're saying something like this somewhere. JY: There's some wording like that for swap I think. TK: It's also in
++<tt>list::splice()</tt>. DK to JY: 23.2.1p9.
++<p/>
++VV: The issue says that STL was going to propose new wording. Has he done that? AM: I believe we're looking at that.
++GR: The request touches on multiple paragraphs, and this PR has only one new paragraph, so this looks like it's not up-to-date.
++MC: This was last updated a year ago in Issaquah.
++<p/>
++<b>Conclusion</b>: Skip, not up to date.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 23.2.1 [container.requirements.general]/10 change as indicated:</p>
++
++<blockquote><p>
++-10- Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.3.4, and 23.3.7.5) all container types defined in this
++Clause meet the following additional requirements:
++</p>
++<ul>
++<li><p>
++[&hellip;]
++</p></li>
++<li><p>
++no copy constructor or assignment operator of a returned iterator throws an exception.
++</p></li>
++<li><p>
++<ins>no move constructor (or move assignment operator when
++<tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment::value</tt> is true) of a container
++(except for <tt>array</tt>) invalidates any references, pointers, or iterators referring to the elements of the source container.
++[<i>Note:</i> The <tt>end()</tt> iterator does not refer to any element, so it may be invalidated. &mdash; <i>end note</i>]</ins>
++</p></li>
++<li><p>
++no <tt>swap()</tt> function throws an exception.
++</p></li>
++<li><p>
++no <tt>swap()</tt> function invalidates any references, pointers, or iterators referring to the elements of the
++containers being swapped. [<i>Note:</i> The <tt>end()</tt> iterator does not refer to any element, so it may be
++invalidated. &mdash; <i>end note</i>]
++</p></li>
++</ul>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2326"></a>2326. <tt>uniform_int_distribution&lt;unsigned char&gt;</tt> should be permitted</h3>
++<p><b>Section:</b> 26.5.1.1 [rand.req.genl] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++26.5.1.1 [rand.req.genl]/1 says: "Throughout this subclause 26.5, the effect of instantiating a template [...] that has a
++template type parameter named <tt>IntType</tt> is undefined unless the corresponding template argument is <i>cv</i>-unqualified
++and is one of <tt>short</tt>, <tt>int</tt>, <tt>long</tt>, <tt>long long</tt>, <tt>unsigned short</tt>, <tt>unsigned int</tt>,
++<tt>unsigned long</tt>, or <tt>unsigned long long</tt>." 26.5.8.2.1 [rand.dist.uni.int] specifies
++<tt>template&lt;class IntType = int> class uniform_int_distribution</tt>, so this forbids
++<tt>uniform_int_distribution&lt;char/signed char/unsigned char&gt;</tt>.
++<p/>
++I am not aware of anything in <tt>&lt;random&gt;</tt> that works with 16-bit integers but fails with 8-bit integers, so I suspect
++that <tt>IntType</tt> and <tt>UIntType</tt> could simply be extended to permit the <tt>char</tt> family. Alternatively, this
++change could be limited to <tt>uniform_int_distribution</tt> alone, where it is definitely safe. A <tt>&lt;random&gt;</tt> expert
++should decide which change is best.
++</p>
++
++<p><i>[2015-04-04 Geoffrey provides wording]</i></p>
++
++<p>
++ I think it's time to call the question; it's just silly that we have a random number library with no natural way to generate
++ random bytes. However, I don't think it's sufficient to fix only <tt>uniform_int_distribution</tt>, or even all of <tt>IntType</tt>.
++ At a bare minimum we need to also fix <tt>independent_bits_engine</tt> (arguably the cleanest way of generating a random byte)
++ and that's specified in terms of <tt>UIntType</tt>.
++ <p/>
++ The wording provided below is equivalent to adding <tt>unsigned char</tt> to item "f" and adding <tt>signed char</tt> and
++ <tt>unsigned char</tt> to item "e". That means it still excludes <tt>char</tt>, but I'm OK with that. If you want to generate
++ a 1-byte number, you should probably pick a signedess, and if you want to generate a raw byte, the "true" raw byte type is
++ <tt>unsigned char</tt>. This also excludes extended integral types and wide char types, which seem like nice-to-haves at best.
++ I have no objection to supporting any of those types; I just picked this to simplify the wording and hopefully maximize consensus.
++ Note that if we want to broaden <tt>IntType</tt> to permit any integral type, we'll need to decide if we want to exclude <tt>bool</tt>.
++<p/>
++For reference, <tt>IntType</tt> is used as a parameter of the following templates:
++</p>
++<blockquote>
++<pre>
++uniform_int_distribution
++binomial_distribution
++geometric_distribution
++negative_binomial_distribution
++poisson_distribution
++discrete_distribution
++</pre>
++</blockquote>
++<p>
++and <tt>UIntType</tt> is used as a parameter of the following templates:
++</p>
++<blockquote>
++<pre>
++linear_congruential_engine
++mersenne_twister_engine
++subtract_with_carry_engine
++independent_bits_engine
++</pre>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change in 26.5.1.1 [rand.req.genl] p1 as indicated:</p>
++
++<p>
++-1- Throughout this subclause 26.5, the effect of instantiating a template:
++</p>
++<ol style="list-style-type:lower-alpha;" start="4">
++<li><p>[&hellip;]</p></li>
++<li><p>that has a template type parameter named <tt>IntType</tt> is undefined unless the corresponding template
++argument is cv-unqualified and is <ins>a standard integer type (3.9.1 [basic.fundamental])</ins><del>one of
++<tt>short</tt>, <tt>int</tt>, <tt>long</tt>, <tt>long long</tt>, <tt>unsigned short</tt>, <tt>unsigned int</tt>,
++<tt>unsigned long</tt>, or <tt>unsigned long long</tt></del>.</p></li>
++<li><p>that has a template type parameter named <tt>UIntType</tt> is undefined unless the corresponding template
++argument is cv-unqualified and is <ins>a standard unsigned integer type (3.9.1 [basic.fundamental])</ins><del>one
++of <tt>unsigned short</tt>, <tt>unsigned int</tt>, <tt>unsigned long</tt>, or <tt>unsigned long long</tt></del>.</p></li>
++</ol>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2328"></a>2328. Rvalue stream extraction should use perfect forwarding</h3>
++<p><b>Section:</b> 27.7.2.6 [istream.rvalue] <b>Status:</b> <a href="lwg-active.html#Review">Review</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.rvalue">active issues</a> in [istream.rvalue].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.rvalue">issues</a> in [istream.rvalue].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Review">Review</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++27.7.2.6 [istream.rvalue] declares <tt>operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;&amp; is, T&amp; x)</tt>.
++However, 27.7.2.2.3 [istream::extractors]/7 declares <tt>operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp; in, charT* s)</tt>,
++plus additional overloads for <tt>unsigned char*</tt> and <tt>signed char*</tt>. This means that
++"<tt>return_rvalue_istream() &gt;&gt; &amp;arr[0]</tt>" won't compile, because <tt>T&amp;</tt> won't bind to the rvalue <tt>&amp;arr[0]</tt>.
++</p>
++
++<p><i>[2014-02-12 Issaquah : recategorize as P3]</i></p>
++
++
++<p>
++Jonathan Wakely: Bill was certain the change is right, I think so with less certainty
++</p>
++
++<p>
++Jeffrey Yaskin: I think he's right, hate that we need this
++</p>
++
++<p>
++Jonathan Wakely: is this the security issue Jeffrey raised on lib reflector?
++</p>
++
++<p>
++Move to P3
++</p>
++
++<p><i>[2015-05-06 Lenexa: Move to Review]</i></p>
++
++
++<p>WEB, MC: Proposed wording changes one signature (in two places) to take a forwarding reference.</p>
++<p>TK: Should be consistent with an istream rvalue?</p>
++<p>MC: This is the case where you pass the stream by rvalue reference.</p>
++<p>RP: I would try it before standardizing.</p>
++<p>TK: Does it break anything?</p>
++<p>RP, TK: It will take all arguments, will be an exact match for everything.</p>
++<p>RS, TK: This adapts streaming into an rvalue stream to make it act like streaming into an lvalue stream.</p>
++<p>RS: Should this really return the stream by lvalue reference instead of by rvalue reference? => new LWG issue.</p>
++<p>RP: Security issue?</p>
++<p>MC: No. That's istream >> char*, C++ version of gets(). Remove it, as we did for gets()? => new LWG issue.</p>
++<p>RS: Proposed resolution looks correct to me.</p>
++<p>MC: Makes me (and Jonathan Wakely) feel uneasy.</p>
++<p>Move to Review, consensus.</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 27.7.1 [iostream.format.overview], header <tt>&lt;istream&gt;</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ template &lt;class charT, class traits, class T&gt;
++ basic_istream&lt;charT, traits&gt;&amp;
++ operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;&amp; is, T&amp;<ins>&amp;</ins> x);
++}
++</pre></blockquote>
++</li>
++
++<li><p>Edit 27.7.2.6 [istream.rvalue] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class charT, class traits, class T&gt;
++ basic_istream&lt;charT, traits&gt;&amp;
++ operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;&amp; is, T&amp;<ins>&amp;</ins> x);
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> <tt>is &gt;&gt;<del>x</del> <ins>std::forward&lt;T&gt;(x)</ins></tt>
++<p/>
++-2- <i>Returns:</i> <tt>is</tt>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2331"></a>2331. <tt>regex_constants::collate</tt>'s effects are inaccurately summarized</h3>
++<p><b>Section:</b> 28.5.1 [re.synopt] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.synopt">active issues</a> in [re.synopt].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.synopt">issues</a> in [re.synopt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The table in 28.5.1 [re.synopt]/1 says that <tt>regex_constants::collate</tt> "Specifies that character ranges of the form
++"<tt>[a-b]</tt>" shall be locale sensitive.", but 28.13 [re.grammar]/14 says that it affects individual character comparisons
++too.
++</p>
++
++<p><i>[2012-02-12 Issaquah : recategorize as P3]</i></p>
++
++
++<p>
++Marshall Clow: 28.13/14 only applies to ECMAScript
++</p>
++
++<p>
++All: we're unsure
++</p>
++
++<p>
++Jonathan Wakely: we should ask John Maddock
++</p>
++
++<p>
++Move to P3
++</p>
++
++<p><i>[2014-5-14, John Maddock response]</i></p>
++
++<p>
++The original intention was the original wording: namely that <tt>collate</tt> only made character ranges locale sensitive.
++To be frank it's a feature that's probably hardly ever used (though I have no real hard data on that), and is a leftover
++from early POSIX standards which <em>required</em> locale sensitive collation for character ranges, and then later changed
++to implementation defined if I remember correctly (basically nobody implemented locale-dependent collation).
++<p/>
++So I guess the question is do we gain anything by requiring all character-comparisons to go through the locale when this bit
++is set? Certainly it adds a great deal to the implementation effort (it's not what Boost.Regex has ever done). I guess the
++question is are differing code-points that collate identically an important use case? I guess there might be a few Unicode
++code points that do that, but I don't know how to go about verifying that.
++<p/>
++STL:
++<p/>
++If this was unintentional, then 28.5.1 [re.synopt]/1's table should be left alone, while 28.13 [re.grammar]/14
++should be changed instead.
++<p/>
++Jeffrey Yasskin:
++<p/>
++<a href="http://www.unicode.org/reports/tr18/tr18-13.html#Tailored_Loose_Matches">This page</a>
++mentions that [V] in Swedish should match "W" in a perfect world.
++<p/>
++However, the most recent version of <a href="http://www.unicode.org/reports/tr18/#Tailored_Loose_Matches">TR18</a> retracts
++both language-specific loose matches <em>and</em> language-specific ranges
++because "for most full-featured regular expression engines, it is
++quite difficult to match under code point equivalences that are not
++1:1" and "tailored ranges can be quite difficult to implement
++properly, and can have very unexpected results in practice. For
++example, languages may also vary whether they consider lowercase below
++uppercase or the reverse. This can have some surprising results: [a-Z]
++may not match anything if <tt>Z &lt; a</tt> in that locale."
++<p/>
++<a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.15">ECMAScript</a> doesn't include collation at all.
++<p/>
++IMO, +1 to changing 28.13 instead of 28.5.1. It seems like we'd be on
++fairly solid ground if we wanted to remove <tt>regex_constants::collate</tt>
++entirely, in favor of named character classes, but of course that's
++not for this issue.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 28.5.1 [re.synopt]/1, Table 138 &mdash; "<tt>syntax_option_type</tt> effects", change as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 138 &mdash; <tt>syntax_option_type</tt> effects</caption>
++<tr>
++<th align="center">Element</th>
++<th align="center">Effect(s) if set</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>collate</tt>
++</td>
++<td>
++Specifies that character <del>ranges of the form "<tt>[a-b]</tt>"</del><ins>comparisons and character range comparisons</ins>
++shall be locale sensitive.
++</td>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2334"></a>2334. <tt>atomic</tt>'s default constructor requires "uninitialized" state even for types with non-trivial default-constructor</h3>
++<p><b>Section:</b> 29.6.5 [atomics.types.operations.req] <b>Status:</b> <a href="lwg-active.html#SG1">SG1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-10-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.operations.req">active issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations.req">issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#SG1">SG1</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to 29.6.5 [atomics.types.operations.req] p4,
++</p>
++<blockquote><pre>
++A ::A () noexcept = default;
++</pre><blockquote>
++<p>
++<i>Effects:</i> leaves the atomic object in an uninitialized state. [<i>Note:</i> These semantics ensure compatibility
++with <tt>C</tt>. &mdash; <i>end note</i>]
++</p>
++</blockquote></blockquote>
++<p>
++This implementation requirement is OK for POD types, like <tt>int</tt>, but 29.5 [atomics.types.generic] p1
++intentionally allows template arguments of <tt>atomic</tt> with a non-trivial default constructor ("The type of the template argument
++<tt>T</tt> shall be trivially copyable (3.9)"), so this wording can be read in a way that makes the behaviour of the following code
++undefined:
++</p>
++<blockquote><pre>
++#include &lt;atomic&gt;
++#include &lt;iostream&gt;
++
++struct S {
++ S() noexcept : v(42) {}
++ int v;
++};
++
++int main() {
++ std::atomic&lt;S&gt; as; // Default-initialization
++ std::cout &lt;&lt; as.load().v &lt;&lt; std::endl; // ?
++}
++</pre></blockquote>
++<p>
++For a user-defined emulation of <tt>atomic</tt> the expected outcome would be defined and the program would output "42",
++but existing implementations differ and the result value is a "random number" for at least one implementation. This seems
++very surprising to me.
++<p/>
++To realize that seemingly existing requirement, an implementation is either required to violate normal language rules internally
++or to perform specific bit-randomization-techniques after the normal default-initialization that called the default constructor
++of <tt>S</tt>.
++<p/>
++According to my understanding, the non-normative note in 29.6.5 [atomics.types.operations.req] p4 is intended to
++refer to types that are valid <tt>C</tt>-types, but the example type <tt>S</tt> is not such a type.
++<p/>
++To make the mental model of <tt>atomic</tt>'s default constructor more intuitive for user-code, I suggest to clarify the wording
++to have the effects of default-initialization instead. The current state seems more like an unintended effect of imprecise
++language used here and has some similarities to wording that was incorrectly used to specify <tt>atomic_flag</tt> initialization
++as described by LWG <a href="lwg-defects.html#2159">2159</a>.
++</p>
++
++<p><i>[2014-05-17, Daniel comments and provides alternative wording]</i></p>
++
++
++<p>
++The current wording was considered controversial as expressed by reflector discussions. To me, the actual problem is not newly
++introduced by that wording, but instead is already present in basically all paragraphs specifying semantics of atomic types,
++since the wording never clearly distinguishes the value of the actual atomic type <i>A</i> and the value of the "underlying",
++corresponding non-atomic type <i>C</i>. The revised proposed wording attempts to improve the current ambiguity of these two
++kinds of values.
++</p>
++
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Modify 29.6.5 [atomics.types.operations.req] p4 as indicated: <em>[Editorial note: There is no exposition-only
++member in <tt>atomic</tt>, which makes it a bit hard to specify what actually is initialized, but the usage of the term "value"
++seems consistent with similar wording used to specify the effects of the atomic <tt>load</tt> functions]</em></p>
++
++<blockquote><pre>
++A ::A () noexcept = default;
++</pre><blockquote>
++<p>
++-4- <i>Effects:</i> <del>leaves the atomic object in an uninitialized state</del><ins>The value of the atomic object
++is default-initialized (8.5 [dcl.init])</ins>. [<i>Note:</i> These semantics ensure compatibility
++with <tt>C</tt>. &mdash; <i>end note</i>]
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Modify 29.6.5 [atomics.types.operations.req] p2 as indicated: <em>[Editorial note: This is a near-to editorial
++change not directly affecting this issue, but <tt>atomic_address</tt> does no longer exist and the pointed to definition is
++relevant in the context of this issue resolution.]</em>
++</p>
++<blockquote>
++<p>
++-2- In the following operation definitions:
++</p>
++<ul>
++<li><p>an <i>A</i> refers to one of the atomic types.</p></li>
++<li><p>a <i>C</i> refers to its corresponding non-atomic type. <del>The <tt>atomic_address</tt> atomic type corresponds to the
++<tt>void*</tt> non-atomic type.</del></p></li>
++<li><p>[&hellip;]</p></li>
++</ul>
++</blockquote>
++</li>
++
++<li><p>Modify 29.6.5 [atomics.types.operations.req] p4 and the following as indicated: <em>[Editorial note: There
++is no exposition-only member in <tt>atomic</tt>, which makes it a bit hard to specify what actually is initialized, but
++the introductory wording of 29.6.5 [atomics.types.operations.req] p2 b2 defines: "a <i>C</i> refers to its
++corresponding non-atomic type." which helps to specify the semantics in terms of "the <i>C</i> value referred to by the
++atomic object"]</em></p>
++
++<blockquote>
++<pre>
++<i>A</i>::<i>A</i>() noexcept = default;
++</pre>
++<blockquote>
++<p>
++-4- <i>Effects:</i> <del>leaves the atomic object in an uninitialized state</del><ins>Default-initializes (8.5 [dcl.init])
++the <i>C</i> value referred to by the atomic object</ins>. [<i>Note:</i> These semantics ensure compatibility with <tt>C</tt>.
++&mdash; <i>end note</i>]
++</p>
++</blockquote>
++
++<pre>
++constexpr <i>A</i>::<i>A</i>(<i>C</i> desired) noexcept;
++</pre>
++<blockquote>
++<p>
++-5- <i>Effects:</i> <ins>Direct-i</ins><del>I</del>nitializes the <ins><i>C</i> value referred to by the atomic</ins> object
++with the value <tt>desired</tt>. Initialization is not an atomic operation (1.10). [&hellip;]
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++void atomic_init(volatile <i>A</i>* object, <i>C</i> desired) noexcept;
++void atomic_init(<i>A</i>* object, <i>C</i> desired) noexcept;
++</pre>
++<blockquote>
++<p>
++-8- <i>Effects:</i> Non-atomically initializes <ins>the <i>C</i> value referred to by</ins> <tt>*object</tt> with value
++<tt>desired</tt>. [&hellip;]
++</p>
++</blockquote>
++
++<pre>
++void atomic_store(volatile <i>A</i>* object, <i>C</i> desired) noexcept;
++[&hellip;]
++void <i>A</i>::store(<i>C</i> desired, memory_order order = memory_order_seq_cst) noexcept;
++</pre>
++<blockquote>
++<p>
++-9- [&hellip;]
++<p/>
++-10- <i>Effects:</i> Atomically replaces the <ins><i>C</i></ins> value pointed to by
++<tt>object</tt> or by <tt>this</tt> with the value of <tt>desired</tt>. [&hellip;]
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++<i>C</i> atomic_load(const volatile <i>A</i>* object) noexcept;
++[&hellip;]
++<i>C</i> <i>A</i>::load(memory_order order = memory_order_seq_cst) const noexcept;
++</pre>
++<blockquote>
++<p>
++-13- [&hellip;]
++<p/>
++-14- [&hellip;]
++<p/>
++-15- <i>Returns:</i> Atomically returns the <ins><i>C</i></ins> value pointed to by <tt>object</tt> or by <tt>this</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++<i>C</i> atomic_exchange(volatile <i>A</i>* object, C desired) noexcept;
++[&hellip;]
++<i>C</i> <i>A</i>::exchange(C desired, memory_order order = memory_order_seq_cst) noexcept;
++</pre>
++<blockquote>
++<p>
++-18- <i>Effects</i>: Atomically replaces the <ins><i>C</i></ins> value pointed to by <tt>object</tt> or by <tt>this</tt> with <tt>desired</tt>. [&hellip;]
++<p/>
++-19- <i>Returns:</i> Atomically returns the <ins><i>C</i></ins> value pointed to by <tt>object</tt> or by <tt>this</tt>
++immediately before the effects.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++<i>C</i> atomic_fetch_key(volatile <i>A</i>* object, <i>M</i> operand) noexcept;
++[&hellip;]
++<i>C</i> <i>A</i>::fetch_key(<i>M</i> operand, memory_order order = memory_order_seq_cst) noexcept;
++</pre>
++<blockquote>
++<p>
++-28- <i>Effects</i>: Atomically replaces the <ins><i>C</i></ins> value pointed to by <tt>object</tt> or by <tt>this</tt> with
++the result of the computation applied to the <ins><i>C</i></ins> value pointed to by <tt>object</tt> or by <tt>this</tt> and
++the given <tt>operand</tt>. [&hellip;]
++<p/>
++-29- <i>Returns:</i> Atomically<del>,</del> <ins>returns</ins> the <ins><i>C</i></ins> value pointed to by <tt>object</tt>
++or by <tt>this</tt> immediately before the effects.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++
++<li><p>Modify 29.7 [atomics.flag] p5 and the following as indicated:</p>
++
++<blockquote>
++<pre>
++bool atomic_flag_test_and_set(volatile atomic_flag* object) noexcept;
++[&hellip;]
++bool atomic_flag::test_and_set(memory_order order = memory_order_seq_cst) noexcept;
++</pre>
++<blockquote>
++<p>
++-5- <i>Effects</i>: Atomically sets the <ins>bool</ins> value pointed to by <tt>object</tt> or by <tt>this</tt> to <tt>true</tt>.
++[&hellip;]
++<p/>
++-6- <i>Returns</i>: Atomically<del>,</del> <ins>returns</ins> the <ins>bool</ins> value <del>of the</del><ins>pointed
++to by</ins> <tt>object</tt> <ins>or by <tt>this</tt></ins> immediately before the effects.
++</p>
++</blockquote>
++
++<pre>
++void atomic_flag_clear(volatile atomic_flag* object) noexcept;
++[&hellip;]
++void atomic_flag::clear(memory_order order = memory_order_seq_cst) noexcept;
++</pre>
++<blockquote>
++<p>
++-7- [&hellip;]
++<p/>
++-8- <i>Effects</i>: Atomically sets the <ins>bool</ins> value pointed to by <tt>object</tt> or by <tt>this</tt> to <tt>false</tt>.
++[&hellip;]
++</p>
++</blockquote>
++
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2335"></a>2335. <tt>array&lt;array&lt;int, 3&gt;, 4&gt;</tt> should be layout-compatible with <tt>int[4][3]</tt></h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2013-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In order to replace some uses of C arrays with <tt>std::array</tt>, we need it
++to be possible to cast from a <tt>std::array&lt;&gt;</tt> to an equivalent C array.
++Core wording doesn't appear to be in quite the right state to allow
++casting, but if we specify that appropriate types are
++layout-compatible, we can at least write:
++</p>
++<blockquote><pre>
++union {
++ array&lt;array&lt;array&lt;int, 2&gt;, 3&gt;, 4&gt; arr;
++ int carr[4][3][2];
++};
++</pre></blockquote>
++<p>
++to view memory as the other type: C++14 CD [class.mem]p18.
++</p>
++I believe it's sufficient to add "<tt>array&lt;T, N&gt;</tt> shall be
++layout-compatible (3.9 [basic.types]) with <tt>T[N]</tt>." to
++23.3.2.1 [array.overview], but we might also need some extension to
++9.2 [class.mem] to address the possibility of layout-compatibility
++between struct and array types.
++<p>
++I checked that libc++ on MacOS already implements this, although it
++would be good for someone else to double-check; I haven't checked any
++other standard libraries.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2336"></a>2336. <tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-10-01 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 20.10.4.3 [meta.unary.prop] we have traits to allow testing for triviality of specific operations, such as
++<tt>is_trivially_constructible</tt> and <tt>is_trivially_assignable</tt> (and their derived forms), which are specified
++in terms of the following initialization and assignment, respectively:
++</p>
++<blockquote><pre>
++T t(create&lt;Args&gt;()...);
++
++declval&lt;T&gt;() = declval&lt;U&gt;()
++</pre></blockquote>
++<p>
++The wording that describes the way how triviality is deduced, is in both cases of the same form:
++</p>
++<blockquote><p>
++[&hellip; ] and the variable definition/assignment, as defined by <tt>is_constructible/is_assignable</tt>, is known
++to call no operation that is not trivial (3.9, 12).
++</p></blockquote>
++<p>
++The problematic part of this wording is that both definitions are specified in terms of an "object construction" function
++<tt>create</tt> or <tt>declval</tt>, respectively, (The former being a conceptual function, the latter being a library function),
++but for none of these functions we can assume that they could be considered as trivial &mdash; only special member functions can
++have this property and none of these is one. This problem became obvious, when the similar issue LWG <a href="lwg-defects.html#2298">2298</a>
++in regard to <tt>is_nothrow_constructible</tt> was opened.
++<p/>
++A possible approach to solve this specification problem is to make a blanket statement for sub-clause 20.10.4.3 [meta.unary.prop]
++that these helper functions are considered trivial for the purpose of defining these traits.
++<p/>
++Using this kind of wording technique can also be used to get rid of the additional helper function template <tt>create</tt>, which
++is currently needed for the <tt>is_convertible</tt> and the <tt>is_constructible</tt> traits, because both traits are specified in
++terms of contexts where technically the corresponding "object construction" function would be considered as odr-used. This is problematic,
++because these traits are defined in terms of well-formed code and odr-using <tt>declval</tt> would make the program ill-formed (see
++20.2.5 [declval]). So extending above blanket statement to consider <tt>std::declval&lt;T&gt;()</tt> as not odr-used
++in the context of the corresponding trait definition would allow for replacing <tt>create</tt> by <tt>declval</tt>.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: would you consider moving the change to 20.10 as editorial or are you uncomfortable with it?<br/>
++JW: this sounds a viable editorial change<br/>
++VV: I guarantee you that moving it doesn't change anything<br/>
++MC: how about this: we move it to Ready as is and if we conclude moving it is editorial we can do it and if not open an issue<br/>
++STL: I would like to guarantee that the lifting happens<br/>
++JW: I do that! If it goes in I move it up<br/>
++MC: move to Ready: in favor: 15, opposed: 0, abstain: 1
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Add a new paragraph after 20.10.4.3 [meta.unary.prop] p3 as indicated: <em>[Editorial note: The first change in
++20.10.4.3 [meta.unary.prop] p3 is recommended, because technically a Clause is always a "main chapter" &mdash; such as
++Clause 20 &mdash; but every child of a Clause or sub-clause is a sub-clause]</em></p>
++
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- For all of the class templates <tt>X</tt> declared in this <del>Clause</del><ins>sub-clause</ins>, instantiating that
++template with a template-argument that is a class template specialization may result in the implicit instantiation of the
++template argument if and only if the semantics of <tt>X</tt> require that the argument must be a complete type.
++<p/>
++<ins>-?- For the purpose of defining the templates in this sub-clause, a function call expression
++<tt>declval&lt;T&gt;()</tt> for any type <tt>T</tt> is considered to be a trivial (3.9 [basic.types], 12 [special])
++function call that is not an odr-use (3.2 [basic.def.odr]) of <tt>declval</tt> in the context of the corresponding definition
++notwithstanding the restrictions of 20.2.5 [declval].</ins>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Modify 20.10.4.3 [meta.unary.prop] p7 as indicated:</p>
++
++<blockquote>
++<p>
++-7- <del>Given the following function prototype:</del>
++</p>
++<blockquote><pre>
++<del>template &lt;class T&gt;
++ typename add_rvalue_reference&lt;T&gt;::type create();</del>
++</pre></blockquote>
++<p>
++<del>t</del><ins>T</ins>he predicate condition for a template specialization <tt>is_constructible&lt;T, Args...&gt;</tt>
++shall be satisfied if and only if the following variable definition would be well-formed for some invented variable <tt>t</tt>:
++</p>
++<blockquote><pre>
++T t(<del>create</del><ins>declval</ins>&lt;Args&gt;()...);
++</pre></blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Add a new paragraph after 20.10.6 [meta.rel] p2 as indicated: <em>[Editorial note: Technically we don't need
++the guarantee of "a trivial function call" for the type relationship predicates at the very moment, but it seems more robust and
++consistent to have the exact same guarantee here as well]</em>
++</p>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-2- [&hellip;]
++<p/>
++<ins>-?- For the purpose of defining the templates in this sub-clause, a function call expression
++<tt>declval&lt;T&gt;()</tt> for any type <tt>T</tt> is considered to be a trivial (3.9 [basic.types], 12 [special])
++function call that is not an odr-use (3.2 [basic.def.odr]) of <tt>declval</tt> in the context of the corresponding definition
++notwithstanding the restrictions of 20.2.5 [declval].</ins>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Modify 20.10.6 [meta.rel] p4 as indicated:</p>
++
++<blockquote>
++<p>
++-4- <del>Given the following function prototype:</del>
++</p>
++<blockquote><pre>
++<del>template &lt;class T&gt;
++ typename add_rvalue_reference&lt;T&gt;::type create();</del>
++</pre></blockquote>
++<p>
++<del>t</del><ins>T</ins>he predicate condition for a template specialization <tt>is_convertible&lt;From, To&gt;</tt>
++shall be satisfied if and only if the return expression in the following code would be well-formed, including any implicit
++conversions to the return type of the function:
++</p>
++<blockquote><pre>
++To test() {
++ return <del>create</del><ins>declval</ins>&lt;From&gt;();
++}
++</pre></blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2337"></a>2337. <tt>shared_ptr operator*()</tt> should not be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.8.2.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#NAD">Tentatively NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Tentatively NAD">Tentatively NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.8.1.2.4 [unique.ptr.single.observers]/3: "<tt>pointer operator-&gt;() const noexcept;</tt> <i>Requires:</i> <tt>get() != nullptr</tt>."
++<p/>
++20.8.2.2.5 [util.smartptr.shared.obs]/2: "<tt>T&amp; operator*() const noexcept;</tt> <i>Requires:</i> <tt>get() != 0</tt>."
++<p/>
++20.8.2.2.5 [util.smartptr.shared.obs]/5: "<tt>T* operator-&gt;() const noexcept;</tt> <i>Requires:</i> <tt>get() != 0</tt>."
++<p/>
++Narrow-contract functions should not be <tt>noexcept</tt>.
++</p>
++
++<p><i>[2014-02-15 Issaquah]</i></p>
++
++<p>
++Issue is contentious, raise to P2.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++AM: This ship has sailed. JM: What's the issue? AM: <tt>operator-&gt;</tt> has narrow contract and should never have had
++<tt>noexcept</tt>. DK: Not quite. We explicitly called out that for <tt>shared_ptr</tt> this is fine. You said so in your
++"narrow contract" paper. GR: This would be a fairly major regression in the design of {<tt>unique</tt>,<tt>shared</tt>}<tt>_ptr</tt>
++over raw pointers; raw pointer dereferencing is <tt>noexcept</tt>. It's not a performance regression but a usability regression.
++AM: Do we expect users to query <tt>noexpect</tt> on dereference expressions? Room: Yes. VV: We don't just expect it, we have
++seen it. JM: Yes, users may be querying something like <tt>noexcept(x-&gt;y)</tt> and expect to be checking <tt>y</tt>, but
++silently end up checking <tt>x-&gt;</tt>.
++<p/>
++Close as NAD, with explanation from GR.
++</p>
++
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<blockquote class="note">
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 20.8.1.2 [unique.ptr.single]/1, class template <tt>unique_ptr</tt> synopsis for single objects, change as indicated:</p>
++
++<blockquote><pre>
++pointer operator-&gt;() const <del>noexcept</del>;
++</pre></blockquote>
++</li>
++
++<li><p>In 20.8.1.2.4 [unique.ptr.single.observers] change as indicated:</p>
++
++<blockquote><pre>
++pointer operator-&gt;() const <del>noexcept</del>;
++</pre><blockquote>
++<p>
++-3- <i>Requires:</i> <tt>get() != nullptr</tt>.
++<p/>
++-4- <i>Returns:</i> <tt>get()</tt>.
++<p/>
++<ins>-?- <i>Throws:</i> Nothing.</ins>
++<p/>
++-5- <i>Note:</i> use typically requires that <tt>T</tt> be a complete type.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>In 20.8.2.2 [util.smartptr.shared]/1, class template <tt>shared_ptr</tt> synopsis, change as indicated:</p>
++
++<blockquote><pre>
++T&amp; operator*() const <del>noexcept</del>;
++T* operator-&gt;() const <del>noexcept</del>;
++</pre></blockquote>
++</li>
++
++<li><p>In 20.8.2.2.5 [util.smartptr.shared.obs] change as indicated:</p>
++
++<blockquote><pre>
++T&amp; operator*() const <del>noexcept</del>;
++</pre><blockquote>
++<p>
++-2- <i>Requires:</i> <tt>get() != 0</tt>.
++<p/>
++-3- <i>Returns:</i> <tt>*get()</tt>.
++<p/>
++<ins>-?- <i>Throws:</i> Nothing.</ins>
++<p/>
++-4- <i>Remarks:</i> When <tt>T</tt> is <tt>void</tt>, it is unspecified whether this member function is declared.
++If it is declared, it is unspecified what its return type is, except that the declaration (although not necessarily the
++definition) of the function shall be well formed.
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++T* operator-&gt;() const <del>noexcept</del>;
++</pre><blockquote>
++<p>
++-5- <i>Requires:</i> <tt>get() != 0</tt>.
++<p/>
++-6- <i>Returns:</i> <tt>get()</tt>.
++<p/>
++<ins>-?- <i>Throws:</i> Nothing.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2015-03-03, Geoffrey provides rationale]</i></p>
++
++<p>
++<b>Rationale</b>:
++</p>
++<blockquote>
++<p>
++It is by design that these members are <tt>noexcept</tt>, and changing that now would be a substantial regression in functionality.
++These classes were designed to substitute for plain pointers as transparently as possible, so since those operations are effectively
++<tt>noexcept</tt> on plain pointers, they should be <tt>noexcept</tt> on <tt>unique_ptr</tt> and <tt>shared_ptr</tt> as well.
++This matters in practice because we expect these members to be used fairly often inside the <tt>noexcept</tt> operator, and such
++code could be broken by this change. These design considerations override our general policy against <tt>noexcept</tt> for
++narrow-contract functions.
++<p/>
++It is notable that N3279, which proposed this policy, did not propose striking <tt>noexcept</tt> from these operations. It's not
++clear if the omission of <tt>operator*</tt> and <tt>operator-&gt;</tt> was an oversight, or an intentional reflection of the above
++considerations. N3279 was based on N3248 by the same authors, which states that:
++</p>
++<blockquote>
++<p>
++"Most applications of <tt>noexcept</tt> for <tt>unique_ptr</tt> and <tt>shared_ptr</tt> are on functions with wide contracts.
++However, there are preconditions on the atomic access functions, so these should lose the specification."
++</p>
++</blockquote>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2338"></a>2338. [re.traits]/7 expects of locale facets something not guaranteed by [locale.facet]/4</h3>
++<p><b>Section:</b> 28.7 [re.traits], 22.3.1.1.2 [locale.facet] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Sergey Zubkov <b>Opened:</b> 2013-10-15 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.traits">issues</a> in [re.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++28.7 [re.traits]/7, begins with "if <tt>typeid(use_facet&lt;collate&lt;charT&gt; &gt;) == typeid(collate_byname&lt;charT&gt;)</tt>",
++which appears to be pseudocode with the intention to convey that the collate facet has not been replaced by the user. Cf. the wording in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1429.htm">N1429</a> "there is no portable way to implement
++<tt>transform_primary</tt> in terms of <tt>std::locale</tt>, since even if the sort key format returned by
++<tt>std::collate_byname&lt;&gt;::transform</tt> is known and can be converted into a primary sort key, the user can still
++install their own custom <tt>std::collate</tt> implementation into the locale object used, and that can use any sort key
++format they see fit.".
++<p/>
++Taken literally, 28.7 [re.traits]/7 appears to imply that named locales are required to hold their collate facets with
++dynamic type <tt>std::collate_byname&lt;charT&gt;</tt>, which is in fact true in some implementations (e.g libc++), but not others
++(e.g. libstdc++). This does not follow from the description of <tt>_byname</tt> in 22.3.1.1.2 [locale.facet]/4, which is only
++required to provide equivalent semantics, to the named locale's facet, not to actually be one.
++</p>
++
++
++<p><i>[2015-05-06 Lenexa: Move to Open]</i></p>
++
++
++<p>MC, RP: Consequence of failing to follow the rule is UB.</p>
++<p>MC: Tightening of requirements.</p>
++<p>RP: It should be this way, we just didn't impose it before.</p>
++<p>MC: Second change is a bug fix, original code didn't work.</p>
++<p>TK: Doesn't seem to make things worse.</p>
++<p>Bring up in larger group tomorrow.</p>
++<p>JW arrives.</p>
++<p>JW: libstdc++ violates this due to two std::string ABIs.</p>
++<p>JW: This prevents installing a type derived from Facet_byname, constrains the implementor from using a smarter derived class version.</p>
++<p>JW: Can't look at facet id to detect replacement, because replacements have the same id.</p>
++<p>RP: Can you give it multiple ids through multiple inheritance?</p>
++<p>JW: No, the facet mechanism wouldn't like that.</p>
++<p>JW: We should also ask Martin Sebor, he's implemented this stuff recently.</p>
++<p>MC: Sounds like this resolution doesn't work, need a better solution.</p>
++<p>JW: Write in words "if the facet has not been replaced by the user", the implementation knows how to detect that, but not like this.</p>
++<p>RP: User RE traits need to detect this too.</p>
++<p>JW: =(</p>
++<p>Move to Open, JW will invite Martin Sebor to join LWG for discussion.</p>
++<p>Later ... </p>
++<p>JW: This is not needed for user specializations after all.</p>
++<p>MC: Agree, [re.traits]/7 only applies to the stdlib traits.</p>
++<p>NM: Effects: doesn't make sense.</p>
++<p>JW, NM, Martin Sebor to come up with new wording.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Modify 22.3.1.1.2 [locale.facet]/4 as indicated:</p>
++
++<blockquote><p>
++For some standard facets a standard "...<tt>_byname</tt>" class, derived from it, implements the virtual function
++semantics <del>equivalent to</del><ins>provided by</ins> that facet of the locale constructed by <tt>locale(const char*)</tt>
++with the same name.
++Each such facet provides a constructor that takes a <tt>const char*</tt> argument, which names the locale, and a
++<tt>refs</tt> argument, which is passed to the base class constructor. Each such facet also provides a constructor
++that takes a string argument <tt>str</tt> and a <tt>refs</tt> argument, which has the same effect as calling the first
++constructor with the two arguments <tt>str.c_str()</tt> and <tt>refs</tt>. If there is no "...<tt>_byname</tt>"
++version of a facet, the base class implements named locale semantics itself by reference to other facets. <ins>For any
++locale <tt>loc</tt> constructed by <tt>locale(const char*)</tt> and facet <tt>Facet</tt> that has a corresponding standard
++<tt>Facet_byname</tt> class, <tt>typeid(use_facet&lt;Facet&gt;(loc)) == typeid(Facet_byname)</tt>.</ins>
++</p></blockquote>
++</li>
++
++<li><p>Modify 28.7 [re.traits]/7 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class ForwardIterator&gt;
++ string_type transform_primary(ForwardIterator first, ForwardIterator last) const;
++</pre><blockquote>
++<p>
++-7- <i>Effects:</i> if <tt>typeid(use_facet&lt;collate&lt;charT&gt; &gt;<ins>(getloc())</ins>) == typeid(collate_byname&lt;charT&gt;)</tt>
++and the form of the sort key returned by <tt>collate_byname&lt;charT&gt;::transform(first, last)</tt> is known and
++can be converted into a primary sort key then returns that key, otherwise returns an empty string.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2342"></a>2342. User conversion to <tt>wchar_t const*</tt> or to <tt>wchar_t</tt> not invoked for <tt>operator&lt;&lt;</tt></h3>
++<p><b>Section:</b> 27.7.3.1 [ostream] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Alf P. Steinbach <b>Opened:</b> 2013-10-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream">issues</a> in [ostream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++For wide streams argument types <tt>wchar_t const*</tt> and <tt>wchar_t</tt> are supported only as template parameters.
++User defined conversions are not considered for template parameter matching. Hence inappropriate overloads of
++<tt>operator&lt;&lt;</tt> are selected when an implicit conversion is required for the argument, which is inconsistent
++with the behavior for <tt>char const*</tt> and <tt>char</tt>, is unexpected, and is a useless result.
++<p/>
++Demonstration:
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++
++struct Byte_string
++{
++ operator char const*() const { return "Hurray, it works!"; }
++};
++
++struct Wide_string
++{
++ operator wchar_t const*() const { return L"Hurray, it works!"; }
++};
++
++struct Byte_ch
++{
++ operator char() const { return 'X'; }
++};
++
++struct Wide_ch
++{
++ operator wchar_t() const { return L'X'; }
++};
++
++auto main() -> int
++{
++ using namespace std;
++ wcout &lt;&lt; "'X' as char value : " &lt;&lt; Byte_ch() &lt;&lt; endl;
++ wcout &lt;&lt; "'X' as wchar_t value: " &lt;&lt; Wide_ch() &lt;&lt; endl;
++ wcout &lt;&lt; "Byte string pointer : " &lt;&lt; Byte_string() &lt;&lt; endl;
++ wcout &lt;&lt; "Wide string pointer : " &lt;&lt; Wide_string() &lt;&lt; endl;
++}
++</pre></blockquote>
++<p>
++Example output:
++</p>
++<blockquote><pre>
++'X' as char value : X
++'X' as wchar_t value: 88
++Byte string pointer : Hurray, it works!
++Wide string pointer : 000803C8
++</pre></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 27.7.3.1 [ostream], class template <tt>basic_ostream</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++[&hellip;]
++
++<i>// 27.7.3.6.4 character inserters</i>
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
++ charT);
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
++ char);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
++ char);
++<ins>template&lt;class traits&gt;
++ basic_ostream&lt;wchar_t,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;wchar_t,traits&gt;&amp;,
++ wchar_t);</ins>
++[&hellip;]
++
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
++ const charT*);
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
++ const char*);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
++ const char*);
++<ins>template&lt;class traits&gt;
++ basic_ostream&lt;wchar_t,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;wchar_t,traits&gt;&amp;,
++ const wchar_t*);</ins>
++[&hellip;]
++}
++
++</pre></blockquote>
++</li>
++
++<li><p>Modify 27.7.3.6.4 [ostream.inserters.character] as indicated: <em>[Drafting note:
++The replacement of <tt>os</tt> by <tt>out</tt> in p1 and the insertion of "<tt>out.</tt>" in p4
++just fix two obvious typos &mdash; end drafting note]</em></p>
++
++<blockquote><pre>
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ charT c);
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ char c);
++<i>// specialization</i>
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ char c);
++<ins>template&lt;class traits&gt;
++ basic_ostream&lt;wchar_t,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;wchar_t,traits&gt;&amp; out,
++ wchar_t c);</ins>
++
++<i>// signed and unsigned</i>
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ signed char c);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ unsigned char c);
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> Behaves as a formatted output function (27.7.3.6.1 [ostream.formatted.reqmts]) of <tt>out</tt>.
++Constructs a character sequence <tt>seq</tt>. If <tt>c</tt> has type <tt>char</tt> and the character type of the stream
++is not <tt>char</tt>, then <tt>seq</tt> consists of <tt>out.widen(c)</tt>; otherwise <tt>seq</tt> consists of <tt>c</tt>.
++Determines padding for <tt>seq</tt> as described in 27.7.3.6.1 [ostream.formatted.reqmts]. Inserts <tt>seq</tt> into
++<tt>out</tt>. Calls <tt><del>os</del><ins>out</ins>.width(0)</tt>.
++<p/>
++-2- <i>Returns:</i> <tt>out</tt>.
++</p>
++</blockquote>
++<pre>
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ const charT* s);
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ const char* s);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const char* s);
++<ins>template&lt;class traits&gt;
++ basic_ostream&lt;wchar_t,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;wchar_t,traits&gt;&amp; out,
++ const wchar_t* s);</ins>
++
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const signed char* s);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const unsigned char* s);
++</pre><blockquote>
++<p>
++-3- <i>Requires:</i> <tt>s</tt> shall not be a null pointer.
++<p/>
++-4- <i>Effects:</i> Behaves like a formatted inserter (as described in 27.7.3.6.1 [ostream.formatted.reqmts]) of <tt>out</tt>.
++Creates a character sequence <tt>seq</tt> of <tt>n</tt> characters starting at <tt>s</tt>, each widened using <tt>out.widen()</tt>
++(27.5.5.3), where <tt>n</tt> is the number that would be computed as if by:
++</p>
++<ul>
++<li><p>
++<tt>traits::length(s)</tt> for the <ins>following</ins> overload<ins>s:</ins>
++<ul>
++<li><p>
++where the first argument is of type <tt>basic_ostream&lt;charT, traits&gt;&amp;</tt>
++and the second is of type <tt>const charT*</tt>,
++</p></li>
++<li><p>
++<del>and also for the overload</del> where the first argument is of type
++<tt>basic_ostream&lt;char, traits&gt;&amp;</tt> and the second is of type <tt>const char*</tt>,
++</p></li>
++<li><p>
++<ins>where the first argument is of type
++<tt>basic_ostream&lt;wchar_t, traits&gt;&amp;</tt> and the second is of type <tt>const wchar_t*</tt>,</ins>
++</p></li>
++</ul>
++</p></li>
++<li><p>
++<tt>std::char_traits&lt;char&gt;::length(s)</tt> for the overload where the first argument is of type
++<tt>basic_ostream&lt;charT, traits&gt;&amp;</tt> and the second is of type <tt>const char*</tt>,
++</p></li>
++<li><p>
++<tt>traits::length(reinterpret_cast&lt;const char*&gt;(s))</tt> for the other two overloads.
++</p></li>
++</ul>
++<p>
++Determines padding for <tt>seq</tt> as described in 27.7.3.6.1 [ostream.formatted.reqmts]. Inserts <tt>seq</tt> into
++<tt>out</tt>. Calls <tt><ins>out.</ins>width(0)</tt>.
++<p/>
++-5- <i>Returns:</i> <tt>out</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2343"></a>2343. Is the value of the ECMA-262 RegExp object's multiline property really false?</h3>
++<p><b>Section:</b> 28.13 [re.grammar] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Nayuta Taga <b>Opened:</b> 2013-10-30 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.grammar">issues</a> in [re.grammar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In the following "Multiline" is the value of the ECMA-262 RegExp object's multiline property.
++<p/>
++In <a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf">ECMA-262</a>,
++there are some definitions that relate to Multiline:
++</p>
++<ul>
++<li><p>
++ECMA-262 15.10.2.6:
++</p>
++<blockquote>
++<p>
++If Multiline is true, ^ matches just after LineTerminator.
++<p/>
++If Multiline is false, ^ does not match just after LineTerminator.
++<p/>
++If Multiline is true, $ matches just before LineTerminator.
++<p/>
++If Multiline is false, $ does not match just before LineTerminator.
++</p>
++</blockquote>
++</li>
++<li>
++<p>
++ECMA-262 15.10.4.1, 15.10.7.4:
++</p>
++<blockquote><p>
++By default, Multiline is false.
++</p></blockquote>
++</li>
++</ul>
++<p>
++So, the C++11 standard says that Multiline is false. As it is false,
++^ matches only the beginning of the string, and $ matches only the end
++of the string.
++<p/>
++However, two flags are defined in 28.5.2 [re.matchflag] Table 139:
++</p>
++<blockquote>
++<p>
++<tt>match_not_bol</tt>: the character ^ in the regular expression shall not match <tt>[first,first)</tt>.
++<p/>
++<tt>match_not_eol</tt>: the character "$" in the regular expression shall not match <tt>[last,last)</tt>.
++</p>
++</blockquote>
++<p>
++As Multiline is false, the <tt>match_not_bol</tt> and the <tt>match_not_eol</tt> are
++meaningless because they only make ^ and $ match none.
++<p/>
++In my opinion, Multiline should be true.
++<p/>
++FYI, Multiline of the existing implementations are as follows:
++<p/>
++<em>Multiline=false:</em>
++</p>
++<ul>
++<li><p>
++libstdc++ r206594
++</p></li>
++<li><p>
++libc++ r199174
++</p></li>
++</ul>
++<p>
++<em>Multiline=true:</em>
++</p>
++<ul>
++<li><p>
++Visual Studio Express 2013
++</p></li>
++<li><p>
++boost 1.55
++</p></li>
++</ul>
++
++<p><i>[2015-05-22, Daniel comments]</i></p>
++
++<p>
++This issue interacts with LWG <a href="lwg-active.html#2503">2503</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2348"></a>2348. <tt>charT('1')</tt> is not the wide equivalent of <tt>'1'</tt></h3>
++<p><b>Section:</b> 20.6 [template.bitset], 27.7.6 [quoted.manip] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2013-12-02 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Example: <tt>char16_t('1') != u'1'</tt> is possible.
++<p/>
++The numeric value of <tt>char16_t</tt> is defined to be Unicode
++code point, which is same to the ASCII value and UTF-8 for
++7-bit chars. However, <tt>char</tt> is not guaranteed to have an
++encoding which is compatible with ASCII. For example, <tt>'1'</tt> in EBCDIC is 241.
++<p/>
++I found three places in the standard casting narrow char
++literals: <tt>bitset::bitset</tt>, <tt>bitset::to_string</tt> and <tt>quoted</tt>.
++<p/>
++PJ confirmed this issue and says he has a solution used
++in their <tt>&lt;filesystem&gt;</tt> implementation, and he may want to
++propose it to the standard.
++<p/>
++The solution in my mind, for now, is to make those default
++arguments magical, where the "magic" can be implemented
++with a C11 <tt>_Generic</tt> selection (works in clang):
++</p>
++<blockquote><pre>
++#define _G(T, literal) _Generic(T{}, \
++ char: literal, \
++ wchar_t: L ## literal, \
++ char16_t: u ## literal, \
++ char32_t: U ## literal)
++
++ _G(char16_t, '1') == u'1'
++</pre></blockquote>
++
++<p><i>[Lenexa 2015-05-05: Move to Open]</i></p>
++
++<p>Ask for complete PR (need quoted, to string, et al.)</p>
++<p>Will then take it up again</p>
++<p>Expectation is that this is correct way to fix this</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++[<i>Drafting note:</i> This is a sample wording fixing only one case;
++ I'm just too lazy to copy-paste it before we discussed whether
++ the solution is worth and sufficient (for example, should the
++ other `charT`s like `unsigned char` just don't compile without
++ supplying those arguments? I hope so). &mdash; <i>end drafting note</i>]
++
++<ol>
++<li><p>Modify 20.6 [template.bitset] p1, class template <tt>bitset</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;size_t N&gt; class bitset {
++ public:
++ [&hellip;]
++ template&lt;class charT, class traits, class Allocator&gt;
++ explicit bitset(
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
++ typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos = 0,
++ typename basic_string&lt;charT,traits,Allocator&gt;::size_type n =
++ basic_string&lt;charT,traits,Allocator&gt;::npos,
++ charT zero = <del>charT('0')</del><ins><em>see below</em></ins>, charT one = <del>charT('1')</del><ins><em>see below</em></ins>);
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify 20.6.1 [bitset.cons] as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++explicit
++bitset(const basic_string&lt;charT, traits, Allocator&gt;&amp; str,
++ typename basic_string&lt;charT, traits, Allocator&gt;::size_type pos = 0,
++ typename basic_string&lt;charT, traits, Allocator&gt;::size_type n =
++ basic_string&lt;charT, traits, Allocator&gt;::npos,
++ charT zero = <del>charT('0')</del><ins><em>see below</em></ins>, charT one = <del>charT('1')</del><ins><em>see below</em></ins>);
++</pre><blockquote>
++<p>
++<ins>-?- The default values of <tt>zero</tt> and <tt>one</tt> compare equal to the
++character literals <tt>0</tt> and <tt>1</tt> of type <tt>charT</tt>, respectively.</ins>
++<p/>
++-3- <i>Requires::</i> <tt>pos &lt;= str.size()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2349"></a>2349. Clarify input/output function rethrow behavior</h3>
++<p><b>Section:</b> 27.7.2.2.1 [istream.formatted.reqmts] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2013-12-06 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.reqmts">issues</a> in [istream.formatted.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The formatted input function requirement says in 27.7.2.2.1 [istream.formatted.reqmts]:
++</p>
++<blockquote><p>
++"If an exception is thrown during input then <tt>ios::badbit</tt> is turned on
++in <tt>*this</tt>'s error state. If <tt>(exceptions()&amp;badbit) != 0</tt> then the exception
++is rethrown."
++</p></blockquote>
++<p>
++while some formatted function may throw an exception from <tt>basic_ios::clear</tt>, for example
++in 20.6.4 [bitset.operators] p6:
++</p>
++<blockquote><p>
++"If no characters are stored in <tt>str</tt>, calls <tt>is.setstate(ios_base::failbit)</tt> (which may
++throw <tt>ios_base::failure</tt>)"
++</p></blockquote>
++<p>
++So should this exception be considered as "an exception [...] thrown
++during input"? And here is an implementation divergence (or you
++can read the following as "a bug libc++ only has" :)
++</p>
++<blockquote><pre>
++cin.exceptions(ios_base::failbit);
++bitset&lt;N&gt; b;
++try {
++ cin &gt;&gt; b; // type 'a' and return
++} catch (...)
++{}
++</pre></blockquote>
++<p>
++Now <tt>cin.rdstate()</tt> is just <tt>failbit</tt> in libstdc++ (and Dinkumware, by
++PJ), but <tt>failbit &amp; badbit</tt> libc++. Similar difference found in other
++places, like <tt>eofbit &amp; badbid</tt> after <tt>std::getline</tt>.
++<p/>
++PJ and Matt both agree that the intention (of <tt>badbit</tt> + rethrow) is
++"to signify an exception arising in user code, not the iostreams package".
++<p/>
++In addition, I found the following words in unformatted input
++function's requirements (27.7.2.3 [istream.unformatted]):
++</p>
++<blockquote><p>
++If an exception is thrown during input then <tt>ios::badbit</tt> is turned on
++in <tt>*this</tt>'s error state. (Exceptions thrown from <tt>basic_ios&lt;&gt;::clear()</tt>
++are not caught or rethrown.) If <tt>(exceptions()&amp;badbit) != 0</tt> then the
++exception is rethrown.
++</p></blockquote>
++<p>
++The content within the parenthesis is added by LWG defect <a href="lwg-defects.html#61">61</a>,
++and does fix the ambiguity. However, it only fixed the 1 of 4
++requirements, and it lost some context (the word "rethrown" is not
++seen before this sentence within this section).
++</p>
++
++<p><i>[Lenexa 2015-05-07: Marshall to research and report]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++[<i>Drafting note:</i> The editor is kindly asked to introduce additional spaces at the following marked occurrences of
++<tt>operator&amp;</tt> &mdash; <i>end drafting note</i>]
++
++<ol>
++<li><p>Modify 27.7.2.2.1 [istream.formatted.reqmts] p1 as indicated:</p>
++
++<blockquote><p>
++-1- Each formatted input function begins execution by constructing an object of class <tt>sentry</tt> with the <tt>noskipws</tt>
++(second) argument false. If the <tt>sentry</tt> object returns true, when converted to a value of type <tt>bool</tt>, the
++function endeavors to obtain the requested input. If an exception<ins>, other than the ones thrown from <tt>clear()</tt>, if any,</ins>
++is thrown during input then <tt>ios::badbit</tt>
++is turned on[Footnote 314] in <tt>*this</tt>'s error state. If <tt>(exceptions()<ins> </ins>&amp;<ins> </ins>badbit) != 0</tt>
++then the exception is rethrown.
++In any case, the formatted input function destroys the <tt>sentry</tt> object. If no exception has been thrown, it returns <tt>*this</tt>.
++</p></blockquote>
++</li>
++
++<li><p>Modify 27.7.3.6.1 [ostream.formatted.reqmts] p1 as indicated:</p>
++
++<blockquote><p>
++-1- Each formatted output function begins execution by constructing an object of class <tt>sentry</tt>. If this object
++returns true when converted to a value of type <tt>bool</tt>, the function endeavors to generate the requested
++output. If the generation fails, then the formatted output function does <tt>setstate(ios_base::failbit)</tt>,
++which might throw an exception. If an exception<ins>, other than the ones thrown from <tt>clear()</tt>, if any,</ins> is thrown
++during output, then <tt>ios::badbit</tt> is turned on[Footnote 327]
++in <tt>*this</tt>'s error state. If <tt>(exceptions()<ins> </ins>&amp;<ins> </ins>badbit) != 0</tt> then the exception is rethrown.
++Whether or not
++an exception is thrown, the <tt>sentry</tt> object is destroyed before leaving the formatted output function. If no
++exception is thrown, the result of the formatted output function is <tt>*this</tt>.
++</p></blockquote>
++</li>
++
++<li><p>Modify 27.7.3.7 [ostream.unformatted] p1 as indicated:</p>
++
++<blockquote><p>
++-1- Each unformatted output function begins execution by constructing an object of class <tt>sentry</tt>. If this object
++returns true, while converting to a value of type <tt>bool</tt>, the function endeavors to generate the requested
++output. If an exception<ins>, other than the ones thrown from <tt>clear()</tt>, if any,</ins> is thrown during output,
++then ios::badbit is turned on[Footnote 330] in <tt>*this</tt>'s error state.
++If <tt>(exceptions() &amp; badbit) != 0</tt> then the exception is rethrown. In any case, the unformatted output
++function ends by destroying the <tt>sentry</tt> object, then, if no exception was thrown, returning the value specified
++for the unformatted output function.
++</p></blockquote>
++</li>
++
++<li><p>Modify 27.7.2.3 [istream.unformatted] p1 as indicated:</p>
++
++<blockquote><p>
++-1- Each unformatted input function begins execution by constructing an object of class <tt>sentry</tt> with the default
++argument <tt>noskipws</tt> (second) argument true. If the <tt>sentry</tt> object returns true, when converted to a value
++of type <tt>bool</tt>, the function endeavors to obtain the requested input. Otherwise, if the <tt>sentry</tt> constructor exits
++by throwing an exception or if the sentry object returns false, when converted to a value of type <tt>bool</tt>, the
++function returns without attempting to obtain any input. In either case the number of extracted characters
++is set to <tt>0</tt>; unformatted input functions taking a character array of non-zero size as an argument shall also
++store a null character (using <tt>charT()</tt>) in the first location of the array. If an exception<ins>, other than the
++ones thrown from <tt>clear()</tt>, if any,</ins> is thrown during input
++then <tt>ios::badbit</tt> is turned on[Footnote 317] in <tt>*this</tt>'s error state. <del>(Exceptions thrown from
++<tt>basic_ios&lt;&gt;::clear()</tt> are not caught or rethrown.)</del> If <tt>(exceptions()<ins> </ins>&amp;<ins> </ins>badbit) != 0</tt>
++then the exception is rethrown. It also counts the number of characters extracted. If no exception has been thrown it ends
++by storing the count in a member object and returning the value specified. In any event the <tt>sentry</tt> object is destroyed
++before leaving the unformatted input function.
++</p></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2352"></a>2352. Is a default-constructed <tt>std::seed_seq</tt> intended to produce a predictable <tt>.generate()</tt>?</h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2013-12-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++With respect to class <tt>seed_seq</tt> 26.5.7.1 [rand.util.seedseq], is a default-constructed
++<tt>std::seed_seq</tt> intended to produce a predictable <tt>.generate()</tt> sequence?
++<p/>
++Implementations differ.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2353"></a>2353. <tt>std::next</tt> is over-constrained</h3>
++<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2013-12-24 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In LWG <a href="lwg-defects.html#1011">1011</a>, <tt>std::next</tt> and <tt>std::prev</tt> were changed
++from accepting <tt>InputIterator</tt> to accepting
++<tt>ForwardIterator</tt>. This needlessly excludes perfectly legitimate use
++cases. Consider the following hypothetical range-based implementation of
++drop, which creates a view of a range without the first <tt>n</tt> elements:
++</p>
++<blockquote><pre>
++template&lt;typename Distance, typename InputRange&gt;
++iterator_range&lt;range_iterator_t&lt;InputRange&gt;&gt;
++drop(Distance n, InputRange&amp; rng)
++{
++ return make_iterator_range(
++ std::next(std::begin(rng), n),
++ std::end(rng)
++ );
++}
++</pre></blockquote>
++<p>
++I believe this to be a legitimate use case that is currently outlawed by
++the standard without cause. See the discussion beginning at
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=35313">c++std-lib-35313</a>
++for an in-depth discussion of the issue, in which
++Howard Hinnant agreed that it was a defect.
++<p/>
++(Some discussion then ensued about whether an overload should be added
++that only accepts rvalue <tt>InputIterators</tt> to avoid the surprise that issue
++<a href="lwg-defects.html#1011">1011</a> sought to address. I make no such attempt, nor do I believe it to
++be necessary.)
++<p/>
++Suggested resolution:
++<p/>
++Back out the resolution of <a href="lwg-defects.html#1011">1011</a>.
++</p>
++
++<p><i>[Lenexa 2015-05-07: Move to Ready]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Change 24.3 [iterator.synopsis], header <tt>&lt;iterator&gt;</tt> synopsis, and 24.4.4 [iterator.operations]
++before p.6 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class <del>Forward</del><ins>Input</ins>Iterator&gt;
++ <del>Forward</del><ins>Input</ins>Iterator next(<del>Forward</del><ins>Input</ins>Iterator x,
++ typename std::iterator_traits&lt;<del>Forward</del><ins>Input</ins>Iterator&gt;::difference_type n = 1);
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2358"></a>2358. Apparently-bogus definition of <tt>is_empty</tt> type trait</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The 'Condition' for <tt>std::is_empty</tt> is listed as:
++</p>
++<blockquote><p>
++"<tt>T</tt> is a class type, but not a union type, with no non-static data members other than bit-fields of length 0,
++no virtual member functions, no virtual base classes, and no base class <tt>B</tt> for which <tt>is_empty&lt;B&gt;::value</tt>
++is false."
++</p></blockquote>
++<p>
++This is incorrect: there is no such thing as a non-static data member that is a bit-field of length 0, since bit-fields of
++length 0 must be unnamed, and unnamed bit-fields are not members (see 9.6 [class.bit] p2).
++<p/>
++It also means that classes such as:
++</p>
++<blockquote><pre>
++struct S {
++ int : 3;
++};
++</pre></blockquote>
++<p>
++are empty (because they have no non-static data members). There's implementation divergence on the value of
++<tt>is_empty&lt;S&gt;::value</tt>.
++<p/>
++I'm not sure what the purpose of <tt>is_empty</tt> is (or how it could be useful), but if it's desirable for the above type to
++not be treated as empty, something like this could work:
++</p>
++<blockquote><p>
++"<tt>T</tt> is a class type, but not a union type, with no non-static data members <del>other than</del><ins>, no unnamed</ins>
++bit-fields of <ins>non-zero</ins> length <del>0</del>, no virtual member functions, no virtual base classes, and no base class
++<tt>B</tt> for which <tt>is_empty&lt;B&gt;::value</tt> is false."
++</p></blockquote>
++<p>
++and if the above type <em>should</em> be treated as empty, then this might be appropriate:
++</p>
++<blockquote><p>
++"<tt>T</tt> is a class type, but not a union type, with no <ins>(named)</ins> non-static data members <del>other than bit-fields of
++length 0</del>, no virtual member functions, no virtual base classes, and no base class <tt>B</tt> for which
++<tt>is_empty&lt;B&gt;::value</tt> is false."
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2362"></a>2362. unique, associative <tt>emplace()</tt> should not move/copy the <tt>mapped_type</tt> constructor arguments when no insertion happens</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2014-02-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>a_uniq.emplace(args)</tt> is specified as:
++</p>
++
++<blockquote><p>
++<i>Effects</i>: Inserts a value_type object <tt>t</tt> constructed with<br/>
++<tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element in the<br/>
++container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt> component of<br/>
++the returned pair is true if and only if the insertion takes place,<br/>
++and the iterator component of the pair points to the element with key<br/>
++equivalent to the key of <tt>t</tt>.
++</p></blockquote>
++
++<p>
++However, we occasionally find code of the form:
++</p>
++
++<blockquote><pre>
++std::unique_ptr&lt;Foo&gt; p(new Foo);
++auto res = m.emplace("foo", std::move(p));
++</pre></blockquote>
++
++<p>
++where we'd like to avoid destroying the <tt>Foo</tt> if the insertion doesn't
++take place (if the container already had an element with the specified key).
++<p/>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3873">N3873</a> includes
++a partial solution to this in the form of a new <tt>emplace_stable</tt> member function, but LEWG's
++discussion strongly agreed that we'd rather have <tt>emplace()</tt> Just Work:
++<p/>
++Should <tt>map::emplace()</tt> be guaranteed not to move/copy its arguments if the insertion doesn't happen?
++<p/>
++SF: 8 F: 3 N: 0 A: 0 SA: 0
++<p/>
++This poll was marred by the fact that we didn't notice or call out
++that <tt>emplace()</tt> must construct the key before doing the lookup, and it
++must not then move the key after it determines whether an insert is
++going to happen, and the <tt>mapped_type</tt> instance must live next to the key.
++<p/>
++The very similar issue <a href="lwg-closed.html#2006">2006</a> was previously marked NAD, with
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3178.htm">N3178</a> as
++discussion. However, given LEWG's interest in the alternate behavior,
++we should reopen the question in this issue.
++<p/>
++We will need a paper that describes how to implement this before we can make more progress.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2363"></a>2363. Defect in 30.4.1.4.1 [thread.sharedtimedmutex.class]</h3>
++<p><b>Section:</b> 30.4.1.5.1 [thread.sharedtimedmutex.class] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-02-16 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.4.1.5.1 [thread.sharedtimedmutex.class] paragraph 2:
++</p>
++<blockquote><p> The class <tt>shared_timed_mutex</tt> shall satisfy all of the
++<tt>SharedTimedMutex</tt> requirements (30.4.1.4). It shall be a standard layout class (Clause 9).
++</p></blockquote>
++<p>
++There's no <tt>SharedTimedMutex</tt> requirements; this name doesn't appear anywhere else in the standard. (Prior to N3891,
++this was <tt>SharedMutex</tt>, which was equally undefined.)
++<p/>
++I assume this concept should be defined somewhere?
++<p/>
++Also, n3891 changes 30.4.1.5 [thread.sharedtimedmutex.requirements] from defining "shared mutex type" to defining
++"shared timed mutex type", but its paragraph 2 still talks about "shared mutex type". Is that OK? I think you could argue
++that it's clear enough what it means, but presumably it should use the term that paragraph 1 defined.
++<p/>
++30.4.2.3 [thread.lock.shared] paragraph 1 talks about the "shared mutex requirements", which again is a term that isn't
++defined, and presumably means "the requirements on a shared timed mutex type" or similar (maybe if <tt>SharedMutex</tt> or
++<tt>SharedTimedMutex</tt> were defined it could be reused here).
++</p>
++
++<p><i>[2014-05-22, Daniel comments]</i></p>
++
++<p>
++As for <tt>SharedTimedMutex</tt>, there exists a similar problem in regard to <tt>TimedMutex</tt> referred to in
++30.4.1.3.1 [thread.timedmutex.class] p2 and in 30.4.1.3.2 [thread.timedmutex.recursive] p2, but nowhere defined.
++<p/>
++Another problem is, that according to 30.4.1.2.1 [thread.mutex.class] p3, "The class <tt>mutex</tt> shall satisfy all the
++<tt>Mutex</tt> requirements (30.4.1 [thread.mutex.requirements]).", but there are no concrete <tt>Mutex</tt> requirements,
++30.4.1 [thread.mutex.requirements] &mdash; titled as "Mutex requirements" &mdash; describes <em>mutex types</em>,
++<em>timed mutex types</em>, and <em>shared timed mutex types</em>.
++</p>
++
++<p><i>[2014-06-08, Daniel comments and provides wording]</i></p>
++
++<p>
++The presented wording adds to the existing <em>mutex types</em>, <em>timed mutex types</em>, and <em>shared timed mutex types</em>
++terms a new set of corresponding <tt>MutexType</tt>, <tt>TimedMutexType</tt>, and <tt>SharedTimedMutexType</tt> requirements.
++<p/>
++The reason for the change of requirement names is two-fold: First, the new name better matches the intention to have a concrete
++name for the requirements imposed on the corresponding <em>mutex types</em> (This kind of requirement deviate from the more general
++<tt>Lockable</tt> requirements, which are not restricted to a explicitly enumerated set of library types). Second, using
++<tt>**MutexType</tt> over <tt>**Mutex</tt> provides the additional advantage that it reduces the chances of confusing named
++requirements from template parameters named <tt>Mutex</tt> (such as for <tt>unique_lock</tt> or <tt>shared_lock</tt>).
++<p/>
++Nonetheless the here presented wording has one unfortunate side-effect: Once applied it would have the effect that types
++used to instantiate <tt>std::shared_lock</tt> cannot be user-defined shared mutex types due to 30.4.2.3 [thread.lock.shared].
++The reason is based on the currently lack of an existing <tt>SharedLockable</tt> requirement set, which would complete the
++existing <tt>BasicLockable</tt> and <tt>Lockable</tt> requirements (which are "real" requirements). This restriction is not
++actually a problem introduced by the provided resolution but instead one that existed before but becomes more obvious now.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++Thanks to Daniel, and please put it in SG1-OK status. Perhaps open another issue for the remaining problem Daniel points out?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 30.4.1.2 [thread.mutex.requirements.mutex] as indicated:</p>
++
++<blockquote><p>
++-1- The <em>mutex types</em> are the standard library types <tt>std::mutex</tt>, <tt>std::recursive_mutex</tt>, <tt>std::timed_mutex</tt>,
++<tt>std::recursive_timed_mutex</tt>, and <tt>std::shared_timed_mutex</tt>. They shall meet the <ins><tt><em>MutexType</em></tt></ins>
++requirements set out in this section. In this description, <tt>m</tt> denotes an object of a mutex type.
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.2.1 [thread.mutex.class] as indicated:</p>
++
++<blockquote><p>
++-3- The class <tt>mutex</tt> shall satisfy all the <tt>Mutex<ins>Type</ins></tt> requirements
++(<ins>30.4.1.2 [thread.mutex.requirements.mutex]</ins><del>30.4.1 [thread.mutex.requirements]</del>).
++It shall be a standard-layout class (Clause 9).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.2.2 [thread.mutex.recursive] as indicated:</p>
++
++<blockquote><p>
++-2- The class <tt>recursive_mutex</tt> shall satisfy all the <del>Mutex</del><ins><tt>MutexType</tt></ins> requirements
++(<ins>30.4.1.2 [thread.mutex.requirements.mutex]</ins><del>30.4.1 [thread.mutex.requirements]</del>).
++It shall be a standard-layout class (Clause 9).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.3 [thread.timedmutex.requirements] as indicated:</p>
++
++<blockquote><p>
++-1- The <em>timed mutex types</em> are the standard library types <tt>std::timed_mutex</tt>, <tt>std::recursive_timed_mutex</tt>,
++and <tt>std::shared_timed_mutex</tt>. They shall meet the <ins><tt><em>TimedMutexType</em></tt></ins> requirements set out below.
++In this description, <tt>m</tt> denotes an object of a mutex type, <tt>rel_time</tt> denotes an object of an instantiation of
++<tt>duration</tt> (20.12.5), and <tt>abs_time</tt> denotes an object of an instantiation of <tt>time_point</tt> (20.12.6).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.3.1 [thread.timedmutex.class] as indicated:</p>
++
++<blockquote><p>
++-2- The class <tt>timed_mutex</tt> shall satisfy all of the <tt>TimedMutex<ins>Type</ins></tt> requirements
++(30.4.1.3 [thread.timedmutex.requirements]). It shall be a standard-layout class (Clause 9).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.3.2 [thread.timedmutex.recursive] as indicated:</p>
++
++<blockquote><p>
++-2- The class <tt>recursive_timed_mutex</tt> shall satisfy all of the <tt>TimedMutex<ins>Type</ins></tt> requirements
++(30.4.1.3 [thread.timedmutex.requirements]). It shall be a standard-layout class (Clause 9).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.1.5 [thread.sharedtimedmutex.requirements] as indicated: [<i>Drafting note</i>: The reference to the
++timed mutex types requirements has been moved <em>after</em> introducing the new requirement set to ensure that
++<tt>SharedTimedMutexType</tt> <em>refine</em> <tt>TimedMutexType</tt>.]</p>
++
++<blockquote>
++<p>
++-1- The standard library type <tt>std::shared_timed_mutex</tt> is a <em>shared timed mutex type</em>. Shared timed mutex
++types shall meet the <ins><tt><em>SharedTimedMutexType</em></tt></ins> requirements <del>of timed mutex types
++(30.4.1.3 [thread.timedmutex.requirements]), and additionally shall meet the requirements</del> set out below. In this
++description, <tt>m</tt> denotes an object of a mutex type, <tt>rel_type</tt> denotes
++an object of an instantiation of <tt>duration</tt> (20.12.5), and <tt>abs_time</tt> denotes an object of an instantiation of
++<tt>time_point</tt> (20.12.6).
++<p/>
++<ins>-?- The shared timed mutex types shall meet the <tt>TimedMutexType</tt> requirements (30.4.1.3 [thread.timedmutex.requirements]).</ins>
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 30.4.1.5.1 [thread.sharedtimedmutex.class] as indicated:</p>
++
++<blockquote><p>
++-2- The class <tt>shared_timed_mutex</tt> shall satisfy all of the <tt>SharedTimedMutex<ins>Type</ins></tt> requirements
++(30.4.1.5 [thread.sharedtimedmutex.requirements]). It shall be a standard-layout class (Clause 9).
++</p></blockquote>
++</li>
++
++<li><p>Change 30.4.2.3 [thread.lock.shared] as indicated: [<i>Drafting note</i>: Once
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3995.htm">N3995</a> has been applied, the following
++reference should be changed to the new <tt>SharedMutexType</tt> requirements ([thread.sharedmutex.requirements]) or
++even better to some new <tt>SharedLockable</tt> requirements (to be defined) &mdash; <i>end drafting note</i>]</p>
++
++<blockquote><p>
++-1- [&hellip;] The supplied <tt>Mutex</tt> type shall meet the <del>shared mutex</del><ins><tt>SharedTimedMutexType</tt></ins> requirements
++(30.4.1.5 [thread.sharedtimedmutex.requirements]).
++<p/>
++-2- [<i>Note</i>: <tt>shared_lock&lt;Mutex&gt;</tt> meets the <tt>TimedLockable</tt> requirements
++(30.2.5.4). &mdash; <i>end note</i>]
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2366"></a>2366. <tt>istreambuf_iterator</tt> end-of-stream equality</h3>
++<p><b>Section:</b> 24.6.3 [istreambuf.iterator] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Hyman Rosen <b>Opened:</b> 2014-02-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istreambuf.iterator">issues</a> in [istreambuf.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Given the following code,
++</p>
++<blockquote><pre>
++#include &lt;sstream&gt;
++
++std::stringbuf buf;
++std::istreambuf_iterator&lt;char&gt; begin(&amp;buf);
++std::istreambuf_iterator&lt;char&gt; end;
++</pre></blockquote>
++<p>
++it is not clear from the wording of the Standard whether <tt>begin.equal(end)</tt>
++must be true. In at least one implementation it is not (CC: Sun C++ 5.10 SunOS_sparc Patch 128228-25 2013/02/20) and in at least
++one implementation it is (gcc version 4.3.2 x86_64-unknown-linux-gnu).
++<p/>
++24.6.3 [istreambuf.iterator] says that <tt>end</tt> is an end-of-stream iterator since it was default
++constructed. It also says that an iterator becomes equal to an end-of-stream
++iterator when end of stream is reached by <tt>sgetc()</tt> having returned <tt>eof()</tt>.
++24.6.3.5 [istreambuf.iterator::equal] says that <tt>equal()</tt> returns true iff both iterators are end of stream
++or not end of stream. But there seems to be no requirement that <tt>equal</tt> check for end-of-stream by calling <tt>sgetc()</tt>.
++<p/>
++Jiahan Zi at BloombergLP discovered this issue through his code failing to
++work correctly. Dietmar K&uuml;hl has opined in a private communication that
++the iterators should compare equal.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2367"></a>2367. <tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2014-02-19 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider:
++</p>
++<blockquote><pre>
++struct X
++{
++ X() = delete;
++};
++
++int main()
++{
++ typedef std::pair&lt;int, X&gt; P;
++ static_assert(!std::is_constructible&lt;P&gt;::value, "");
++ static_assert(!std::is_default_constructible&lt;P&gt;::value, "");
++ typedef std::tuple&lt;int, X&gt; T;
++ static_assert(!std::is_constructible&lt;T&gt;::value, "");
++ static_assert(!std::is_default_constructible&lt;T&gt;::value, "");
++}
++</pre></blockquote>
++<p>
++For me these <tt>static_asserts</tt> fail. And worse than that, even asking the question fails (as opposed to gets the wrong answer):
++</p>
++<blockquote><pre>
++assert(!std::is_constructible&lt;P&gt;::value);
++</pre></blockquote>
++<p>
++In file included from test.cpp:2:
++</p>
++<blockquote><pre>
++error:
++ call to deleted constructor of 'X'
++ pair() : first(), second() {}
++ ^
++note: function has been explicitly marked deleted here
++ X() = delete;
++ ^
++1 error generated.
++</pre></blockquote>
++<p>
++This can be solved by specializing <tt>is_constructible</tt> on <tt>pair</tt> and <tt>tuple</tt> for zero Args:
++</p>
++<blockquote><pre>
++template &lt;class T, class U&gt;
++struct is_constructible&lt;pair&lt;T, U&gt;&gt;
++ : integral_constant&lt;bool, is_default_constructible&lt;T&gt;::value &amp;&amp;
++ is_default_constructible&lt;U&gt;::value&gt;
++{};
++
++template &lt;class ...T&gt;
++struct is_constructible&lt;tuple&lt;T...&gt;&gt;
++ : integral_constant&lt;bool,
++ __all&lt;is_default_constructible&lt;T&gt;::value...&gt;::value&gt;
++{};
++</pre></blockquote>
++<p>
++Now everything just works.
++</p>
++
++<p><i>[2014-05-14, Daniel comments]</i></p>
++
++
++<p>
++The proposed resolution is incomplete, because it wouldn't work for <i>cv</i>-qualified objects of
++<tt>pair</tt> or for references of them during reference-initialization.
++<p/>
++I would like to point out that the approach suggested in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3739.html">N3739</a>
++can be easily extended to solve the problem without need to muddle with specializing <tt>is_constructible</tt>:
++</p>
++<blockquote><pre>
++template&lt;class U1 = T1, class U2 = T2,
++ typename enable_if&lt;
++ is_default_constructible&lt;U1&gt;::value &amp;&amp; is_default_constructible&lt;U2&gt;::value
++ , bool&gt;::type = false
++&gt;
++constexpr pair();
++</pre></blockquote>
++<p>
++The new wording proposal represents an alternative wording change that I would strongly prefer.
++</p>
++
++<strong>Previous resolution from Howard [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Add to 20.3.3 [pairs.spec]:</p>
++
++<blockquote>
++<pre>
++<ins>template &lt;class T, class U&gt;
++struct is_constructible&lt;pair&lt;T, U&gt;&gt;
++ : integral_constant&lt;bool, is_default_constructible&lt;T&gt;::value &amp;&amp;
++ is_default_constructible&lt;U&gt;::value&gt;
++{};</ins>
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to 20.4.2.9 [tuple.special]:</p>
++
++<blockquote>
++<pre>
++<ins>template &lt;class ...T&gt;
++struct is_constructible&lt;tuple&lt;T...&gt;&gt;
++ : integral_constant&lt;bool, <i>see below</i>&gt;
++{};</ins>
++</pre>
++<blockquote><p>
++<ins>-?- The second argument to <tt>integral_constant</tt> shall be true if for each <tt>T</tt>,
++<tt>is_default_constructible&lt;T&gt;::value</tt> is true.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: I object to this resolution due to British spelling of behavior<br/>
++JW: we already have other places of this spelling<br/>
++VV: the easy resolution is to remove the notes<br/>
++MC: if that's all we want to change: put it in and make the editorial change of removing the note<br/>
++VV: the other paper doesn't make any of these changes so it would be consistent<br/>
++JW: this make me want even more the features of having constructors doing the Right Thing
++- I haven't written up the request to do something like that<br/>
++VV: so it would be an aggregate reflecting the properties of the constituting types<br/>
++JW: I should write that up<br/>
++MC: any objection to move to ready? in favor: 16, opposed: 0, abstain: 1
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.3.2 [pairs.pair] around p3 as indicated:</p>
++
++<blockquote><pre>
++constexpr pair();
++</pre>
++<blockquote>
++<p>
++<del>-3- <i>Requires</i>: <tt>is_default_constructible&lt;first_type&gt;::value</tt> is true and
++<tt>is_default_constructible&lt;second_type&gt;::value</tt> is true.</del>
++<p/>
++-4- <i>Effects</i>: Value-initializes first and second.
++<p/>
++<ins>-?- <i>Remarks</i>: This constructor shall not participate in overload resolution unless
++<tt>is_default_constructible&lt;first_type&gt;::value</tt> is true and
++<tt>is_default_constructible&lt;second_type&gt;::value</tt> is true. [<i>Note</i>: This behaviour can be implemented
++by a constructor template with default template arguments &mdash; <i>end note</i>].</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.1 [tuple.cnstr] around p4 as indicated:</p>
++
++<blockquote><pre>
++constexpr tuple();
++</pre>
++<blockquote>
++<p>
++<del>-4- <i>Requires</i>: <tt>is_default_constructible&lt;<i>T<sub>i</sub></i>&gt;::value</tt> is true for all <i>i</i>.</del>
++<p/>
++-5- <i>Effects</i>: Value initializes each element.
++<p/>
++<ins>-?- <i>Remarks</i>: This constructor shall not participate in overload resolution unless
++<tt>is_default_constructible&lt;<i>T<sub>i</sub></i>&gt;::value</tt> is true for all <i>i</i>. [<i>Note</i>: This behaviour can
++be implemented by a constructor template with default template arguments &mdash; <i>end note</i>].</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2368"></a>2368. Replacing global <tt>operator new</tt></h3>
++<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Stephen Clamage <b>Opened:</b> 2014-02-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete">issues</a> in [new.delete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Section 18.6.1 [new.delete] and subsections shows:
++</p>
++<blockquote><pre>
++void* operator new(std::size_t size);
++void* operator new[](std::size_t size);
++</pre></blockquote>
++<p>
++That is, without exception-specifications. (Recall that C++03 specified these functions with <tt>throw(std::bad_alloc)</tt>.)
++<p/>
++Section 17.6.5.12 [res.on.exception.handling] the end of paragraph 4 says:
++</p>
++<blockquote><p>
++Any other functions defined in the C++ standard library that do not have an exception-specification may throw implementation-defined
++exceptions unless otherwise specified. An implementation may strengthen this implicit exception-specification by adding an explicit one.
++</p></blockquote>
++<p>
++For example, an implementation could provide C++03-compatible declarations of <tt>operator new</tt>.
++<p/>
++Programmers are allowed to replace these <tt>operator new</tt> functions. But how can you write the definition of these functions when
++the exception specification can vary among implementations? For example, the declarations
++</p>
++<blockquote><pre>
++void* operator new(std::size_t size) throw(std::bad_alloc);
++void* operator new(std::size_t size);
++</pre></blockquote>
++<p>
++are not compatible.
++<p/>
++From what I have been able to determine, gcc has a hack for the special case of <tt>operator new</tt> to ignore the differences in
++(at least) the two cases I show above. But can users expect all compilers to quietly ignore the incompatibility?
++<p/>
++The blanket permission to add any explicit exception specification could cause a problem for any user-overridable function.
++Different implementations could provide incompatible specifications, making portable code impossible to write.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2370"></a>2370. Operations involving type-erased allocators should not be <tt>noexcept</tt> in <tt>std::function</tt></h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2014-02-27 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The following constructors in 20.9.12.2 [func.wrap.func] are declared <tt>noexcept</tt>, even
++though it is not possible for an implementation to guarantee that they will not throw:
++</p>
++
++<blockquote><pre>
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;) noexcept;
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;, nullptr_t) noexcept;
++</pre></blockquote>
++
++<p>
++In addition, the following functions are guaranteed not to throw if the target
++is a function pointer or a <tt>reference_wrapper</tt>:
++</p>
++
++<blockquote><pre>
++template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, const function&amp; f);
++template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
++</pre></blockquote>
++
++<p>
++In all of the above cases, the function object might need to allocate memory
++(an operation that can throw) in order to hold a copy of the type-erased
++allocator itself. The first two constructors produce an empty function
++object, but the allocator is still needed in case the object is later assigned
++to. In this case, we note that the propagation of allocators on assignment is
++underspecified for <tt>std::function</tt>. There are three possibilities:
++</p>
++
++<ol>
++<li><p>The allocator is never copied on copy-assignment, moved on move-assignment, or swapped on swap.</p>
++</li>
++
++<li><p>The allocator is always copied on copy-assignment, moved on move-assignment, and swapped on swap.</p>
++</li>
++
++<li><p>Whether or not the allocator is copied, moved, or swapped is determined at
++ run-time based on the <tt>propagate_on_container_copy_assignment</tt> and
++ <tt>propagate_on_container_move_assignment</tt> traits of the allocators at
++ construction of the source function, the target function, or both.</p>
++</li>
++</ol>
++
++<p>
++Although the third option seems to be the most consistent with existing
++wording in the containers section of the standard, it is problematic in a
++number of respects. To begin with, the propagation behavior is determined at
++run time based on a pair of type-erased allocators, instead of at compile
++time. Such run-time logic is <em>not</em> consistent with the rest of the standard
++and is hard to reason about. Additionally, there are two allocator types
++involved, rather than one. Any set of rules that attempts to rationally
++interpret the propagation traits of both allocators is likely to be arcane
++at best, and subtly wrong for some set of codes at worst.
++</p>
++
++<p>
++The second option is a non-starter. Historically, and in the vast majority of
++existing code, an allocator does not change after an object is constructed.
++The second option, if adopted, would undermine the programmer's ability to
++construct, e.g., an array of function objects, all using the same allocator.
++</p>
++
++<p>
++The first option is (in Pablo's opinion) the simplest and best. It is
++consistent with historical use of allocators, is easy to understand, and
++requires minimal wording. It is also consistent with the wording in N3916,
++which formalizes type-erased allocators.
++</p>
++
++<p>
++For cross-referencing purposes: The resolution of this issue should be
++harmonized with any resolution to LWG <a href="lwg-active.html#2062">2062</a>, which questions the <tt>noexcept</tt>
++specification on the following member functions of std::function:
++</p>
++
++<blockquote><pre>
++template &lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt;) noexcept;
++void swap(function&amp;) noexcept;
++</pre></blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: change to P3 and status to open.
++<p/>
++STL: note that <tt>noexcept</tt> is an issue and large chunks of allocator should be destroyed.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.9.12.2 [func.wrap.func], class template <tt>function</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;) <del>noexcept</del>;
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;, nullptr_t) <del>noexcept</del>;
++</pre></blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.1 [func.wrap.func.con] as indicated:</p>
++
++<blockquote>
++<p>
++-1- When any function constructor that takes a first argument of type <tt>allocator_arg_t</tt> is invoked, the second
++argument shall have a type that conforms to the requirements for <tt>Allocator</tt> (Table 17.6.3.5). A copy of the
++allocator argument is used to allocate memory, if necessary, for the internal data structures of the constructed
++function object. <ins> For the remaining constructors, an instance of <tt>allocator&lt;T&gt;</tt>, for some suitable type
++<tt>T</tt>, is used to allocate memory, if necessary, for the internal data structures of the constructed function object.</ins>
++</p>
++
++<pre>
++function() noexcept;
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;) <del>noexcept</del>;
++</pre>
++
++<blockquote>
++<p>
++-2- <i>Postconditions</i>: <tt>!*this</tt>.
++</p>
++</blockquote>
++
++<pre>
++function(nullptr_t) noexcept;
++template &lt;class A&gt; function(allocator_arg_t, const A&amp;, nullptr_t) <del>noexcept</del>;
++</pre>
++
++<blockquote><p>
++-3- <i>Postconditions</i>: <tt>!*this</tt>.
++</p></blockquote>
++
++<pre>
++function(const function&amp; f);
++<del>template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, const function&amp; f);</del>
++</pre>
++
++<blockquote><p>
++-4- <i>Postconditions</i>: <tt>!*this</tt> if <tt>!f</tt>; otherwise, <tt>*this</tt> targets a copy of <tt>f.target()</tt>.
++</p>
++
++<p>
++-5- <i>Throws</i>: shall not throw exceptions if <tt>f</tt>'s target is a callable object passed
++via <tt>reference_wrapper</tt> or a function pointer. Otherwise, may throw <tt>bad_alloc</tt>
++or any exception thrown by the copy constructor of the stored callable
++object. [<i>Note</i>: Implementations are encouraged to avoid the use of
++dynamically allocated memory for small callable objects, for example, where
++<tt>f</tt>'s target is an object holding only a pointer or reference to an object and
++a member function pointer. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<pre>
++<ins>template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, const function&amp; f);</ins>
++</pre>
++
++<blockquote><p>
++<ins>-?- <i>Postconditions</i>: <tt>!*this</tt> if <tt>!f</tt>; otherwise, <tt>*this</tt> targets a copy of <tt>f.target()</tt>.</ins>
++</p></blockquote>
++
++<pre>
++function(function&amp;&amp; f);
++template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, function&amp;&amp; f);
++</pre>
++
++<blockquote><p>
++-6- <i>Effects</i>: If <tt>!f</tt>, <tt>*this</tt> has no target; otherwise, move-constructs the target
++of <tt>f</tt> into the target of <tt>*this</tt>, leaving <tt>f</tt> in a valid state with an
++unspecified value. <ins>If an allocator is not specified, the constructed function will use the same allocator as <tt>f</tt>.</ins>
++</p></blockquote>
++
++<pre>
++template&lt;class F&gt; function(F f);
++template &lt;class F, class A> function(allocator_arg_t, const A&amp; a, F f);
++</pre>
++
++<blockquote>
++<p>
++-7- <i>Requires</i>: <tt>F</tt> shall be <tt>CopyConstructible</tt>.
++<p/>
++-8- <i>Remarks</i>: These constructors shall not participate in overload resolution unless <tt>f</tt> is Callable (20.9.11.2)
++for argument types <tt>ArgTypes...</tt> and return type <tt>R</tt>.
++</p>
++
++<p>
++-9- <i>Postconditions</i>: <tt>!*this</tt> if any of the following hold:
++</p>
++<ul>
++<li><p><tt>f</tt> is a null function pointer value.</p></li>
++<li><p><tt>f</tt> is a null member pointer value.</p></li>
++<li><p><tt>F</tt> is an instance of the function class template, and <tt>!f</tt></p></li>
++</ul>
++
++<p>
++-10- Otherwise, <tt>*this</tt> targets a copy of <tt>f</tt> initialized with <tt>std::move(f)</tt>.
++[<i>Note</i>: Implementations are encouraged to avoid the use of dynamically
++allocated memory for small callable objects, for example, where <tt>f</tt>'s target
++is an object holding only a pointer or reference to an object and a member
++function pointer. &mdash; <i>end note</i>]
++</p>
++
++<p>
++-11- <i>Throws</i>: shall not throw exceptions when <ins>an allocator is not specified
++and</ins> <tt>f</tt> is a function pointer or a <tt>reference_wrapper&lt;T&gt;</tt> for some
++<tt>T</tt>. Otherwise, may throw <tt>bad_alloc</tt> or any exception thrown by <tt>F</tt>'s copy or
++move constructor<ins> or by <tt>A</tt>'s allocate function</ins>.
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2372"></a>2372. Assignment from int to <tt>std::string</tt></h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Andrzej Krzemie&#324;ski <b>Opened:</b> 2014-03-13 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The following code works in C++:
++</p>
++<blockquote><pre>
++int i = 300;
++std::string threeHundred;
++threeHundred = i;
++</pre></blockquote>
++<p>
++"Works" == "Compiles and doesn't have an undefined behavior". But it may not be obvious and in fact misleading what it does.
++This assignment converts an <tt>int</tt> to <tt>char</tt> and then uses <tt>string</tt>'s assignment from <tt>char</tt>. While
++the assignment from <tt>char</tt> can be considered a feature, being able to assign from an int looks like a safety gap. Someone
++may believe C++ works like "dynamically typed" languages and expect a lexical conversion to take place.
++<p/>
++Ideally the assignment from <tt>char</tt> could be deprecated and later removed, but as a less intrusive alternative one could
++consider adding a SFINAEd deleted function template:
++</p>
++<blockquote><pre>
++template &lt;typename IntT&gt; // enable if is_integral&lt;IntT&gt;::value
++basic_string&amp; operator=(IntT) = delete;
++</pre></blockquote>
++
++<p><i>[Lenexa 2015-06-06: Move to LEWG]</i></p>
++
++<p>RS: std::string x('0' + n); broken by this.</p>
++<p>MC: This is an extension, move to LEWG.</p>
++<p>Move to LEWG, consensus.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>To 21.4 [basic.string], class template <tt>basic_string</tt> synopsis, add as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; operator=(const basic_string&amp; str);
++basic_string&amp; operator=(basic_string&amp;&amp; str) noexcept;
++basic_string&amp; operator=(const charT* s);
++basic_string&amp; operator=(charT c);
++<ins>template &lt;class IntT&gt; basic_string&amp; operator=(IntT i) = delete;</ins>
++basic_string&amp; operator=(initializer_list&lt;charT&gt;);
++</pre></blockquote>
++</li>
++
++<li><p>Add after 21.4.2 [string.cons] p26 as indicated:</p>
++
++<blockquote>
++<pre>
++basic_string&amp; operator=(charT c);
++</pre>
++<blockquote>
++<p>
++-26- <i>Returns</i>: <tt>*this = basic_string(1,c)</tt>.
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class IntT&gt; basic_string&amp; operator=(IntT i) = delete;</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Remarks</i>: This signature shall not participate in overload resolution unless <tt>is_integral&lt;T&gt;::value</tt> is
++<tt>true</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2375"></a>2375. Is [iterator.requirements.general]/9 too broadly applied?</h3>
++<p><b>Section:</b> 24.2.1 [iterator.requirements.general] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2014-03-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++24.2.1 [iterator.requirements.general] p9 says:
++</p>
++<blockquote><p>
++Destruction of an iterator may invalidate pointers and references previously obtained from that iterator.
++</p></blockquote>
++<p>
++But the resolution of LWG issue <a href="lwg-defects.html#2360">2360</a> specifically advocates returning <tt>*--temp;</tt> where <tt>temp</tt> is a
++local variable.
++<p/>
++And 24.2.5 [forward.iterators] p6 says:
++</p>
++<blockquote><p>
++If <tt>a</tt> and <tt>b</tt> are both dereferenceable, then <tt>a == b</tt> if and only if <tt>*a</tt> and <tt>*b</tt> are bound
++to the same object.
++</p></blockquote>
++<p>
++which disallows "stashing" iterators (i.e, iterators that refer to data inside themselves).
++<p/>
++So, I suspect that the restriction in p9 should only apply to input iterators, and can probably be moved into
++24.2.3 [input.iterators] instead of 24.2.1 [iterator.requirements.general].
++</p>
++
++<p><i>[2014-05-22, Daniel comments]</i></p>
++
++
++<p>
++Given that forward iterators (and beyond) are refinements of input iterator, moving this constraint to input iterators won't help
++much because it would still hold for all refined forms.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2379"></a>2379. Obtaining native handle of the current thread</h3>
++<p><b>Section:</b> 30.2.3 [thread.req.native], 30.3.2 [thread.thread.this] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2014-03-31 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Class <tt>thread</tt> contains an implementation-defined type <tt>thread::native_handle_type</tt>, and an implementation-defined
++function <tt>thread::native_handle()</tt> that returns a value of that type. The presence and semantics of those members is
++implementation-defined; the intention is that they can be used for interoperability with libraries that rely on operating system
++specific features. (Posix libraries that accept arguments of type <tt>pthread_t</tt>, for example.)
++<p/>
++Unfortunately, there appears to be no native handle support for the equivalent of <tt>pthread_self()</tt>. We can use
++<tt>this_thread::get_id()</tt> to obtain the <tt>thread::id</tt> of the current thread, but there is no mechanism for converting
++a <tt>thread::id</tt> to a <tt>thread::native_handle</tt>.
++<p/>
++<em>Proposed wording:</em>
++<p/>
++In 30.3.2 [thread.thread.this] add:
++</p>
++<blockquote><pre>
++thread::native_handle_type native_handle(); <i>// See 30.2.3</i>
++</pre></blockquote>
++<p>
++ to the <tt>this_thread</tt> namespace synopsis.
++<p/>
++<em>Rationale:</em>
++<p/>
++Informally, we could address this issue either by adding a new function in <tt>this_thread</tt> or by providing a mechanism for converting
++between <tt>thread::id</tt> and <tt>thread::native_handle</tt>. I propose the former because it seems more localized, and doesn't involve
++saying anything more about implementation defined native functionality than we currently do.
++<p/>
++It's intentional that the proposed resolution adds a declaration of <tt>native_handle()</tt> without adding a paragraph explaining what
++it does. This is because everything about <tt>native_handle()</tt> is implementation-defined. The standard does the same thing in
++30.3.1.5 [thread.thread.member].
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++Strong "don't care" reaction from SG1, after pointing out that this only matters in non-portable code, which can call pthread_self() or the like anyway, but the change also doesn't add any non-trivial implementation requirements. This defused initial strong opinions on both sides. Since this is essentially a feature request, we did not have sufficient consensus to proceed at this point. There was a feeling we should reconsider after making more sense out of the much more general TLS issues we have been discussing.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 30.2.3 [thread.req.native] p1 as indicated:</p>
++
++<blockquote>
++<p>
++-1- <del>Several classes described in this Clause have members</del><ins>This Clause includes several members named</ins>
++<tt>native_handle_type</tt> and <tt>native_handle</tt>. The presence of these members and their semantics is
++implementation-defined. [&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>In 30.3 [thread.threads], header <tt>&lt;thread&gt;</tt> synopsis, add:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ [&hellip;]
++ namespace this_thread {
++ thread::id get_id() noexcept;
++ <ins>thread::native_handle_type native_handle();</ins>
++ [&hellip;]
++ }
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>In 30.3.2 [thread.thread.this] add:</p>
++<blockquote>
++<pre>
++namespace std {
++ namespace this_thread {
++ thread::id get_id() noexcept;
++ <ins>thread::native_handle_type native_handle(); <i>// See 30.2.3 [thread.req.native]</i></ins>
++ [&hellip;]
++ }
++}
++</pre>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2380"></a>2380. May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</h3>
++<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-03-31 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View all other</b> <a href="lwg-index.html#headers">issues</a> in [headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++D.5 [depr.c.headers] p3 says:
++</p>
++<blockquote><p>
++[<i>Example</i>: The header <tt>&lt;cstdlib&gt;</tt> assuredly provides its declarations and definitions within the namespace
++<tt>std</tt>. It may also provide these names within the global namespace. The header <tt>&lt;stdlib.h&gt;</tt> assuredly
++provides the same declarations and definitions within the global namespace, much as in the C Standard. It
++may also provide these names within the namespace <tt>std</tt>. &mdash; <i>end example</i>]
++</p></blockquote>
++<p>
++This suggests that <tt>&lt;cstdlib&gt;</tt> may provide <tt>::abs(long)</tt> and <tt>::abs(long long)</tt>. But this seems like
++it might contradict the normative wording of 17.6.1.2 [headers] p4:
++</p>
++<blockquote><p>
++Except as noted in Clauses 18 through 30 and Annex D, the contents of each header <tt>c<em>name</em></tt> shall be the same
++as that of the corresponding header <tt><em>name</em>.h</tt>, as specified in the C standard library (1.2) or the C Unicode
++TR, as appropriate, as if by inclusion. In the C++ standard library, however, the declarations (except for
++names which are defined as macros in C) are within namespace scope (3.3.6) of the namespace <tt>std</tt>. It is
++unspecified whether these names are first declared within the global namespace scope and are then injected
++into namespace <tt>std</tt> by explicit using-declarations (7.3.3).
++</p></blockquote>
++<p>
++Note that this allows <tt>&lt;cstdlib&gt;</tt> to provide <tt>::abs(int)</tt>, but does not obviously allow <tt>::abs(long)</tt>
++nor <tt>::abs(long long)</tt>, since they are not part of the header <tt>stdlib.h</tt> as specified in the C standard library.
++<p/>
++26.8 [c.math] p7 adds signatures <tt>std::abs(long)</tt> and <tt>std::abs(long long)</tt>, but not in a way that seems
++to allow <tt>::abs(long)</tt> and <tt>::abs(long long)</tt> to be provided.
++<p/>
++I think the right approach here would be to allow <tt>&lt;cstdlib&gt;</tt> to either provide no <tt>::abs</tt> declaration, or
++to provide all three declarations from namespace <tt>std</tt>, but it should not be permitted to provide only <tt>int abs(int)</tt>.
++Suggestion:
++<p/>
++Change in 17.6.1.2 [headers] p4:
++</p>
++<blockquote><p>
++[&hellip;]. It is unspecified whether these names <ins>(including any overloads added in Clauses 18 through 30 and Annex D)</ins>
++are first declared within the global namespace scope and are then injected into namespace <tt>std</tt> by explicit using-declarations
++(7.3.3).
++</p></blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: do we need to defer this?<br/>
++PJP: just need to get my mind around it, already playing dirty games here, my reaction is just do it as it will help C++<br/>
++STL: this is safe<br/>
++TP: would be surprising if using abs didn't bring in all of the overloads<br/>
++MC: that's Richard's argument<br/>
++MC: move to ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Modify 17.6.1.2 [headers] p4 as indicated:</p>
++
++<blockquote><p>
++Except as noted in Clauses 18 through 30 and Annex D, the contents of each header <tt>c<em>name</em></tt> shall be the same
++as that of the corresponding header <tt><em>name</em>.h</tt>, as specified in the C standard library (1.2) or the C Unicode
++TR, as appropriate, as if by inclusion. In the C++ standard library, however, the declarations (except for
++names which are defined as macros in C) are within namespace scope (3.3.6) of the namespace <tt>std</tt>. It is
++unspecified whether these names <ins>(including any overloads added in Clauses 18 through 30 and Annex D)</ins> are first
++declared within the global namespace scope and are then injected into namespace <tt>std</tt> by explicit using-declarations (7.3.3).
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2381"></a>2381. Inconsistency in parsing floating point numbers</h3>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2014-04-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 22.4.2.1.2 [facet.num.get.virtuals] we have:
++</p>
++<blockquote><p>
++Stage 3: The sequence of chars accumulated in stage 2 (the field) is converted to a numeric value by the
++rules of one of the functions declared in the header <tt>&lt;cstdlib&gt;</tt>:
++</p>
++<ul>
++<li><p>For a signed integer value, the function <tt>strtoll</tt>.</p></li>
++<li><p>For an unsigned integer value, the function <tt>strtoull</tt>.</p></li>
++<li><p>For a floating-point value, the function <tt>strtold</tt>.</p></li>
++</ul>
++</blockquote>
++<p>
++This implies that for many cases, this routine should return true:
++</p>
++<blockquote><pre>
++bool is_same(const char* p)
++{
++ std::string str{p};
++ double val1 = std::strtod(str.c_str(), nullptr);
++ std::stringstream ss(str);
++ double val2;
++ ss &gt;&gt; val2;
++ return std::isinf(val1) == std::isinf(val2) &amp;&amp; // either they're both infinity
++ std::isnan(val1) == std::isnan(val2) &amp;&amp; // or they're both NaN
++ (std::isinf(val1) || std::isnan(val1) || val1 == val2); // or they're equal
++}
++</pre></blockquote>
++<p>
++and this is indeed true, for many strings:
++</p>
++<blockquote><pre>
++assert(is_same("0"));
++assert(is_same("1.0"));
++assert(is_same("-1.0"));
++assert(is_same("100.123"));
++assert(is_same("1234.456e89"));
++</pre></blockquote>
++<p>
++but not for others
++</p>
++<blockquote><pre>
++assert(is_same("0xABp-4")); // hex float
++assert(is_same("inf"));
++assert(is_same("+inf"));
++assert(is_same("-inf"));
++assert(is_same("nan"));
++assert(is_same("+nan"));
++assert(is_same("-nan"));
++
++assert(is_same("infinity"));
++assert(is_same("+infinity"));
++assert(is_same("-infinity"));
++</pre></blockquote>
++<p>
++These are all strings that are correctly parsed by <tt>std::strtod</tt>, but not by the stream extraction operators.
++They contain characters that are deemed invalid in stage 2 of parsing.
++<p/>
++If we're going to say that we're converting by the rules of <tt>strtold</tt>, then we should accept all the things that
++<tt>strtold</tt> accepts.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2383"></a>2383. Overflow cannot be ill-formed for chrono::duration integer literals</h3>
++<p><b>Section:</b> 20.12.5.8 [time.duration.literals] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-05-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.12.5.8 [time.duration.literals] p3 says:
++</p>
++<blockquote><p>
++If any of these suffixes are applied to an integer literal and the
++resulting <tt>chrono::duration</tt> value cannot be represented in the result
++type because of overflow, the program is ill-formed.
++</p></blockquote>
++<p>
++Ill-formed requires a diagnostic at compile-time, but there is no way
++to detect the overflow from <tt>unsigned long long</tt> to the <tt>signed
++duration&lt;&gt;::rep</tt> type.
++<p/>
++Overflow could be detected if the duration integer literals were
++literal operator templates, otherwise overflow can either be undefined
++or a run-time error, not ill-formed.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Open]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2384"></a>2384. Allocator's <tt>deallocate</tt> function needs better specification</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-05-19 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to Table 28, 17.6.3.5 [allocator.requirements], an <tt>Allocator</tt>'s <tt>deallocate</tt>
++function is specified as follows:
++</p>
++<blockquote><p>
++All <tt>n</tt> <tt>T</tt> objects in the area
++pointed to by <tt>p</tt> shall be
++destroyed prior to this call. <tt>n</tt>
++shall match the value passed to
++allocate to obtain this
++memory. Does not throw
++exceptions. [<i>Note</i>: <tt>p</tt> shall not be
++singular. &mdash; <i>end note</i>]
++</p></blockquote>
++<p>
++This wording is confusing in regard to the following points:
++</p>
++<ol>
++<li><p>This specification does not make clear that the result of an <tt>allocate</tt>
++call can only be returned once to the <tt>deallocate</tt> function. This is much
++clearer expressed for <tt>operator delete</tt> (18.6.1.1 [new.delete.single] p12, emphasis mine):</p>
++<blockquote><p>
++<i>Requires</i>: <tt>ptr</tt> shall be a null pointer or <span style="color:#C80000;font-weight:bold">its value shall be a value returned
++by an earlier call to</span> the (possibly replaced) <span style="color:#C80000;font-weight:bold"><tt>operator new(std::size_t)</tt> or
++<tt>operator new(std::size_t,const std::nothrow_t&amp;)</tt> which has not been invalidated
++by an intervening call to <tt>operator delete(void*)</tt></span>.
++</p></blockquote>
++</li>
++<li><p>The intended meaning of that wording was to say that <tt>deallocate</tt> shall accept <em>every</em> result value
++that had been returned by a corresponding call to <tt>allocate</tt>, this includes also a possible result of a
++null pointer value, which is possible ("[<i>Note</i>: If <tt>n == 0</tt>, the return value is unspecified.
++&mdash; <i>end note</i>]"). Unfortunately the <tt>deallocate</tt> function uses a non-normative note ("<tt>p</tt> shall not be
++singular.") which refers to the fuzzy term <tt>singular</tt>, that is one of the most unclear and misunderstood terms
++of the library, as pointed out in <a href="lwg-active.html#1213">1213</a>. The occurrence of this term has lead to the possible understanding,
++that this function would never allow null pointer values. Albeit for allocators the intention had not been to require the support
++<em>in general</em> that a null pointer value can be provided to <tt>deallocate</tt> (as it is allowed for <tt>std::free</tt>
++and <tt>operator delete</tt>), the mental model was that <em>every</em> returned value of <tt>allocate</tt> shall be an
++acceptable argument type of the corresponding <tt>deallocate</tt> function.
++</p>
++</li>
++</ol>
++
++<p>
++This issue is not intending to enforce a specific meaning of <em>singular</em> iterator values, but the assertion is
++that this note does more harm than good. In addition to wording from <tt>operator delete</tt> there is no longer any need
++to obfuscate the normative wording.
++</p>
++
++<p><i>[2014-05-24 Alisdair comments]</i></p>
++
++
++<p>
++Now that I am reading it very precisely, there is another mis-stated assumption
++as a precondition for <tt>deallocate</tt>:
++</p>
++<blockquote><p>
++All <tt>n T</tt> objects in the area pointed to by <tt>p</tt> shall be destroyed prior to this call.
++</p></blockquote>
++<p>
++This makes a poor assumption that every possible object in the allocated buffer
++was indeed constructed, but this is often not the case, e.g., a <tt>vector</tt> that is not
++filled to capacity. We should require calling the destructor for only those objects
++actually constructed in the buffer, which may be fewer than <tt>n</tt>, or even 0.
++<p/>
++I wonder if we really require all objects to be destroyed before calling <tt>deallocate</tt>
++though. Are we really so concerned about leaking objects that might not manage
++resources? Should this not be the proper concern of the library managing the
++objects and memory?
++</p>
++
++<p><i>[2014-06-05 Daniel responds and improves wording]</i></p>
++
++
++<p>
++I fully agree with the last comment and I think that this requirement should be removed. We have no such
++requirements for comparable functions such as <tt>operator delete</tt> or <tt>return_temporary_buffer()</tt>,
++and this wording seems to be a wording rudiment that exists since C++98.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++Marshall: What do people think about this?<br/>
++PJP: Sure.<br/>
++Wakely: Love it.<br/>
++Marshall: Ready?<br/>
++Everyone agrees.<br/>
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change Table 28 ("<tt>Allocator</tt> requirements") as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; <tt>Allocator</tt> requirements</caption>
++<tr>
++<th align="center">Expression</th>
++<th align="center">Return type</th>
++<th align="center">Assertion/note<br/>pre-/post-condition</th>
++<th align="center">Default</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.deallocate(p,n)</tt>
++</td>
++<td>
++(not used)
++</td>
++<td>
++<ins><i>Pre</i>: <tt>p</tt> shall be a value returned by an earlier<br/>
++call to <tt>allocate</tt> which has not been invalidated by<br/>
++an intervening call to <tt>deallocate</tt>. <tt>n</tt> shall<br/>
++match the value passed to <tt>allocate</tt> to obtain this<br/>
++memory.</ins> <del>All <tt>n T</tt> objects in the area pointed to by<br/>
++<tt>p</tt> shall be destroyed prior to this call.</del><br/>
++<ins><i>Throws</i>: Nothing.</ins><del><tt>n</tt><br/>
++shall match the value passed to<br/>
++allocate to obtain this<br/>
++memory. Does not throw<br/>
++exceptions. [<i>Note</i>: <tt>p</tt> shall not<br/>
++be singular. &mdash; <i>end note</i>]</del>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2385"></a>2385. <tt>function::assign</tt> allocator argument doesn't make sense</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2014-05-23 <b>Last modified:</b> 2015-05-07</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The definition of <tt>function::assign</tt> in N3936 is:
++</p>
++<blockquote><pre>
++template&lt;class F, class A&gt;
++ void assign(F&amp;&amp; f, const A&amp; a);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: <tt>function(allocator_arg, a, std::forward&lt;F&gt;(f)).swap(*this)</tt>
++</p>
++</blockquote>
++</blockquote>
++<p>
++This definition is flawed in several respects:
++</p>
++<ol>
++<li><p>The interface implies that the intent is to replace the allocator in <tt>*this</tt>
++with the specified allocator, <tt>a</tt>. Such functionality is unique in the
++standard and is problematic when creating, e.g. a container of function
++objects, all using the same allocator.</p>
++</li>
++<li><p>The current definition of <tt>swap()</tt> makes it unclear whether the objects being
++swapped can have different allocators. The general practice is that
++allocators must be equal in order to support swap, and this practice is
++reinforced by the proposed library TS. Thus, the definition of <tt>assign</tt> would
++have undefined behavior unless the allocator matched the allocator already
++within function.
++</p>
++</li>
++<li><p>
++The general rule for members of function is to supply the allocator before
++the functor, using the <tt>allocator_arg</tt> prefix. Supplying the allocator as a
++second argument, without the <tt>allocator_arg</tt> prefix is error prone and
++confusing.
++</p></li>
++</ol>
++
++<p>
++I believe that this ill-conceived interface was introduced in the effort to
++add allocators to parts of the standard where it had been missing, when we
++were unpracticed in the right way to accomplish that. Allocators were added
++to function at a time when the allocator model was in flux and it was the
++first class in the standard after <tt>shared_ptr</tt> to use type-erased allocators, so
++it is not surprising to see some errors in specification here. (<tt>shared_ptr</tt> is
++a special case because of its shared semantics, and so is not a good model.)
++<p/>
++The main question is whether this member should be specified with better
++precision or whether it should be deprecated/removed. The only way I can see to
++give a "reasonable" meaning to the existing interface is to describe it in
++terms of destroying and re-constructing <tt>*this</tt>:
++</p>
++<blockquote><pre>
++function temp(allocator_arg, a, std::forward&lt;F&gt;(f));
++this-&gt;~function();
++::new(this) function(std::move(temp));
++</pre></blockquote>
++<p>
++(The temp variable is needed for exception safety). The ugliness of this
++specification underscores the ugliness of the concept. What is the purpose of
++this member other than to reconstruct the object from scratch, a facility that
++library classes do not generally provide? Programmers are always free to
++destroy and re-construct objects &mdash; there is no reason why function should
++make that especially easy.
++<p/>
++I propose, therefore, that we make no attempt at giving the current interface
++a meaningful definition of questionable utility, but simply get rid of it
++all together. This leaves us with only two questions:
++</p>
++<ol>
++<li><p>Should we deprecate the interface or just remove it?</p></li>
++<li><p>Should we replace it with an <tt>assign(f)</tt> member that doesn't take an
++allocator?</p></li>
++</ol>
++<p>
++Of these four combinations of binary answers to the above questions, I think
++the ones that make the most sense are (remove, no) and (deprecate, yes). The
++proposed new interface provides nothing that <tt>operator=</tt> does not already
++provide. However, if the old (deprecated) interface remains, then having the
++new interface will guide the programmer away from it.
++<p/>
++The proposed wording below assumes deprecation. If we choose removal, then
++there is no wording needed; simply remove the offending declaration and
++definition.
++</p>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change class template <tt>function</tt> synopsis, 20.9.12.2 [func.wrap.func], as indicated:</p>
++
++<blockquote>
++<pre>
++template&lt;class R, class... ArgTypes&gt;
++class function&lt;R(ArgTypes...)&gt; {
++ [&hellip;]
++ <i>// 20.9.11.2.2, function modifiers:</i>
++ void swap(function&amp;) noexcept;
++ template&lt;class F<del>, class A</del>&gt; void assign(F&amp;&amp;<del>, const A&amp;</del>);
++ [&hellip;]
++};
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.2 [func.wrap.func.mod] as indicated:</p>
++
++<blockquote>
++<pre>
++template&lt;class F<del>, class A</del>&gt; void assign(F&amp;&amp; f<del>, const A&amp; a</del>);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: <tt><ins>*this = forward&lt;F&gt;(f);</ins><del>function(allocator_arg, a, std::forward&lt;F&gt;(f)).swap(*this)</del></tt>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>To deprecation section [depr.function.objects], add the following new sub-clause:</p>
++
++<blockquote>
++<p>
++<b>Old <tt>assign</tt> member of polymorphic function wrappers [depr.function.objects.assign]</b>
++</p>
++<blockquote>
++<pre>
++namespace std{
++ template&lt;class R, class... ArgTypes&gt;
++ class function&lt;R(ArgTypes...)&gt; {
++ <i>// remainder unchanged</i>
++ template&lt;class F, class A&gt; void assign(F&amp;&amp; f, const A&amp; a);
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++<p>
++The two-argument form of <tt>assign</tt> is defined as follows:
++</p>
++<pre>
++template&lt;class F, class A&gt; void assign(F&amp;&amp; f, const A&amp; a);
++</pre>
++<blockquote>
++<p>
++<i>Requires</i>: <tt>a</tt> shall be equivalent to the allocator used to construct <tt>*this</tt>.
++<p/>
++<i>Effects</i>: <tt>this-&gt;assign(forward&lt;F&gt;(f));</tt>
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: I would ask, does anybody oppose removing this outright?<br/>
++Wakely: I don't even have this signature.<br/>
++Hwrd: And I think this doesn't go far enough, even more should be removed. This is a step in the right direction.<br/>
++PJP: I'm in favor of removal.<br/>
++Wakely: We've already got TS1 that has a new function that does it right. We could wait for feedback on that.
++I think this issue should be taken now.<br/>
++Marshall: Then the goal will be to move to ready.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<ol>
++<li><p>Change class template <tt>function</tt> synopsis, 20.9.12.2 [func.wrap.func], as indicated:</p>
++
++<blockquote>
++<pre>
++template&lt;class R, class... ArgTypes&gt;
++class function&lt;R(ArgTypes...)&gt; {
++ [&hellip;]
++ <i>// 20.9.12.2.2, function modifiers:</i>
++ void swap(function&amp;) noexcept;
++ <del>template&lt;class F, class A&gt; void assign(F&amp;&amp;, const A&amp;);</del>
++ [&hellip;]
++};
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.2 [func.wrap.func.mod] as indicated:</p>
++
++<blockquote>
++<pre>
++<del>template&lt;class F, class A&gt;
++ void assign(F&amp;&amp; f, const A&amp; a);</del>
++</pre>
++<blockquote>
++<p>
++<del>-2- <i>Effects</i>: <tt>function(allocator_arg, a, std::forward&lt;F&gt;(f)).swap(*this)</tt></del>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2391"></a>2391. <tt>basic_string</tt> is missing non-<tt>const</tt> <tt>data()</tt></h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Michael Bradshaw <b>Opened:</b> 2014-05-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Regarding 21.4 [basic.string], <tt>std::basic_string&lt;charT&gt;::data()</tt> returns a <tt>const charT*</tt>
++21.4.7.1 [string.accessors]. While this method is convenient, it doesn't quite match <tt>std::array&lt;T&gt;::data()</tt>
++23.3.2.5 [array.data] or <tt>std::vector&lt;T&gt;::data()</tt> 23.3.6.4 [vector.data], both of which provide two
++versions (that return <tt>T*</tt> or <tt>const T*</tt>). An additional <tt>data()</tt> method can be added to
++<tt>std::basic_string</tt> that returns a <tt>charT*</tt> so it can be used in similar situations that <tt>std::array</tt> and
++<tt>std::vector</tt> can be used. Without a non-<tt>const</tt> <tt>data()</tt> method, <tt>std::basic_string</tt> has to be treated
++specially in code that is otherwise oblivious to the container type being used.
++<p/>
++Adding a <tt>charT*</tt> return type to <tt>data()</tt> would be equivalent to doing <tt>&amp;str[0]</tt> or <tt>&amp;str.front()</tt>.
++<p/>
++Small discussion on the issue can be found <a href="http://stackoverflow.com/questions/7518732/why-are-stdvectordata-and-stdstringdata-different">here</a>
++and in the <a href="https://groups.google.com/a/isocpp.org/forum/#!topic/std-discussion/ll9HuEML6zo/discussion">std-discussion thread</a>
++(which didn't get too much attention).
++<p/>
++This requires a small change to <tt>std::basic_string</tt>'s definition in 21.4 [basic.string] to add the method to
++<tt>std::basic_string</tt>, and another small change in 21.4.7.1 [string.accessors] to define the new method.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Back to LEWG.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change class template <tt>basic_string</tt> synopsis, 21.4 [basic.string], as indicated:</p>
++<blockquote>
++<pre>
++namespace std {
++ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
++ class Allocator = allocator&lt;charT&gt; &gt;
++ class basic_string {
++ public:
++ [&hellip;]
++ <i>// 21.4.7, string operations:</i>
++ const charT* c_str() const noexcept;
++ const charT* data() const noexcept;
++ <ins>charT* data() noexcept;</ins>
++ allocator_type get_allocator() const noexcept;
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++
++</li>
++
++<li><p>Add the following sequence of paragraphs following 21.4.7.1 [string.accessors] p3, as indicated:</p>
++<blockquote>
++<pre>
++<ins>charT* data() noexcept;</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: A pointer <tt>p</tt> such that <tt>p + i == &amp;operator[](i)</tt> for each <tt>i</tt> in <tt>[0,size()]</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: Constant time.</ins>
++<p/>
++<ins>-?- <i>Requires</i>: The program shall not alter the value stored at <tt>p + size()</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2392"></a>2392. "character type" is used but not defined</h3>
++<p><b>Section:</b> 17.3 [defns.ntcts], 22.3.1.1.1 [locale.category], 27.2.2 [iostreams.limits.pos], 27.7.3.6.1 [ostream.formatted.reqmts], 27.7.3.6.4 [ostream.inserters.character] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2014-06-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The term "character type" is used in 17.3 [defns.ntcts], 22.3.1.1.1 [locale.category],
++27.2.2 [iostreams.limits.pos], 27.7.3.6.1 [ostream.formatted.reqmts], and
++27.7.3.6.4 [ostream.inserters.character], but the core language only defines
++"narrow character types" (3.9.1 [basic.fundamental]).
++<p/>
++"wide-character type" is used in 22.5 [locale.stdcvt], but the core
++language only defines a "wide-character set" and "wide-character literal".
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2393"></a>2393. <tt>std::function</tt>'s <em>Callable</em> definition is broken</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The existing definition of <tt>std::function</tt>'s <em>Callable</em> requirements provided in 20.9.12.2 [func.wrap.func]
++p2,
++</p>
++<blockquote><p>
++A callable object <tt>f</tt> of type <tt>F</tt> is <em>Callable</em> for argument types <tt>ArgTypes</tt> and return type
++<tt>R</tt> if the expression <tt><i>INVOKE</i>(f, declval&lt;ArgTypes&gt;()..., R)</tt>, considered as an unevaluated operand
++(Clause 5), is well formed (20.9.2).
++</p></blockquote>
++<p>
++is defective in several aspects:
++</p>
++<ol style="list-style-type:upper-roman">
++<li><p>The wording can be read to be defined in terms of callable objects, not of callable types.</p>
++</li>
++<li><p>Contrary to that, 20.9.12.2.5 [func.wrap.func.targ] p2 speaks of "<tt>T</tt> shall be a type that is <em>Callable</em>
++(20.9.11.2) for parameter types <tt>ArgTypes</tt> and return type <tt>R</tt>."</p>
++</li>
++<li><p>
++The required value category of the callable object during the call expression (lvalue or rvalue) strongly depends on
++an interpretation of the expression <tt>f</tt> and therefore needs to be specified unambiguously.
++</p></li>
++</ol>
++<p>
++The intention of original <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1402.html">proposal</a>
++(see IIIa. Relaxation of target requirements) was to refer to both types and values ("we say that the function object <tt>f</tt>
++(and its type <tt>F</tt>) is <em>Callable</em> [&hellip;]"), but that mental model is not really deducible from the
++existing wording. An improved type-dependence wording would also make the sfinae-conditions specified in 20.9.12.2.1 [func.wrap.func.con]
++p8 and p21 ("[&hellip;] shall not participate in overload resolution unless <tt>f</tt> is Callable (20.9.11.2)
++for argument types <tt>ArgTypes...</tt> and return type <tt>R</tt>.") easier to interpret.
++<p/>
++My understanding always had been (see e.g. Howard's code example in the 2009-05-01 comment in LWG <a href="lwg-defects.html#815">815</a>), that
++<tt>std::function</tt> invokes the call operator of its target via an <b>lvalue</b>. The required value-category is relevant,
++because it allows to reflect upon whether an callable object such as
++</p>
++<blockquote><pre>
++struct RVF
++{
++ void operator()() const &amp;&amp; {}
++};
++</pre></blockquote>
++<p>
++would be a feasible target object for <tt>std::function&lt;void()&gt;</tt> or not.
++<p/>
++Clarifying the current <em>Callable</em> definition seems also wise to make a future transition to language-based concepts
++easier. A local fix of the current wording is simple to achieve, e.g. by rewriting it as follows:
++</p>
++<blockquote><p>
++A callable <del>object <tt>f</tt> of</del> type <ins>(20.9.1 [func.def])</ins> <tt>F</tt> is <em>Callable</em>
++for argument types <tt>ArgTypes</tt> and return type <tt>R</tt> if the expression <tt><i>INVOKE</i>(<del>f</del><ins>declval&lt;F&amp;&gt;()</ins>,
++declval&lt;ArgTypes&gt;()..., R)</tt>, considered as an unevaluated operand (Clause 5), is well formed (20.9.2).
++</p></blockquote>
++<p>
++It seems appealing to move such a general <em>Callable</em> definition to a more "fundamental" place (e.g. as another
++paragraph of 20.9.1 [func.def]), but the question arises, whether such a more general concept should impose
++the requirement that the call expression is invoked on an <b>lvalue</b> of the callable object &mdash; such a
++special condition would also conflict with the more general definition of the <tt>result_of</tt> trait, which
++is defined for either lvalues or rvalues of the callable type <tt>Fn</tt>. In this context I would like to point out that
++"<em>Lvalue-Callable</em>" is not the one and only <em>Callable</em> requirement in the library. Counter examples are
++<tt>std::thread</tt>, <tt>call_once</tt>, or <tt>async</tt>, which depend on "<em>Rvalue-Callable</em>", because they
++all act on functor rvalues, see e.g. 30.3.1.2 [thread.thread.constr]:
++</p>
++<blockquote><p>
++[&hellip;] The new thread of execution executes <tt><i>INVOKE</i>(<i>DECAY_COPY</i>(std::forward&lt;F&gt;(f)),
++<i>DECAY_COPY</i>(std::forward&lt;Args&gt;(args))...)</tt> [&hellip;]
++</p></blockquote>
++<p>
++For every callable object <tt>F</tt>, the result of <tt><i>DECAY_COPY</i></tt> is an rvalue. These implied rvalue function calls are
++no artifacts, but had been deliberately voted for by a Committee decision (see LWG <a href="lwg-defects.html#2021">2021</a>, 2011-06-13 comment)
++and existing implementations respect these constraints correctly. Just to give an example,
++</p>
++<blockquote><pre>
++#include &lt;thread&gt;
++
++struct LVF
++{
++ void operator()() &amp; {}
++};
++
++int main()
++{
++ LVF lf;
++ std::thread t(lf);
++ t.join();
++}
++</pre></blockquote>
++<p>
++is supposed to be rejected.
++<p/>
++The below presented wording changes are suggested to be minimal (still local to <tt>std::function</tt>), but the used approach
++would simplify a future (second) conceptualization or any further generalization of <em>Callable</em> requirements of the Library.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4348.html">N4348</a>. Don't touch with a barge pole.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.9.12.2 [func.wrap.func] p2 as indicated:</p>
++
++<blockquote><p>
++-2- A callable <del>object <tt>f</tt> of</del> type <ins>(20.9.1 [func.def])</ins> <tt>F</tt> is <em><ins>Lvalue-</ins>Callable</em>
++for argument types <tt>ArgTypes</tt> and return type <tt>R</tt> if the expression <tt><i>INVOKE</i>(<del>f</del><ins>declval&lt;F&amp;&gt;()</ins>,
++declval&lt;ArgTypes&gt;()..., R)</tt>, considered as an unevaluated operand (Clause 5), is well formed (20.9.2).
++</p></blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.1 [func.wrap.func.con] p8+p21 as indicated:</p>
++
++<blockquote>
++<pre>
++template&lt;class F&gt; function(F f);
++template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-8- <i>Remarks</i>: These constructors shall not participate in overload resolution unless <tt><del>f</del><ins>F</ins></tt> is
++<tt><ins>Lvalue-</ins>Callable</tt> (20.9.11.2) for argument types <tt>ArgTypes...</tt> and return type <tt>R</tt>.
++</p>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<pre>
++template&lt;class F&gt; function&amp; operator=(F&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-21- <i>Remarks</i>: This assignment operator shall not participate in overload resolution unless
++<tt><del>declval&lt;typename decay&lt;F&gt;::type&amp;&gt;()</del><ins>decay_t&lt;F&gt;</ins></tt> is
++<tt><ins>Lvalue-</ins>Callable</tt> (20.9.11.2) for argument types <tt>ArgTypes...</tt> and return type <tt>R</tt>.
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.5 [func.wrap.func.targ] p2 as indicated: [<i>Editorial comment</i>: Instead of adapting the preconditions
++for the naming change I recommend to strike it completely, because the <tt>target()</tt> functions do not depend on it; the
++corresponding wording exists since its <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1667.pdf">initial proposal</a>
++and it seems without any advantage to me. Assume that some template argument <tt>T</tt> is provided, which does <em>not</em>
++satisfy the requirements: The effect will be that the result is a null pointer value, but that case can happen in other (valid) situations
++as well. &mdash; <i>end comment</i>]</p>
++
++<blockquote><pre>
++template&lt;class T&gt; T* target() noexcept;
++template&lt;class T&gt; const T* target() const noexcept;
++</pre>
++<blockquote>
++<p>
++<del>-2- <i>Requires</i>: <tt>T</tt> shall be a type that is <tt>Callable</tt> (20.9.11.2) for parameter types
++<tt>ArgTypes</tt> and return type <tt>R</tt>.</del>
++<p/>
++-3- <i>Returns</i>: If <tt>target_type() == typeid(T)</tt> a pointer to the stored function target; otherwise a null
++pointer.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2394"></a>2394. <tt>locale::name</tt> specification unclear &mdash; what is implementation-defined?</h3>
++<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-06-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.members">issues</a> in [locale.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++22.3.1.3 [locale.members] p5 says:
++</p>
++<blockquote><p>
++<i>Returns</i>: The name of <tt>*this</tt>, if it has one; otherwise, the string <tt>"*"</tt>. If <tt>*this</tt> has a name, then
++<tt>locale(name().c_str())</tt> is equivalent to <tt>*this</tt>. Details of the contents of the resulting string are
++otherwise implementation-defined.
++</p></blockquote>
++<p>
++So&hellip; what is implementation-defined here, exactly? The first sentence <em>completely</em> defines the behavior of this function
++in all cases.
++<p/>
++Also, the second sentence says (effectively) that all locales with the same name are equivalent: given <tt>L1</tt> and <tt>L2</tt>
++that have the same name <tt>N</tt>, they are both equivalent to <tt>locale(N)</tt>, and since there is no definition of
++"equivalent" specific to <tt>locale</tt>, I assume it's the normal transitive equivalence property, which would imply that
++<tt>L1</tt> is equivalent to <tt>L2</tt>. I'm not sure why this central fact is in the description of <tt>locale::name</tt>, nor
++why it's written in this roundabout way.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2398"></a>2398. <tt>type_info</tt>'s destructor shouldn't be required to be virtual</h3>
++<p><b>Section:</b> 18.7.1 [type.info] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#type.info">issues</a> in [type.info].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>type_info</tt>'s destructor is depicted as being <tt>virtual</tt>, which is nearly unobservable to users (since they can't construct
++or copy this class, they can't usefully derive from it). However, it's technically observable (via <tt>is_polymorphic</tt> and
++<tt>has_virtual_destructor</tt>). It also imposes real costs on implementations, requiring them to store one vptr per
++<tt>type_info</tt> object, when RTTI space consumption is a significant concern.
++<p/>
++Making this implementation-defined wouldn't affect users (who can observe this only if they're specifically looking for it) and
++wouldn't affect implementations who need <tt>virtual</tt> here, but it would allow other implementations to drop <tt>virtual</tt>
++and improve their RTTI space consumption.
++<p/>
++Richard Smith:
++<p/>
++It's observable in a few other ways.
++</p>
++<blockquote><pre>
++std::map&lt;void*, something&gt; m;
++m[dynamic_cast&lt;void*&gt;(&amp;typeid(blah))] = stuff;
++</pre></blockquote>
++<p>
++... is broken by this change, because you can't <tt>dynamic_cast</tt> a non-polymorphic class type to <tt>void*</tt>.
++</p>
++<blockquote><pre>
++type_info&amp; f();
++typeid(f());
++</pre></blockquote>
++<p>
++... evaluates <tt>f()</tt> at runtime without this change, and might not do so with this change.
++<p/>
++These are probably rare things, but I can imagine at least some forms of the latter being used in SFINAE tricks.
++</p>
++
++<p><i>[Lenexa 2015-05-05: Move to Open]</i></p>
++
++<p>Marshall to poll LEWG for their opinion</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 18.7.1 [type.info] as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ class type_info {
++ public:
++ <del>virtual</del><ins><i>see below</i></ins> ~type_info();
++ [&hellip;]
++ };
++}
++</pre>
++<p>
++-1- The class <tt>type_info</tt> describes type information generated by the implementation. Objects of this class
++effectively store a pointer to a name for the type, and an encoded value suitable for comparing two types for
++equality or collating order. The names, encoding rule, and collating sequence for types are all unspecified
++and may differ between programs. <ins>Whether <tt>~type_info()</tt> is <tt>virtual</tt> is implementation-defined.</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2402"></a>2402. <tt>basic_string(const basic_string&amp; str, size_type pos, size_type n = npos)</tt> shouldn't use <tt>Allocator()</tt></h3>
++<p><b>Section:</b> 21.4.2 [string.cons] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.cons">issues</a> in [string.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++21.4.2 [string.cons] p3 specifies:
++</p>
++<blockquote>
++<pre>
++basic_string(const basic_string&amp; str, size_type pos, size_type n = npos, const Allocator&amp; a = Allocator());
++</pre>
++<p>
++But this implies that <tt>basic_string(str, pos)</tt> and <tt>basic_string(str, pos, n)</tt> use <tt>Allocator()</tt>
++instead of getting an allocator from <tt>str</tt>.
++<p/>
++21.4.1 [string.require] p3 says "The <tt>Allocator</tt> object used shall be obtained as described in 23.2.1."
++23.2.1 [container.requirements.general] p8 says "Copy constructors for these container types obtain an allocator
++by calling <tt>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</tt> on the allocator
++belonging to the container being copied.", but this isn't exactly a copy constructor. Then it talks about move constructors
++(which this definitely isn't), and finally says that "All other constructors for these container types take a
++<tt>const allocator_type&amp;</tt> argument. [&hellip;] A copy of this allocator is used for any memory allocation performed".
++</p>
++</blockquote>
++
++<p><i>[2015-05-06 Lenexa: move to Open]</i></p>
++
++<p>STL: there an allocator right there in str, why default-construct one</p>
++<p>STL: my fix, which may not be right, splits out functions with and without allocators</p>
++<p>JW: there are other ways to propagate the allocator from str to the new object</p>
++<p>PJP: hard to get motivated about this one</p>
++<p>JW: I think this is not a copy operation, this is init'ing a string from a range of characters which happens to originate in a string. It makes it inconsistent with the similar ctor taking a const char pointer, and if we had a std::string_view we wouldn't even have this ctor, and it wouldn't be possible to propagate the allocator.</p>
++<p>STL: but people with stateful allocators want it to propagate</p>
++<p>JW: I think the people using stateful allocators will alter the default behaviour of select_on_container_copy_construction so that it doesn't propagate, but will return a default-constructed one (to ensure a stateful allocator referring to a stack buffer doesn't leak to a region where the stack buffer has gone). So for those people, your proposed change does nothing, it changes one default-constructed allocator to a call to select_on_container_copy_construction which returns a default-constructed allocator. For other people who have different stateful allocators they can still provide the right allocator (whatever that may be) by passing it in.</p>
++<p>STL: OK, that's convincing.</p>
++<p>PJP: I agree with Jonathan</p>
++<p>JW: would like to run both our arguments by Pablo in case I'm totally misrepresenting the expected users of allocator-traits stuff</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 21.4 [basic.string] p5, class template <tt>basic_string</tt> synopsis, as indicated:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++<i>// 21.4.2, construct/copy/destroy:</i>
++[&hellip;]
++basic_string(basic_string&amp;&amp; str) noexcept;
++<ins>basic_string(const basic_string&amp; str, size_type pos, size_type n = npos);</ins>
++basic_string(const basic_string&amp; str, size_type pos, size_type n<del> = npos</del>,
++ const Allocator&amp; a<del> = Allocator()</del>);
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 21.4.2 [string.cons] around p3 as indicated:</p>
++
++<blockquote>
++<pre>
++<ins>basic_string(const basic_string&amp; str,
++ size_type pos, size_type n = npos);</ins>
++basic_string(const basic_string&amp; str,
++ size_type pos, size_type n<del> = npos</del>,
++ const Allocator&amp; a<del> = Allocator()</del>);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-5- <i>Effects</i>: Constructs an object of class <tt>basic_string</tt> and determines the effective length <tt>rlen</tt> of the
++initial string value as the smaller of <tt>n</tt> and <tt>str.size() - pos</tt>, as indicated in Table 65. <ins>The first constructor
++obtains an allocator by calling <tt>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</tt> on the
++allocator belonging to <tt>str</tt>.</ins>
++<p/>
++Table 65 &mdash; <ins><tt>basic_string(const basic_string&amp;, size_type, size_type)</tt> and</ins>
++<tt>basic_string(const basic_string&amp;, size_type, size_type, const Allocator&amp;)</tt> effects
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2412"></a>2412. <tt>promise::set_value()</tt> and <tt>promise::get_future()</tt> should not race</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise], 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#SG1">SG1</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#SG1">SG1</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The following code has a data race according to the standard:
++</p>
++<blockquote>
++<pre>
++std::promise&lt;void&gt; p;
++std::thread t{ []{
++ p.get_future().wait();
++}};
++p.set_value();
++t.join();
++</pre>
++</blockquote>
++<p>
++The problem is that both <tt>promise::set_value()</tt> and
++<tt>promise::get_future()</tt> are non-const member functions which modify the
++same object, and we only have wording saying that the <tt>set_value()</tt> and
++<tt>wait()</tt> calls (i.e. calls setting and reading the shared state) are
++synchronized.
++<p/>
++The calls don't actually access the same memory locations, so the
++standard should allow it. My suggestion is to state that calling
++<tt>get_future()</tt> does not conflict with calling the various functions that
++make the shared state ready, but clarify with a note that this does
++not imply any synchronization or "happens before", only being free
++from data races.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 30.6.5 [futures.promise] around p12 as indicated:</p>
++
++<blockquote>
++<pre>
++future&lt;R&gt; get_future();
++</pre>
++<blockquote>
++<p>
++-12- <i>Returns</i>: A <tt>future&lt;R&gt;</tt> object with the same shared state as <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Synchronization</i>: Calls to this function do not conflict (1.10 [intro.multithread])
++with calls to <tt>set_value</tt>, <tt>set_exception</tt>, <tt>set_value_at_thread_exit</tt>, or
++<tt>set_exception_at_thread_exit</tt>. [<i>Note</i>: Such calls need not be synchronized, but implementations
++must ensure they do not introduce data races. &mdash; <i>end note</i>]</ins>
++<p/>
++-13- <i>Throws</i>: <tt>future_error</tt> if <tt>*this</tt> has no shared state or if <tt>get_future</tt> has already been called on a
++<tt>promise</tt> with the same shared state as <tt>*this</tt>.
++<p/>
++-14- <i>Error conditions</i>: [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 30.6.9.1 [futures.task.members] around p13 as indicated:</p>
++
++<blockquote>
++<pre>
++future&lt;R&gt; get_future();
++</pre>
++<blockquote>
++<p>
++-13- <i>Returns</i>: A <tt>future&lt;R&gt;</tt> object that shares the same shared state as <tt>*this</tt>.
++<p/>
++<ins>-?- <i>Synchronization</i>: Calls to this function do not conflict (1.10 [intro.multithread])
++with calls to <tt>operator()</tt> or <tt>make_ready_at_thread_exit</tt>. [<i>Note</i>: Such calls need not be
++synchronized, but implementations must ensure they do not introduce data races. &mdash; <i>end note</i>]</ins>
++<p/>
++-14- <i>Throws</i>: a <tt>future_error</tt> object if an error occurs.
++<p/>
++-15- <i>Error conditions</i>: [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2413"></a>2413. <tt>assert</tt> macro is overconstrained</h3>
++<p><b>Section:</b> 19.3 [assertions] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2014-06-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#assertions">active issues</a> in [assertions].</p>
++<p><b>View all other</b> <a href="lwg-index.html#assertions">issues</a> in [assertions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++When <tt>NDEBUG</tt> is defined, <tt>assert</tt> must expand exactly to the token sequence <tt>((void)0)</tt>, with no
++whitespace (C99 &sect;7.2/1 and also C11 &sect;7.2/1). This is a lost opportunity to pass the condition along to the optimizer.
++<p/>
++The user may observe the token sequence using the stringize operator or discriminate it by making a matching <tt>#define</tt>
++directive. There is little chance of practical code doing such things. It's reasonable to allow any expansion that is a <tt>void</tt>
++expression with no side effects or semantic requirements, for example, an extension keyword or an attribute-specifier finagled
++into the context.
++<p/>
++Conforming optimizations would still be limited to treating the condition as hint, not a requirement. Nonconformance on this
++point is quite reasonable though, given user preferences. Anyway, it shouldn't depend on preprocessor quirks.
++<p/>
++As for current practice, Darwin OS <tt>&lt;assert.h&gt;</tt> provides a GCC-style compiler hint <tt>__builtin_expect</tt> but only in
++debug mode. Shouldn't release mode preserve hints?
++<p/>
++Daniel:
++<p/>
++The corresponding resolution should take care not to conflict with the intention behind LWG <a href="lwg-active.html#2234">2234</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2414"></a>2414. Member function reentrancy should be implementation-defined</h3>
++<p><b>Section:</b> 17.6.5.8 [reentrancy] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-07-01 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View all other</b> <a href="lwg-index.html#reentrancy">issues</a> in [reentrancy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++N3936 17.6.5.8 [reentrancy]/1 talks about "functions", but that doesn't address the scenario of calling different member
++functions of a single object. Member functions often have to violate and then re-establish invariants. For example, vectors
++often have "holes" during insertion, and element constructors/destructors/etc. shouldn't be allowed to observe the vector
++while it's in this invariant-violating state. The [reentrancy] Standardese should be extended to cover member functions,
++so that implementers can either say that member function reentrancy is universally prohibited, or selectively allowed for
++very specific scenarios.
++<p/>
++(For clarity, this issue has been split off from LWG <a href="lwg-closed.html#2382">2382</a>.)
++</p>
++
++<p><i>[2014-11-03 Urbana]</i></p>
++
++<p>
++AJM confirmed with SG1 that they had no special concerns with this issue, and LWG should retain ownership.
++<p/>
++AM: this is too overly broad as it also covers calling the exact same member function on a different object<br/>
++STL: so you insert into a map, and copying the value triggers another insertion into a different map of the same type<br/>
++GR: reentrancy seems to imply the single-threaded case, but needs to consider the multi-threaded case
++<p/>
++Needs more wording.
++</p>
++<p>
++Move to Open
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 17.6.5.8 [reentrancy] p1 as indicated:</p>
++<blockquote>
++<p>
++-1- Except where explicitly specified in this standard, it is implementation-defined which functions <ins>(including different
++member functions called on a single object)</ins> in the Standard C++ library may be recursively reentered.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2417"></a>2417. [fund.ts] <tt>std::experimental::optional::operator&lt;</tt> and <tt>LessThanComparable</tt> requirement</h3>
++<p><b>Section:</b> X [optional.relops], X [optional.comp_with_t] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-06-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++Currently, <tt>std::experimental::optional::operator==</tt> imposes the <tt>EqualityComparable</tt> requirement which provides
++two guarantees: It ensures that <tt>operator!=</tt> can rely on the equivalence-relation property and more importantly, that
++the <tt>BooleanTestable</tt> requirements suggested by issue <a href="lwg-active.html#2114">2114</a> are automatically implied.
++<p/>
++<tt>std::experimental::optional::operator&lt;</tt> doesn't provide a <tt>LessThanComparable</tt> requirement, but there was quite
++an historic set of changes involved with that family of types: As of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3527.html">N3527</a>
++this operator was defined in terms of <tt>operator&lt;</tt> of the contained type <tt>T</tt> and imposed the <tt>LessThanComparable</tt>
++requirement. In the final acceptance step of <tt>optional</tt> by the committee, the definition was expressed in terms of <tt>std::less</tt>
++and the <tt>LessThanComparable</tt> requirement had been removed.
++<p/>
++The inconsistency between <tt>operator==</tt> and <tt>operator&lt;</tt> should be removed. One possible course of action would be
++to add the <tt>LessThanComparable</tt> to <tt>std::experimental::optional::operator&lt;</tt>. The <tt>EqualityComparable</tt> requirement
++of <tt>operator==</tt> could also be removed, but in that case both operators would at least need to require the <tt>BooleanTestable</tt>
++requirements (see <a href="lwg-active.html#2114">2114</a>) for the result type of <tt>T</tt>'s <tt>operator==</tt> and <tt>operator&lt;</tt>.
++<p/>
++Arguably, corresponding operators for <tt>pair</tt> and <tt>tuple</tt> do not impose <tt>LessThanComparable</tt> (nor
++<tt>EqualityComparable</tt>), albeit the definition of the "derived" relation functions depend on properties ensured by
++<tt>LessThanComparable</tt>. According to the <a href="https://www.sgi.com/tech/stl/pair.html">SGI definition</a>, the intention was
++to imposed both <tt>EqualityComparable</tt> and <tt>LessThanComparable</tt>. If this is not intended, the standard should clarify
++this position.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++VV, DK, JY discuss why and when <tt>LessThanComparable</tt> was removed. AM: Move to LEWG. Please tell LWG when you look at it.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2419"></a>2419. Clang's libc++ extension to <tt>std::tuple</tt></h3>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Akim Demaille <b>Opened:</b> 2014-07-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The issue has been submitted after exchanges with the clang++ team
++as a consequence of two PR I sent:
++<p/>
++<a href="http://llvm.org/bugs/show_bug.cgi?id=20174">Issue 20174</a>
++<p/>
++<a href="http://llvm.org/bugs/show_bug.cgi?id=20175">Issue 20175</a>
++<p/>
++The short version is shown in the program below:
++</p>
++<blockquote>
++<pre>
++#include &lt;iostream&gt;
++#include &lt;tuple&gt;
++
++struct base
++{
++ void out(const std::tuple&lt;char, char&gt;&amp; w) const
++ {
++ std::cerr &lt;&lt; "Tuple: " &lt;&lt; std::get&lt;0&gt;(w) &lt;&lt; std::get&lt;1&gt;(w) &lt;&lt; '\n';
++ }
++};
++
++struct decorator
++{
++ base b_;
++
++ template &lt;typename... Args&gt;
++ auto
++ out(Args&amp;&amp;... args)
++ -> decltype(b_.out(args...))
++ {
++ return b_.out(args...);
++ }
++
++ void out(const char&amp; w)
++ {
++ std::cerr &lt;&lt; "char: " &lt;&lt; w &lt;&lt; '\n';
++ }
++};
++
++int main()
++{
++ decorator d{base{}};
++ char l = 'a';
++ d.out(l);
++}
++</pre>
++</blockquote>
++<p>
++This is a stripped down version of a real world case where I
++wrap objects in decorators. These decorators contributes some
++functions, and forward all the rest of the API to the wrapped
++object using perfect forwarding. There can be overloaded names.
++<p/>
++Here the inner object provides an
++</p>
++<blockquote><pre>
++out(const std::tuple&lt;char, char&gt;&amp;) -&gt; void
++</pre></blockquote>
++<p>
++function, and the wrappers, in addition to perfect forwarding,
++provides
++</p>
++<blockquote><pre>
++out(const char&amp;) -&gt; void
++</pre></blockquote>
++<p>
++The main function then call <tt>out(l)</tt> where <tt>l</tt> is a <tt>char</tt> lvalue.
++<p/>
++With (GCC's) libstdc++ I get the expected result: the <tt>char</tt>
++overload is run. With (clang++'s) libc++ it is the tuple
++version which is run.
++</p>
++<blockquote><pre>
++$ g++-mp-4.9 -std=c++11 bar.cc &amp;&amp; ./a.out
++char: a
++$ clang++-mp-3.5 -std=c++11 bar.cc -Wall &amp;&amp; ./a.out
++Tuple: a
++</pre></blockquote>
++<p>
++It turns out that this is the result of an extension of <tt>std::tuple</tt>
++in libc++ where they accept constructors with fewer values that
++tuple elements.
++<p/>
++The purpose of this issue is to ask the standard to forbid
++that this extension be allowed to participate in overload resolution.
++</p>
++
++<p><i>[2014-10-05, Daniel comments]</i></p>
++
++<p>
++This issue is closely related to LWG <a href="lwg-active.html#2312">2312</a>.
++</p>
++
++<p><i>[2014-11 Urbana]</i></p>
++
++<p>
++Moved to LEWG.
++</p>
++<p>
++Extensions to <tt>tuple</tt>'s design are initially a question for LEWG.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-5 <i>Returns:</i> <tt><ins>!(y &lt; x)</ins><del>x.get() &lt;= y.get()</del></tt>.
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
+-<blockquote>
+-6 <i>Returns:</i> <tt><ins>(y &lt; x)</ins><del>x.get() &gt; y.get()</del></tt>.
+-</blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
+- bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+-</pre>
+
++<hr>
++<h3><a name="2421"></a>2421. Non-specification of handling zero size in <tt>std::align</tt> [ptr.align]</h3>
++<p><b>Section:</b> 20.7.5 [ptr.align] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Melissa Mears <b>Opened:</b> 2014-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ptr.align">issues</a> in [ptr.align].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The specification of <tt>std::align</tt> does not appear to specify what happens when the value of the <tt>size</tt>
++parameter is 0. (The question of what happens when <tt>alignment</tt> is 0 is mentioned in another Defect Report, <a href="lwg-defects.html#2377">2377</a>;
++it would change the behavior to be undefined rather than potentially implementation-defined.)
++<p/>
++The case of <tt>size</tt> being 0 is interesting because the result is ambiguous. Consider the following code's output:
++</p>
+ <blockquote>
+-7 <i>Returns:</i> <tt><ins>!(x &lt; y)</ins><del>x.get() &gt;= y.get()</del></tt>.
++<pre>
++#include &lt;cstdio&gt;
++#include &lt;memory&gt;
++
++int main()
++{
++ alignas(8) char buffer[8];
++ void *ptr = &amp;buffer[1];
++ std::size_t space = sizeof(buffer) - sizeof(char[1]);
++
++ void *result = std::align(8, 0, ptr, space);
++
++ std::printf("%d %td\n", !!result, result ? (static_cast&lt;char*&gt;(result) - buffer) : std::ptrdiff_t(-1));
++}
++</pre>
+ </blockquote>
++<p>
++There are four straightforward answers as to what the behavior of <tt>std::align</tt> with size 0 should be:
++</p>
++<ol>
++<li><p>The behavior is undefined because the size is invalid.</p></li>
++<li><p>The behavior is implementation-defined. This seems to be the status quo, with current implementations using #3.</p></li>
++<li><p>Act the same as <tt>size == 1</tt>, except that if <tt>size == 1</tt> would fail but would be defined and succeed
++if space were exactly 1 larger, the result is a pointer to the byte past the end of the <tt>ptr</tt> buffer. That is, the
++"aligned" version of a 0-byte object can be one past the end of an allocation. Such pointers are, of course, valid when not
++dereferenced (and a "0-byte object" shouldn't be), but whether that is desired is not specified in the Standard's definition
++of <tt>std::align</tt>, it appears. The output of the code sample is "<tt>1 8</tt>" in this case.</p></li>
++<li><p>Act the same as <tt>size == 1</tt>; this means that returning "one past the end" is not a possible result. In this case,
++the code sample's output is "<tt>0 -1</tt>".</p></li>
++</ol>
++<p>
++The two compilers I could get working with <tt>std::align</tt>, Visual Studio 2013 and Clang 3.4, implement #3. (Change <tt>%td</tt> to
++<tt>%Id</tt> on Visual Studio 2013 and earlier. 2014 and later will have <tt>%td</tt>.)
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2422"></a>2422. <tt>std::numeric_limits&lt;T&gt;::is_modulo</tt> description: "most machines" errata</h3>
++<p><b>Section:</b> 18.3.2.4 [numeric.limits.members] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Melissa Mears <b>Opened:</b> 2014-08-06 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The seemingly non-normative (?) paragraph 61 (referring to N3936) describing how "most machines" define
++<tt>std::numeric_limits&lt;T&gt;::is_modulo</tt> in [numeric.limits.members] appears to have some issues, in my opinion.
++</p>
++<blockquote>
++<p>
++-61- On most machines, this is <tt>false</tt> for floating types, <tt>true</tt> for unsigned integers, and <tt>true</tt>
++for signed integers.
++</p>
+ </blockquote>
++<p>
++Issues I see:
++</p>
++<ol>
++<li><p>Very minor: change clause 2 to "this is <tt>false</tt> for floating <ins>point</ins> types". Other uses of the term
++say "floating point types" rather than just "floating types" &mdash; see nearby <tt>is_iec559</tt>, <tt>tinyness_before</tt>,
++etc.</p></li>
++<li><p><tt>is_modulo</tt> <em>must</em> be <tt>true</tt> for unsigned integers in order to be compliant with the Standard;
++this is not just for "most machines". For reference, this requirement is from [basic.fundamental] paragraph 4 with its
++footnote 48.</p></li>
++<li><p>Depending on the definition of "most machines", <tt>is_modulo</tt> could be <tt>false</tt> for most machines' signed
++integer types. GCC, Clang and Visual Studio, the 3 most popular C++ compilers by far, by default treat signed integer overflow
++as undefined.</p></li>
++</ol>
++<p>
++As an additional note regarding the definition of <tt>is_modulo</tt>, it seems like it should be explicitly mentioned that
++on an implementation for which signed integer overflow is undefined, <tt>is_modulo</tt> shall be <tt>false</tt> for signed
++integer types. It took bugs filed for all three of these compilers before they finally changed (or planned to change)
++<tt>is_modulo</tt> to <tt>false</tt> for signed types.
++</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!x</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2014-12 telecon]</i></p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>(bool) x</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++HH: agree with the proposal, don't like the phrasing<br/>
++AM: second note feels a bit wooly<br/>
++WB: not even happy with the first note, notes shouldn't say "shall"<br/>
++JW: the original isn't very prescriptive because "on most machines" is not something the standard controls.<br/>
++AM: "On most machines" should become a note too?<br/>
++AM: first note is repeating something defined in core, shouldn't say it normatively here. Change "shall" to "is"?<br/>
++MC: don't like "signed integer overflow is left undefined" ... it's just plain undefined.<br/>
++AM: implementations can define what they do in that case and provide guarantees.<br/>
++WB: in paragraph 61, would like to see "this" replaced by "is_modulo"<br/>
++AM: Move to Open
++</p>
++
++<p><i>[2015-05-05 Lenexa]</i></p>
++
++<p>Marshall: I will contact the submitter to see if she can re-draft the Proposed Resolution</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Edit 18.3.2.4 [numeric.limits.members] around p60 as indicated:</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre>
+ <blockquote>
+-<ins>? <i>Requires:</i> The specialization <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;</tt>
+-shall be a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting])
+-on the pointer values.</ins>
++<pre>
++static constexpr bool is_modulo;
++</pre>
++<p>
++-60- True if the type is modulo.(footnote) A type is modulo if, for any operation involving <tt>+</tt>, <tt>-</tt>, or <tt>*</tt>
++on values of that type whose result would fall outside the range <tt>[min(),max()]</tt>, the value returned differs from
++the true value by an integer multiple of <tt>max() - min() + 1</tt>.
++<p/>
++<ins>-??- [<i>Note</i>: <tt>is_modulo</tt> shall be <tt>true</tt> for unsigned integer types (3.9.1 [basic.fundamental]). &mdash;
++<i>end note</i>]</ins>
++<p/>
++<ins>-??- [<i>Note</i>: <tt>is_modulo</tt> shall be <tt>false</tt> for types for which overflow is undefined on the implementation,
++because such types cannot meet the modulo requirement. Often, signed integer overflow is left undefined on implementations. &mdash;
++<i>end note</i>]</ins>
++<p/>
++-61- On most machines, this is <tt>false</tt> for floating <ins>point</ins> types<del>, <tt>true</tt> for unsigned integers,
++and <tt>true</tt> for signed integers</del>.
++<p/>
++-62- Meaningful for all specializations.
++</p>
+ </blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2423"></a>2423. Missing specification <tt>slice_array</tt>, <tt>gslice_array</tt>, <tt>mask_array</tt>, <tt>indirect_array</tt> copy constructor</h3>
++<p><b>Section:</b> 26.6.5 [template.slice.array], 26.6.7 [template.gslice.array], 26.6.8 [template.mask.array], 26.6.9 [template.indirect.array] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Akira Takahashi <b>Opened:</b> 2014-08-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.slice.array">issues</a> in [template.slice.array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I found a missing specification of the copy constructor of the following class templates:
++</p>
++<ul>
++<li><p><tt>slice_array</tt> (26.6.5 [template.slice.array])</p></li>
++<li><p><tt>gslice_array</tt> (26.6.7 [template.gslice.array])</p></li>
++<li><p><tt>mask_array</tt> (26.6.8 [template.mask.array])</p></li>
++<li><p><tt>indirect_array</tt> (26.6.9 [template.indirect.array])</p></li>
++</ul>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Before 26.6.5.2 [slice.arr.assign] insert a new sub-clause as indicated:</p>
++
++<p>
++<ins><b>-?- <tt>slice_array</tt> constructors [slice.arr.cons]</b></ins>
++</p>
+ <blockquote>
+-<ins>? <i>Returns</i>: <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;()(x.get(), nullptr)</tt>.</ins>
+-</blockquote></blockquote>
++<pre>
++<ins>slice_array(const slice_array&amp;);</ins>
++</pre>
++<p>
++<ins>-?- <i>Effects</i>: The constructed slice refers to the same <tt>valarray&lt;T&gt;</tt> object to which
++the argument slice refers.</ins>
++</p>
++</blockquote>
++</li>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++<li><p>Before 26.6.7.2 [gslice.array.assign] insert a new sub-clause as indicated:</p>
++
++<p>
++<ins><b>-?- <tt>gslice_array</tt> constructors [gslice.array.cons]</b></ins>
++</p>
++<blockquote>
++<pre>
++<ins>gslice_array(const gslice_array&amp;);</ins>
+ </pre>
++<p>
++<ins>-?- <i>Effects</i>: The constructed slice refers to the same <tt>valarray&lt;T&gt;</tt> object to which
++the argument slice refers.</ins>
++</p>
++</blockquote>
++</li>
++
++<li><p>Before 26.6.8.2 [mask.array.assign] insert a new sub-clause as indicated:</p>
++
++<p>
++<ins><b>-?- <tt>mask_array</tt> constructors [mask.array.cons]</b></ins>
++</p>
+ <blockquote>
+-<ins>? <i>Requires:</i> The specialization <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;</tt>
+-shall be a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting])
+-on the pointer values.</ins>
++<pre>
++<ins>mask_array(const mask_array&amp;);</ins>
++</pre>
++<p>
++<ins>-?- <i>Effects</i>: The constructed slice refers to the same <tt>valarray&lt;T&gt;</tt> object to which
++the argument slice refers.</ins>
++</p>
+ </blockquote>
++</li>
++
++<li><p>Before 26.6.9.2 [indirect.array.assign] insert a new sub-clause as indicated:</p>
++
++<p>
++<ins><b>-?- <tt>indirect_array</tt> constructors [indirect.array.cons]</b></ins>
++</p>
+ <blockquote>
+-<ins>? <i>Returns</i>: <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;()(nullptr, x.get())</tt>.</ins>
+-</blockquote></blockquote>
++<pre>
++<ins>indirect_array(const indirect_array&amp;);</ins>
++</pre>
++<p>
++<ins>-?- <i>Effects</i>: The constructed slice refers to the same <tt>valarray&lt;T&gt;</tt> object to which
++the argument slice refers.</ins>
++</p>
++</blockquote>
++</li>
++</ol>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!(nullptr &lt; x)</tt>.</ins>
+-</blockquote></blockquote>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!(x &lt; nullptr)</tt>.</ins>
+-</blockquote></blockquote>
+
+-</li>
+-<li>
+-Add the following series of prototype specifications at the very end of 20.9.9.4 [unique.ptr.special].
+-Intentionally, the relational operators are defined individually, because there is no guarantee that
+-from <tt>x.get() &lt; nullptr</tt> follows the relation <tt>nullptr &gt; x.get()</tt>:
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!x</tt>.</ins>
+-</blockquote></blockquote>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
+-<ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>(bool) x</tt>.</ins>
+-</blockquote></blockquote>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>x.get() &lt; nullptr</tt>.</ins>
+-</blockquote></blockquote>
++<hr>
++<h3><a name="2424"></a>2424. 29.5 should state that atomic types are not trivially copyable</h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#Review">Review</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2014-08-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Review">Review</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Otherwise, one could use <tt>memcpy</tt> to save and restore the value according to 3.9p2.
++<p/>
++It seems the core language rules in 9 [class]p6 with 12.8 [class.copy]p12
++(trivial copy constructor) etc. and 8.4.2 [dcl.fct.def.default]p5 (user-provided) say
++that the atomic types are trivially copyable, which is bad. We shouldn't rely on future core
++changes in that area and simply say in the library section 29.5 [atomics.types.generic]
++that these very special types are not trivially copyable.
++</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>nullptr &lt; x.get()</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2014-11 Urbana]</i></p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>x.get() &lt;= nullptr</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++Lawrence:Definition of "trivially copyable" has been changing.
++</p>
++<p>
++Doesn't hurt to add proposed change, even if the sentence is redundant
++</p>
++<p>
++Move to Review.
++</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>nullptr &lt;= x.get()</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2015-02 Cologne]</i></p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>x.get() &gt; nullptr</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++GR has a minor problem with the style of the wording. VV has major issues with implementability.
++</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>nullptr &gt; x.get()</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2015-03-22, Jens Maurer responses to Cologne discussion]</i></p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>x.get() &gt;= nullptr</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++A library implementation could provide a partial specialization for <tt>is_trivially_copyable&lt;atomic&lt;T&gt;&gt;</tt>,
++to ensure that any such type query would return <tt>false</tt>.
++<p/>
++Assuming such a specialization would be provided, how could a conforming program observe that per
++language rules an <tt>atomic</tt> specialization would actually be trivially copyable if there
++is no way to call the (deleted) copy constructor or copy assignment operator?
++<p/>
++The sole effect of the suggested addition of the constraining sentence is that it would make a user program
++non-conforming that attempts to invoke <tt>memcpy</tt> (and the like) on <tt>atomic</tt> types, since that
++would invoke undefined behaviour.
++</p>
+
+-<blockquote><pre><ins>template &lt;class T, class D&gt;</ins>
+-<ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>nullptr &gt;= x.get()</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++SG1 is fine with P/R (and agrees it's needed), but LWG may want to
++check the details; it's not entirely an SG1 issue.
++</p>
++
++<p><i>[2015-05-05 Lenexa]</i></p>
++
++<p>Marshall: This was discussed on the telecon. Alisdair was going to write something to Mike and send it to Core.</p>
++<p>Hwrd: Core says that deleted copies are trivially copyable, which makes no sense to Library people.</p>
++<p>STL: There doesn't appear to be a Core issue about it.</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Change 29.5 [atomics.types.generic]p3 as indicated:</p>
++
++<blockquote>
++<p>
++Specializations and instantiations of the <tt>atomic</tt> template shall have a deleted copy constructor, a deleted
++copy assignment operator, and a constexpr value constructor. <ins>They are not trivially copyable
++types (3.9 [basic.types]).</ins>
++</p>
++</blockquote>
+ </li>
+ </ol>
+-</li>
+-<li>Change 20.9.10.2 [util.smartptr.shared] p. 1, class template shared_ptr
+-synopsis as indicated. For consistency reasons the remaining normal relation
+-operators are added as well:
+-<blockquote><pre>namespace std {
+- [..]
+- // <i>20.9.11.2.7, shared_ptr comparisons:</i>
+- template&lt;class T, class U&gt;
+- bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+- template&lt;class T, class U&gt;
+- bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+- <ins>template&lt;class T, class U&gt;</ins>
+- <ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
+- <ins>template&lt;class T, class U&gt;</ins>
+- <ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
+- <ins>template&lt;class T, class U&gt;</ins>
+- <ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
+-
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&lt;class T&gt;</ins>
+- <ins>bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+- <ins>template&gt;class T&gt;</ins>
+- <ins>bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+
+- [..]
++
++
++
++
++<hr>
++<h3><a name="2426"></a>2426. Issue about <tt>compare_exchange</tt></h3>
++<p><b>Section:</b> 29.6.5 [atomics.types.operations.req] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2014-08-25 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.operations.req">active issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations.req">issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The standard is either ambiguous or misleading about the nature of accesses through the <tt>expected</tt> argument
++to the <tt>compare_exchange_*</tt> functions in 29.6.5 [atomics.types.operations.req]p21.
++<p/>
++It is unclear whether the access to <tt>expected</tt> is itself atomic (intent clearly no) and exactly when the implementation
++is allowed to read or write it. These affect the correctness of reasonable code.
++<p/>
++Herb Sutter, summarizing a complaint from Duncan Forster wrote:
++</p>
++<blockquote class="note">
++<p>
++Thanks Duncan,
++<p/>
++I think we have a bug in the standardese wording and the implementations are
++legal, but let's check with the designers of the feature.
++<p/>
++Let me try to summarize the issue as I understand it:
++</p>
++<ol>
++<li><p>
++What I think was intended: Lawrence, I believe you championed having
++<tt>compare_exchange_*</tt> take the <tt>expected</tt> value by reference, and update
++<tt>expected</tt> on failure to expose the old value, but this was only for convenience
++to simplify the calling loops which would otherwise always have to write an
++extra "reload" line of code. Lawrence, did I summarize your intent correctly?
++</p></li>
++<li><p>
++What I think Duncan is trying to do: However, it turns out that, now that
++<tt>expected</tt> is an lvalue, it has misled(?) Duncan into trying to use the success of
++<tt>compare_exchange_*</tt> to hand off ownership <em>of <tt>expected</tt> itself</em> to another
++thread. For that to be safe, if the <tt>compare_exchange_*</tt> succeeds then the
++thread that performed it must no longer read or write from <tt>expected</tt> else his
++technique contains a race. Duncan, did I summarize your usage correctly? Is
++that the only use that is broken?
++</p></li>
++<li><p>
++What the standard says: I can see why Duncan thinks the standard supports
++his use, but I don't think this was intended (I don't remember this being
++discussed but I may have been away for that part) and unless you tell me this
++was intended I think it's a defect in the standard. From 29.6.5 [atomics.types.operations.req]/21:
++</p>
++<blockquote><p>
++-21- <i>Effects</i>: Atomically, compares the contents of the memory pointed to by
++<tt>object</tt> or by <tt>this</tt> for equality with that in <tt>expected</tt>, and if true, replaces the
++contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> with that in <tt>desired</tt>, and
++if false, updates the contents of the memory in <tt>expected</tt> with the contents of
++the memory pointed to by <tt>object</tt> or by <tt>this</tt>. [&hellip;]
++</p></blockquote>
++<p>
++I think we have a wording defect here in any case, because the "atomically"
++should not apply to the entire sentence &mdash; I'm pretty sure we never intended the
++atomicity to cover the write to <tt>expected</tt>.
++<p/>
++As a case in point, borrowing from Duncan's mail below, I think the following
++implementation is intended to be legal:
++</p>
++<blockquote><pre>
++inline int _Compare_exchange_seq_cst_4(volatile _Uint4_t *_Tgt, _Uint4_t *_Exp, _Uint4_t _Value)
++{ /* compare and exchange values atomically with
++ sequentially consistent memory order */
++ int _Res;
++ _Uint4_t _Prev = _InterlockedCompareExchange((volatile long *)_Tgt, _Value, *_Exp);
++ <span style="color:#C80000">if (_Prev == *_Exp) //!!!!! Note the unconditional read from *_Exp here</span>
++ _Res = 1;
++ else
++ { /* copy old value */
++ _Res = 0;
++ *_Exp = _Prev;
++ }
++ return (_Res);
+ }
+ </pre></blockquote>
++<p>
++I think this implementation is intended to be valid &mdash; I think the only code that
++could be broken with the "!!!!!" read of <tt>*_Exp</tt> is Duncan's use of treating
++<tt>a.compare_exchange_*(expected, desired) == true</tt> as implying <tt>expected</tt> got
++handed off, because then another thread could validly be using <tt>*_Exp</tt> &mdash; but we
++never intended this use, right?
++</p>
+ </li>
+-<li>Add the following series of prototype specifications at the very end of 20.9.10.2.7 [util.smartptr.shared.cmp].
+-For mixed comparison the general "generation" rule of 20.3.1 [operators] p. 10 does not apply,
+-therefore all of them are defined. Below wording takes advantage of the simplified definition of the
+-<em>composite pointer type</em> if one partner is a null pointer constant:
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!a</tt>.</ins>
+-</blockquote></blockquote>
++</ol>
++</blockquote>
++<p>
++In a different thread Richard Smith wrote about the same problem:
++</p>
++<blockquote class="note">
++<p>
++The <tt>atomic_compare_exchange</tt> functions are described as follows:
++</p>
++<blockquote><p>
++"Atomically, compares the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt>
++for equality with that in <tt>expected</tt>, and if true, replaces the contents of the memory pointed to
++by <tt>object</tt> or by <tt>this</tt> with that in <tt>desired</tt>, and if false, updates the contents
++of the memory in <tt>expected</tt> with the contents of the memory pointed to by <tt>object</tt> or by
++<tt>this</tt>. Further, if the comparison is true, memory is affected according to the value of <tt>success</tt>,
++and if the comparison is false, memory is affected according to the value of <tt>failure</tt>."
++</p></blockquote>
++<p>
++I think this is less clear than it could be about the effects of these operations on <tt>*expected</tt> in the failure case:
++</p>
++<ol>
++<li><p>We have "Atomically, compares [&hellip;] and updates the contents of the memory in <tt>expected</tt> [&hellip;]".
++The update to the memory in <tt>expected</tt> is clearly not atomic, and yet this wording parallels the success case,
++in which the memory update is atomic.
++</p></li>
++<li><p>The wording suggests that memory (including <tt>*expected</tt>) is affected according to the value of <tt>failure</tt>.
++In particular, the failure order could be <tt>memory_order_seq_cst</tt>, which might lead someone to incorrectly think they'd
++published the value of <tt>*expected</tt>.</p></li>
++</ol>
++<p>
++I think this can be clarified with no change in meaning by reordering the wording a little:
++</p>
++<blockquote><p>
++"Atomically, compares the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> for equality with that in
++<tt>expected</tt>, and if true, replaces the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> with
++that in <tt>desired</tt><del>, and if</del><ins>. If the comparison is true, memory is affected according to the value of
++<tt>success</tt>, and if the comparison is false, memory is affected according to the value of <tt>failure</tt>. Further,
++if the comparison is</ins> false, <del>updates</del><ins>replaces</ins> the contents of the memory in <tt>expected</tt> with
++the <del>contents of</del><ins>value that was atomically read from</ins> the memory pointed to by <tt>object</tt> or by
++<tt>this</tt>. <del>Further, if the comparison is true, memory is affected according to the value of <tt>success</tt>, and
++if the comparison is false, memory is affected according to the value of <tt>failure</tt>.</del>"
++</p></blockquote>
++</blockquote>
++<p>
++Jens Maurer add:
++</p>
++<blockquote class="note">
++<p>
++I believe this is an improvement.
++<p/>
++I like to see the following additional improvements:
++</p>
++<ul>
++<li><p>
++"contents of the memory" is strange phrasing, which doesn't say how large the
++memory block is. Do we compare the values or the value representation of the lvalue
++<tt>*object</tt> (or <tt>*this</tt>)?
++</p></li>
++<li><p>
++29.3 [atomics.order] defines memory order based on the "affected memory location". It would be
++better to say something like "If the comparison is true, the memory synchronization order for the
++affected memory location <tt>*object</tt> is [&hellip;]"
++</p></li>
++</ul>
++</blockquote>
++<p>
++There was also a discussion thread involving Herb Sutter, Hans Boehm, and Lawrence Crowl, resulting in proposed
++wording along the lines of:
++</p>
++<blockquote class="note">
++<blockquote>
++<p>
++-21- <i>Effects</i>: Atomically with respect to <tt>expected</tt> and the memory pointed
++to by <tt>object</tt> or by <tt>this</tt>, compares the contents of the memory pointed
++to by <tt>object</tt> or by <tt>this</tt> for equality with that in <tt>expected</tt>, and if and
++only if true, replaces the contents of the memory pointed to by <tt>object</tt>
++or by <tt>this</tt> with that in desired, and if and only if false, updates the
++contents of the memory in expected with the contents of the memory pointed to by
++<tt>object</tt> or by <tt>this</tt>.
++</p>
++</blockquote>
++<p>
++At the end of paragraph 23, perhaps add
++</p>
++<blockquote>
++<p>
++[<i>Example</i>: Because the <tt>expected</tt> value is updated only on failure,
++code releasing the memory containing the <tt>expected</tt> value on success
++will work. E.g. list head insertion will act atomically and not
++have a data race in the following code.
++</p>
++<blockquote><pre>
++do {
++ p->next = head; // make new list node point to the current head
++} while(!head.compare_exchange_weak(p->next, p)); // try to insert
++</pre></blockquote>
++<p>
++&mdash; <i>end example</i>]
++</p>
++</blockquote>
++</blockquote>
++<p>
++Hans objected that this still gives the misimpression that the update to <tt>expected</tt> is atomic.
++</p>
+
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>(bool) a</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2014-11 Urbana]</i></p>
+
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>less&lt;T*&gt;()(a.get(), nullptr)</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++Proposed resolution was added after Redmond.
++</p>
++<p>
++Recommendations from SG1:
++</p>
++<ol>
++<li>Change wording to <del>if true</del><ins>if and only if true</ins>, and change <del>if false</del><ins>if and only if false</ins>.</li>
++<li>If they want to add "respect to" clause, say "respect to object or this".</li>
++<li>In example, load from head should be "head.load(memory_order_relaxed)", because people are going to use example as example of good code.</li>
++</ol>
+
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>less&lt;T*&gt;()(nullptr, a.get())</tt>.</ins>
+-</blockquote></blockquote>
++<p>
++<i>(wording edits not yet applied)</i>
++</p>
+
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!(nullptr &lt; a)</tt>.</ins>
+-</blockquote></blockquote>
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++We believed we were done with it, but it was kicked back to us, with the wording we suggested not yet applied. It may have been that our suggestions were unclear. Was that the concern?
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Edit 29.6.5 [atomics.types.operations.req] p21 as indicated:</p>
++
++<blockquote>
++<p>
++-21- <i>Effects</i>: <ins>Retrieves the value in <tt>expected</tt>. It then a</ins><del>A</del>tomically<del>,</del>
++compares the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> for equality with that
++<del>in</del><ins>previously retrieved from</ins> <tt>expected</tt>, and if true, replaces the contents of the
++memory pointed to by <tt>object</tt> or by <tt>this</tt> with that in <tt>desired</tt><del>, and if false,
++updates the contents of the memory in expected with the contents of the memory pointed to by <tt>object</tt>
++or by <tt>this</tt>. Further, if</del><ins>. If and only if</ins> the comparison is true, memory is affected according to the value of
++<tt>success</tt>, and if the comparison is false, memory is affected according to the value of <tt>failure</tt>.
++When only one <tt>memory_order</tt> argument is supplied, the value of <tt>success</tt> is <tt>order</tt>,
++and the value of <tt>failure</tt> is <tt>order</tt> except that a value of <tt>memory_order_acq_rel</tt>
++shall be replaced by the value <tt>memory_order_acquire</tt> and a value of <tt>memory_order_release</tt> shall
++be replaced by the value <tt>memory_order_relaxed</tt>. <ins>If the comparison is false then, after the atomic
++operation, the contents of the memory in <tt>expected</tt> are replaced by the value read from <tt>object</tt> or
++by <tt>this</tt> during the atomic comparison.</ins> If the operation returns true, these operations are
++atomic read-modify-write operations (1.10) <ins>on the memory pointed to by <tt>this</tt> or
++<tt>object</tt></ins>. Otherwise, these operations are atomic load operations <ins>on that memory</ins>.
++</p>
++</blockquote>
++</li>
+
+-<blockquote><pre><ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
+-<ins>template&lt;class T&gt;</ins>
+-<ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
+-</pre><blockquote>
+-<ins>? <i>Returns</i>: <tt>!(a &lt; nullptr)</tt>.</ins>
+-</blockquote></blockquote>
++<li><p>Add the following example to the end of 29.6.5 [atomics.types.operations.req] p23:</p>
+
++<blockquote>
++<p>
++-23- [<i>Note</i>: [&hellip;] &mdash; <i>end note</i>] [<i>Example</i>: [&hellip;] &mdash; <i>end example</i>]
++<p/>
++<ins>[<i>Example</i>: Because the expected value is updated only on failure,
++code releasing the memory containing the <tt>expected</tt> value
++on success will work. E.g. list head insertion will act atomically
++and would not introduce a data race in the following code:</ins>
++</p>
++<blockquote>
++<pre><ins>
++do {
++ p-i&gt;next = head; // make new list node point to the current head
++} while(!head.compare_exchange_weak(p-&gt;next, p)); // try to insert
++</ins></pre>
++</blockquote>
++<p>
++<ins>&mdash; <i>end example</i>]</ins>
++</p>
++</blockquote>
+ </li>
+ </ol>
+
+@@ -4976,171 +25454,485 @@ therefore all of them are defined. Below wording takes advantage of the simplifi
+
+
+
++
+ <hr>
+-<h3><a name="1408"></a>1408. [FCD] Allow recycling of pointers after <tt>undeclare_no_pointers</tt></h3>
+-<p><b>Section:</b> 20.9.11 [util.dynamic.safety] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
++<h3><a name="2430"></a>2430. Heterogeneous container lookup should be enabled using meta-function instead of nested type</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Tomasz Kami&nacute;ski <b>Opened:</b> 2014-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-103</b></p>
+ <p>
+-The precondition to calling <tt>declare_no_pointers</tt> is that no
+-bytes in the range "have been previously registered" with
+-this call. As written, this precondition includes bytes in
+-ranges, even after they have been explicitly unregistered
+-with a later call to <tt>undeclare_no_pointers</tt>.
++Currently the heterogeneous lookup in associative container are
++enabled by presence of <tt>is_transparent</tt> nested type in the comparator
++type (23.2.4 [associative.reqmts]). This complicates the definition
++of call wrapper types that want to define <tt>is_transparent</tt> if they wrap
++a callable type that defines <tt>is_transparent</tt>, and requires the target
++to be a complete type in cases where an incomplete type would otherwise be ok.
++<p/>
++Another problem is that users cannot add the <tt>is_transparent</tt> member to
++a third-party comparison type that they do not control, even if they
++know it supports heterogeneous comparisons.
++<p/>
++If the associative containers used a trait instead of checking for an
++<tt>is_transparent</tt> member type then it would avoid the requirement for
++complete types, and would allow customization of the trait without
++modifying the comparator type. This would also be consistent with the
++traits <tt>is_placeholder</tt> and <tt>is_bind_expression</tt>.
++<p/>
++For backward compatibility with the existing design, the default
++implementation of the <tt>is_transparent</tt> trait could depend on the
++presence of the <tt>is_transparent</tt> nested type.
+ </p>
+
++<p><i>[2014-11 Urbana]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
++<p>Move to LEWG</p>
+ <p>
+-Update 20.9.11 [util.dynamic.safety] p.9:
++Request for a new metafunction should first be responded to by LEWG.
+ </p>
+-<blockquote><pre>void declare_no_pointers(char *p, size_t n);
+-</pre><blockquote>
+-<tt>9</tt> <em>Requires</em>: No bytes in the specified range <del>have been
+-previously registered</del><ins>are currently registered</ins> with <tt>declare_no_pointers()</tt>.
+-If the specified range is in an allocated object, then it must be entirely within a single allocated object.
+-The object must be live until the corresponding <tt>undeclare_no_pointers()</tt> call. [..]
+-</blockquote></blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1413"></a>1413. [FCD] Specify whether <tt>high_resolution_clock</tt> is a distinct type or a typedef</h3>
+-<p><b>Section:</b> 20.11.5.3 [time.clock.hires] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">Tentatively NAD</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively NAD">Tentatively NAD</a> status.</p>
++<h3><a name="2431"></a>2431. Missing regular expression traits requirements</h3>
++<p><b>Section:</b> 28.3 [re.req] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-112</b></p>
+ <p>
+-What it means for <tt>high_resolution_clock</tt> to be a synonym
+-is undefined. If it may or may not be a typedef, then
+-certain classes of programs become unportable.
++The requirements on the traits class in 28.3 [re.req] do not say whether a
++regular expression traits class is required to be <tt>DefaultConstructible</tt>,
++<tt>CopyConstructible</tt>, <tt>CopyAssignable</tt> etc.
++<p/>
++The <tt>std::regex_traits</tt> class appears to be all of the above, but can
++<tt>basic_regex</tt> assume that for user-defined traits classes?
++<p/>
++Should the following statements all leave <tt>u</tt> in equivalent states?
++</p>
++<blockquote><pre>
++X u{v};
++X u; u = v;
++X u; u.imbue(v.getloc();
++</pre></blockquote>
++<p>
++Whether they are equivalent has implications for <tt>basic_regex</tt> copy construction and
++assignment.
+ </p>
+
+-<p><i>[
+-Resolution proposed in ballot comment
+-]</i></p>
+
+-<p>
+-Require that it be a distinct class type.
+-</p>
++<p><b>Proposed resolution:</b></p>
++
++
++
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
+
++<hr>
++<h3><a name="2432"></a>2432. <tt>initializer_list</tt> assignability</h3>
++<p><b>Section:</b> 18.9 [support.initlist] <b>Status:</b> <a href="lwg-active.html#EWG">EWG</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2014-09-30 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.initlist">active issues</a> in [support.initlist].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.initlist">issues</a> in [support.initlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#EWG">EWG</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-This is not a defect. Threre are a number of places in the standard where
+-we allow implentations to choose their preferred technique, the most obvious
+-example being the <tt>iterator</tt>/<tt>const_iterator</tt> types of <tt>set</tt>.
++<tt>std::initializer_list::operator=</tt> 18.9 [support.initlist] is horribly broken and it needs deprecation:
+ </p>
++<blockquote><pre>
++std::initializer_list&lt;foo&gt; a = {{1}, {2}, {3}};
++a = {{4}, {5}, {6}};
++// New sequence is already destroyed.
++</pre></blockquote>
+ <p>
+-Typically, this means it is not portable to declare function overloads that differ
+-only in their use of these types.
++Assignability of <tt>initializer_list</tt> isn't explicitly specified, but most implementations supply a default assignment
++operator. I'm not sure what 17.5 [description] says, but it probably doesn't matter.
+ </p>
+
++<p><i>[Lenexa 2015-05-05: Send to EWG as discussed in Telecon]</i></p>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+
++<ol>
++<li><p>Edit 18.9 [support.initlist] p1, class template <tt>initializer_list</tt> synopsis, as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template&lt;class E&gt; class initializer_list {
++ public:
++ [&hellip;]
++ constexpr initializer_list() noexcept;
++
++ <ins>initializer_list(const initializer_list&amp;) = default;</ins>
++ <ins>initializer_list(initializer_list&amp;&amp;) = default;</ins>
++ <ins>initializer_list&amp; operator=(const initializer_list&amp;) = delete;</ins>
++ <ins>initializer_list&amp; operator=(initializer_list&amp;&amp;) = delete;</ins>
++
++ constexpr size_t size() const noexcept;
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre>
++</blockquote>
++
++</li>
++</ol>
++
++
+
+
+
+
+ <hr>
+-<h3><a name="1418"></a>1418. [FCD] Effects of <tt>resize(size())</tt> on a <tt>deque</tt></h3>
+-<p><b>Section:</b> 23.3.2.2 [deque.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
++<h3><a name="2435"></a>2435. <tt>reference_wrapper::operator()</tt>'s Remark should be deleted</h3>
++<p><b>Section:</b> 20.9.4.4 [refwrap.invoke] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-113</b></p>
+ <p>
+-There is no mention of what happens if <tt>sz==size()</tt>. While
+-it obviously does nothing I feel a standard needs to say
+-this explicitely.
++20.9.4.4 [refwrap.invoke]/2 is no longer useful. (It was originally TR1 2.1.2.4 [tr.util.refwrp.invoke]/2.)
++First, we already have the As If Rule (1.9 [intro.execution]/1) and the STL Implementers Can Be Sneaky Rule
++(17.6.5.5 [member.functions]). Second, with variadic templates and other C++11/14 tech, this can be implemented
++exactly as depicted.
+ </p>
+
+-
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++<p><i>[2015-05, Lenexa]</i></p>
+
+ <p>
+-Accepted with a simplified resolution turning one of the <tt>&lt;</tt>
+-comparisons into <tt>&lt;=.</tt>
++DK: I don't see a defect here<br/>
++STL: the issue is that the standard is overly verbose, we don't need this sentence. It's redundant.<br/>
++MC: does anyone think this paragraph has value?<br/>
++JW: it has negative value. reading it makes me wonder if there's some reason I would want to provide a set of overloaded
++functions, maybe there's some problem with doing it the obvious way that I'm not clever enough to see.<br/>
++Move to Ready status: 8 in favor, none against.
+ </p>
+
++
+ <p><b>Proposed resolution:</b></p>
+-<p>Ammend [deque.capacity]</p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 20.9.4.4 [refwrap.invoke] p2 as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class... ArgTypes&gt;
++ result_of_t&lt;T&amp;(ArgTypes&amp;&amp;...)>
++ operator()(ArgTypes&amp;&amp;... args) const;
++</pre>
+ <blockquote>
+-</blockquote>
+-<p><tt>void resize(size_type sz);</tt></p>
+ <p>
+-<i>Effects</i>: If <tt>sz &lt;<ins>=</ins> size()</tt>, equivalent to <tt>erase(begin() +
+-sz, end());</tt>. If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> <del>default
+-constructed</del><ins>value initialized</ins> elements to the sequence.
++-1- <i>Returns</i>: <tt>INVOKE(get(), std::forward&lt;ArgTypes&gt;(args)...)</tt>. (20.9.2)
++<p/>
++<del>-2- <i>Remark</i>: <tt>operator()</tt> is described for exposition only. Implementations are not required to provide an
++actual <tt>reference_wrapper::operator()</tt>. Implementations are permitted to support <tt>reference_wrapper</tt> function
++invocation through multiple overloaded operators or through other means.</del>
+ </p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="1420"></a>1420. [FCD] Effects of <tt>resize(size())</tt> on a <tt>list</tt></h3>
+-<p><b>Section:</b> 23.3.4.2 [list.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.capacity">issues</a> in [list.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
++<h3><a name="2436"></a>2436. Comparators for associative containers should always be <tt>CopyConstructible</tt></h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-115</b></p>
+ <p>
+-There is no mention of what happens if <tt>sz==size()</tt>. While
+-it obviously does nothing I feel a standard needs to say
+-this explicitely.
++The associative container requirements attempt to permit comparators that are <tt>DefaultConstructible</tt>
++but non-<tt>CopyConstructible</tt>. However, the Standard contradicts itself. 23.4.4.1 [map.overview] depicts
++<tt>map() : map(Compare()) { }</tt> which requires both <tt>DefaultConstructible</tt> and <tt>CopyConstructible</tt>.
++<p/>
++Unlike fine-grained element requirements (which are burdensome for implementers, but valuable for users), such
++fine-grained comparator requirements are both burdensome for implementers (as the Standard's self-contradiction
++demonstrates) and worthless for users. We should unconditionally require <tt>CopyConstructible</tt> comparators.
++(Note that <tt>DefaultConstructible</tt> should remain optional; this is not problematic for implementers, and
++allows users to use lambdas.)
++<p/>
++Key equality predicates for unordered associative containers are also affected. However, 17.6.3.4 [hash.requirements]/1
++already requires hashers to be <tt>CopyConstructible</tt>, so 23.2.5 [unord.req]'s redundant wording should
++be removed.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++GR: I prefer to say "<tt>Compare</tt>" rather than "<tt>X::key_compare</tt>", since the former is what the user supplies.
++JY: It makes sense to use "<tt>Compare</tt>" when we talk about requirements but "<tt>key_compare</tt>" when we use it.
++<p/>
++AM: We're adding requirements here, which is a breaking change, even though nobody will ever have had a non-<tt>CopyConstructible</tt>
++comparator. But the simplification is probably worth it.
++<p/>
++GR: I don't care about unmovable containers. But I do worry that people might want to move they comparators. MC: How do
++you reconcile that with the function that says "give me the comparator"? GR: That one returns by value? JY: Yes. [To MC]
++You make it a requirement of that function. [To GR] And it [the <tt>key_comp()</tt> function] is missing its requirements.
++We need to add them everywhere. GR: map already has the right requirements.
++<p/>
++JM: I dispute this. If in C++98 a type wasn't copyable, it had some interesting internal state, but in C++98 you wouldn't
++have been able to pass it into the container since you would have had to make a copy. JY: No, you could have
++default-constructed it and never moved it, e.g. a mutex. AM: So, it's a design change, but one that we should make.
++That's probably an LEWG issue. AM: There's a contradiction in the Standard here, and we need to fix it one way or another.
++<p/>
++<b>Conclusion</b>: Move to LEWG
+ </p>
+
+-<p><i>[
+-Resolution proposed in ballot comment
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Express the semantics as pseudo-code similarly
+-to the way it is done for the copying overload that
+-follows (in p3). Include an else clause that does
+-nothing and covers the <tt>sz==size()</tt> case.
++This wording is relative to N3936.
+ </p>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++<ol>
++<li><p>Change 23.2.4 [associative.reqmts] Table 102 as indicated (Editorial note: For "expression" <tt>X::key_compare</tt>
++"defaults to" is redundant with the class definitions for map/etc.):</p>
+
+-<p>
+-Accepted with a simplified resolution turning one of the <tt>&lt;</tt>
+-comparisons into <tt>&lt;=.</tt>
+-</p>
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++<tr>
++<td>
++<tt>X::key_compare</tt>
++</td>
++<td>
++<tt>Compare</tt>
++</td>
++<td>
++<del>defaults to <tt>less&lt;key_type&gt;</tt></del><br/>
++<ins><i>Requires</i>: <tt>key_compare</tt> is <tt>CopyConstructible</tt>.</ins>
++</td>
++<td>
++compile time
++</td>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(c)<br/>
++X a(c);</tt>
++</td>
++<td>
++</td>
++<td>
++<del><i>Requires</i>: <tt>key_compare</tt> is <tt>CopyConstructible</tt>.</del><br/>
++<i>Effects</i>: Constructs an empty
++container. Uses a copy of <tt>c</tt> as
++a comparison object.
++</td>
++<td>
++constant
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(i,j,c)<br/>
++X a(i,j,c);</tt>
++</td>
++<td>
++</td>
++<td>
++<i>Requires</i>: <del><tt>key_compare</tt> is <tt>CopyConstructible</tt>.</del><br/>
++<tt>value_type</tt> is <tt>EmplaceConstructible</tt> into <tt>X</tt> from <tt>*i</tt>.<br/>
++<i>Effects</i>: Constructs [&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote></li>
++
++<li><p>Change 23.2.5 [unord.req] Table 103 as indicated:</p>
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Ammend [list.capacity] p1:
+-</p>
+-<blockquote>
+-<p><tt>void resize(size_type sz);</tt></p>
+ <blockquote>
+-<i>Effects</i>: If <tt>sz &lt;<ins>=</ins> size()</tt>, equivalent to <tt>list&lt;T&gt;::iterator
+-it = begin(); advance(it, sz); erase(it, end());</tt>. If
+-<tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> <del>default constructed</del>
+-<ins>value initialized</ins> elements to the sequence<del></del>.
+-</blockquote>
+-</blockquote>
++<table border="1">
++<caption>Table 103 &mdash; Unordered associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X::key_equal</tt>
++</td>
++<td>
++<tt>Pred</tt>
++</td>
++<td>
++<ins><i>Requires</i>: <tt>Pred</tt> is <tt>CopyConstructible</tt>.</ins><br/>
++<tt>Pred</tt> shall be a binary predicate that takes two arguments of type <tt>Key</tt>.<br/>
++<tt>Pred</tt> is an equivalence relation.
++</td>
++<td>
++compile time
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(n, hf, eq)<br/>
++X a(n, hf, eq);</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++<del><i>Requires</i>: <tt>hasher</tt> and <tt>key_equal</tt> are <tt>CopyConstructible</tt>.</del><br/>
++<i>Effects</i>: Constructs [&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(n, hf)<br/>
++X a(n, hf);</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++<i>Requires</i>: <del><tt>hasher</tt> is <tt>CopyConstructible</tt> and</del><br/>
++<tt>key_equal</tt> is <tt>DefaultConstructible</tt><br/>
++<i>Effects</i>: Constructs [&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(i, j, n, hf, eq)<br/>
++X a(i, j, n, hf, eq);</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++<i>Requires</i>: <del><tt>hasher</tt> and <tt>key_equal</tt> are <tt>CopyConstructible</tt>.</del><br/>
++<tt>value_type</tt> is <tt>EmplaceConstructible</tt> into <tt>X</tt> from <tt>*i</tt>.<br/>
++<i>Effects</i>: Constructs [&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(i, j, n, hf)<br/>
++X a(i, j, n, hf);</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++<i>Requires</i>: <del><tt>hasher</tt> is <tt>CopyConstructible</tt> and</del><br/>
++<tt>key_equal</tt> is <tt>DefaultConstructible</tt><br/>
++<tt>value_type</tt> is <tt>EmplaceConstructible</tt> into <tt>X</tt> from <tt>*i</tt>.<br/>
++<i>Effects</i>: Constructs [&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote></li>
++</ol>
+
+
+
+@@ -5148,213 +25940,333 @@ it = begin(); advance(it, sz); erase(it, end());</tt>. If
+
+
+ <hr>
+-<h3><a name="1421"></a>1421. [FCD] Accidental move-only library types due to new core language rules</h3>
+-<p><b>Section:</b> 23.5 [container.adaptors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a></p>
++<h3><a name="2441"></a>2441. Exact-width atomic typedefs should be provided</h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses DE-22, CH-15</b></p>
+ <p>
+-With the final acceptance of move operations as special
+-members and introduction of corresponding suppression
+-rules of implicitly generated copy operations the some
+-library types that were copyable in C++03 are no longer
+-copyable (only movable) in C++03, among them <tt>queue</tt>,
+-<tt>priority_queue</tt>, and <tt>stack</tt>.
++<tt>&lt;atomic&gt;</tt> doesn't provide counterparts for <tt>&lt;inttypes.h&gt;</tt>'s most useful typedefs, possibly
++because they're quasi-optional. We can easily fix this.
+ </p>
+
+-<p><i>[
+-2010-10-26: Daniel comments:
+-]</i></p>
++<p><i>[2014-11, Urbana]</i></p>
+
++<p>
++Typedefs were transitional compatibility hack. Should use <tt>_Atomic</tt> macro or template.
++E.g. <tt>_Atomic(int8_t)</tt>. BUT <tt>_Atomic</tt> disappeared!</p>
+
+ <p>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3112.pdf">n3112</a> should fix this.
++Detlef will look for <tt>_Atomic</tt> macro. If missing, will open issue.
+ </p>
+
++<p><i>[2014-11-25, Hans comments]</i></p>
++
++<p>
++There is no <tt>_Atomic</tt> in C++. This is related to the much more general unanswered question of whether C++17
++should reference C11, C99, or neither.
++</p>
+
++<p><i>[2015-02 Cologne]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3112.pdf">n3112</a>
++<p>
++AM: I think this is still an SG1 issue; they need to deal with it before we do.
++</p>
+
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
+
++<p>
++Move to SG1-OK status. This seems like an easy short-term fix. We probably need a paper on C/C++ atomics compatibility to deal with _Atomic, but that's a separable issue.
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
+
+-<hr>
+-<h3><a name="1438"></a>1438. [FCD] No definition for <tt>base()</tt></h3>
+-<p><b>Section:</b> 26.5.4.1 [rand.adapt.disc] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Ready</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.adapt.disc">issues</a> in [rand.adapt.disc].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Ready">Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-126</b></p>
++<ol>
++<li><p>Change 29.5 [atomics.types.generic] p8 as depicted:</p>
+
+-Each adaptor has a member function called <tt>base()</tt> which has no definition.
++<blockquote>
++<p>
++-8- There shall be atomic typedefs corresponding to the typedefs in the header <tt>&lt;inttypes.h&gt;</tt> as specified in
++Table 147. <ins><tt>atomic_int<i>N</i>_t</tt>, <tt>atomic_uint<i>N</i>_t</tt>, <tt>atomic_intptr_t</tt>, and
++<tt>atomic_uintptr_t</tt> shall be defined if and only if <tt>int<i>N</i>_t</tt>, <tt>uint<i>N</i>_t</tt>, <tt>intptr_t</tt>,
++and <tt>uintptr_t</tt> are defined, respectively.</ins>
++</p>
++</blockquote></li>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<li><p>Change 29.6.5 [atomics.types.operations.req], Table 147 ("<tt>atomic</tt> <tt>&lt;inttypes.h&gt;</tt>
++typedefs"), as depicted:</p>
+
+ <blockquote>
+-Give it the obvious definition.
+-</blockquote>
++<table border="1">
++<caption>Table 147 &mdash; <tt>atomic</tt> <tt>&lt;inttypes.h&gt;</tt> typedefs</caption>
++<tr>
++<th>Atomic typedef</th>
++<th><tt>&lt;inttypes.h&gt;</tt> type</th>
++</tr>
+
+-<p><i>[
+-2010-11-03 Daniel comments and provides a proposed resolution:
+-]</i></p>
++<tr>
++<td>
++<ins><tt>atomic_int8_t</tt></ins>
++</td>
++<td>
++<ins><tt>int8_t</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td>
++<ins><tt>atomic_uint8_t</tt></ins>
++</td>
++<td>
++<ins><tt>uint8_t</tt></ins>
++</td>
++</tr>
+
+-<p>The following proposal adds <tt>noexcept</tt> specifiers to the declarations of
+-the <tt>base()</tt> functions as replacement for a "<i>Throws</i>: Nothing" element.
+-</p>
++<tr>
++<td>
++<ins><tt>atomic_int16_t</tt></ins>
++</td>
++<td>
++<ins><tt>int16_t</tt></ins>
++</td>
++</tr>
+
+-<p><i>[
+-2010 Batavia: The working group reviewed this issue, and recommended to add the following to the Proposed Resolution.
+-</i></p><ul><li><i>
+-Append to paragraph 1 of [rand.req.adapt] (or at the Editor's discretion insert as a new paragraph following that paragraph):
+-The expression <tt>a.base()</tt> shall be valid and shall return a const reference to <tt>a</tt>'s base engine.
+-</i></li><i>
+-</i></ul><i>
+-After further review, the working group concurred with the Proposed Resolution.
+-]</i><p></p>
++<tr>
++<td>
++<ins><tt>atomic_uint16_t</tt></ins>
++</td>
++<td>
++<ins><tt>uint16_t</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td>
++<ins><tt>atomic_int32_t</tt></ins>
++</td>
++<td>
++<ins><tt>int32_t</tt></ins>
++</td>
++</tr>
+
+-<p><i>[Batavia: waiting for WEB to review wording]</i></p>
++<tr>
++<td>
++<ins><tt>atomic_uint32_t</tt></ins>
++</td>
++<td>
++<ins><tt>uint32_t</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td>
++<ins><tt>atomic_int64_t</tt></ins>
++</td>
++<td>
++<ins><tt>int64_t</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td>
++<ins><tt>atomic_uint64_t</tt></ins>
++</td>
++<td>
++<ins><tt>uint64_t</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-Add the following sentence to the end of 26.5.1.5 [rand.req.adapt]/1:
+-<blockquote>
+-A <i>random number engine adaptor</i> (commonly shortened to <i>adaptor</i>) <tt>a</tt> of type <tt>A</tt> is a
+-random number engine that takes values produced by some other random number engine, and applies an algorithm to
+-those values in order to deliver a sequence of values with different randomness properties. An engine <tt>b</tt>
+-of type <tt>B</tt> adapted in this way is termed a <i>base engine</i> in this context.<ins> The expression
+-<tt>a.base()</tt> shall be valid and shall return a const reference to <tt>a</tt>'s base engine.</ins>
+-</blockquote>
+-</li>
+-<li>Change in [rand.adapt.disc]/3, class template <tt>discard_block_engine</tt> synopsis, the following declaration:
+-<blockquote><pre>// <em>property functions</em>
+-const Engine&amp; base() const <ins>noexcept</ins>;
+-</pre></blockquote>
+-</li>
+-<li>Add the following new prototype description at the end of sub-clause 26.5.4.1 [rand.adapt.disc]:
+-<blockquote>
+-<pre><ins>const Engine&amp; base() const noexcept;</ins>
+-</pre>
+-<blockquote>
+-<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
+-</blockquote>
+-</blockquote>
+-</li>
+-<li>Change in [rand.adapt.ibits]/4, class template <tt>independent_bits_engine</tt> synopsis, the following declaration:
+-<blockquote><pre>// <em>property functions</em>
+-const Engine&amp; base() const <ins>noexcept</ins>;
+-</pre></blockquote>
+-</li>
+-<li>Add the following new prototype description at the end of sub-clause 26.5.4.2 [rand.adapt.ibits]:
+-<blockquote>
+-<pre><ins>const Engine&amp; base() const noexcept;</ins>
+-</pre>
+-<blockquote>
+-<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
++</table>
+ </blockquote>
+-</blockquote>
+-</li>
+-<li>Change in 26.5.4.3 [rand.adapt.shuf]/3, class template <tt>shuffle_order_engine</tt> synopsis, the following declaration:
+-<blockquote><pre>// <em>property functions</em>
+-const Engine&amp; base() const <ins>noexcept</ins>;
+-</pre></blockquote>
+ </li>
+-<li>Add the following new prototype description at the end of sub-clause 26.5.4.3 [rand.adapt.shuf]:
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2443"></a>2443. <tt>std::array</tt> member functions should be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Peter Sommerlad <b>Opened:</b> 2014-10-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++When experimenting with C++14 relaxed <tt>constexpr</tt> functions I made the observation that I couldn't
++use <tt>std::array</tt> to create a table of data at compile time directly using loops in a function.
++However, a simple substitute I could use instead:
++</p>
+ <blockquote>
+-<pre><ins>const Engine&amp; base() const noexcept;</ins>
++<pre>
++template &lt;typename T, size_t n&gt;
++struct ar {
++ T a[n];
++ constexpr ar() : a{{}}{}
++ constexpr auto data() const { return &amp;a[0];}
++ constexpr T const &amp; operator[](size_t i) const { return a[i]; }
++ constexpr T &amp; operator[](size_t i) { return a[i]; }
++};
++
++template &lt;size_t n&gt;
++using arr = ar&lt;size_t, n&gt;; // std::array&lt;size_t, n&gt;;
++
++template &lt;size_t n&gt;
++constexpr auto make_tab(){
++ arr&lt;n&gt; result;
++ for(size_t i=0; i &lt; n; ++i)
++ result[i] = (i+1)*(i+1); // cannot define operator[] for mutable array...
++ return result;
++}
++
++template &lt;size_t n&gt;
++constexpr auto squares=make_tab&lt; n&gt;();
++
++int main() {
++ int dummy[squares&lt;5&gt;[3]];
++}
+ </pre>
+-<blockquote>
+-<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
+ </blockquote>
+-</blockquote>
+-</li>
+-</ol>
++<p>
++Therefore, I suggest that all member functions of <tt>std::array</tt> should be made <tt>constexpr</tt>
++to make the type usable in <tt>constexpr</tt> functions.
++<p/>
++Wording should be straight forward, may be with the exception of <tt>fill</tt>, which would require
++<tt>fill_n</tt> to be <tt>constexpr</tt> as well.
++</p>
++
++<p><i>[2014-11 Urbana]</i></p>
++
++<p>Move to LEWG</p>
++<p>
++The extent to which <tt>constexpr</tt> becomes a part of the Library design is a policy
++matter best handled initially by LEWG.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1448"></a>1448. [FCD] Concerns about <tt>basic_stringbuf::str(basic_string)</tt> postconditions</h3>
+-<p><b>Section:</b> 27.8.1.3 [stringbuf.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2444"></a>2444. Inconsistent complexity for <tt>std::sort_heap</tt></h3>
++<p><b>Section:</b> 25.4.6.4 [sort.heap] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Fran&ccedil;ois Dumont <b>Opened:</b> 2014-10-07 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-124</b></p>
+-
+ <p>
+-N3092 27.8.1.3 [stringbuf.members] contains this textcspecifying the postconditions of
+-<tt>basic_stringbuf::str(basic_string)</tt>:
++While creating complexity tests for the GNU libstdc++ implementation <a href="https://gcc.gnu.org/ml/libstdc++/2014-10/msg00048.html">I
++stumbled</a> across a surprising requirement for the <tt>std::sort_heap</tt> algorithm.
++<p/>
++In 25.4.6.4 [sort.heap] p3 the Standard states:
+ </p>
+-<blockquote>
+-Postconditions: If <tt>mode &amp; ios_base::out</tt> is <tt>true</tt>,
+-<tt>pbase()</tt> points to the first underlying character and <tt>epptr() &gt;=
+-pbase() + s.size()</tt> holds; in addition, if <tt>mode &amp; ios_base::in</tt>
+-is <tt>true</tt>, <tt>pptr() == pbase() + s.data()</tt> holds, otherwise
+-<tt>pptr() == pbase()</tt> is <tt>true</tt>. [...]
+-</blockquote>
++<blockquote><p>
++<i>Complexity</i>: At most <tt><i>N</i> log(<i>N</i>)</tt> comparisons (where <tt><i>N</i> == last - first</tt>).
++</p></blockquote>
+ <p>
+-Firstly, there's a simple mistake: It should be <tt>pbase() + s.length()</tt>,
+-not <tt>pbase() + s.data()</tt>.
++As stated on the libstdc++ mailing list by Marc Glisse <tt>sort_heap</tt> can be implemented by <tt><i>N</i></tt> calls to
++<tt>pop_heap</tt>. As max number of comparisons of <tt>pop_heap</tt> is <tt>2 * log(<i>N</i>)</tt> then <tt>sort_heap</tt>
++max limit should be <tt>2 * log(1) + 2 * log(2) + .... + 2 * log(<i>N</i>)</tt> that is to say <tt>2 * log(<i>N</i>!)</tt>.
++In terms of <tt>log(<i>N</i>)</tt> we can also consider that this limit is also cap by <tt>2 * <i>N</i> * log(<i>N</i>)</tt>
++which is surely what the Standard wanted to set as a limit.
++<p/>
++This is why I would like to propose to replace paragraph 3 by:
+ </p>
++<blockquote><p>
++<i>Complexity</i>: At most <tt><ins>2</ins><i>N</i> log(<i>N</i>)</tt> comparisons (where <tt><i>N</i> == last - first</tt>).
++</p></blockquote>
++
++<p><i>[2015-02 Cologne]</i></p>
++
+ <p>
+-Secondly, it doesn't match existing implementations. As far as I can tell,
+-GCC 4.5 does not test for <tt>mode &amp; ios_base::in</tt> in the second part
+-of that sentence, but for <tt>mode &amp; (ios_base::app | ios_base_ate)</tt>,
+-and Visual C++ 9 for <tt>mode &amp; ios_base::app</tt>. Besides, the wording of
+-the C++0x draft doesn't make any sense to me. I suggest changing the second part
+-of the sentence to one of the following:
++Marshall will research the maths and report back in Lenexa.
+ </p>
++
++<p><i>[2015-05-06 Lenexa]</i></p>
++
++<p>STL: I dislike exact complexity requirements, they prevent one or two extra checks in debug mode. Would it be better to say O(N log(N)) not at most?</p>
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Replace <tt>ios_base::in</tt> with <tt>(ios_base::ate | ios_base::app)</tt>,
+-but this would require Visual C++ to change (replacing only with
+-<tt>ios_base::ate</tt> would require GCC to change, and would make
+-<tt>ios_base::app</tt> completely useless with <tt>stringstreams</tt>):
++This wording is relative to N3936.
+ </p>
++
++<ol><li>
+ <p>
+-in addition, if <tt>mode &amp; (ios_base::ate | ios_base::app)</tt> is <tt>true</tt>,
+-<tt>pptr() == pbase() + s.length()</tt> holds, otherwise <tt>pptr() == pbase()</tt>
+-is <tt>true</tt>.
++In 25.4.6.4 [sort.heap] p3 the Standard states:
+ </p>
++<blockquote>
++<pre>
++template&lt;class RandomAccessIterator&gt;
++ void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
++template&lt;class RandomAccessIterator, class Compare&gt;
++ void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
++ Compare comp);
++</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-3- <i>Complexity</i>: At most <tt><ins>2</ins><i>N</i> log(<i>N</i>)</tt> comparisons (where <tt><i>N</i> == last - first</tt>).
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2445"></a>2445. "Stronger" memory ordering</h3>
++<p><b>Section:</b> 20.8.2.6 [util.smartptr.shared.atomic], 29.6.5 [atomics.types.operations.req] <b>Status:</b> <a href="lwg-active.html#SG1">SG1</a>
++ <b>Submitter:</b> JF Bastien <b>Opened:</b> 2014-10-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.atomic">issues</a> in [util.smartptr.shared.atomic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#SG1">SG1</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Leave <tt>pptr()</tt> unspecified if <tt>mode &amp; ios_base::app</tt>, but not
+-<tt>mode &amp; ios_base::ate</tt> (implementations already differ in this case, and it
+-is always possible to use <tt>ios_base::ate</tt> to get the effect of appending, so it
+-is not necessary to require any implementation to change):
++The definitions of compare and exchange in 20.8.2.6 [util.smartptr.shared.atomic] p32 and
++29.6.5 [atomics.types.operations.req] p20 state:
+ </p>
++<blockquote><p>
++<i>Requires</i>: The failure argument shall not be <tt>memory_order_release</tt> nor <tt>memory_order_acq_rel</tt>.
++The <tt>failure</tt> argument shall be no stronger than the <tt>success</tt> argument.
++</p></blockquote>
+ <p>
+-in addition, if <tt>mode &amp; ios_base::ate</tt> is <tt>true</tt>,
+-<tt>pptr() == pbase() + s.length()</tt> holds, if neither <tt>mode &amp; ios_base::ate</tt>
+-nor <tt>mode &amp; ios_base::app</tt> is <tt>true</tt>, <tt>pptr() == pbase()</tt> holds,
+-otherwise <tt>pptr() &gt;= pbase() &amp;&amp; pptr() &lt;= pbase() + s.length()</tt>
+-(which of the values in this range is unspecified).
++The term "stronger" isn't defined by the standard.
++<p/>
++It is hinted at by 29.6.5 [atomics.types.operations.req] p21:
+ </p>
++<blockquote><p>
++When only one <tt>memory_order</tt> argument is supplied, the value of <tt>success</tt> is <tt>order</tt>, and the
++value of <tt>failure</tt> is <tt>order</tt> except that a value of <tt>memory_order_acq_rel</tt> shall be replaced
++by the value <tt>memory_order_acquire</tt> and a value of <tt>memory_order_release</tt> shall be replaced by the
++value <tt>memory_order_relaxed</tt>.
++</p></blockquote>
+ <p>
+-Slightly stricter:
++Should the standard define a partial ordering for memory orders, where consume and acquire are incomparable with release?
+ </p>
++
++<p><i>[2014-11 Urbana]</i></p>
++
+ <p>
+-in addition, if <tt>mode &amp; ios_base::ate</tt> is <tt>true</tt>,
+-<tt>pptr() == pbase() + s.length()</tt> holds, if neither
+-<tt>mode &amp; ios_base::ate</tt> nor <tt>mode &amp; ios_base::app</tt> is <tt>true</tt>,
+-<tt>pptr() == pbase()</tt> holds, otherwise <tt>pptr() == pbase() || pptr() == pbase() + s.length()</tt>
+-(which of these two values is unspecified). A small table might help to better explain the three cases.
+-BTW, at the end of the postconditions is this text: "<tt>egptr() == eback() + s.size()</tt> hold".
+-Is there a perference for <tt>basic_string::length</tt> or <tt>basic_string::size</tt>? It doesn't really
+-matter, but it looks a bit inconsistent.
++Move to SG1.
+ </p>
+
+
+@@ -5365,362 +26277,508 @@ matter, but it looks a bit inconsistent.
+
+
+ <hr>
+-<h3><a name="1450"></a>1450. [FCD] Contradiction in regex_constants</h3>
+-<p><b>Section:</b> 28.5.2 [re.matchflag] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Deferred">Deferred</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Deferred">Deferred</a> status.</p>
++<h3><a name="2446"></a>2446. Unspecialized <tt>std::tuple_size</tt> should be defined</h3>
++<p><b>Section:</b> 20.4.1 [tuple.general] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Nevin Liber <b>Opened:</b> 2014-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-127</b></p>
+-
+-The Bitmask Type requirements in 17.5.2.1.3 [bitmask.types] p.3 say that
+-all elements on a bitmask type have distinct values, but
+-28.5.2 [re.matchflag] defines <tt>regex_constants::match_default</tt> and
+-<tt>regex_constants::format_default</tt> as elements of the
+-bitmask type <tt>regex_constants::match_flag_type</tt>, both with
+-value 0. This is a contradiction.
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+-<blockquote>
+-One of the bitmask elements should be removed
+-from the declaration and should be defined
+-separately, in the same manner as
+-<tt>ios_base::adjustfield</tt>, <tt>ios_base::basefield</tt> and
+-<tt>ios_base::floatfield</tt> are defined by 27.5.2.1.2 [ios::fmtflags] p.2
+-and Table 120. These are constants of a bitmask
+-type, but are not distinct elements, they have
+-more than one value set in the bitmask.
+-<tt>regex_constants::format_default</tt> should be
+-specified as a constant with the same value as
+-<tt>regex_constants::match_default</tt>.
+-</blockquote>
++<p>
++In 20.4.1 [tuple.general] paragraph 2, the unspecialized <tt>std::tuple_size</tt> is undefined. It would
++be a lot more useful with SFINAE if it were defined as an empty struct; that way, it can be used with <tt>enable_if</tt>
++for determining whether or not it is valid to use <tt>tuple_size</tt>, <tt>tuple_element</tt> and get on the
++corresponding data structure.
++</p>
+
+-<p><i>[
+-2010-10-31 Daniel comments:
+-]</i></p>
++<p><i>[2014-11 Urbana]</i></p>
+
++<p>Moved to LEWG 42.</p>
+ <p>
+-Strictly speaking, a bitmask type cannot have any element of value 0 at all, because
+-any such value would contradict the requirement expressed in 17.5.2.1.3 [bitmask.types] p. 3:
+-</p><blockquote>
+-for any pair <em>Ci</em> and <em>Cj</em>, <em>Ci</em> &amp; <em>Ci</em> is nonzero
+-</blockquote>
+-So, actually <em>both</em> <tt>regex_constants::match_default</tt> and
+-<tt>regex_constants::format_default</tt> are only constants of the type
+-<tt>regex_constants::match_flag_type</tt>, and no bitmask elements.
+-<p></p>
+-
+-<p><i>[
+-2010-11-03 Daniel comments and provides a proposed resolution:
+-]</i></p>
++This request goes beyond simply making an API respond well to SFINAE, but coupling that with an
++implication for other tuple APIs. The proper place for such design discussions is LEWG.
++</p>
+
+
+-<p>The proposed resolution is written against N3126 and considered as a further improvement
+-of the fixes suggested by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3110.html">n3110</a>.
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
+ </p>
+
++<ol>
++<li><p>Change 20.4.1 [tuple.general] p2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated</p>
++<blockquote>
++<pre>
++[&hellip;]
++// <i>20.4.2.5, tuple helper classes</i>:
++template &lt;class T&gt; class tuple_size; <del>// undefined</del>
++[&hellip;]
++</pre>
++</blockquote>
++</li>
+
+-<p><b>Proposed resolution:</b></p>
+-Add the following sentence to 28.5.2 [re.matchflag] paragraph 1:
++<li><p>Change 20.4.2.5 [tuple.helper] as indicated</p>
+ <blockquote>
+-1 The type <tt>regex_constants::match_flag_type</tt> is an implementation-defined bitmask type (17.5.2.1.3).
+-Matching a regular expression against a sequence of characters [first,last) proceeds according to the
+-rules of the grammar specified for the regular expression object, modified according to the effects listed in
+-Table 136 for any bitmask elements set. <ins>Type <tt>regex_constants::match_flag_type</tt> also defines the
+-constants <tt>regex_constants::match_default</tt> and <tt>regex_constants::format_default</tt>.</ins>
++<pre>
++[&hellip;]
++template &lt;class T&gt; struct tuple_size <ins>{ }</ins>;
++[&hellip;]
++</pre>
+ </blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1452"></a>1452. [FCD] "target sequence" is not defined</h3>
+-<p><b>Section:</b> 28.10.4 [re.results.acc] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-01</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.results.acc">issues</a> in [re.results.acc].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2447"></a>2447. Allocators and <tt>volatile</tt>-qualified value types</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-10-16 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-125</b></p>
+-
+-The term "target sequence" is not defined (28.10.4 [re.results.acc] p. 2).
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+ <p>
+-Replace "target sequence" with "string being searched/matched"
++According to Table 27 &mdash; "Descriptive variable definitions" which is used to define the symbols used in the
++allocator requirements table within 17.6.3.5 [allocator.requirements] we have the following constraints for
++the types <tt>T, U, C</tt>:
++</p>
++<blockquote><p>
++any non-const object type (3.9)
++</p></blockquote>
++<p>
++This wording can be read to allow instead a <tt>volatile</tt>-qualified value type such as <tt>volatile int</tt>.
++<p/>
++The nearest-by way of fixing this would be to add "non-<tt>volatile</tt>" as additional constraint to this table
++row.
++<p/>
++Another choice would be to think of requiring that allocators must be capable to handle any <tt><i>cv</i></tt>-qualified
++value types. This would make all currently existing allocators non-conforming that can't handle <tt><i>cv</i></tt>-qualified
++value types, so I'm not suggesting to follow that route.
++<p/>
++A less radical step would be to allow <tt><ii>cv</ii></tt>-qualified types just for <tt>C</tt> (which is used to specify the
++functions <tt>construct</tt> and <tt>destroy</tt> and where does not even exist any requirement that <tt>C</tt> actually
++is related to the value type of the allocator at all). This seemingly extension would be harmless because as of p8 of the
++same sub-clause "An allocator may constrain the types on which it can be instantiated and the arguments for which its
++<tt>construct</tt> member may be called."
++<p/>
++This differs from the requirements imposed on the types <tt>T</tt> and <tt>U</tt> which both refer to value types of allocators.
++<p/>
++The proposed wording attempts to separate the two classes of requirements.
+ </p>
+
+-<p><i>[
+-2010-11-01 Daniel comments:
+-]</i></p>
+-
+ <p>
+-The proposed resolution looks incomplete to me, there are more normative
+-usages of the term <em>target sequence</em> in clause 28, e.g.
+-28.12.2 [re.tokiter] p. 7.
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>
++This wording is relative to N4140.
+ </p>
+
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements], Table 27 &mdash; "Descriptive variable definitions", as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 27 &mdash; Descriptive variable definitions</caption>
++<tr>
++<th>Variable</th>
++<th>Definition</th>
++</tr>
++
++<tr>
++<td>
++<tt>T, U<del>, C</del></tt>
++</td>
++<td>
++any non-<del>const</del><ins><tt>const</tt> and non-<tt>volatile</tt></ins> object type (3.9)
++</td>
++</tr>
+
++<tr>
++<td>
++<ins><tt>C</tt></ins>
++</td>
++<td>
++<ins>any object type</ins>
++</td>
++</tr>
+
+-<p><b>Proposed resolution:</b></p>
+-Wording changes are against N3126. They are intended not to conflict with the wording changes
+-suggested by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a>.
+-<p>
+-Change 28.10.4 [re.results.acc] p. 2 as indicated:
+-</p><blockquote><pre>difference_type position(size_type sub = 0) const;
+-</pre><blockquote>
+-2 <em>Returns</em>: The distance from the start of the <del>target sequence</del><ins>string being matched</ins> to <tt>(*this)[sub].first</tt>.
+-</blockquote></blockquote>
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>Change 17.6.3.5 [allocator.requirements] p8 as indicated: (This wording change is intended to
++fix an obvious asymmetry between <tt>construct</tt> and <tt>destroy</tt> which I believe is not intended)</p>
+
++<blockquote><p>
++-8- An allocator may constrain the types on which it can be instantiated and the arguments for which its
++<tt>construct</tt> <ins>or <tt>destroy</tt></ins> member<ins>s</ins> may be called. If a type cannot be
++used with a particular allocator, the allocator class or the call to <tt>construct</tt> <ins>or <tt>destroy</tt></ins>
++may fail to instantiate.
++</p></blockquote>
++</li>
++</ol>
+
++</blockquote>
+
++<p><i>[2014-11, Urbana]</i></p>
+
++<p>
++JW: say "cv-unqualified" instead?<br/>
++JW: very nervous about allowing construct on const-types, because of the cast to (non-const) <tt>void*</tt><br/>
++MA: should we just make the minimal fix?<br/>
++STL: don't break <tt>C</tt> out for special treatment<br/>
++New proposed resolution: just change "non-const" to "cv-unqualified". Keep addition of <tt>destroy</tt> later.
++</p>
+
+-<hr>
+-<h3><a name="1456"></a>1456. [FCD] Missing fixed-size atomic_ typedefs</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-129</b></p>
++<p><i>[2015-02 Cologne]</i></p>
+
+-Table 143 lists the typedefs for various atomic types
+-corresponding to the various standard integer typedefs,
+-such as atomic_int_least8_t for int_least8_t, and
+-atomic_uint_fast64_t for uint_fast64_t. However, there are
+-no atomic typedefs corresponding to the fixed-size
+-standard typedefs int8_t, int16_t, and so forth.
++<p>
++GR: It makes me nervous that someone at some point decided to not add "non-<tt>volatile</tt>".<br/>
++AM: That was over ten years ago. It was a deliberate, minuted choice to support <tt>volatile</tt>. We are now reversing that decision.
++It would be good to poll our vendors, none of which are in the room. This is a bit more work than we expect of a P0 issue.<br/>
++VV: libstdc++ and libc++ seem to support <tt>volatile</tt> template parameters for the standard allocator.<br/>
++AM: To clarify, the proposed resolution here would remove the requirement to support <tt>volatile</tt>. Implementations could still
++choose to support <tt>volatile</tt>.<br/>
++DK: I'm happy to drop this and open a new issue in regard to the <tt>destroy</tt> member specification.<br/>
++AM: I just think this is harder than a P0. Let's reprioritize.
++</p>
+
+-<p><i>[
+-2010-10-24 Daniel adds:
+-]</i></p>
++<p><i>[2015-04-01 Daniel comments]</i></p>
+
++<p>
++The less controversial part of the issue related to constraints imposed on <tt>destroy</tt> has be handed over to the new
++issue <a href="lwg-defects.html#2470">2470</a>.
++</p>
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue.
+-</blockquote>
++<p><i>[2015-05-06 Lenexa: Move to Ready]</i></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add the following entries to table 143:
++<p>
++This wording is relative to N4431.
++</p>
+
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements], Table 27 &mdash; "Descriptive variable definitions", as indicated:</p>
+ <blockquote>
+ <table border="1">
+-<caption>Table 143 — Atomics for standard typedef types</caption>
+-<tbody><tr>
+-<th>atomic typedef name</th>
+-<th><tt>&lt;cstdint&gt;</tt> typedef name</th>
+-</tr>
+-<tr>
+-<td><tt>...</tt></td>
+-<td><tt>...</tt></td>
+-</tr>
+-<tr>
+-<td><tt>atomic_uintmax_t</tt></td>
+-<td><tt>uintmax_t</tt></td>
+-</tr>
+-<tr>
+-<td><ins><tt>atomic_int8_t</tt></ins></td>
+-<td><ins><tt>int8_t</tt> (optional)</ins></td>
+-</tr>
+-<tr>
+-<td><ins><tt>atomic_int16_t</tt></ins></td>
+-<td><ins><tt>int16_t</tt> (optional)</ins></td>
+-</tr>
+-<tr>
+-<td><ins><tt>atomic_int32_t</tt></ins></td>
+-<td><ins><tt>int32_t</tt> (optional)</ins></td>
+-</tr>
+-<tr>
+-<td><ins><tt>atomic_int64_t</tt></ins></td>
+-<td><ins><tt>int64_t</tt> (optional)</ins></td>
+-</tr>
+-<tr>
+-<td><ins><tt>atomic_uint8_t</tt></ins></td>
+-<td><ins><tt>uint8_t</tt> (optional)</ins></td>
+-</tr>
++<caption>Table 27 &mdash; Descriptive variable definitions</caption>
+ <tr>
+-<td><ins><tt>atomic_uint16_t</tt></ins></td>
+-<td><ins><tt>uint16_t</tt> (optional)</ins></td>
++<th>Variable</th>
++<th>Definition</th>
+ </tr>
++
+ <tr>
+-<td><ins><tt>atomic_uint32_t</tt></ins></td>
+-<td><ins><tt>uint32_t</tt> (optional)</ins></td>
++<td>
++<tt>T, U, C</tt>
++</td>
++<td>
++any <del>non-const</del><ins><i>cv</i>-unqualified</ins> object type (3.9)
++</td>
+ </tr>
++
+ <tr>
+-<td><ins><tt>atomic_uint64_t</tt></ins></td>
+-<td><ins><tt>uint64_t</tt> (optional)</ins></td>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
+ </tr>
+-</tbody></table>
+-</blockquote>
++
++</table>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1457"></a>1457. [FCD] Splitting lock-free properties</h3>
+-<p><b>Section:</b> 29.2 [atomics.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2449"></a>2449. <tt>vector::insert</tt> invalidates <tt>end()</tt>?</h3>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Marc Glisse <b>Opened:</b> 2014-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-130</b></p>
+-
+-The synopsis for the <tt>&lt;atomic&gt;</tt> header lists the macros
+-<tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> and <tt>ATOMIC_ADDRESS_LOCK_FREE</tt>.
+ <p>
+-The <tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> macro has been replaced with a set of macros
+-for each integral type, as listed in 29.4 [atomics.lockfree].
++this issue is based on the discussion <a href="https://groups.google.com/a/isocpp.org/d/topic/std-discussion/oYvKscnl280/discussion">here</a>.
++<p/>
++23.3.6.5 [vector.modifiers] says about <tt>vector::insert</tt>: "If no reallocation happens, all the iterators and references
++before the insertion point remain valid." This doesn't seem to guarantee anything about the iterator <em>at</em> the point of insertion.
++<p/>
++The question comes from people asking if the following is valid, assuming a sufficient call to <tt>reserve()</tt> was done first:
++</p>
++<blockquote><pre>
++v.insert(v.end(), v.begin(), v.end());
++</pre></blockquote>
++<p>
++It could fail for an implementation using a sentinel for the end of the vector, but I don't know of any (it would be quite
++inconvenient). And for any implementation using a simple position as iterator (pointer (possibly in a wrapper), or base+offset),
++this is needlessly restrictive. The fact that this alternative:
++</p>
++<blockquote><pre>
++v.insert(v.end(), &amp;v[0], &amp;v[0]+v.size())
++</pre></blockquote>
++<p>
++is arguably valid (again assuming a large enough <tt>reserve()</tt>) makes it a bit confusing that the first version isn't
++(23.2.3 [sequence.reqmts] has a precondition that iterator arguments to <tt>insert()</tt> do not point into the sequence,
++but <tt>vector::insert</tt> is more refined and seems to give enough guarantees that it cannot fail).
++<p/>
++Then we might as well say that <tt>vector</tt> iterators act as positions, and that after a reallocation-free operation an
++iterator points to the same position, whatever may be there now&hellip;
+ </p>
+
+
+-<p><i>[
+-2010-10-26: Daniel adds:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
++
+
+
++
++
++<hr>
++<h3><a name="2450"></a>2450. <tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</h3>
++<p><b>Section:</b> 20.9.6 [comparisons] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2014-10-30 <b>Last modified:</b> 2015-05-06</p>
++<p><b>View other</b> <a href="lwg-index-open.html#comparisons">active issues</a> in [comparisons].</p>
++<p><b>View all other</b> <a href="lwg-index.html#comparisons">issues</a> in [comparisons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-The proposed resolution below is against the FCD working draft. After application
+-of the editorial issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US144">US-144</a>
+-and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US146">US-146</a> the remaining difference
+-against the working draft is the usage of <em>implementation-defined</em> instead of <em>unspecified</em>, effectively
+-resulting in this delta:
++<tt>less&lt;void&gt;::operator(t, u)</tt> (and the same applies to the rest of <tt>void</tt> specializations for standard
++comparison function objects) returns <tt>t &lt; u</tt> even if <tt>t</tt> and <tt>u</tt> are pointers, which by
++5.9 [expr.rel]/3 is undefined except if both pointers point to the same array or object. This might be
++regarded as a specification defect since the intention of N3421 is that <tt>less&lt;&gt;</tt> can substitute for
++<tt>less&lt;T&gt;</tt> in any case where the latter is applicable. <tt>less&lt;void&gt;</tt> can be rewritten in
++the following manner to cope with pointers:
++</p>
++<blockquote><pre>
++template&lt;&gt; struct less&lt;void&gt;
++{
++
++ typedef <i>unspecified</i> is_transparent;
++
++ template &lt;class T, class U&gt;
++ struct pointer_overload : std::is_pointer&lt;std::common_type_t&lt;T, U&gt;&gt;
++ {};
++
++ template &lt;
++ class T, class U,
++ typename std::enable_if&lt;!pointer_overload&lt;T, U&gt;::value&gt;::type* = nullptr
++ &gt;
++ auto operator()(T&amp;&amp; t, U&amp;&amp; u) const
++ -&gt; decltype(std::forward&lt;T&gt;(t) &lt; std::forward&lt;U&gt;(u))
++ {
++ return std::forward&lt;T&gt;(t) &lt; std::forward&lt;U&gt;(u);
++ }
++
++ template &lt;
++ class T, class U,
++ typename std::enable_if&lt;pointer_overload&lt;T, U>::value>::type* = nullptr
++ &gt;
++ auto operator()(T&amp;&amp; t, U&amp;&amp; u) const
++ -&gt; decltype(std::declval&lt;std::less&lt;std::common_type_t&lt;T, U&gt;&gt;&gt;()(std::forward&lt;T&gt;(t), std::forward&lt;U&gt;(u)))
++ {
++ std::less&lt;std::common_type_t&lt;T, U&gt;&gt; l;
++ return l(std::forward&lt;T&gt;(t), std::forward&lt;U&gt;(u));
++ }
+
+-</p><blockquote><pre>// 29.4, lock-free property
+-#define ATOMIC_CHAR_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_CHAR16_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_CHAR32_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_WCHAR_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_SHORT_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_INT_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_LONG_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_LLONG_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
+-#define ATOMIC_ADDRESS_LOCK_FREE <em>unspecified</em>
++};
+ </pre></blockquote>
+-<p></p>
+
++<blockquote class="note">
+ <p>
+-It is my understanding that the intended wording should be <em>unspecified</em> as for <tt>ATOMIC_ADDRESS_LOCK_FREE</tt>
+-but if this is right, we need to use the same wording in 29.4 [atomics.lockfree], which consequently uses
+-the term <em>implementation-defined</em>. I recommend to keep 29.2 [atomics.syn] as it currently is and to
+-fix 29.4 [atomics.lockfree] instead as indicated (against N3126):
++This wording is relative to N4140.
+ </p>
++
++<ol>
++<li><p>Change 20.9.6 [comparisons] p14 as indicated:</p>
++<blockquote><p>
++-14- For templates <tt>greater</tt>, <tt>less</tt>, <tt>greater_equal</tt>, and <tt>less_equal</tt>, the specializations
++for any pointer type yield a total order, even if the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>, <tt>&lt;=</tt>,
++<tt>&gt;=</tt> do not. <ins>For template specializations <tt>greater&lt;void&gt;</tt>, <tt>less&lt;void&gt;</tt>,
++<tt>greater_equal&lt;void&gt;</tt>, and <tt>less_equal&lt;void&gt;</tt>, the call operator with arguments whose common
++type <tt><i>CT</i></tt> is a pointer yields the same value as the corresponding comparison function object class
++specialization for <tt><i>CT</i></tt>.</ins>
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-02, Cologne]</i></p>
++
+ <p>
+-New proposed resolution:
++AM: Is there any way this will be resolved elsewhere? VV: No. AM: Then we should bite the bullet and deal with it here.
++<p/>
++MC: These diamond operators are already ugly. Making them more ugly isn't a big problem.
++<p/>
++JY found some issue with types that are convertible, and will reword.
++<p/>
++Jeffrey suggests improved wording.
+ </p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
+ <p>
+-Change 29.4 [atomics.lockfree] as indicated:
+-</p><blockquote><pre>#define ATOMIC_CHAR_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_CHAR16_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_CHAR32_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_WCHAR_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_SHORT_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_INT_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_LONG_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_LLONG_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-#define ATOMIC_ADDRESS_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
+-</pre></blockquote>
+-<p></p>
++STL: when diamond functions designed, this was on purpose<br/>
++STL: this does go against the original design<br/>
++STL: library is smarter and can give a total order<br/>
++MC: given that the original design rejected this, give back to LEWG<br/>
++STL: original proposal did not talk about total order<br/>
++STL: don't feel strongly about changing the design<br/>
++STL: no objections to taking this issue with some wording changes if people want it<br/>
++MC: not happy with wording, comparing pointers &mdash; what does that mean?<br/>
++STL: needs careful attention to wording<br/>
++STL: want to guarantee that <tt>nullptr</tt> participates in total ordering<br/>
++STL: all hooks into composite pointer type<br/>
++MC: move from new to open with better wording<br/>
++STL: to check updates to issue after Lenexa
++</p>
++
++
+ <p><b>Proposed resolution:</b></p>
+-Against FCD, N3092:
+ <p>
+-In [atomics.syn], header <tt>&lt;atomic&gt;</tt> synopsis replace as indicated:
++This wording is relative to N4296.
++</p>
++
++<ol>
++<li><p>Change 20.9.6 [comparisons] p14 as indicated:</p>
++<blockquote><p>
++-14- For templates <tt>greater</tt>, <tt>less</tt>, <tt>greater_equal</tt>, and <tt>less_equal</tt>, the specializations
++for any pointer type yield a total order, even if the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>, <tt>&lt;=</tt>,
++<tt>&gt;=</tt> do not. <ins>For template specializations <tt>greater&lt;void&gt;</tt>, <tt>less&lt;void&gt;</tt>,
++<tt>greater_equal&lt;void&gt;</tt>, and <tt>less_equal&lt;void&gt;</tt>, if the call operator calls a built-in operator
++comparing pointers, the call operator yields a total order.</ins>
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2451"></a>2451. [fund.ts] <tt>optional&lt;T&gt;</tt> should 'forward' <tt>T</tt>'s implicit conversions</h3>
++<p><b>Section:</b> X [optional.object] <b>Status:</b> <a href="lwg-active.html#LEWG">LEWG</a>
++ <b>Submitter:</b> Geoffrey Romer <b>Opened:</b> 2014-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#LEWG">LEWG</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++Code such as the following is currently ill-formed (thanks to STL for the compelling example):
+ </p>
+-<blockquote><pre>// 29.4, lock-free property
+-<del>#define ATOMIC_INTEGRAL_LOCK_FREE <em>unspecified</em></del>
+-<ins>#define ATOMIC_CHAR_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_CHAR16_T_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_CHAR32_T_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_WCHAR_T_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_SHORT_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_INT_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_LONG_LOCK_FREE <em>implementation-defined</em></ins>
+-<ins>#define ATOMIC_LLONG_LOCK_FREE <em>implementation-defined</em></ins>
+-#define ATOMIC_ADDRESS_LOCK_FREE <em>unspecified</em>
++<blockquote><pre>
++optional&lt;string&gt; opt_str = "meow";
+ </pre></blockquote>
++<p>
++This is because it would require two user-defined conversions (from <tt>const char*</tt> to <tt>string</tt>,
++and from <tt>string</tt> to <tt>optional&lt;string&gt;</tt>) where the language permits only one. This is
++likely to be a surprise and an inconvenience for users.
++<p/>
++<tt>optional&lt;T&gt;</tt> should be implicitly convertible from any <tt>U</tt> that is implicitly convertible
++to <tt>T</tt>. This can be implemented as a non-explicit constructor template <tt>optional(U&amp;&amp;)</tt>,
++which is enabled via SFINAE only if <tt>is_convertible_v&lt;U, T&gt;</tt> and <tt>is_constructible_v&lt;T, U&gt;</tt>,
++plus any additional conditions needed to avoid ambiguity with other constructors (see
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4064.html">N4064</a>, particularly the
++"Odd" example, for why <tt>is_convertible</tt> and <tt>is_constructible</tt> are both needed; thanks to Howard
++Hinnant for spotting this).
++<p/>
++In addition, we may want to support explicit construction from <tt>U</tt>, which would mean providing a corresponding
++explicit constructor with a complementary SFINAE condition (this is the single-argument case of the "perfect
++initialization" pattern described in N4064).
++</p>
++
+
+
++<p><b>Proposed resolution:</b></p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1459"></a>1459. [FCD] Overlapping evaluations are allowed</h3>
+-<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a></p>
++<h3><a name="2452"></a>2452. <tt>is_constructible</tt>, etc. and default arguments</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#Core">Core</a>
++ <b>Submitter:</b> Hubert Tong <b>Opened:</b> 2014-11-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Core">Core</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CA-21, GB-131</b></p>
++<p>
++The <tt>BaseCharacteristic</tt> for <tt>is_constructible</tt> is defined in terms of the well-formedness
++of a declaration for an invented variable. The well-formedness of the described declaration itself may
++change for the same set of arguments because of the introduction of default arguments.
++<p/>
++In the following program, there appears to be conflicting definitions of a specialization of
++<tt>std::is_constructible</tt>; however, it seems that this situation is caused without a user violation
++of the library requirements or the ODR. There is a similar issue with <tt>is_convertible</tt>, <tt>result_of</tt>
++and others.
++<p/>
++a.cc:
++</p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++struct A { A(int, int); };
++const std::false_type&amp; x1 = std::is_constructible&lt;A, int&gt;();
+
+-29.4 [atomics.lockfree] p.8 states:
+-<p></p><blockquote>
+-An atomic store shall only store a value that has
+-been computed from constants and program input values
+-by a finite sequence of program evaluations, such
+-that each evaluation observes the values of variables
+-as computed by the last prior assignment in the
+-sequence.
+-</blockquote><p></p>
++int main() { }
++</pre></blockquote>
+ <p>
+-... but 1.9 [intro.execution] p.13 states:
++b.cc:
+ </p>
+-<p></p><blockquote>
+-If A is not sequenced before B and B is not
+-sequenced before A, then A and B are unsequenced.
+-[ <em>Note</em>: The execution of unsequenced
+-evaluations can overlap. — <em>end note</em> ]
+-</blockquote><p></p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++struct A { A(int, int); };
++
++inline A::A(int, int = 0) { }
++
++const std::true_type&amp; x2 = std::is_constructible&lt;A, int&gt;();
++</pre></blockquote>
+ <p>
+-Overlapping executions can make it impossible to
+-construct the sequence described in 29.4 [atomics.lockfree] p.8. We are not
+-sure of the intention here and do not offer a suggestion for
+-change, but note that 29.4 [atomics.lockfree] p.8 is the condition that prevents
+-out-of-thin-air reads.
++Presumably this program should invoke undefined behaviour, but the Library specification doesn't
++say that.
+ </p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
+ <p>
+-For an example, suppose we have a function invocation
+-f(e1,e2). The evaluations of e1 and e2 can overlap.
+-Suppose that the evaluation of e1 writes y and reads x
+-whereas the evaluation of e2 reads y and writes x, with
+-reads-from edges as below (all this is within a single
+-thread).
+-</p><pre> e1 e2
+-Wrlx y-- --Wrlx x
+- rf\ /rf
+- X
+- / \
+-Rrlx x&lt;- -&gt;Rrlx y
+-</pre>
+-This seems like it should be allowed, but there seems to
+-be no way to produce a sequence of evaluations with the
+-property above.
+-<p></p>
+-In more detail, here the two evaluations, e1 and e2, are
+-being executed as the arguments of a function and are
+-consequently not sequenced-before each other. In
+-practice we'd expect that they could overlap (as allowed
+-by 1.9 [intro.execution] p.13), with the two writes taking effect before the two
+-reads. However, if we have to construct a linear order of
+-evaluations, as in 29.4 [atomics.lockfree] p.8, then the execution above is not
+-permited. Is that really intended?
++Core wording should say "this kind of thing is ill-formed, no diagnostic required"
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
+
++<hr>
++<h3><a name="2453"></a>2453. [iterator.range] and now [iterator.container] aren't available via <tt>&lt;initializer_list&gt;</tt></h3>
++<p><b>Section:</b> 18.9 [support.initlist], 24.7 [iterator.range], 24.8 [iterator.container] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-11-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.initlist">active issues</a> in [support.initlist].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.initlist">issues</a> in [support.initlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Please clarify.
++These sections define helper functions, some of which apply to <tt>initializer_list&lt;T&gt;</tt>. And they're
++available if you include one of a long list of header files, many of which include <tt>&lt;initializer_list&gt;</tt>.
++But they are not available if you include <tt>&lt;initializer_list&gt;</tt>. This seems very odd.
+ </p>
++<blockquote><pre>
++#include &lt;initializer_list&gt;
++auto x = {1, 2, 3};
++const int *p = data(x); // error, undeclared
++#include &lt;vector&gt;
++const int *q = data(x); // ok
++</pre></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -5730,399 +26788,793 @@ Please clarify.
+
+
+ <hr>
+-<h3><a name="1460"></a>1460. [FCD] Missing lock-free property for type <tt>bool</tt> should be added</h3>
+-<p><b>Section:</b> 29.4 [atomics.lockfree] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.lockfree">issues</a> in [atomics.lockfree].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2456"></a>2456. Incorrect exception specifications for '<tt>swap</tt>' throughout library</h3>
++<p><b>Section:</b> 20.2 [utility], 20.3.2 [pairs.pair], 20.4 [tuple], 23.3.2 [array], 23.6.3 [queue], 23.6.4 [priority.queue], 23.6.5 [stack] <b>Status:</b> <a href="lwg-active.html#Open">Open</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-11-14 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Open">Open</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-154</b></p>
+-
+-There is no <tt>ATOMIC_BOOL_LOCK_FREE</tt> macro.
++<p>
++We have this antipattern in various library classes:
++</p>
++<blockquote><pre>
++void swap(priority_queue&amp; q) noexcept(
++ noexcept(swap(c, q.c)) &amp;&amp; noexcept(swap(comp, q.comp)))
++</pre></blockquote>
++<p>
++This doesn't work. The unqualified lookup for 'swap' finds the member named 'swap', and that suppresses ADL,
++so the exception specification is always ill-formed because you can't call the member 'swap' with two arguments.
++<p/>
++Relevant history on the core language side:
++<p/>
++This used to be ill-formed due to 3.3.7 [basic.scope.class] p1 rule 2: "A name <tt>N</tt> used in a class
++<tt>S</tt> shall refer to the same declaration in its context and when re-evaluated in the completed scope of <tt>S</tt>.
++No diagnostic is required for a violation of this rule."
++<p/>
++Core issue 1330 introduced delay-parsing for exception specifications. Due to the 3.3.7 [basic.scope.class] rules,
++this shouldn't have changed the behavior of any conforming programs. But it changes the behavior in the non-conforming
++case from "no diagnostic required" to "diagnostic required", so implementations that implement core issue 1330 are now
++required to diagnose the ill-formed declarations in the standard library.
++<p/>
++Suggested resolution:
++<p/>
++Add an <tt>is_nothrow_swappable</tt> trait, and use it throughout the library in place of these <tt>noexcept</tt> expressions.
++</p>
+
++<p><i>[2015-02, Cologne]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+-Add <tt>ATOMIC_BOOL_LOCK_FREE</tt> to 29.4 [atomics.lockfree] and to 29.2 [atomics.syn]:
+ <p>
+-</p><blockquote><pre>[..]
+-<ins>#define ATOMIC_BOOL_LOCK_FREE <em>unspecified</em></ins>
+-#define ATOMIC_CHAR_LOCK_FREE <em>unspecified</em>
+-#define ATOMIC_CHAR16_T_LOCK_FREE <em>unspecified</em>
+-#define ATOMIC_CHAR32_T_LOCK_FREE <em>unspecified</em>
+-[..]
+-</pre></blockquote>
+-<p></p>
++No action for now; we intend to have papers for Lenexa.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++Move to Open.
++<p/>
++Daniel: A first paper (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4426.html">N4426</a>) exists
++to suggest some ways of solving this issue.
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
+
+
+-<hr>
+-<h3><a name="1461"></a>1461. [FCD] Rename all <tt>ATOMIC_*</tt> macros as <tt>STD_ATOMIC_*</tt></h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CA-1</b></p>
+
+-All <tt>ATOMIC_</tt>... macros should be prefixed with <tt>STD_</tt> as
+-in <tt>STD_ATOMIC_</tt>... to indicate they are <tt>STD</tt> macros as
+-other standard macros. The rationale that they all seem too long seems weak.
+
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>Change sub-clause 29.2 [atomics.syn] as indicated:
++<hr>
++<h3><a name="2457"></a>2457. <tt>std::begin()</tt> and <tt>std::end()</tt> do not support multi-dimensional arrays correctly</h3>
++<p><b>Section:</b> 24.7 [iterator.range] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Janez &#x17d;emva <b>Opened:</b> 2014-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#iterator.range">active issues</a> in [iterator.range].</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.range">issues</a> in [iterator.range].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-</p><blockquote><pre>[..]
+-// <em>29.4, lock-free property</em>
+-#define <ins>STD_</ins>ATOMIC_CHAR_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_CHAR16_T_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_CHAR32_T_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_WCHAR_T_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_SHORT_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_INT_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_LONG_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_LLONG_LOCK_FREE <em>unspecified</em>
+-#define <ins>STD_</ins>ATOMIC_ADDRESS_LOCK_FREE <em>unspecified</em>
++The following code:
++</p>
++<blockquote><pre>
++#include &lt;algorithm&gt;
++#include &lt;iterator&gt;
++#include &lt;iostream&gt;
++#include &lt;cassert&gt;
+
+-// <em>29.6, operations on atomic types</em>
+-#define <ins>STD_</ins>ATOMIC_VAR_INIT(value) <em>see below</em>
+-[..]
+-</pre></blockquote>
+-<p></p>
+-</li>
+-<li>
+-Change 29.4 [atomics.lockfree] p. 1 as indicated:
+-<blockquote><pre>#define <ins>STD_</ins>ATOMIC_CHAR_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_CHAR16_T_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_CHAR32_T_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_WCHAR_T_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_SHORT_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_INT_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_LONG_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_LLONG_LOCK_FREE <em>implementation-defined</em>
+-#define <ins>STD_</ins>ATOMIC_ADDRESS_LOCK_FREE <em>implementation-defined</em>
+-</pre><blockquote>
+-1 The <tt><ins>STD_</ins>ATOMIC_..._LOCK_FREE</tt> macros indicate the lock-free property of the corresponding atomic types, [..]
+-</blockquote></blockquote>
+-</li>
+-<li>
+-Change 29.6 [atomics.types.operations] p. 5 as indicated:
+-<blockquote><pre>#define <ins>STD_</ins>ATOMIC_VAR_INIT(value) <em>see below</em>
+-</pre><blockquote>
+-5 <em>Remarks</em>: A macro that expands to a token sequence suitable for initializing an atomic variable of
+-a type that is initializion-compatible with value. Concurrent access to the variable being initialized,
+-even via an atomic operation, constitutes a data race. [ <em>Example:</em>
+-<blockquote><pre>atomic_int v = <ins>STD_</ins>ATOMIC_VAR_INIT(5);
+-</pre></blockquote>
+-— <em>end example</em> ]
+-</blockquote></blockquote>
+-</li>
+-<li>
+-Change 29.7 [atomics.flag] p. 1+4 as indicated:
+-<blockquote><pre>namespace std {
+- [..]
+- #define <ins>STD_</ins>ATOMIC_FLAG_INIT <em>see below</em>
++int main()
++{
++ int a[2][3][4] = { { { 1, 2, 3, 4}, { 5, 6, 7, 8}, { 9, 10, 11, 12} },
++ { {13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24} } };
++ int b[2][3][4];
++
++ assert(std::distance(std::begin(a), std::end(a)) == 2 * 3 * 4);
++ std::copy(std::begin(a), std::end(a), std::begin(b));
++ std::copy(std::begin(b), std::end(b), std::ostream_iterator&lt;int&gt;(std::cout, ","));
+ }
+-</pre><blockquote>
+-[..]
+-4 The macro <tt><ins>STD_</ins>ATOMIC_FLAG_INIT</tt> shall be defined in such a way that it can be used to initialize an object of
+-type <tt>atomic_flag</tt> to the clear state. For a static-duration object, that initialization shall be static. It is
+-unspecified whether an unitialized <tt>atomic_flag</tt> object has an initial state of set or clear. [ <em>Example:</em>
+-<blockquote><pre>atomic_flag guard = <ins>STD_</ins>ATOMIC_FLAG_INIT;
+ </pre></blockquote>
+-— <em>end example</em> ]
+-</blockquote></blockquote>
+-</li>
+-</ol>
+-
++<p>
++does not compile.
++<p/>
++A possible way to remedy this would be to add the following overloads of
++<tt>begin</tt>, <tt>end</tt>, <tt>rbegin</tt>, and <tt>rend</tt> to 24.7 [iterator.range],
++relying on recursive evaluation:
++</p>
++<blockquote><pre>
++namespace std {
+
++ template &lt;typename T, size_t M, size_t N&gt;
++ constexpr remove_all_extents_t&lt;T&gt;*
++ begin(T (&amp;array)[M][N])
++ {
++ return begin(*array);
++ }
++
++ template &lt;typename T, size_t M, size_t N&gt;
++ constexpr remove_all_extents_t&lt;T&gt;*
++ end(T (&amp;array)[M][N])
++ {
++ return end(array[M - 1]);
++ }
+
++ template &lt;typename T, size_t M, size_t N&gt;
++ reverse_iterator&lt;remove_all_extents_t&lt;T&gt;*&gt;
++ rbegin(T (&amp;array)[M][N])
++ {
++ return decltype(rbegin(array))(end(array[M - 1]));
++ }
++
++ template &lt;typename T, size_t M, size_t N&gt;
++ reverse_iterator&lt;remove_all_extents_t&lt;T&gt;*&gt;
++ rend(T (&amp;array)[M][N])
++ {
++ return decltype(rend(array))(begin(*array));
++ }
+
++}
++</pre></blockquote>
+
+-<hr>
+-<h3><a name="1474"></a>1474. [FCD] weak compare-and-exchange confusion</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a></p>
+-<p><b>Discussion:</b></p>
+
++<p><b>Proposed resolution:</b></p>
+
+
+-<p><b>Addresses US-175, US-165, CH-23, GB-135</b></p>
+
+-29.6 [atomics.types.operations] p. 23: The first sentence is grammatically incorrect.
+
+-<p><i>[
+-2010-10-28 Daniel adds:
+-]</i></p>
+
++<hr>
++<h3><a name="2460"></a>2460. LWG issue 2408 and value categories</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other], 24.4.1 [iterator.traits] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-11-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Proposed resolution of duplicate issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>:
++LWG issue <a href="lwg-defects.html#2408">2408</a> changes the meat of the specification of <tt>common_type</tt> to compute:
+ </p>
+-Change 29.6 [atomics.types.operations] p. 23 as indicated:
+-<blockquote>
+-23 <em>Remark</em>: <del>The weak compare-and-exchange operations may fail spuriously, that is, return false while
+-leaving the contents of memory pointed to by <tt>expected</tt> before the operation is the same that same
+-as that of the <tt>object</tt> and the same as that of <tt>expected</tt> after the operation</del><ins>The weak
+-compare-and-exchange operations may fail spuriously, that is, return false while leaving the contents of memory
+-pointed to by <tt>expected</tt> unchanged.</ins>. [ <em>Note</em>: This spurious failure enables implementation of
+-compare-and-exchange on a broader class of machines, e.g., loadlocked store-conditional machines. A consequence of
+-spurious failure is that nearly all uses of weak compare-and-exchange will be in a loop.
+-<p>
+-When a compare-and-exchange is in a loop, the weak version will yield better performance on some
+-platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
+-strong one is preferable. — <em>end note</em> ]
++<blockquote><p>
++[..] the type, if any, of an unevaluated conditional expression (5.16) whose first operand is an
++arbitrary value of type <tt>bool</tt>, whose second operand is an <tt>xvalue</tt> of type <tt>T1</tt>,
++and whose third operand is an xvalue of type <tt>T2</tt>.
+ </p></blockquote>
++<p>
++This has an effect on the specification that I think was unintended. It used to be the case that
++<tt>common_type&lt;T&amp;, U&amp;&amp;&gt;</tt> would consider the type of a conditional between an
++lvalue of type <tt>T</tt> and an xvalue of type <tt>U</tt>. It's now either invalid (because there is
++no such thing as an xvalue of reference type) or considers the type of a conditional between an xvalue
++of type <tt>T</tt> and an xvalue of type <tt>U</tt>, depending on how you choose to read it.
++<p/>
++Put another way, this has the effect of changing the usual definition from:
++</p>
++<blockquote><pre>
++typedef decay_t&lt;decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())&gt; type;
++</pre></blockquote>
++<p>
++to:
++</p>
++<blockquote><pre>
++typedef decay_t&lt;decltype(true ? declval&lt;remove_reference_t&lt;T&gt;&gt;() : declval&lt;remove_reference_t&lt;U&gt;&gt;())&gt; type;
++</pre></blockquote>
++<p>
++It also makes <tt>common_type</tt> underspecified in the case where one of the operands is of type <tt>void</tt>;
++in that case, the resulting type depends on whether the expression is a throw-expression, which is not
++specified (but used to be).
++<p/>
++Also on the subject of this wording: the changes to 24.4.1 [iterator.traits] say that
++<tt>iterator_traits&lt;T&gt;</tt> "shall have no members" in some cases. That's wrong. It's a class type;
++it always has at least a copy constructor, a copy assignment operator, and a destructor. Plus this
++removes the usual library liberty to add additional members with names that don't collide with normal
++usage (for instance, if a later version of the standard adds members, they can't be present here as a
++conforming extension). Perhaps this should instead require that the class doesn't have members with any
++of those five names? That's what <a href="lwg-defects.html#2408">2408</a> does for <tt>common_type</tt>'s type member.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change 29.6 [atomics.types.operations] p. 23 as indicated:
+-<blockquote>
+-23 <em>Remark</em>: <del>The weak compare-and-exchange operations may fail spuriously, that is, return false while
+-leaving the contents of memory pointed to by <tt>expected</tt> before the operation is the same that same
+-as that of the <tt>object</tt> and the same as that of <tt>expected</tt> after the operation</del><ins>The weak
+-compare-and-exchange operations may fail spuriously. That is, it may return false while leaving the contents of
+-memory pointed to by <tt>expected</tt> the same as it was before the operation</ins>. [ <em>Note</em>: This spurious
+-failure enables implementation of compare-and-exchange on a broader class of machines, e.g., loadlocked
+-store-conditional machines. A consequence of spurious failure is that nearly all uses of weak
+-compare-and-exchange will be in a loop.
+-<p>
+-When a compare-and-exchange is in a loop, the weak version will yield better performance on some
+-platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
+-strong one is preferable. — <em>end note</em> ]
+-</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1478"></a>1478. [FCD] Clarify race conditions in atomics initialization</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2461"></a>2461. Interaction between allocators and container exception safety guarantees</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 23.3.6.3 [vector.capacity], 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> dyp <b>Opened:</b> 2014-12-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-136</b></p>
++<p>
++When resizing a <tt>vector</tt>, the accessibility and exception specification of the value type's
++constructors determines whether the elements are copied or moved to the new buffer.
++However, the copy/move is performed via the allocator's <tt>construct</tt> member function, which is
++assumed, but not required, to call the copy/move constructor and propagate only exceptions
++from the value type's copy/move constructor. The issue might also affect other classes.
++<p/>
++The current wording in N4296 relevant here is from Table 28 &mdash; "Allocator requirements" in
++17.6.3.5 [allocator.requirements]:
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
+
+-GB requests normative clarification in 29.6 [atomics.types.operations] p.4 that
+-concurrent access constitutes a race, as already done on p.6 and p.7.
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-<p><i>[
+-Resolution proposed in ballot comment:
+-]</i></p>
++<tr>
++<td>
++<tt>a.construct(c, args)</tt>
++</td>
++<td>
++(not used)
++</td>
++<td>
++<i>Effect</i>: Constructs an object of type <tt>C</tt> at <tt>c</tt>
++</td>
++<td>
++<tt>::new ((void*)c) C(forward&lt;Args&gt;(args)...)</tt>
++</td>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++</table>
++</blockquote>
++<p>
++and from 17.6.3.5 [allocator.requirements] p9:
++</p>
++<blockquote><p>
++An allocator may constrain the types on which it can be instantiated and the arguments for which its
++<tt>construct</tt> member may be called. If a type cannot be used with a particular allocator, the allocator class
++or the call to <tt>construct</tt> may fail to instantiate.
++</p></blockquote>
++<p>
++I conclude the following from the wording:
++</p>
++<ol>
++<li><p>The allocator is not required to call the copy constructor if the
++arguments (args) is a single (potentially const) lvalue of the value
++type. Similarly for a non-const rvalue + move constructor. See also
++23.2.1 [container.requirements.general] p15 which seems to try to require
++this, but is not sufficient:
++That paragraph specifies the semantics of the allocator's operations,
++but not which constructors of the value type are used, if any.
++</p></li>
++<li>
++<p>The allocator may throw exceptions in addition to the exceptions propagated by
++the constructors of the value type; it can also propagate exceptions from constructors
++other than a copy/move constructor.
++</p>
++</li>
++</ol>
++<p>
++This leads to an issue with the wording of the exception safety guarantees for vector modifiers in
++23.3.6.5 [vector.modifiers] p1:
++</p>
+ <blockquote>
+-Initialisation of atomics:
+ <p>
+-We believe the intent is that for any atomics there is a distinguished
+-initialisation write, but that this need not happens-before all the
+-other operations on that atomic - specifically so that the
+-initialisation write might be non-atomic and hence give rise to a data
+-race, and hence undefined behaviour, in examples such as this (from
+-Hans):
+-</p><blockquote><pre>atomic&lt;atomic&lt;int&gt; *&gt; p
+-f() |
+-{ atomic&lt;int&gt;x; | W_na x
+- p.store(&amp;x,mo_rlx); | W_rlx p=&amp;x
+-} |
+-</pre></blockquote>
+-(where na is nonatomic and rlx is relaxed). We suspect also that no
+-other mixed atomic/nonatomic access to the same location is intended
+-to be permitted. Either way, a note would probably help.
++[&hellip;]
++</p>
++<pre>
++void push_back(const T&amp; x);
++void push_back(T&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++<i>Remarks</i>: Causes reallocation if the new size is greater than the old capacity. If no
++reallocation happens, all the iterators and references before the insertion point remain valid.
++If an exception is thrown other than by the copy constructor, move constructor, assignment
++operator, or move assignment operator of <tt>T</tt> or by any InputIterator operation there are
++no effects.
++<span style="color:#C80000;font-weight:bold">
++If an exception is thrown while inserting a single element at the end and <tt>T</tt>
++is <tt>CopyInsertable</tt> or <tt>is_nothrow_move_constructible&lt;T&gt;::value</tt>
++is true, there are no effects. Otherwise, if an exception is thrown by the move constructor of a
++non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</span>
++</p>
+ </blockquote>
++</blockquote>
++<p>
++The wording leads to the following problem:
++Copy and move assignment are invoked directly from <tt>vector</tt>.
++For intermediary objects (see <a href="lwg-active.html#2164">2164</a>),
++<tt>vector</tt> also directly invokes the copy and move constructor of the value type.
++However, construction of the actual element within the buffer is invoked via the allocator abstraction.
++As discussed above, the allocator currently is not required to call a copy/move constructor.
++If <tt>is_nothrow_move_constructible&lt;T&gt;::value</tt> is <tt>true</tt> for some value type <tt>T</tt>,
++but the allocator uses modifying operations for <tt>MoveInsertion</tt> that do throw,
++the implementation is required to ensure that "there are no effects",
++even if the source buffer has been modified.
++<p/>
++Similarly, the <tt>vector</tt> capacity functions specify exception safety guarantees
++referring to the move constructor of the value type. For example, <tt>vector::resize</tt> in 23.3.6.3 [vector.capacity] p14:
++</p>
++<blockquote>
++<i>Remarks</i>: If an exception is thrown other than by the move constructor of a
++non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.
++</blockquote>
++<p>
++The wording leads to the same issue as described above.
++<p/>
++Code example:
++</p>
++<blockquote>
++<pre>
++template&lt;class T&gt;
++class allocator;
+
++class pot_reg_type // a type which creates
++ // potentially registered instances
++{
++private:
++ friend class allocator&lt;pot_reg_type&gt;;
++ struct register_t {};
+
+-<p><b>Proposed resolution:</b></p>
+-
+-
++ static std::set&lt;pot_reg_type*&gt;&amp; get_registry()
++ {
++ static std::set&lt;pot_reg_type*&gt; registry;
++ return registry;
++ }
++ void enregister() noexcept(false)
++ {
++ get_registry().insert(this);
++ }
++ void deregister()
++ {
++ get_registry().erase(this);
++ }
+
++public:
++ pot_reg_type(void ) noexcept(true) {}
++ pot_reg_type(pot_reg_type const&amp;) noexcept(true) {}
++ pot_reg_type(pot_reg_type&amp;&amp; ) noexcept(true) {}
++
++private:
++ pot_reg_type(register_t ) noexcept(false)
++ { enregister(); }
++ pot_reg_type(register_t, pot_reg_type const&amp;) noexcept(false)
++ { enregister(); }
++ pot_reg_type(register_t, pot_reg_type&amp;&amp; ) noexcept(false)
++ { enregister(); }
++};
+
++template&lt;class T&gt;
++class allocator
++{
++public:
++ using value_type = T;
+
+-<hr>
+-<h3><a name="1479"></a>1479. [FCD] Fence functions should be <tt>extern "C"</tt></h3>
+-<p><b>Section:</b> 29.8 [atomics.fences] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.fences">active issues</a> in [atomics.fences].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.fences">issues</a> in [atomics.fences].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-179</b></p>
++ value_type* allocate(std::size_t p)
++ { return (value_type*) ::operator new(p); }
+
+-The fence functions (29.8 [atomics.fences] p.5 + p.6) should be <tt>extern "C"</tt>, for <tt>C</tt> compatibility.
++ void deallocate(value_type* p, std::size_t)
++ { ::operator delete(p); }
+
++ void construct(pot_reg_type* pos)
++ {
++ new((void*)pos) pot_reg_type((pot_reg_type::register_t()));
++ }
++ void construct(pot_reg_type* pos, pot_reg_type const&amp; source)
++ {
++ new((void*)pos) pot_reg_type(pot_reg_type::register_t(), source);
++ }
+
+-<p><b>Proposed resolution:</b></p>
++ template&lt;class... Args&gt;
++ void construct(T* p, Args&amp;&amp;... args)
++ {
++ new((void*)p) T(std::forward&lt;Args&gt;(args)...);
++ }
++};
++</pre>
++</blockquote>
++<p>
++The <tt>construct</tt> member function template is only required for rebinding,
++which can be required e.g. to store additional debug information in
++the allocated memory (e.g. VS2013).
++<p/>
++Even though the value type has an accessible and <tt>noexcept(true)</tt> move
++constructor, this allocator won't call that constructor for rvalue arguments.
++In any case, it does not call a constructor for which vector has formulated its
++requirements. An exception thrown by a constructor called by this allocator is not
++covered by the specification in 23.3.6.5 [vector.modifiers] and therefore is
++guaranteed not to have any effect on the vector object when resizing.
++<p/>
++For an example how this might invalidate the exception safety
++guarantees, see <a href="https://groups.google.com/a/isocpp.org/d/topic/std-discussion/BcM7ya8JeqY/discussion">this post on the std-discussion mailing list</a>.
++<p/>
++Another problem arises for value types whose constructors are private,
++but may be called by the allocator e.g. via friendship.
++Those value types are not <tt>MoveConstructible</tt>
++(<tt>is_move_constructible</tt> is false), yet they can be <tt>MoveInsertable</tt>.
++It is not possible for <tt>vector</tt> to create intermediary objects (see <a href="lwg-active.html#2164">2164</a>) of such a type
++by directly using the move constructor.
++Current implementations of the single-element forms of <tt>vector::insert</tt> and <tt>vector::emplace</tt>
++do create intermediary objects by directly calling one of the value type's constructors,
++probably to allow inserting objects from references that alias other elements of the container.
++As far as I can see, Table 100 &mdash; "Sequence container requirements" in 23.2.3 [sequence.reqmts]
++does not require that the creation of such intermediare objects can be performed
++by containers using the value type's constructor directly.
++It is unclear to me if the allocator's construct function could be used to create those
++intermediary objects, given that they have not been allocated by the allocator.
++<p/>
++Two possible solutions:
++</p>
+ <ol>
+-<li>Change 29.2 [atomics.syn], header <tt>&lt;atomic&gt;</tt> synopsis as indicated:
+-<blockquote><pre>namespace std {
+- [..]
+- // <em>29.8, fences</em>
+- <ins>extern "C"</ins> void atomic_thread_fence(memory_order);
+- <ins>extern "C"</ins> void atomic_signal_fence(memory_order);
+-}
+-</pre></blockquote>
+-</li>
+-<li>Change 29.8 [atomics.fences], p. 5 and p. 6 as indicated:
+-<blockquote><pre><ins>extern "C"</ins> void atomic_thread_fence(memory_order);
+-</pre><blockquote>
+-5 <em>Effects</em>: depending on the value of <tt>order</tt>, this operation: [..]
+-</blockquote></blockquote>
+-<blockquote><pre><ins>extern "C"</ins> void atomic_signal_fence(memory_order);
+-</pre><blockquote>
+-6 <em>Effects</em>: equivalent to <tt>atomic_thread_fence(order)</tt>, except that synchronizes with relationships are
+-established only between a thread and a signal handler executed in the same thread.
+-</blockquote></blockquote>
++<li><p>
++Add the following requirement to the <tt>allocator_traits::construct</tt> function:
++If the parameter pack <tt>args</tt> consists of a single parameter of the type
++<tt>value_type&amp;&amp;</tt>,
++the function may only propagate exceptions if <tt>is_nothrow_move_constructible&lt;value_type&gt;::value</tt>
++is <tt>false</tt>.
++<p/>
++Requiring <tt>alloctor_traits::construct</tt> to call a true copy/move constructor
++of the value type breaks <tt>std::scoped_allocator_adapter</tt>,
++as pointed out by <a href="https://groups.google.com/a/isocpp.org/d/msg/std-discussion/0yxikZInp-E/Lxj-msFT22cJ">Casey Carter in a post on the std-discussion mailing list</a>.
++</p></li>
++<li>
++<p>
++Change vector's criterion whether to move or copy when resizing:
++<p/>
++Instead of testing the value type's constructors via
++<tt>is_move_constructible</tt>, check the value of
++<tt>noexcept( allocator_traits&lt;Allocator&gt;::construct(alloc, ptr, rval) )</tt>
++where
++<tt>alloc</tt> is an lvalue of type <tt>Allocator</tt>,
++<tt>ptr</tt> is an expression of type <tt>allocator_traits&lt;Allocator&gt;::pointer</tt>
++and
++<tt>rval</tt> is a non-const rvalue of type <tt>value_type</tt>.
++</p>
+ </li>
+ </ol>
++<p>
++A short discussion of the two solutions:
++<p/>
++Solution 1 allows keeping <tt>is_nothrow_move_constructible&lt;value_type&gt;</tt>
++as the criterion for <tt>vector</tt> to decide between copying and moving when resizing.
++It restricts what can be done inside the <tt>construct</tt> member function of allocators,
++and requires implementers of allocators to pay attention to the value types used.
++One could conceive allocators checking the following with a <tt>static_assert</tt>:
++If the value type <tt>is_nothrow_move_constructible</tt>,
++then the constructor actually called for <tt>MoveInsertion</tt> within the <tt>construct</tt>
++member function is also declared as noexcept.
++<p/>
++Solution 2 requires changing both the implementation of the default
++allocator (add a conditional <tt>noexcept</tt>) and <tt>vector</tt> (replace
++<tt>is_move_constructible</tt> with an allocator-targeted check).
++It does not impose additional restrictions on the allocator (other than
++23.2.1 [container.requirements.general] p15),
++and works nicely even if the move constructor of a <tt>MoveInsertable</tt> type is private or deleted
++(the allocator might be a friend of the value type).
++<p/>
++In both cases, an addition might be required to provide the basic exception safety guarantee.
++A short discussion on this topic can be found
++<a href="https://groups.google.com/a/isocpp.org/d/topic/std-discussion/yZLnYy_y2z0/discussion">
++in the std-discussion mailing list</a>.
++Essentially, if <tt>allocator_traits&lt;Allocator&gt;::construct</tt> throws an exception,
++the object may or may not have been constructed.
++Two solutions are mentioned in that discussion:
++</p>
++<ol>
++<li><p>
++<tt>allocator_traits&lt;Allocator&gt;::construct</tt> needs to tell its caller
++whether or not the construction was successful, in case of an exception.
++</p></li>
++<li><p>
++If <tt>allocator_traits&lt;Allocator&gt;::construct</tt> propagates an exception,
++it shall either not have constructed an object at the specified location,
++or that object shall have been destroyed
++(or it shall ensure otherwise that no resources are leaked).
++</p></li>
++</ol>
+
+
+
++<p><b>Proposed resolution:</b></p>
+
+
+-<hr>
+-<h3><a name="1480"></a>1480. [FCD] Atomic fences don't have <em>synchronizes with</em> relation</h3>
+-<p><b>Section:</b> 29.8 [atomics.fences] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Review">Review</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.fences">active issues</a> in [atomics.fences].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.fences">issues</a> in [atomics.fences].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Review">Review</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-137</b></p>
+-
+-Thread fence not only establish synchronizes with relationships,
+-there are semantics of fences that are expressed not in
+-terms of <em>synchronizes with</em> relationships (for example see 29.3 [atomics.order] p.5).
+-These semantics also need to apply to the use of
+-<tt>atomic_signal_fence</tt> in a restricted way.
+
+-<p><i>[Batavia: Concurrency group discussed issue, and is OK with the proposed resolution.]</i></p>
+
+
++<hr>
++<h3><a name="2462"></a>2462. <tt>std::ios_base::failure</tt> is overspecified</h3>
++<p><b>Section:</b> 27.5.3 [ios.base], 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-12-15 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base">issues</a> in [ios.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++27.5.3 [ios.base] defines <tt>ios_base::failure</tt> as a nested class:
++</p>
++<blockquote>
++<pre>
++namespace std {
++ class ios_base {
++ public:
++ class failure;
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre>
++</blockquote>
++<p>
++This means it is valid to use an elaborated-type-specifier to
++refer to <tt>ios_base::failure</tt>:
++</p>
++<blockquote>
++<pre>
++using F = class std::ios_base::failure;
++throw F();
++</pre>
++</blockquote>
++<p>
++Therefore implementations are not permitted to define
++<tt>ios_base::failure</tt> as a typedef e.g.
++</p>
++<blockquote>
++<pre>
++ class ios_base {
++ public:
++#if __cplusplus &lt; 201103L
++ class failure_cxx03 : public exception {...};
++ typedef failure_cxx03 failure;
++#else
++ class failure_cxx11 : public system_error {...};
++ typedef failure_cxx11 failure;
++#endif
++ [&hellip;]
++ };
++</pre>
++</blockquote>
++<p>
++This constrains implementations, making it harder to manage the ABI
++change to <tt>ios_base::failure</tt> between C++03 and C++11.
++</p>
+
+-<p><b>Proposed resolution:</b></p>
+-Change 29.8 [atomics.fences] p. 6 as indicated:
+-<blockquote><pre>void atomic_signal_fence(memory_order);
+-</pre><blockquote>
+-6 <em>Effects</em>: equivalent to <tt>atomic_thread_fence(order)</tt>, except that <del>synchronizes
+-with relationships</del><ins>the resulting ordering constraints</ins> are established only between a
+-thread and a signal handler executed in the same thread.
+-</blockquote></blockquote>
++<p><i>[2015-05-06 Lenexa: Move to Ready]</i></p>
+
++<p>JW: the issue is that users are currently allowed to write "class failure" with an elaborated-type-specifier and it must be well-formed, I want the freedom to make that type a typedef, so they can't necessarily use an elaborated-type-specifier (which there is no good reason to use anyway)</p>
++<p>JW: ideally I'd like this everywhere for all nested classes, but that's a paper not an issue, I only need this type fixed right now.</p>
++<p>RD: is a synonym the same as an alias?</p>
++<p>JW: dcl.typedef says a typedef introduces a synonym for another type, so I think this is the right way to say this</p>
++<p>JW: I already shipped this last month</p>
++<p>PJP: we're going to have to break ABIs again some time, we need all the wiggle room we can get to make that easier. This helps.</p>
++<p>MC: do we want this at all? Ready?</p>
++<p>9 in favor, none opose or abstaining</p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
++<ol>
++<li><p>Change the synopsis in 27.5.3 [ios.base] as indicated:</p>
+
+-<hr>
+-<h3><a name="1485"></a>1485. [FCD] Unclear <tt>thread::id</tt> specification</h3>
+-<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-184</b></p>
++<blockquote>
++<pre>
++namespace std {
++ class ios_base {
++ public:
++ class failure; <ins><i>// see below</i></ins>
++ [&hellip;]
++ };
++ [&hellip;]
++};
++</pre>
++</blockquote>
++</li>
+
+-It is unclear when a <tt>thread::id</tt> ceases to be meaningful.
+-The sentence "The library may reuse the value of a
+-<tt>thread::id</tt> of a terminated thread that can no longer be
+-joined." implies that some terminated threads can be
+-joined. It says nothing about detached threads.
++<li><p>Change 27.5.3 [ios.base] paragraph 1:</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<blockquote>
++<p>
++<tt>ios_base</tt> defines several member types:
++</p>
++<ul>
++<li><p>a <del>class <tt>failure</tt></del><ins>type <tt>failure</tt>, defined as either
++a class derived from <tt>system_error</tt> or a synonym for a class</ins> derived from
++<tt>system_error</tt>;</p></li>
++</ul>
++</blockquote>
++</li>
+
++<li><p>Change 27.5.3.1.1 [ios::failure] paragraph 1:</p>
+ <blockquote>
+-Require a unique <tt>thread::id</tt> for every thread that is
+-(1) detached and not terminated or (2) has an associated <tt>std::thread</tt>
+-object.
++<p>
++-1- <ins>An implementation is permitted to define <tt>ios_base::failure</tt> as
++a synonym for a class with equivalent functionality to class <tt>ios_base::failure</tt> shown
++in this subclause. [<i>Note</i>: When <tt>ios_base::failure</tt> is a synonym for another type
++it shall provide a nested type <tt>failure</tt>, to emulate the injected class name. &mdash;
++<i>end note</i>]</ins> The class <tt>failure</tt> defines the base class for the types of all
++objects thrown as exceptions, by functions in the iostreams library, to report errors detected
++during stream buffer operations.
++</p>
+ </blockquote>
++</li>
++</ol>
++
+
+-<p><i>[
+-2010-11-22 Howard Hinnant observes
+-]</i></p>
+
+
+
++<hr>
++<h3><a name="2465"></a>2465. SFINAE-friendly <tt>common_type</tt> is nearly impossible to specialize
++correctly and regresses key functionality</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2015-01-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-A thread can either be running or terminated. Additionally a thread can be joined, detached, or neither. These combine into the five possible states shown in this table:
++I think there's a defect regarding <tt>common_type</tt> and its specializations.
++Unless I've missed it, there is nothing preventing folks from
++instantiating <tt>common_type</tt> with <i>cv</i>-qualified types or reference types. In
++fact, the wording in N3797 explicitly mentions <i>cv</i> <tt>void</tt>, so presumably at
++least <i>cv</i> qualifications are allowed.
++<p/>
++Users are given license to specialize <tt>common_type</tt> when at least of of
++the types is user-defined. (A separate issue is the meaning of
++user-defined. In core, I believe this is any class/struct/union/enum,
++but in lib, I think it means any type not defined in std, right?) There
++is at least one place in the standard that specializes <tt>common_type</tt>
++(time.traits.specializations) on time_point and duration. But the
++specializations are only for non-<i>cv</i>-qualified and non-reference
++specializations of <tt>time_point</tt> and <tt>duration</tt>.
++<p/>
++If the user uses, say, <tt>common_type&lt;duration&lt;X,Y&gt; const, duration&lt;A,B&gt;
++const&gt;</tt>, they're not going to get the behavior they expect.
++<p/>
++Suggest we clarify the requirements of <tt>common_type</tt>'s template
++parameters. Also, perhaps we can add blanket wording that <tt>common_type&lt;A
++[<i>cv</i>][&amp;], B [<i>cv</i>][&amp;]&gt;</tt> is required to be equivalent to
++<tt>common_type&lt;A,B&gt;</tt> (if that is in fact the way we intent this to work).
++<p/>
++Also, the change to make <tt>common_type</tt> SFINAE-friendly regressed key
++functionality, as noted by Agust&iacute;n K-ballo Berg&eacute; in
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=37178">c++std-lib-37178</a>.
++Since <tt>decay_t</tt> is not applied until the very end of the type computation,
++user specializations are very likely to to be found.
++<p/>
++Agust&iacute;n says:
++</p>
++<blockquote class="note">
++<p>
++Consider the following snippet:
+ </p>
++<blockquote>
++<pre>
++struct X {};
++struct Y { explicit Y(X){} };
+
+-<table border="1">
+-<tbody><tr>
+-<th></th><th>Running</th><th>Terminated</th>
+-</tr>
+-<tr>
+-<th>Neither joined nor detached</th><td>shall not reuse id</td><td>shall not reuse id</td>
+-</tr>
+-<tr>
+-<th>detached</th><td>shall not reuse id</td><td>may reuse id</td>
+-</tr>
+-<tr>
+-<th>joined</th><td>impossible state</td><td>may reuse id</td>
+-</tr>
+-</tbody></table>
+-<p>
+-Only if a thread is neither joined nor detached can it be joined. Or said differently, if a thread has already been joined or detached, then it can not be joined. The sentence:
+-</p><blockquote>
+-The library may reuse the value of a <tt>thread::id</tt> of a terminated thread that can no longer be joined.
++namespace std {
++ template&lt;> struct common_type&lt;X, Y> { typedef Y type; };
++ template&lt;> struct common_type&lt;Y, X> { typedef Y type; };
++}
++
++static_assert(is_same&lt;common_type_t&lt;X, Y>, Y>()); // (A)
++static_assert(is_same&lt;common_type_t&lt;X, Y, Y>, Y>()); // (B)
++static_assert(is_same&lt;common_type_t&lt;X, X, Y>, Y>()); // (C)
++</pre>
+ </blockquote>
+-precisely defines the two states shown in the above table where a thread::id may be reused.
+-<p></p>
+ <p>
+-The following program illustrates all of the possibilities:
++Under the original wording, all three assertion holds. Under the current wording,
+ </p>
+-<blockquote><pre>#include &lt;mutex&gt;
+-#include &lt;thread&gt;
+-#include &lt;iostream&gt;
+-#include &lt;chrono&gt;
++<ul>
++<li><p>(A) picks the user-defined specialization, so the assertion holds.</p></li>
+
+-std::mutex mut;
++<li><p>(B) goes to the third bullet and, ignoring the user-defined specialization, looks for
++<tt>decltype(true ? declval&lt;X&gt;() : declval&lt;Y&gt;())</tt>; since it is ill-formed
++there is no common type.</p></li>
+
+-void f()
++<li><p>(C) goes to the third bullet and yields <tt>common_type_t&lt;X&amp;&amp;, Y&gt;</tt>, which again misses
++the user-defined specialization.</p></li>
++</ul>
++</blockquote>
++<p>
++The discussion following <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=35636">c++std-lib-35636</a>
++seemed to cohere around the idea that the primary <tt>common_type</tt> specialization should have the effect
++of stripping top-level ref and <i>cv</i> qualifiers by applying <tt>std::decay_t</tt> to its arguments and,
++if any of them change as a result of that transformation, re-dispatching to <tt>common_type</tt> on those transformed
++arguments, thereby picking up any user-defined specializations. This change to <tt>common_type</tt> would make
++the specializations in time.traits.specializations sufficient.
++<p/>
++<b>Suggested wording</b>:
++<p/>
++I'm afraid I don't know enough to suggest wording. But for exposition,
++the following is my best shot at implementing the suggested resolution.
++I believe it also fixes the regression noted by Agust&iacute;n K-ballo Berg&eacute; in
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=37178">c++std-lib-37178</a>.
++</p>
++<blockquote>
++<pre>
++namespace detail
+ {
+- std::lock_guard&lt;std::mutex&gt; _(mut);
+- std::cout &lt;&lt; "f id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; " terminating\n";
++ template&lt;typename T, typename U&gt;
++ using default_common_t =
++ decltype(true? std::declval&lt;T&gt;() : std::declval&lt;U&gt;());
++
++ template&lt;typename T, typename U, typename Enable = void&gt;
++ struct common_type_if
++ {};
++
++ template&lt;typename T, typename U&gt;
++ struct common_type_if&lt;T, U,
++ void_t&lt;default_common_t&lt;T, U&gt;&gt;&gt;
++ {
++ using type = decay_t&lt;default_common_t&lt;T, U&gt;&gt;;
++ };
++
++ template&lt;typename T, typename U,
++ typename TT = decay_t&lt;T&gt;, typename UU = decay_t&lt;U&gt;&gt;
++ struct common_type2
++ : common_type&lt;TT, UU&gt; // Recurse to catch user specializations
++ {};
++
++ template&lt;typename T, typename U&gt;
++ struct common_type2&lt;T, U, T, U&gt;
++ : common_type_if&lt;T, U&gt;
++ {};
++
++ template&lt;typename Meta, typename Enable = void&gt;
++ struct has_type
++ : std::false_type
++ {};
++
++ template&lt;typename Meta&gt;
++ struct has_type&lt;Meta, void_t&lt;typename Meta::type&gt;&gt;
++ : std::true_type
++ {};
++
++ template&lt;typename Meta, typename...Ts&gt;
++ struct common_type_recurse
++ : common_type&lt;typename Meta::type, Ts...&gt;
++ {};
++
++ template&lt;typename Meta, typename...Ts&gt;
++ struct common_type_recurse_if
++ : std::conditional&lt;
++ has_type&lt;Meta>::value,
++ common_type_recurse&lt;Meta, Ts...&gt;,
++ empty
++ >::type
++ {};
+ }
+
+-void g()
+-{
+- std::lock_guard&lt;std::mutex&gt; _(mut);
+- std::cout &lt;&lt; "g id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; " terminating\n";
+-}
++template&lt;typename ...Ts&gt;
++struct common_type
++{};
+
+-int main()
++template&lt;typename T>
++struct common_type&lt;T>
+ {
+- std::cout &lt;&lt; "main id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; "\n";
+- std::thread t1(f);
+- std::thread(g).detach();
+- std::this_thread::sleep_for(std::chrono::seconds(1));
+- std::cout &lt;&lt; "g's thread::id can be reused here because g has terminated and is detached.\n";
+- std::cout &lt;&lt; "f's thread::id can't be reused here because f has terminated but is still joinable.\n";
+- std::cout &lt;&lt; "f id = " &lt;&lt; t1.get_id() &lt;&lt; "\n";
+- t1.join();
+- std::cout &lt;&lt; "f's thread::id can be reused here because f has terminated and is joined.\n";
+- std::cout &lt;&lt; "f id = " &lt;&lt; t1.get_id() &lt;&lt; "\n";
+-}
++ using type = std::decay_t&lt;T&gt;;
++};
++
++template&lt;typename T, typename U&gt;
++struct common_type&lt;T, U&gt;
++ : detail::common_type2&lt;T, U&gt;
++{};
++
++template&lt;typename T, typename U, typename... Vs&gt;
++struct common_type&lt;T, U, Vs...&gt;
++ : detail::common_type_recurse_if&lt;common_type&lt;T, U&gt;, Vs...&gt;
++{};
++</pre>
++</blockquote>
+
+-main id = 0x7fff71197ca0
+-f id = 0x100381000 terminating
+-g id = 0x100581000 terminating
+-g's thread::id can be reused here because g has terminated and is detached.
+-f's thread::id can't be reused here because f has terminated but is still joinable.
+-f id = 0x100381000
+-f's thread::id can be reused here because f has terminated and is joined.
+-f id = 0x0
+-</pre></blockquote>
+
+ <p><b>Proposed resolution:</b></p>
+
+@@ -6131,406 +27583,523 @@ f id = 0x0
+
+
+ <hr>
+-<h3><a name="1486"></a>1486. [FCD] Value of <tt>this_thread::get_id()</tt> underspecified for detached thread</h3>
+-<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#thread.thread.this">active issues</a> in [thread.thread.this].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2466"></a>2466. <tt>allocator_traits::max_size()</tt> default behavior is incorrect</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 20.7.8.2 [allocator.traits.members] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2015-01-17 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-24</b></p>
+-
+-What would be the value <tt>this_thread::get_id()</tt> when called from a detached thread?
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+ <p>
+-Add some text to clarify that get_id() still returns
+-the same value even after detaching.
++Table 28 &mdash; "Allocator requirements" says that default behavior for <tt>a.max_size()</tt> is
++<tt>numeric_limits&lt;size_type&gt;::max()</tt>. And this is consistent with the matching statement
++for <tt>allocator_traits</tt> in 20.7.8.2 [allocator.traits.members]/p7:
+ </p>
+-
+-<p><i>[
+-2010-11-22 Howard Hinnant observes
+-]</i></p>
+-
+-
++<blockquote>
++<pre>
++static size_type max_size(const Alloc&amp; a) noexcept;
++</pre>
++<blockquote>
+ <p>
+-30.3.2 [thread.thread.this]/1 contains the following sentence describing <tt>this_thread::get_id()</tt>:
++<i>Returns</i>: <tt>a.max_size()</tt> if that expression is well-formed; otherwise,
++<tt>numeric_limits&lt;size_type&gt;::max()</tt>.
++</p>
++</blockquote>
++</blockquote>
++<p>
++However, when allocating memory, an allocator must allocate <tt>n*sizeof(value_type)</tt> bytes, for example:
+ </p>
+-
+ <blockquote>
+-... No other thread of execution shall have this id and this thread of execution shall always have this id.
++<pre>
++value_type*
++allocate(std::size_t n)
++{
++ return static_cast&lt;value_type*&gt;(::operator new (n * sizeof(value_type)));
++}
++</pre>
+ </blockquote>
++<p>
++When <tt>n == numeric_limits&lt;size_type&gt;::max(), n * sizeof(value_type)</tt> is <em>guaranteed</em>
++to overflow except when <tt>sizeof(value_type) == 1</tt>.
++<p/>
++A more useful default would be <tt>numeric_limits&lt;size_type&gt;::max() / sizeof(value_type)</tt>.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
+
+-I don't object to adding "even if detached" to this sentence, but it seems unnecessary to me. "Always" means always.
++<p>
++Marshall: Is this the right solution?<br/>
++PJP: I think it's gilding the lily.<br/>
++STL: I think this is right, and it doesn't interact with the incomplete container stuff because it's in a member function.<br/>
++Marshall: Objections to this?<br/>
++STL: Spaces around binary operators.<br/>
++Hwrd: It's completely wrong without spaces.<br/>
++Marshall: All in favor of Ready?<br/>
++Lots.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements], Table 28 &mdash; "Allocator requirements", as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++<tr>
++<td>
++<tt>a.max_size()</tt>
++</td>
++<td>
++<tt>X::size_type</tt>
++</td>
++<td>
++the largest value that can<br/>
++meaningfully be passed to<br/>
++<tt>X::allocate()</tt>
++</td>
++<td>
++<tt>numeric_limits&lt;size_type&gt;::max()<ins>/sizeof(value_type)</ins></tt>
++</td>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-<hr>
+-<h3><a name="1487"></a>1487. [FCD] Clock related operations exception specifications conflict</h3>
+-<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-01</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#thread.thread.this">active issues</a> in [thread.thread.this].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CH-25</b></p>
++</table>
++</blockquote>
+
+-Clock related operations are currently not required not to
+-throw. So "Throws: Nothing." is not always true.
++</li>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<li><p>Change 20.7.8.2 [allocator.traits.members]/p7 as indicated:</p>
+
+ <blockquote>
+-Either require clock related operations not to throw
+-(in 20.10) or change the Throws clauses in 30.3.2.
+-Also possibly add a note that <tt>abs_time</tt> in the past
+-or negative <tt>rel_time</tt> is allowed.
++<pre>
++static size_type max_size(const Alloc&amp; a) noexcept;
++</pre>
++<blockquote>
++<p>
++<i>Returns</i>: <tt>a.max_size()</tt> if that expression is well-formed; otherwise,
++<tt>numeric_limits&lt;size_type&gt;::max()<ins>/sizeof(value_type)</ins></tt>.
++</p>
++</blockquote>
+ </blockquote>
+
+-
+-
+-<p><b>Proposed resolution:</b></p>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1494"></a>1494. [FCD] Term "are serialized" not defined</h3>
+-<p><b>Section:</b> 30.4.4.2 [thread.once.callonce] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2468"></a>2468. Self-move-assignment of library types</h3>
++<p><b>Section:</b> 17.6.4.9 [res.on.arguments], 17.6.3.1 [utility.arg.requirements], 17.6.5.15 [lib.types.movedfrom], 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2015-01-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.arguments">issues</a> in [res.on.arguments].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-190</b></p>
+-
+-The term "are serialized" is never defined (30.4.4.2 [thread.once.callonce] p. 2).
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+ <p>
+-Remove the sentence with "are serialized" from
+-paragraph 2. Add "Calls to <tt>call_once</tt> on the same
+-<tt>once_flag</tt> object shall not introduce data races
+-(17.6.4.8)." to paragraph 3.
++Suppose we write
++</p>
++<blockquote>
++<pre>
++vector&lt;string&gt; v{"a", "b", "c", "d"};
++v = move(v);
++</pre>
++</blockquote>
++<p>
++What should be the state of <tt>v</tt> be? The standard doesn't say anything specific about self-move-assignment.
++There's relevant text in several parts of the standard, and it's not clear how to reconcile them.
++<p/>
++17.6.4.9 [res.on.arguments] writes that, for all functions in the standard library, unless explicitly stated
++otherwise, "If a function argument binds to an rvalue reference parameter, the implementation may assume that this
++parameter is a unique reference to this argument." The <tt>MoveAssignable</tt> requirements table in
++17.6.3.1 [utility.arg.requirements] writes that, given <tt>t = rv</tt>, <tt>t</tt>'s state is equivalent to
++<tt>rv</tt>'s from before the assignment and <tt>rv</tt>'s state is unspecified (but valid). For containers
++specifically, the requirements table in 23.2.1 [container.requirements.general] says that, given <tt>a = rv</tt>,
++<tt>a</tt> becomes equal to what <tt>rv</tt> was before the assignment (and doesn't say anything about <tt>rv</tt>'s
++state post-assignment).
++<p/>
++Taking each of these pieces in isolation, without reference to the other two:
++</p>
++<ul>
++<li><p>17.6.4.9 [res.on.arguments] would clearly imply that the effect of <tt>v = move(v)</tt> is undefined.</p></li>
++<li><p>17.6.3.1 [utility.arg.requirements] would clearly imply that <tt>v = move(v)</tt> has defined behavior.
++It might be read to imply that this is a no-op, or might be read to imply that it leaves <tt>v</tt> in a valid but
++unspecified state; I'm not sure which reading is more natural.</p></li>
++<li><p>23.2.1 [container.requirements.general] would clearly imply that <tt>v = move(v)</tt> is a no-op.</p></li>
++</ul>
++<p>
++It's not clear from the text how to put these pieces together, because it's not clear which one takes precedence.
++Maybe 17.6.4.9 [res.on.arguments] wins (it imposes an implicit precondition that isn't mentioned in the
++<tt>MoveAssignable</tt> requirements, so <tt>v = move(v)</tt> is undefined), or maybe
++23.2.1 [container.requirements.general] wins (it explicitly gives additional guarantees for
++<tt>Container::operator=</tt> beyond what's guaranteed for library functions in general, so <tt>v = move(v)</tt>
++is a no-op), or maybe something else.
++<p/>
++On the existing implementations that I checked, for what it's worth, <tt>v = move(v)</tt> appeared to clear the vector;
++it didn't leave the vector unchanged and it didn't cause a crash.
++<p/>
++<em>Proposed wording</em>:
++<p/>
++Informally: change the <tt>MoveAssignable</tt> and Container requirements tables (and any other requirements tables
++that mention move assignment, if any) to make it explicit that <tt>x = move(x)</tt> is defined behavior and it leaves
++<tt>x</tt> in a valid but unspecified state. That's probably not what the standard says today, but it's probably what
++we intended and it's consistent with what we've told users and with what implementations actually do.
+ </p>
+-
+-<p><i>[
+-2010-11-01 Daniel translates NB comment into wording
+-]</i></p>
+-
+-
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change 30.4.4.2 [thread.once.callonce] p.2+3 as indicated:
+-<blockquote><pre>template&lt;class Callable, class ...Args&gt;
+-void call_once(once_flag&amp; flag, Callable&amp;&amp; func, Args&amp;&amp;... args);
+-</pre><blockquote>
+-[..]
+-<p>
+-2 <em>Effects</em>: <del>Calls to <tt>call_once</tt> on the same <tt>once_flag</tt> object are serialized.</del>
+-If there has been a prior effective call to <tt>call_once</tt> on the same <tt>once_flag object</tt>,
+-the call to <tt>call_once</tt> returns without invoking <tt>func</tt>. If there has been no prior
+-effective call to <tt>call_once</tt> on the same <tt>once_flag</tt> object,
+-<tt>INVOKE(decay_copy( std::forward&lt;Callable&gt;(func)), decay_copy(std::forward&lt;Args&gt;(args))...)</tt>
+-is executed. The call to <tt>call_once</tt> is effective if and only if
+-<tt>INVOKE(decay_copy( std::forward&lt;Callable&gt;(func)), decay_copy(std::forward&lt;Args&gt;(args))...)</tt>
+-returns without throwing an exception. If an exception is thrown it is propagated to the caller.
+-</p><p>
+-3 <em>Synchronization</em>: The completion of an effective call to <tt>call_once</tt> on a <tt>once_flag</tt>
+-object synchronizes with (1.10) all subsequent calls to <tt>call_once</tt> on the same <tt>once_flag</tt> object.
+-<ins>Calls to <tt>call_once</tt> on the same <tt>once_flag</tt> object shall not introduce data races ([res.on.data.races]).</ins>
+-</p></blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1497"></a>1497. [FCD] <tt>lock()</tt> postcondition can not be generally achieved</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-08</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
++<h3><a name="2469"></a>2469. Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></h3>
++<p><b>Section:</b> 23.4.4.3 [map.access], 23.5.4.3 [unord.map.elem] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Tomasz Kami&nacute;ski <b>Opened:</b> 2015-01-21 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.access">issues</a> in [map.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-30</b></p>
++<p>
++The "Requires:" clause for the <tt>operator[]</tt> for the <tt>unordered_map</tt> and <tt>map</tt>, are defining
++separate requirements for insertability into container of <tt>mapped_type</tt> and <tt>key_type</tt>.
++<p/>
++23.4.4.3 [map.access] p2: // <tt>T&amp; operator[](const key_type&amp; x);</tt>
++<p/>
++<i>Requires</i>: <tt>key_type</tt> shall be <tt>CopyInsertable</tt> and <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt>
++into <tt>*this</tt>.
++<p/>
++23.4.4.3 [map.access] p6: // <tt>T&amp; operator[](key_type&amp;&amp; x)</tt>
++<p/>
++<i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>.
++<p/>
++23.5.4.3 [unord.map.elem] p1: // <tt>mapped_type&amp; operator[](const key_type&amp; k);
++mapped_type&amp; operator[](key_type&amp;&amp; k);</tt>
++<p/>
++<i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>. For the first operator,
++<tt>key_type</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>. For the second operator, <tt>key_type</tt> shall
++be <tt>MoveConstructible</tt>.
++<p/>
++Definition of the appropriate requirements: 23.2.1 [container.requirements.general] p15.
++<p/>
++<tt>T</tt> is <tt>DefaultInsertable</tt> into <tt>X</tt> means that the following expression is well-formed: //p15.1
++<p/>
++<tt>allocator_traits&lt;A&gt;::construct(m, p)</tt>
++<p/>
++<tt>T</tt> is <tt>MoveInsertable</tt> into <tt>X</tt> means that the following expression is well-formed: //p15.3
++<p/>
++<tt>allocator_traits&lt;A&gt;::construct(m, p, rv)</tt>
++<p/>
++<tt>T</tt> is <tt>CopyInsertable</tt> into <tt>X</tt> means that, in addition to <tt>T</tt> being <tt>MoveInsertable</tt>
++into <tt>X</tt>, the following expression is well-formed: //p15.4
++<p/>
++<tt>allocator_traits&lt;A&gt;::construct(m, p, v)</tt>
++<p/>
++In the context of above definition the requirement "<tt>key_type</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>"
++would mean that the key element of the <tt>pair&lt;const key_type, mapped_type&gt;</tt> (<tt>value_type</tt> of the map)
++should be constructed using separate call to the <tt>construct</tt> method, the same applies for the <tt>mapped_type</tt>.
++Such behavior is explicitly prohibited by 23.2.1 [container.requirements.general] p3.
++</p>
++<blockquote><p>
++For the components affected by this sub-clause that declare an allocator_type, objects stored in these
++components shall be constructed using the <tt>allocator_traits&lt;allocator_type&gt;::construct</tt> function and
++destroyed using the <tt>allocator_traits&lt;allocator_type&gt;::destroy</tt> function (20.7.8.2). These functions
++are called only for the container's element type, not for internal types used by the container.
++</p></blockquote>
++<p>
++It clearly states that <tt>element_type</tt> of the map, must be constructed using allocator for value type, which
++disallows using of separate construction of first and second element, regardless of the fact if it can be actually
++performed without causing undefined behavior.
++<p/>
++That means that the <tt>MoveInsertable</tt> and similar requirements may only be expressed in terms of <tt>value_type</tt>,
++not its members types.
++</p>
+
+-If <tt>lock.lock()</tt> throws an exception, the postcondition can not be generally achieved.
++<p><i>[2015-02 Cologne]</i></p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p>
++This issue is related to <a href="lwg-defects.html#2464">2464</a>.
++<p/>
++GR: Effects should say "returns ...". DK: Or just have a Returns clause? MC: A Returns clause is a directive to implementers.
++<p/>
++TK/DK: This PR fails to address the requirements about which it complained in the first place. DK: I can reword this. TK can help.
++</p>
+
++<p><i>[2015-03-29, Daniel provides improved wording]</i></p>
++
++<p>
++The revised wording fixes the proper usage of the magic "Equivalent to" wording, which automatically induces <i>Requires:</i>,
++<i>Returns:</i>, and <i>Complexity:</i> elements (and possibly more). This allows us to strike all the remaining
++elements, because they fall out from the semantics of the wording defined by <a href="lwg-defects.html#2464">2464</a>. In particular it is important
++to realize that the wording form
++</p>
+ <blockquote>
+-Either state that the postcondition might not be achieved, depending on the error condition, or
+-state that <tt>terminate()</tt> is called in this case.
++<p>
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from <tt>piecewise_construct</tt>,
++<tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>
++</p>
+ </blockquote>
+-
+-<p><i>[
+-2010-08-13 Peter Sommerlad comments and provides wording
+-]</i></p>
+-
+-
++<p>
++degenerates for the empty pack expansion <tt>args</tt> to:
++</p>
+ <blockquote>
+-30.5.1 [thread.condition.condvar], 30.5.2 [thread.condition.condvarany]
+ <p>
+-p. 13, last bullet, and corresponding paragraphs in all wait functions
+-</p><p>
+-Problem:<br>
+-Condition variable wait might fail, because the lock cannot be acquired when notified.
+-CH-30 says: "If lock.lock() throws an exception, the postcondition can not be generally achieved."
+-CH-30 proposes: "Either state that the postcondition might not be achieved, depending on the error
+-condition, or state that terminate() is called in this case."
+-</p><p>
+-The discussion in Rapperswil concluded that calling <tt>terminate()</tt> might be too drastic in
+-this case and a corresponding exception should be thrown/passed on and one should use a lock type
+-that allows querying its status, which <tt>unique_lock</tt> allows for <tt>std::condition_variable</tt>
+-</p><p>
+-We also had some additional observations while discussing in Rapperswil:
+-</p><ul>
+-<li>in 30.5.1 [thread.condition.condvar] <tt>wait</tt> with predicate and <tt>wait_until</tt> with
+-predicate lack the precondition, postcondition and Error conditions sections. the lack of the precondition
+-would allow to call <tt>pred()</tt> without holding the lock.
+-</li>
+-<li>in 30.5.1 [thread.condition.condvar] <tt>wait_until</tt> and <tt>wait_for</tt> and
+-30.5.2 [thread.condition.condvarany] <tt>wait_for</tt> still specify an
+-error condition for a violated precondition. This should be removed.
+-</li>
+-</ul>
+-and add the following proposed solution:
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from <tt>piecewise_construct</tt>,
++<tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple()</tt>
++</p>
+ </blockquote>
++<p>
++which again means that such a <tt>pair</tt> construction (assuming <tt>std::allocator</tt>) would copy <tt>k</tt>
++into member <tt>first</tt> and would value-initialize member <tt>second</tt>.
++</p>
+
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
++
++<p>Accept resolution of the issue issue <a href="lwg-defects.html#2464">2464</a> and define <tt>operator[]</tt> as follows
++(This would also address issue <a href="lwg-defects.html#2274">2274</a>):</p>
+
+-<p><b>Proposed resolution:</b></p>
+ <ol>
+-<li>Change 30.5.1 [thread.condition.condvar] as indicated:
+-<blockquote><pre>void wait(unique_lock&lt;mutex&gt;&amp; lock);
+-</pre></blockquote>
+-<blockquote>
+-12 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
+-<ul>
+-<li>no other thread is waiting on this <tt>condition_variable</tt> object or
+-</li>
+-<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.
+-</li>
+-</ul>
+-</blockquote>
+-[..]
++<li><p>Change 23.4.4.3 [map.access] as indicated:</p>
++
+ <blockquote>
+-14 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++<pre>
++T&amp; operator[](const key_type&amp; x);
++</pre>
++<blockquote><p>
++-1- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(x, T())</tt>
++into the map</del><ins>Equivalent to: <tt>try_emplace(x).first-&gt;second</tt></ins>.
++<p/>
++[&hellip;]
++</p>
+ </blockquote>
+-[..]
+-<blockquote><pre>template &lt;class Predicate&gt;
+-void wait(unique_lock&lt;mutex&gt;&amp; lock, Predicate pred);
+-</pre></blockquote>
++<pre>
++T&amp; operator[](key_type&amp;&amp; x);
++</pre>
+ <blockquote>
+-<ins>?? <i>Requires</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread, and either</ins>
+-<ul>
+-<li><ins>no other thread is waiting on this <tt>condition_variable</tt> object or</ins>
+-</li>
+-<li><ins><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.</ins>
+-</li>
+-</ul>
++<p>
++-5- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(std::move(x), T())</tt>
++into the map</del><ins>Equivalent to: <tt>try_emplace(move(x)).first-&gt;second</tt></ins>.
++</p>
+ </blockquote>
+-<blockquote>
+-17 <i>Effects</i>:
+-<blockquote><pre>while (!pred())
+- wait(lock);
+-</pre></blockquote>
+ </blockquote>
++</li>
++
++<li><p>Change 23.5.4.3 [unord.map.elem] as indicated:</p>
+
+ <blockquote>
+-<ins>?? <i>Postcondition</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread.</ins>
+-</blockquote>
++<pre>
++mapped_type&amp; operator[](const key_type&amp; k);
++mapped_type&amp; operator[](key_type&amp;&amp; k);
++</pre>
+ <blockquote>
+-<ins>?? <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2).</ins>
++<p>
++[&hellip;]
++<p/>
++-2- <i>Effects</i>: <del>If the <tt>unordered_map</tt> does not already contain an element whose key is equivalent to <tt>k</tt>,
++the first operator inserts the value <tt>value_type(k, mapped_type())</tt> and the second operator inserts the
++value <tt>value_type(std::move(k), mapped_type())</tt></del><ins>For the first operator, equivalent to:
++<tt>try_emplace(k).first-&gt;second</tt>; for the second operator, equivalent to:
++<tt>try_emplace(move(k)).first-&gt;second</tt></ins>.
++</p>
+ </blockquote>
+-<blockquote>
+-<ins>?? <em>Error conditions</em>:</ins>
+-<ul>
+-<li><ins>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</ins>
+-</li>
+-</ul>
+ </blockquote>
+-
+-<blockquote><pre>template &lt;class Clock, class Duration&gt;
+-cv_status wait_until(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
+-</pre></blockquote>
+-<blockquote>
+-18 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
+-<ul>
+-<li>no other thread is waiting on this <tt>condition_variable</tt> object or
+-</li>
+-<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
+ </li>
+-</ul>
+-</blockquote>
+-[..]
+-<blockquote>
+-20 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++</ol>
+ </blockquote>
+-[..]
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
++
++<p>Accept resolution of the issue issue <a href="lwg-defects.html#2464">2464</a> and define <tt>operator[]</tt> as follows
++(This would also address issue <a href="lwg-defects.html#2274">2274</a>):</p>
++
++<ol>
++<li><p>Change 23.4.4.3 [map.access] as indicated:</p>
++
+ <blockquote>
+-23 <em>Error conditions</em>:
+-<ul>
+-<li><del><tt>operation_not_permitted</tt> — if the thread does not own the lock.</del>
+-</li>
+-<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</li>
+-</ul>
++<pre>
++T&amp; operator[](const key_type&amp; x);
++</pre>
++<blockquote><p>
++-1- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(x, T())</tt>
++into the map.</del><ins>Equivalent to: <tt>return try_emplace(x).first-&gt;second;</tt></ins>
++<p/>
++<del>-2- <i>Requires</i>: <tt>key_type</tt> shall be <tt>CopyInsertable</tt> and <tt>mapped_type</tt> shall be
++<tt>DefaultInsertable</tt> into <tt>*this</tt>.</del>
++<p/>
++<del>-3- <i>Returns</i>: A reference to the <tt>mapped_type</tt> corresponding to <tt>x</tt> in <tt>*this</tt>.</del>
++<p/>
++<del>-4- <i>Complexity</i>: Logarithmic.</del>
++</p>
+ </blockquote>
+-<blockquote><pre>template &lt;class Rep, class Period&gt;
+-cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+-</pre></blockquote>
++<pre>
++T&amp; operator[](key_type&amp;&amp; x);
++</pre>
+ <blockquote>
+-24 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
+-<ul>
+-<li>no other thread is waiting on this <tt>condition_variable</tt> object or
+-</li>
+-<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
+-</li>
+-</ul>
++<p>
++-5- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(std::move(x), T())</tt>
++into the map.</del><ins>Equivalent to: <tt>return try_emplace(move(x)).first-&gt;second;</tt></ins>
++<p/>
++<del>-6- <i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>.</del>
++<p/>
++<del>-7- <i>Returns</i>: A reference to the <tt>mapped_type</tt> corresponding to <tt>x</tt> in <tt>*this</tt>.</del>
++<p/>
++<del>-8- <i>Complexity</i>: Logarithmic.</del>
++</p>
+ </blockquote>
+-[..]
+-<blockquote>
+-27 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
+ </blockquote>
+-[..]
+-<blockquote>
+-29 <em>Error conditions</em>:
+-<ul>
+-<li><del><tt>operation_not_permitted</tt> — if the thread does not own the lock.</del>
+ </li>
+-<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</li>
+-</ul>
+-</blockquote>
+-<blockquote><pre>template &lt;class Clock, class Duration, class Predicate&gt;
+-bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
+- Predicate pred);
+-</pre></blockquote>
++
++<li><p>Change 23.5.4.3 [unord.map.elem] as indicated:</p>
++
+ <blockquote>
+-<ins>?? <i>Requires</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread, and either</ins>
+-<ul>
+-<li><ins>no other thread is waiting on this <tt>condition_variable</tt> object or</ins>
+-</li>
+-<li><ins><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.</ins>
+-</li>
+-</ul>
+-</blockquote>
++<pre>
++mapped_type&amp; operator[](const key_type&amp; k);
++mapped_type&amp; operator[](key_type&amp;&amp; k);
++</pre>
+ <blockquote>
+-30 <i>Effects</i>:
+-<blockquote><pre>while (!pred())
+- if (wait_until(lock, abs_time) == cv_status::timeout)
+- return pred();
+-return true;
+-</pre></blockquote>
+-</blockquote>
++<p>
++<del>-1- <i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>. For the first operator,
++<tt>key_type</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>. For the second operator, <tt>key_type</tt> shall
++be <tt>MoveConstructible</tt>.</del>
++<p/>
++-2- <i>Effects</i>: <del>If the <tt>unordered_map</tt> does not already contain an element whose key is equivalent to <tt>k</tt>,
++the first operator inserts the value <tt>value_type(k, mapped_type())</tt> and the second operator inserts the
++value <tt>value_type(std::move(k), mapped_type())</tt></del><ins>For the first operator, equivalent to:</ins>
++</p>
+ <blockquote>
+-31 <i>Returns</i>: <tt>pred()</tt>
++<pre>
++<ins>return try_emplace(k).first-&gt;second;</ins>
++</pre>
+ </blockquote>
+-
++<p>
++<ins>for the second operator, equivalent to:</ins>
++</p>
+ <blockquote>
+-<ins>?? <i>Postcondition</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread.</ins>
++<pre>
++<ins>return try_emplace(move(k)).first-&gt;second;</ins>
++</pre>
+ </blockquote>
+-
+-<blockquote>
+-32 [ <i>Note</i>: The returned value indicates whether the predicate evaluates to true regardless of whether the
+-timeout was triggered. — <i>end note</i> ]
++<p>
++<del>-3- <i>Returns</i>: A reference to <tt>x.second</tt>, where <tt>x</tt> is the (unique) element whose key is equivalent to
++<tt>k</tt>.</del>
++<p/>
++<del>-4- <i>Complexity</i>: Average case &#x1d4aa;(<tt>1</tt>), worst case &#x1d4aa;(<tt>size()</tt>).</del>
++</p>
+ </blockquote>
+-
+-<blockquote>
+-<ins>?? <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2).</ins>
+ </blockquote>
+-<blockquote>
+-<ins>?? <em>Error conditions</em>:</ins>
+-<ul>
+-<li><ins>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</ins>
+ </li>
+-</ul>
++</ol>
+ </blockquote>
+
+-<blockquote><pre>template &lt;class Rep, class Period, class Predicate&gt;
+-bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
+- Predicate pred);
+-</pre></blockquote>
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<p>Accept resolution of the issue issue <a href="lwg-defects.html#2464">2464</a> and define <tt>operator[]</tt> as follows
++(This would also address issue <a href="lwg-defects.html#2274">2274</a>):</p>
++
++<ol>
++<li><p>Change 23.4.4.3 [map.access] as indicated:</p>
++
+ <blockquote>
+-33 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
+-<ul>
+-<li>no other thread is waiting on this <tt>condition_variable</tt> object or
+-</li>
+-<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
+-waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
+-</li>
+-</ul>
++<pre>
++T&amp; operator[](const key_type&amp; x);
++</pre>
++<blockquote><p>
++-1- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(x, T())</tt>
++into the map.</del><ins>Equivalent to: <tt>return try_emplace(x).first-&gt;second;</tt></ins>
++<p/>
++<del>-2- <i>Requires</i>: <tt>key_type</tt> shall be <tt>CopyInsertable</tt> and <tt>mapped_type</tt> shall be
++<tt>DefaultInsertable</tt> into <tt>*this</tt>.</del>
++<p/>
++<del>-3- <i>Returns</i>: A reference to the <tt>mapped_type</tt> corresponding to <tt>x</tt> in <tt>*this</tt>.</del>
++<p/>
++<del>-4- <i>Complexity</i>: Logarithmic.</del>
++</p>
+ </blockquote>
+-[..]
++<pre>
++T&amp; operator[](key_type&amp;&amp; x);
++</pre>
+ <blockquote>
+-36 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++<p>
++-5- <i>Effects</i>: <del>If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(std::move(x), T())</tt>
++into the map.</del><ins>Equivalent to: <tt>return try_emplace(move(x)).first-&gt;second;</tt></ins>
++<p/>
++<del>-6- <i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>.</del>
++<p/>
++<del>-7- <i>Returns</i>: A reference to the <tt>mapped_type</tt> corresponding to <tt>x</tt> in <tt>*this</tt>.</del>
++<p/>
++<del>-8- <i>Complexity</i>: Logarithmic.</del>
++</p>
+ </blockquote>
+-[..]
+-<blockquote>
+-40 <em>Error conditions</em>:
+-<ul>
+-<li><del><tt>operation_not_permitted</tt> — if the thread does not own the lock.</del>
+-</li>
+-<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</li>
+-</ul>
+ </blockquote>
+-
+ </li>
+
+-<li>Change 30.5.2 [thread.condition.condvarany] as indicated:
+-<p>
+-[..]
+-</p><blockquote><pre>template &lt;class Lock, class Predicate&gt;
+-void wait(Lock&amp; lock, Predicate pred);
+-</pre></blockquote>
++<li><p>Change 23.5.4.3 [unord.map.elem] as indicated:</p>
++
+ <blockquote>
+-<ins>[<i>Note</i>: if any of the wait functions exits with an exception it is indeterminate if the <tt>Lock</tt> is held.
+-One can use a <tt>Lock</tt> type that allows to query that, such as the <tt>unique_lock</tt> wrapper. — <i>end note</i>]</ins>
+-</blockquote>
++<pre>
++mapped_type&amp; operator[](const key_type&amp; k);
++<del>mapped_type&amp; operator[](key_type&amp;&amp; k);</del>
++</pre>
+ <blockquote>
+-14 <i>Effects</i>:
+-<blockquote><pre>while (!pred())
+- wait(lock);
+-</pre></blockquote>
++<p>
++<del>-1- <i>Requires</i>: <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>. For the first operator,
++<tt>key_type</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>. For the second operator, <tt>key_type</tt> shall
++be <tt>MoveConstructible</tt>.</del>
++<p/>
++-2- <i>Effects</i>: <ins>Equivalent to <tt>return try_emplace(k).first-&gt;second;</tt></ins><del>If the <tt>unordered_map</tt>
++does not already contain an element whose key is equivalent to <tt>k</tt>,
++the first operator inserts the value <tt>value_type(k, mapped_type())</tt> and the second operator inserts the
++value <tt>value_type(std::move(k), mapped_type())</tt></del>
++</p>
++<p>
++<del>-3- <i>Returns</i>: A reference to <tt>x.second</tt>, where <tt>x</tt> is the (unique) element whose key is equivalent to
++<tt>k</tt>.</del>
++<p/>
++<del>-4- <i>Complexity</i>: Average case &#x1d4aa;(<tt>1</tt>), worst case &#x1d4aa;(<tt>size()</tt>).</del>
++</p>
++</blockquote>
++
++<pre>
++<ins>mapped_type&amp; operator[](key_type&amp;&amp; k);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Effects</i>: Equivalent to <tt>return try_emplace(move(k)).first-&gt;second;</tt></ins>
++</p>
+ </blockquote>
+
+-[..]
+-<blockquote>
+-34 <em>Error conditions</em>:
+-<ul>
+-<li><del><tt>operation_not_permitted</tt> — if the thread does not own the lock.</del>
+-</li>
+-<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+-</li>
+-</ul>
+ </blockquote>
+ </li>
+-
+ </ol>
+
+
+@@ -6538,16 +28107,26 @@ One can use a <tt>Lock</tt> type that allows to query that, such as the <tt>uniq
+
+
+ <hr>
+-<h3><a name="1502"></a>1502. [FCD] Specification of [futures.state]</h3>
+-<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.state">active issues</a> in [futures.state].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.state">issues</a> in [futures.state].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2471"></a>2471. <tt>copy_n</tt>'s number of <tt>InputIterator</tt> increments unspecified</h3>
++<p><b>Section:</b> 25.3.1 [alg.copy] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-01-28 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#alg.copy">active issues</a> in [alg.copy].</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.copy">issues</a> in [alg.copy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-195</b></p>
+-
+-The intent and meaning of the paragraph is not apparent.
++<p>
++It's unspecified how many times <tt>copy_n</tt> increments the <tt>InputIterator</tt>.
++<tt>uninitialized_copy_n</tt> is specified to increment it exactly <tt>n</tt> times,
++which means if an <tt>istream_iterator</tt> is used then the next character
++after those copied is read from the stream and then discarded, losing data.
++<p/>
++I believe all three of Dinkumware, libc++ and libstdc++ implement
++<tt>copy_n</tt> with <tt>n - 1</tt> increments of the <tt>InputIterator</tt>, which avoids reading
++and discarding a character when used with <tt>istream_iterator</tt>, but is
++inconsistent with <tt>uninitialized_copy_n</tt> and causes surprising behaviour
++with <tt>istreambuf_iterator</tt> instead, because <tt>copy_n(in, 2, copy_n(in, 2,
++out))</tt> is not equivalent to <tt>copy_n(in, 4, out)</tt>
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -6557,30 +28136,53 @@ The intent and meaning of the paragraph is not apparent.
+
+
+ <hr>
+-<h3><a name="1503"></a>1503. [FCD] "associated asynchronous state" must go</h3>
+-<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-01</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.state">active issues</a> in [futures.state].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.state">issues</a> in [futures.state].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2472"></a>2472. Heterogeneous comparisons in the standard library can result in ambiguities</h3>
++<p><b>Section:</b> 20.4.2.7 [tuple.rel], 20.7.9.2 [allocator.globals], 20.8.1.5 [unique.ptr.special], 20.8.2.2.7 [util.smartptr.shared.cmp], 20.12.5.6 [time.duration.comparisons], 20.12.6.6 [time.point.comparisons], 20.13.5 [scoped.adaptor.operators], 24.5.1.3.13 [reverse.iter.op==], 24.5.3.3.13 [move.iter.op.comp] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2015-02-07 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.rel">active issues</a> in [tuple.rel].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-35</b></p>
+-
+-The term "associated asynchronous state" is long, ugly
+-and misleading terminology. When introduced we agreed
+-upon that we should come up with a better name. Here it
+-is: "liaison state". Since the state is hidden and provides
+-synchronization of a future with its corresponding promise,
+-we believe "liaison state" is a much better and shorter
+-name (liaison ~ (typically hidden) relationship)
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p>
++The standard library specifies a lot of heterogeneous comparison operators. For instance:
++</p>
++<blockquote>
++<pre>
++template&lt;class... TTypes, class... UTypes&gt;
++constexpr bool operator!=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
++</pre>
++</blockquote>
++<p>
++This has an unfortunate consequence:
++</p>
++<blockquote>
++<pre>
++#include &lt;tuple&gt;
++#include &lt;utility&gt;
+
++using namespace std::rel_ops;
++std::tuple&lt;int&gt; a(0);
++bool b = a != a;
++</pre>
++</blockquote>
++<p>
++The last line here is ill-formed due to ambiguity: it might be <tt>rel_ops::operator!=</tt>, and it might be the
++heterogeneous tuple <tt>operator!=</tt>. These are not partially ordered, because they have different constraints:
++<tt>rel_ops</tt> requires the types to match, whereas the tuple comparison requires both types to be tuples (but not
++to match). The same thing happens for user code that defines its own unconstrained
++'<tt>template&lt;typename T&gt; operator!=(const T&amp;, const T&amp;)</tt>' rather than using <tt>rel_ops</tt>.
++<p/>
++One straightforward fix would be to add a homogeneous overload for each heterogeneous comparison:
++</p>
+ <blockquote>
+-Change all occurrences of "associated
+-asynchronous state" to "liaison state".
++<pre>
++template&lt;class... TTypes&gt;
++constexpr bool operator!=(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;TTypes...&gt;&amp;);
++</pre>
++<p>
++This is then unambiguously chosen over the other options in the preceding case. FWIW, libstdc++ already does this
++<a href="https://gcc.gnu.org/onlinedocs/gcc-4.6.4/libstdc++/api/a01065_source.html#l00788">in some cases</a>.
++</p>
+ </blockquote>
+
+
+@@ -6591,106 +28193,157 @@ asynchronous state" to "liaison state".
+
+
+ <hr>
+-<h3><a name="1504"></a>1504. [FCD] Term "are serialized" is not defined</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2473"></a>2473. <tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</h3>
++<p><b>Section:</b> 27.9.1.5 [filebuf.virtuals] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Aaron Ballman <b>Opened:</b> 2015-02-09 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.virtuals">issues</a> in [filebuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-196</b></p>
+-
+-The term "are serialized" is not defined (30.6.5 [futures.promise] p. 21, 25).
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+-<blockquote>
+-Replace "are serialized" with "shall not introduce a data race (17.6.4.8)".
+-</blockquote>
+-
+-<p><i>[
+-2010-11-02 Daniel translates proposal into proper wording changes
+-]</i></p>
++<p>
++The restrictions on reading and writing a sequence controlled by an object of class
++<tt>basic_filebuf&lt;charT, traits&gt;</tt> are the same as for reading and writing with
++the Standard C library <tt>FILE</tt>s. One of the restrictions placed by C is on the behavior of
++a stream that is opened for input and output. See the C99 standard, 7.19.5.3p6 for more
++details, but the gist is that when opened in update mode, reads and writes must have an
++intervening file positioning or flushing call to not trigger UB.
++</p>
+
++<p>
++27.9.1.5 [filebuf.virtuals] p13 specifies that <tt>basic_filebuf::seekoff()</tt> calls
++<tt>std::fseek()</tt>. However, there is no mention of <tt>std::fseek()</tt> in
++<tt>basic_filebuf::seekpos()</tt>, and no mention of <tt>std::fflush()</tt> in
++<tt>basic_filebuf::sync()</tt>, which seem like an oversight.
++</p>
+
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
+
+-<p><b>Proposed resolution:</b></p>
+ <ol>
+-<li>Change 30.6.5 [futures.promise] p. 21 as indicated:
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p16 as follows [Editorial note: A footnote referring to <tt>fseek</tt> is not needed,
++because this is already covered by the existing footnote 334]:</p>
+ <blockquote>
+-21 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
+-<tt>promise</tt> object <del>are serialized</del><ins>shall not introduce a data race ([res.on.data.races])</ins>.
+-[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
+-state. — <em>end note</em> ]
++<p>
++-16- Alters the file position, if possible, to correspond to the position stored in <tt>sp</tt> (as described below).
++Altering the file position performs as follows:
++</p>
++<ol>
++<li><p>if <tt>(om &amp; ios_base::out) != 0</tt>, then update the output sequence and write any unshift sequence;</p></li>
++<li><p>set the file position to <tt>sp</tt> <ins>as if by calling <tt>std::fseek(file, sp, SEEK_SET)</tt></ins>;</p></li>
++<li><p>if <tt>(om &amp; ios_base::in) != 0</tt>, then update the input sequence;</p></li>
++</ol>
++<p>
++where <tt>om</tt> is the open mode passed to the last call to <tt>open()</tt>. The operation fails if
++<tt>is_open()</tt> returns false.
++</p>
+ </blockquote>
+ </li>
+-<li>Change 30.6.5 [futures.promise] p. 25 as indicated:
++
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p19 as follows and add a new footnote that mimics comparable footnotes in
++27.9.1.4 [filebuf.members] and 27.9.1.5 [filebuf.virtuals]:</p>
+ <blockquote>
+-25 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
+-<tt>promise</tt> object <del>are serialized</del><ins>shall not introduce a data race ([res.on.data.races])</ins>.
+-[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
+-state. — <em>end note</em> ]
++<p>
++-19- <i>Effects</i>: If a put area exists, calls <tt>filebuf::overflow</tt> to write the characters to the file<ins>, then
++flushes the file as if by calling <tt>std::fflush(file)</tt> [Footnote: The function signature <tt>fflush(FILE*)</tt>
++is declared in <tt>&lt;cstdio&gt;</tt> (27.9.2).]</ins>. If a get area exists, the effect is implementation-defined.
++</p>
+ </blockquote>
+ </li>
+ </ol>
++</blockquote>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++Aaron provides improved wording by removing the params from <tt>std::fseek()</tt> due to the concerns
++regarding the parameters on systems where <tt>fseek</tt> uses 32-bit parameters.
++<p/>
++Second wording improvement, replacing the new one see below. It
++</p>
++<ol>
++<li><p>drops the <tt>std::</tt></p></li>
++<li><p>drops the footnote for <tt>fflush</tt></p></li>
++<li><p>replaces <tt>fseek</tt> with <tt>fsetpos</tt></p></li>
++</ol>
+
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4431.</p>
+
+-
+-<hr>
+-<h3><a name="1505"></a>1505. [FCD] Synchronization between
+-<tt>promise::set_value</tt> and <tt>future::get</tt></h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-197</b></p>
+-
+-There is no defined synchronization between
+-<tt>promise::set_value</tt> and <tt>future::get</tt> (30.6.5 [futures.promise] p. 21, 25).
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
++<ol>
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p16 as follows [Editorial note: A footnote referring to <tt>fseek</tt> is not needed,
++because this is already covered by the existing footnote 334]:</p>
+ <blockquote>
+-Replace "[Note: and they synchronize and
+-serialize with other functions through the referred
+-associated asynchronous state. --end note]" with
+-the normative "They synchronize with (1.10) any
+-operation on a future object with the same
+-associated asynchronous state marked ready."
++<p>
++-16- Alters the file position, if possible, to correspond to the position stored in <tt>sp</tt> (as described below).
++Altering the file position performs as follows:
++</p>
++<ol>
++<li><p>if <tt>(om &amp; ios_base::out) != 0</tt>, then update the output sequence and write any unshift sequence;</p></li>
++<li><p>set the file position to <tt>sp</tt> <ins>as if by a call to <tt>std::fseek</tt></ins>;</p></li>
++<li><p>if <tt>(om &amp; ios_base::in) != 0</tt>, then update the input sequence;</p></li>
++</ol>
++<p>
++where <tt>om</tt> is the open mode passed to the last call to <tt>open()</tt>. The operation fails if
++<tt>is_open()</tt> returns false.
++</p>
+ </blockquote>
++</li>
+
+-<p><i>[
+-2010-11-02 Daniel translates proposal into proper wording changes
+-]</i></p>
+-
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p19 as follows and add a new footnote that mimics comparable footnotes in
++27.9.1.4 [filebuf.members] and 27.9.1.5 [filebuf.virtuals]:</p>
++<blockquote>
++<p>
++-19- <i>Effects</i>: If a put area exists, calls <tt>filebuf::overflow</tt> to write the characters to the file<ins>, then
++flushes the file as if by calling <tt>std::fflush(file)</tt> [Footnote: The function signature <tt>fflush(FILE*)</tt>
++is declared in <tt>&lt;cstdio&gt;</tt> (27.9.2).]</ins>. If a get area exists, the effect is implementation-defined.
++</p>
++</blockquote>
++</li>
++</ol>
++</blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
+ <ol>
+-<li>Change 30.6.5 [futures.promise] p. 21 as indicated:
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p16 as follows [Editorial note: A footnote referring to <tt>fseek</tt> is not needed,
++because this is already covered by the existing footnote 334]:</p>
+ <blockquote>
+-21 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
+-<tt>promise</tt> object are serialized.
+-<del>[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
+-state. — <em>end note</em> ]</del><ins>They <em>synchronize with</em> ([intro.multithread]) any
+-operation on a future object with the same associated asynchronous state marked ready.</ins>
++<p>
++-16- Alters the file position, if possible, to correspond to the position stored in <tt>sp</tt> (as described below).
++Altering the file position performs as follows:
++</p>
++<ol>
++<li><p>if <tt>(om &amp; ios_base::out) != 0</tt>, then update the output sequence and write any unshift sequence;</p></li>
++<li><p>set the file position to <tt>sp</tt> <ins>as if by a call to <tt>fsetpos</tt></ins>;</p></li>
++<li><p>if <tt>(om &amp; ios_base::in) != 0</tt>, then update the input sequence;</p></li>
++</ol>
++<p>
++where <tt>om</tt> is the open mode passed to the last call to <tt>open()</tt>. The operation fails if
++<tt>is_open()</tt> returns false.
++</p>
+ </blockquote>
+ </li>
+-<li>Change 30.6.5 [futures.promise] p. 25 as indicated:
++
++<li>
++<p>Change 27.9.1.5 [filebuf.virtuals] p19 as follows and add a new footnote that mimics comparable footnotes in
++27.9.1.4 [filebuf.members] and 27.9.1.5 [filebuf.virtuals]:</p>
+ <blockquote>
+-25 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
+-<tt>promise</tt> object are serialized.
+-<del>[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
+-state. — <em>end note</em> ]</del><ins>They <em>synchronize with</em> ([intro.multithread]) any
+-operation on a future object with the same associated asynchronous state marked ready.</ins>
++<p>
++-19- <i>Effects</i>: If a put area exists, calls <tt>filebuf::overflow</tt> to write the characters to the file<ins>, then
++flushes the file as if by calling <tt>fflush(file)</tt></ins>. If a get area exists, the effect is implementation-defined.
++</p>
+ </blockquote>
+ </li>
+ </ol>
+@@ -6700,346 +28353,480 @@ operation on a future object with the same associated asynchronous state marked
+
+
+ <hr>
+-<h3><a name="1507"></a>1507. [FCD] <tt>promise::<i>XXX</i>_at_thread_exit</tt> functions have no
+-synchronization requirements</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2474"></a>2474. <tt>&lt;cmath&gt;</tt> functions unfriendly to <tt>integral_constant</tt> arguments</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matheus Izvekov <b>Opened:</b> 2015-02-13 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-199</b></p>
++<p>
++Using numeric wrappers with <tt>&lt;cmath&gt;</tt> functions is currently troublesome.
++Code such as: "<tt>std::exp2(std::integral_constant&lt;int, 5&gt;{})</tt>" will fail to
++compile because of ambiguity.
++<p/>
++Arguments which are implicitly convertible to an arithmetic type should be accepted whenever
++the latter would be accepted.
++<p/>
++David Krauss pointed out that some issue may present itself with numeric libraries which provide <tt>&lt;cmath&gt;</tt>
++equivalents in their own namespace which are not more specialized than the ones provided in <tt>&lt;cmath&gt;</tt>.
++If the changes proposed are implemented, then cases where the user brings those into scope through ADL might become ambiguous.
++<p/>
++It's hard to assess how much breakage this would cause in the wild, and how much work it would take to fix.
++Should this be determined to be a problem, it's possible to make the new behaviour optional, and disabled by
++default for all user-defined types.
++</p>
+
+-<tt>promise::<i>XXX</i>_at_thread_exit</tt> functions have no
+-synchronization requirements. Specifying synchronization
+-for these member functions requires coordinating with the
+-words in 30.6.5/21 and 25, which give synchronization
+-requirements for <tt>promise::set_value</tt> and
+-<tt>promise::set_exception</tt> (30.6.5 [futures.promise] p. 26 ff., p. 29 ff.).
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
++<ol>
++<li>
++<p>Change 26.8 [c.math] p11 b2 as indicated:</p>
+ <blockquote>
+-Change 30.6.5/21 to mention
+-set_value_at_thread_exit and
+-set_exception_at_thread_exit; with this text,
+-replace 30.6.5/25 and add two new paragraphs,
+-after 30.6.5/28 and 30.6.5/31.
++<p>
++-11- Moreover, there shall be additional overloads sufficient to ensure:
++</p>
++<ol>
++<li><p>[&hellip;]</p></li>
++<li><p>Otherwise, if any arithmetic argument corresponding to a <tt>double</tt> parameter has type <tt>double</tt> or
++<del>an integer type</del><ins>a type which is not floating-point, but which is implicitly convertible to <tt>double</tt></ins>,
++then all arithmetic arguments corresponding to <tt>double</tt> parameters are effectively cast to <tt>double</tt>.</p></li>
++<li><p>[&hellip;]</p></li>
++</ol>
+ </blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1514"></a>1514. [FCD] <tt>packaged_task</tt> constructors need review</h3>
+-<p><b>Section:</b> 30.6.10.1 [futures.task.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.task.members">active issues</a> in [futures.task.members].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2475"></a>2475. Allow overwriting of <tt>std::basic_string</tt> terminator with <tt>charT()</tt> to allow
++cleaner interoperation with legacy APIs</h3>
++<p><b>Section:</b> 21.4.5 [string.access] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Matt Weber <b>Opened:</b> 2015-02-21 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.access">issues</a> in [string.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-207</b></p>
++<p>
++It is often desirable to use a <tt>std::basic_string</tt> object as a buffer when interoperating with libraries
++that mutate null-terminated arrays of characters. In many cases, these legacy APIs write a null terminator at
++the specified end of the provided buffer. Providing such a function with an appropriately-sized
++<tt>std::basic_string</tt> results in undefined behavior when the <tt>charT</tt> object at the <tt>size()</tt>
++position is overwritten, even if the value remains unchanged.
++<p/>
++Absent the ability to allow for this, applications are forced into pessimizations such as: providing
++appropriately-sized <tt>std::vectors</tt> of <tt>charT</tt> for interoperating with the legacy API, and then
++copying the <tt>std::vector</tt> to a <tt>std::basic_string</tt>; providing an oversized <tt>std::basic_string</tt>
++object and then calling <tt>resize()</tt> later.
++<p/>
++A trivial example:
++</p>
++<blockquote>
++<pre>
++#include &lt;string&gt;
++#include &lt;vector&gt;
+
+-The constructor that takes R(*)(ArgTypes...) is not
+-needed; the constructor that takes a callable type works
+-for this argument type. More generally, the constructors
+-for packaged_task should parallel those for function.
++void legacy_function(char *out, size_t count) {
++ for (size_t i = 0; i &lt; count; ++i) {
++ *out++ = '0' + (i % 10);
++ }
++ *out = '\0'; // <span style="color:#C80000;font-weight:bold">if size() == count, this results in undefined behavior</span>
++}
+
+-<p><i>[
+-US-207 Suggested Resolution:
+-]</i></p>
++int main() {
++ std::string s(10, '\0');
++ legacy_function(&amp;s[0], s.size()); // <span style="color:#C80000;font-weight:bold">undefined behavior</span>
+
++ std::vector&lt;char&gt; buffer(11);
++ legacy_function(&amp;buffer[0], buffer.size() - 1);
++ std::string t(&amp;buffer[0], buffer.size() - 1); // potentially expensive copy
+
+-<blockquote>
+-Review the constructors for packaged_task and
+-provide the same ones as function, except where
+-inappropriate.
++ std::string u(11, '\0');
++ legacy_function(&amp;u[0], u.size() - 1);
++ u.resize(u.size() - 1); // needlessly complicates the program's logic
++}
++</pre>
+ </blockquote>
+-
+-<p><i>[
+-2010-10-22 Howard provides wording, as requested by the LWG in Rapperswil.
+-]</i></p>
+-
+-
++<p>
++A slight relaxation of the requirement on the returned object from the element access operator would
++allow for this interaction with no semantic change to existing programs.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Alter the list of constructors in both [futures.task] and in [futures.task.members] as indicated:
++<p>This wording is relative to N4296.</p>
+
++<ol>
++<li>
++<p>Edit 21.4.5 [string.access] as indicated:</p>
+ <blockquote>
+-<pre><del>template &lt;class F&gt;
+-explicit packaged_task(F f);
+-template &lt;class F, class Allocator&gt;
+-explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F f);
+-explicit packaged_task(R(*f)(ArgTypes...));</del>
+-template &lt;class F&gt;
+-explicit packaged_task(F&amp;&amp; f);
+-template &lt;class F, class Allocator&gt;
+-explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++<pre>
++const_reference operator[](size_type pos) const;
++reference operator[](size_type pos);
+ </pre>
++<blockquote>
++<p>
++-1- <i>Requires</i>: [&hellip;]
++<p/>
++-2- <i>Returns</i>: <tt>*(begin() + pos) if pos &lt; size()</tt>. Otherwise, returns a reference to an object of type
++<tt>charT</tt> with value <tt>charT()</tt>, where modifying the object <ins>to any value other than <tt>charT()</tt></ins>
++leads to undefined behavior.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
+ </blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1515"></a>1515. [FCD] <tt>packaged_task::make_ready_at_thread_exit</tt> has no
+-synchronization requirements</h3>
+-<p><b>Section:</b> 30.6.10.1 [futures.task.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.task.members">active issues</a> in [futures.task.members].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2476"></a>2476. <tt>scoped_allocator_adaptor</tt> is not assignable</h3>
++<p><b>Section:</b> 20.13.1 [allocator.adaptor.syn] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-03-02 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-208</b></p>
+-
+ <p>
+-<tt>packaged_task::make_ready_at_thread_exit</tt> has no
+-synchronization requirements.
++The class definition in 20.13.1 [allocator.adaptor.syn] declares a move
++constructor, which means that the copy assignment operator is defined
++as deleted, and no move assignment operator is declared.
++<p/>
++This means a <tt>scoped_allocator_adaptor</tt> is not assignable, and a
++container using <tt>scoped_allocator_adaptor&lt;A...&gt;</tt> may not be
++<tt>CopyAssignable</tt> or <tt>MoveAssignable</tt> (depending on the
++<tt>propagate_on_container_xxxx_assignment</tt> traits of the outer and inner
++allocator types).
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><i>[2015-04-03 Howard comments]</i></p>
++
++<p>
++If the contained allocators are not assignable, I think we need the ability of <tt>= default</tt> to automagically become
++<tt>= delete</tt>. My concern is that <tt>is_copy_assignable&lt;scoped_allocator_adaptor&lt;CustomAllocator&gt;&gt;::value</tt>
++get the right answer for both cases:
++</p>
++<ol>
++<li><p><tt>is_copy_assignable&lt;CustomAllocator&gt;::value</tt> is <tt>true</tt>.</p></li>
++<li><p><tt>is_copy_assignable&lt;CustomAllocator&gt;::value</tt> is <tt>false</tt>.</p></li>
++</ol>
++<p>
++If we allow the vendor to declare and provide the copy assignment operator, the chance of getting #2 correct goes to zero.
++</p>
+
+ <p>
+-Figure out what the synchronization requirements
+-should be and write them.
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li>
++<p>Add to the synopsis in 20.13.1 [allocator.adaptor.syn]/1 [<i>Editorial remark</i>: The proposed wording
++does not explicitly specify the semantics of the added copy/move assignment operators, based on
++17.5.2.2 [functions.within.classes] p1, which says:
++<p/>
++"For the sake of exposition, Clauses 18 through 30 and Annex D do not describe copy/move constructors,
++assignment operators, or (non-virtual) destructors with the same apparent semantics as those that can be
++generated by default (12.1, 12.4, 12.8)."
++<p/>
++&mdash; <i>end remark</i>]:
+ </p>
++<blockquote>
++<pre>
++[&hellip;]
++template &lt;class OuterA2&gt;
++ scoped_allocator_adaptor(
++ scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp;&amp; other) noexcept;
++<ins>
++scoped_allocator_adaptor&amp; operator=(const scoped_allocator_adaptor&amp;);
++scoped_allocator_adaptor&amp; operator=(scoped_allocator_adaptor&amp;&amp;);
++</ins>
++~scoped_allocator_adaptor();
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++Move to Immediate.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li>
++<p>Add to the synopsis in 20.13.1 [allocator.adaptor.syn]/1:
++</p>
++<blockquote>
++<pre>
++[&hellip;]
++template &lt;class OuterA2&gt;
++ scoped_allocator_adaptor(
++ scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp;&amp; other) noexcept;
++<ins>
++scoped_allocator_adaptor&amp; operator=(const scoped_allocator_adaptor&amp;) = default;
++scoped_allocator_adaptor&amp; operator=(scoped_allocator_adaptor&amp;&amp;) = default;
++</ins>
++~scoped_allocator_adaptor();
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1521"></a>1521. Requirements on internal pointer representations in containers</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Mike Spertus <b>Opened:</b> 2010-10-16 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2477"></a>2477. Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></h3>
++<p><b>Section:</b> 23.3.3.4 [deque.modifiers], 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Anton Savin <b>Opened:</b> 2015-03-03 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.modifiers">issues</a> in [deque.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-104, US-141</b></p>
+-
+ <p>
+-The standard doesn't say that containers should use abstract pointer
+-types internally. Both Howard and Pablo agree that this is the intent.
+-Further, it is necessary for containers to be stored, for example, in
+-shared memory with an interprocess allocator (the type of scenario that
+-allocators are intended to support).
++In the latest draft N4296, and in all drafts up to at least N3337:
++<p/>
++23.3.3.4 [deque.modifiers]/5 (regarding <tt>deque::erase()</tt>):
+ </p>
++<blockquote>
+ <p>
+-In spite of the (possible) agreement on intent, it is necessary to make
+-this explicit:
++<i>Complexity</i>: The number of calls to the destructor is the same as the number of elements erased, but
++the number of calls to the <span style="color:#C80000;font-weight:bold">assignment operator</span> is no more
++than the lesser of the number of elements before the erased elements and the number of elements after the erased elements.
+ </p>
++</blockquote>
+ <p>
+-An implementations may like to store the result of dereferencing the
+-pointer (which is a raw reference) as an optimization, but that prevents
+-the data structure from being put in shared memory, etc. In fact, a
+-container could store raw references to the allocator, which would be a
+-little weird but conforming as long as it has one by-value copy.
+-Furthermore, pointers to locales, ctypes, etc. may be there, which also
+-prevents the data structure from being put in shared memory, so we
+-should make explicit that a container does not store raw pointers or
+-references at all.
++23.3.6.5 [vector.modifiers]/4 (regarding <tt>vector::erase()</tt>):
+ </p>
+-
+-<p><i>[
+-Pre-batavia
+-]</i></p>
+-
++<blockquote>
+ <p>
+-This issue is being opened as part of the response to NB comments US-104/141.
+-See paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">N3171</a>
+-in the pre-Batavia mailing.
++<i>Complexity</i>: The destructor of <tt>T</tt> is called the number of times equal to the number of the elements
++erased, but the <span style="color:#C80000;font-weight:bold">move assignment operator</span> of <tt>T</tt> is called
++the number of times equal to the number of elements in the vector after the erased elements.
+ </p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
++</blockquote>
+ <p>
+-Add to the end of 23.2.1 [container.requirements.general] p. 8:
++Is there any reason for explicit mentioning of move assignment for <tt>std::vector::erase()</tt>?
++Shouldn't these two wordings be the same with this regard?
++<p/>
++Also, for <tt>std::deque</tt>, it's not clear from the text which destructors and assignment operators are called.
+ </p>
+-<blockquote>
+-[..] In all container types defined in this Clause, the member <tt>get_allocator()</tt> returns
+-a copy of the allocator used to construct the container or, if that allocator has been replaced,
+-a copy of the most recent replacement. <ins>The container may not store internal objects whose
+-types are of the form <tt>T *</tt> or <tt>T &amp;</tt> except insofar as they are part of the
+-item type or members.</ins>
+-</blockquote>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++Move to Immediate.
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
+-<hr>
+-<h3><a name="1523"></a>1523. [FCD] <tt>noexcept</tt> for Clause 29</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2010-11-13 <b>Last modified:</b> 2010-11-14</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses GB-63 for Clause 29</b></p>
++<ol>
++<li><p>Change 23.3.3.4 [deque.modifiers]/5 to:</p>
+
+-<p>Clause 29 does not specify noexcept for any of the atomic operations.
+-It probably should, though that's not completely clear.
+-In particular, atomics may want to throw in implementations that support transactional memory.
++<p>
++-5- <i>Complexity</i>: The number of calls to the destructor <ins>of <tt>T</tt></ins> is the same as the number of
++elements erased, but the number of calls to the assignment operator <ins>of <tt>T</tt></ins> is no more than the
++lesser of the number of elements before the erased elements and the number of elements after the erased elements.
+ </p>
++</li>
+
++<li><p>Change 23.3.6.5 [vector.modifiers]/4 to:</p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
++-4- <i>Complexity</i>: The destructor of <tt>T</tt> is called the number of times equal to the number of the elements
++erased, but the <del>move</del> assignment operator of <tt>T</tt> is called the number of times equal to the number of
++elements in the vector after the erased elements.
+ </p>
++</li>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="2000"></a>2000. Missing definition of <tt>packaged_task</tt> specialization of <tt>uses_allocator</tt></h3>
+-<p><b>Section:</b> 30.6.10.2 [futures.task.nonmembers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-08-29 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
++<h3><a name="2478"></a>2478. Unclear how <tt>wstring_convert</tt> uses <tt>cvtstate</tt></h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-03-04 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-[futures.task.nonmembers]/3 says:
+-</p><blockquote><pre> template &lt;class R, class Alloc&gt;
+- struct uses_allocator&lt;packaged_task&lt;R&gt;, Alloc&gt;;
+-</pre></blockquote>
+-
+-This is a declaration, but should be a definition.
+-<p></p>
++How do <tt>wstring_convert::from_bytes</tt> and <tt>wstring_convert::to_bytes</tt> use
++the <tt>cvtstate</tt> member?
++<p/>
++Is it passed to the <tt>codecvt</tt> member functions? Is a copy of it passed
++to the member functions? "Otherwise it shall be left unchanged"
++implies a copy is used, but if that's really what's intended there are
++simpler ways to say so.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2479"></a>2479. Unclear how <tt>wbuffer_convert</tt> uses <tt>cvtstate</tt></h3>
++<p><b>Section:</b> 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-03-04 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.buffer">active issues</a> in [conversions.buffer].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.buffer">issues</a> in [conversions.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Change [futures.task.nonmembers]/3:
++How does <tt>wbuffer_convert</tt> use the <tt>cvtstate</tt> member?
++<p/>
++Is the same conversion state object used for converting both the get
++and put areas? That means a read which runs out of bytes halfway
++through a multibyte character will leave some shift state in cvtstate,
++which would then be used by a following write, even though the shift
++state of the get area is unrelated to the put area.
+ </p>
+
+-<blockquote><pre> template &lt;class R, class Alloc&gt;
+- struct uses_allocator&lt;packaged_task&lt;R&gt;, Alloc&gt;<del>;</del>
+- <ins>: true_type {};</ins>
+-</pre></blockquote>
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="2001"></a>2001. Class template <tt>basic_regex</tt> uses non existent <tt>string_type</tt></h3>
+-<p><b>Section:</b> 28.8.3 [re.regex.assign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Volker Lukas <b>Opened:</b> 2010-10-21 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2480"></a>2480. Error handling of <tt>wbuffer_convert</tt> unclear</h3>
++<p><b>Section:</b> 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-03-04 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.buffer">active issues</a> in [conversions.buffer].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.buffer">issues</a> in [conversions.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In working draft N3126, subclause 28.8.3 [re.regex.assign], paragraphs 12, 13 and 19,
+-the name <tt>string_type</tt> is used. This is presumably a typedef for <tt>basic_string&lt;value_type&gt;</tt>, where
+-<tt>value_type</tt> is the character type used by <tt>basic_regex</tt>. The <tt>basic_regex</tt>
+-template however defines no such typedef, and neither does the <tt>&lt;regex&gt;</tt>
+-header or the <tt>&lt;initializer_list&gt;</tt> header included by <tt>&lt;regex&gt;</tt>.
++If a <tt>codecvt</tt> conversion returns <tt>codecvt_base::error</tt> should that be
++treated as <tt>EOF</tt>? An exception? Should all the successfully converted
++characters before a conversion error be available to the users of the
++<tt>wbuffer_convert</tt> and/or the internal <tt>streambuf</tt>, or does a conversion
++error lose information?
+ </p>
+
+-<p><i>[
+-2010-11-03 Daniel comments and suggests alternative wording:
+-]</i></p>
+
+-<blockquote>
+-The proposed resolution needs to use <tt>basic_string&lt;<strong>charT</strong>&gt;</tt> instead of <tt>basic_string&lt;char&gt;</tt>
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
+-<p>Proposed Resolution:</p>
+
+-Make the following changes to [re.regex.assign]:<p>
+
+-</p><blockquote>
+-<pre>basic_regex&amp; assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
+-</pre>
+-<blockquote>
+-12 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(ptr), f)</tt>.
+-</blockquote>
+
+-<pre>basic_regex&amp; assign(const charT* ptr, size_t len,
+- flag_type f = regex_constants::ECMAScript);
+-</pre>
+-<blockquote>
+-13 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(ptr, len), f)</tt>.
+-</blockquote>
+
+-<pre>[..]
++<hr>
++<h3><a name="2481"></a>2481. <tt>wstring_convert</tt> should be more precise regarding "byte-error string" etc.</h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-03-04 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Paragraph 4 of 22.3.3.2.2 [conversions.string] introduces <tt>byte_err_string</tt>
++as "a byte string to display on errors". What does display mean? The string is returned
++on error, it's not displayed anywhere.
++<p/>
++Paragraph 14 says "Otherwise, if the object was constructed with a
++byte-error string, the member function shall return the byte-error
++string." The term byte-error string is not used anywhere else.
++<p/>
++Paragraph 17 talks about storing "default values in <tt>byte_err_string</tt>".
++What default value? Is "Hello, world!" allowed? If it means
++default-construction it should say so. If paragraph 14 says it won't
++be used what does it matter how it's initialized? The end of the
++paragraph refers to storing "<tt>byte_err</tt> in <tt>byte_err_string</tt>". This should
++be more clearly related to the wording in paragraph 14.
++<p/>
++It might help if the constructor (and destructor) was specified before
++the other member functions, so it can more formally define the
++difference between being "constructed with a byte-error string" and
++not.
++<p/>
++All the same issues apply to the <tt>wide_err_string</tt> member.
++</p>
+
+-template &lt;class InputIterator&gt;
+- basic_regex&amp; assign(InputIterator first, InputIterator last,
+- flag_type f = regex_constants::ECMAScript);
+-</pre>
+
+-<blockquote>
+-18 <i>Requires</i>: The type <tt>InputIterator</tt> shall satisfy the requirements for an Input Iterator (24.2.3).
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-19 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(first, last), f)</tt>.
+-</blockquote>
+
+-</blockquote>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
+
+
++<hr>
++<h3><a name="2483"></a>2483. <tt>throw_with_nested()</tt> should use <tt>is_final</tt></h3>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Unsure if we should just give <tt>basic_regex</tt> a <tt>string_type</tt> typedef. Looking for when <tt>string_type</tt> was
+-introduced into <tt>regex</tt>. Howard to draft wording for <tt>typedef typename traits::string_type string_type</tt>, then move to Review.
++When <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2559.htm">N2559</a> was voted into the Working Paper,
++it said "This function template must take special case to handle non-class types, unions and <tt>[[final]]</tt> classes that cannot
++be derived from, and [...]". However, its Standardese didn't handle <tt>final</tt> classes, and this was never revisited. Now that
++we have <tt>is_final</tt>, we can achieve this proposal's original intention.
++<p/>
++Additionally, we need to handle the case where <tt>U</tt> is <tt>nested_exception</tt> itself. <tt>is_base_of</tt>'s wording
++handles this and ignores <i>cv</i>-qualifiers. (Note that <tt>is_class</tt> detects "non-union class type".)
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Make the following changes to [re.regex.assign]:</p>
+-
+-<blockquote>
+-
+-<pre>basic_regex&amp; assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
+-</pre>
+-<blockquote>
+-12 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;char&gt;</ins>(ptr), f)</tt>.
+-</blockquote>
++STL, MC and JW already do this<br/>
++MC: move to Ready, bring to motion on Friday<br/>
++7 in favor, none opposed
++</p>
+
+-<pre>basic_regex&amp; assign(const charT* ptr, size_t len,
+- flag_type f = regex_constants::ECMAScript);
+-</pre>
+-<blockquote>
+-13 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;char&gt;</ins>(ptr, len), f)</tt>.
+-</blockquote>
+
+-<pre>[..]
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
+-template &lt;class InputIterator&gt;
+- basic_regex&amp; assign(InputIterator first, InputIterator last,
+- flag_type f = regex_constants::ECMAScript);
+-</pre>
++<ol>
++<li><p>Change 18.8.6 [except.nested] as depicted:</p>
+
+ <blockquote>
+-18 <i>Requires</i>: The type <tt>InputIterator</tt> shall satisfy the requirements for an Input Iterator (24.2.3).
+-</blockquote>
+-
++<pre>
++template &lt;class T&gt; [[noreturn]] void throw_with_nested(T&amp;&amp; t);
++</pre>
+ <blockquote>
+-19 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;char&gt;</ins>(first, last), f)</tt>.
++<p>
++-6- Let <tt>U</tt> be <tt>remove_reference_t&lt;T&gt;</tt>.
++<p/>
++-7- Requires: <tt>U</tt> shall be <tt>CopyConstructible</tt>.
++<p/>
++-8- Throws: if <del><tt>U</tt> is a non-union class type not derived from
++<tt>nested_exception</tt></del><ins><tt>is_class&lt;U&gt;::value &amp;&amp; !is_final&lt;U&gt;::value &amp;&amp;
++!is_base_of&lt;nested_exception, U&gt;::value</tt> is <tt>true</tt></ins>, an exception of unspecified type that
++is publicly derived from both <tt>U</tt> and <tt>nested_exception</tt> and constructed from
++<tt>std::forward&lt;T&gt;(t)</tt>, otherwise <tt>std::forward&lt;T&gt;(t)</tt>.
++</p>
+ </blockquote>
+-
+ </blockquote>
++</li>
++</ol>
+
+
+
+@@ -7047,480 +28834,647 @@ template &lt;class InputIterator&gt;
+
+
+ <hr>
+-<h3><a name="2003"></a>2003. String exception inconsistency in erase.</h3>
+-<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> JoseÌ Daniel GarciÌa SaÌnchez <b>Opened:</b> 2010-10-21 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.require">issues</a> in [string.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2484"></a>2484. <tt>rethrow_if_nested()</tt> is doubly unimplementable</h3>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Clause 21.4.1 [string.require]p3 states:
++<tt>rethrow_if_nested()</tt> wants to determine "If the dynamic type of <tt>e</tt> is publicly and unambiguously derived
++from <tt>nested_exception</tt>", but 5.2.7 [expr.dynamic.cast] specifies that <tt>dynamic_cast</tt> has a couple
++of limitations.
++<p/>
++First, nonpolymorphic inputs. These could be non-classes, or nonpolymorphic classes. The Standardese handles non-classes,
++although implementers need special logic. (If <tt>E</tt> is <tt>int</tt>, the dynamic type can't possibly derive from
++<tt>nested_exception</tt>. Implementers need to detect this and avoid <tt>dynamic_cast</tt>, which would be ill-formed
++due to 5.2.7 [expr.dynamic.cast]/2.) The Standardese is defective when <tt>E</tt> is a nonpolymorphic class.
++Consider the following example:
+ </p>
+ <blockquote>
+-No <tt>erase()</tt> or <tt>pop_back()</tt> member function shall throw
+-any exceptions.
++<pre>
++struct Nonpolymorphic { };
++struct MostDerived : Nonpolymorphic, nested_exception { };
++MostDerived md;
++const Nonpolymorphic&amp; np = md;
++rethrow_if_nested(np);
++</pre>
+ </blockquote>
+ <p>
+-However in 21.4.6.5 [string::erase] p2 the first version of <tt>erase</tt> has
++According to 1.3 [defns.dynamic.type], the dynamic type of <tt>np</tt> is <tt>MostDerived</tt>. However, it's
++physically impossible to discover this, and attempting to do so will lead to an ill-formed <tt>dynamic_cast</tt>
++(5.2.7 [expr.dynamic.cast]/6). The Standardese must be changed to say that if <tt>E</tt> is nonpolymorphic, nothing happens.
++<p/>
++Second, statically good but dynamically bad inputs. Consider the following example:
+ </p>
+ <blockquote>
+-<i>Throws</i>: <tt>out_of_range</tt> if <tt>pos &gt; size()</tt>.
++<pre>
++struct Nested1 : nested_exception { };
++struct Nested2 : nested_exception { };
++struct Ambiguous : Nested1, Nested2 { };
++Ambiguous amb;
++const Nested1&amp; n1 = amb;
++rethrow_if_nested(n1);
++</pre>
+ </blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Update [string.require]p/3:
++Here, the static type <tt>Nested1</tt> is good (i.e. publicly and unambiguously derived from <tt>nested_exception</tt>), but
++the dynamic type <tt>Ambiguous</tt> is bad. The Standardese currently says that we have to detect the dynamic badness, but
++<tt>dynamic_cast</tt> won't let us. 5.2.7 [expr.dynamic.cast]/3 and /5 are special cases (identity-casting and upcasting,
++respectively) that activate before the "run-time check" behavior that we want (/6 and below). Statically good inputs succeed
++(regardless of the dynamic type) and statically bad inputs are ill-formed (implementers must use type traits to avoid this).
++<p/>
++It might be possible to implement this with clever trickery involving virtual base classes, but implementers shouldn't be asked
++to do that. It would definitely be possible to implement this with a compiler hook (a special version of <tt>dynamic_cast</tt>),
++but implementers shouldn't be asked to do so much work for such an unimportant case. (This case is pathological because the
++usual way of adding <tt>nested_exception</tt> inheritance is <tt>throw_with_nested()</tt>, which avoids creating bad inheritance.)
++The Standardese should be changed to say that statically good inputs are considered good.
++<p/>
++Finally, we want <tt>is_base_of</tt>'s "base class or same class" semantics. If the static type is <tt>nested_exception</tt>,
++we have to consider it good due to <tt>dynamic_cast</tt>'s identity-casting behavior. And if the dynamic type is
++<tt>nested_exception</tt>, it is definitely good.
+ </p>
+-<blockquote>
+-3 No <del><tt>erase()</tt> or</del> <tt>pop_back()</tt> member function
+-shall throw any exceptions.
+-</blockquote>
+-
+-
+-
+
++<p><i>[2015-05, Lenexa]</i></p>
+
+-<hr>
+-<h3><a name="2004"></a>2004. <tt>duration::operator*</tt> has template parameters in funny order</h3>
+-<p><b>Section:</b> 20.11.3.5 [time.duration.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-In [time] and [time.duration.nonmember] we have:
+-</p>
+-<blockquote><pre>template &lt;class Rep1, class Period, class Rep2&gt;
+- duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+- operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
+-</pre></blockquote>
+ <p>
+-Everywhere else, we always have <tt>&lt;rep, period&gt;</tt> in that order for a given
+-type. But here, we have <tt>Period</tt> and <tt>Rep2</tt> in reverse order for
+-<tt>&lt;Rep2, Period&gt;</tt>. This is probably of little importance, since the
+-template parameters are seldom spelled out for a function like this. But changing it
+-now will eliminate a potential source of future errors and confusion.
++WB: so the <tt>is_polymorphic</tt> trait must be used?<br/>
++STL and JW: yes, that must be used to decide whether to try using <tt>dynamic_cast</tt> or not.<br/>
++JW: I'd already made this fix in our implementation<br/>
++STL: the harder case also involves <tt>dynamic_cast</tt>. should not try using <tt>dynamic_cast</tt> if we can
++statically detect it is OK, doing the <tt>dynamic_cast</tt> might fail.<br/>
++STL: finally, want "is the same or derived from" behaviour of <tt>is_base_of</tt><br/>
++WB: should there be an "else no effect" at the end? We have "Otherwise, if ..." and nothing saying what if the condition is false.<br/>
++TP I agree.<br/>
++MC: move to Ready and bring to motion on Friday<br/>
++7 in favor, none opposed
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 18.8.6 [except.nested] as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
++</pre>
++<blockquote>
+ <p>
+-Change the signature in [time] and [time.duration.nonmember] to:
++-9- <i>Effects</i>: If <ins><tt>E</tt> is not a polymorphic class type, there is no effect. Otherwise, if the static
++type or</ins> the dynamic type of <tt>e</tt> <ins>is <tt>nested_exception</tt> or</ins> is publicly and unambiguously
++derived from <tt>nested_exception</tt>, calls <tt>dynamic_cast&lt;const nested_exception&amp;&gt;(e).rethrow_nested()</tt>.
+ </p>
+-<blockquote><pre>template &lt;class Rep1, class <del>Period</del><ins>Rep2</ins>, class <del>Rep2</del><ins>Period</ins>&gt;
+- duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+- operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
+-</pre></blockquote>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="2005"></a>2005. <tt>unordered_map::insert(T&amp;&amp;)</tt> protection should apply to <tt>map</tt> too</h3>
+-<p><b>Section:</b> 23.6.1.3 [map.modifiers], 23.6.2.2 [multimap.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2485"></a>2485. <tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></h3>
++<p><b>Section:</b> 20.4.2.6 [tuple.elem] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.elem">issues</a> in [tuple.elem].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In [unord.map.modifiers], the signature:
+-</p><blockquote><pre>template &lt;class P&gt;
+- pair&lt;iterator, bool&gt; insert(P&amp;&amp; obj);
+-</pre></blockquote>
+-now has an added Remarks paragraph:
+-<p></p>
+-<blockquote>
+-<i>Remarks</i>: This signature shall not participate in overload resolution unless <tt>P</tt>
+-is implicitly convertible to <tt>value_type</tt>.
+-</blockquote>
+-<p>
+-The same is true for <tt>unordered_multimap</tt>.
+-</p>
+-<p>
+-But neither <tt>map</tt> nor <tt>multimap</tt> have this constraint, even though it is a
+-Good Thing(TM) in those cases as well.
++<tt>const</tt> rvalues are weird, but they're part of the type system. Consider the following code:
+ </p>
++<blockquote>
++<pre>
++#include &lt;functional&gt;
++#include &lt;string&gt;
++#include &lt;tuple&gt;
+
+-<p><i>[
+-The submitter suggests: Add the same Remarks clause to [map.modifiers] and [multimap.modifiers].
+-]</i></p>
+-
+-
+-<p><i>[
+-2010-10-29 Daniel comments:
+-]</i></p>
+-
++using namespace std;
+
+-<p>
+-I believe both paragraphs need more cleanup: First, the current Requires element conflict with the Remark;
+-second, it seems to me that the whole single Requires element is intended to be split into a Requires
+-and an Effects element; third, the reference to <tt>tuple</tt> is incorrect (noticed by Paolo Carlini);
+-fourth, it refers to some non-existing <tt>InputIterator</tt> parameter relevant for a completely different
+-overload; sixth, the return type of the overload with hint is wrong.
+-The following proposed resolution tries to solve these issues as well and uses similar wording as for
+-the corresponding unordered containers. Unfortunately it has some redundancy over Table&nbsp;99, but I did
+-not remove the specification because of the more general template parameter <tt>P</tt> - the Table&nbsp;99
+-requirements apply only for an argument <em>identical</em> to <tt>value_type</tt>.
+-</p>
++string str1() { return "one"; }
++const string str2() { return "two"; }
++tuple&lt;string&gt; tup3() { return make_tuple("three"); }
++const tuple&lt;string&gt; tup4() { return make_tuple("four"); }
+
++int main() {
++ // cref(str1()); // BAD, properly rejected
++ // cref(str2()); // BAD, properly rejected
++ // cref(get&lt;0&gt;(tup3())); // BAD, properly rejected
++ cref(get&lt;0&gt;(tup4())); // BAD, but improperly accepted!
++}
++</pre>
++</blockquote>
+ <p>
+-Proposed resolution:
++As <tt>tuple</tt> is a fundamental building block (and the only convenient way to have variadic data members), it should
++not open a hole in the type system. <tt>get()</tt> should imitate 5.2.5 [expr.ref]'s rules for accessing data members.
++(This is especially true for <tt>pair</tt>, where both <tt>get&lt;0&gt;()</tt> and <tt>.first</tt> are available.)
++<p/>
++While we're in the neighborhood, we can dramatically simplify the wording here. All we need to do is follow
++20.4.2.6 [tuple.elem]/9's example of saying "Returns: A reference to STUFF", and allow implementers to figure out how
++to achieve that with the given return types.
+ </p>
+
+-<p>
+-</p><ol>
+-<li>Change 23.6.1.3 [map.modifiers] around p. 1 as indicated:
+-<blockquote><pre>template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
+-template &lt;class P&gt; <del>pair&lt;</del>iterator<del>, bool&gt;</del> insert(const_iterator position, P&amp;&amp; x);
+-</pre><blockquote>
+-1 <em>Requires</em>: <del><tt>P</tt> shall be convertible to </del><tt>value_type</tt><ins> is constructible
+-from <tt>std::forward&lt;P&gt;(x)</tt>.</ins>.
+-<p>
+-<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise <tt>x</tt> is considered
+-to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map. Specifically, in
+-such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt> unless the conversion
+-from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>, then <tt>key_type</tt>
+-must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters does not require
+-<tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced <tt>InputIterator</tt> returns a
+-non-const rvalue <tt>pair&lt;key_type,mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt> is required for both
+-<tt>key_type</tt> and <tt>mapped_type</tt>.</del><br>
+-<ins>? <em>Effects</em>: Inserts <tt>x</tt> converted to <tt>value_type</tt> if and only if there is no element in the container with
+-key equivalent to the key of <tt>value_type(x)</tt>. For the second form, the iterator <tt>position</tt> is a hint pointing to where the
+-search should start.</ins>
+-</p><p>
+-<ins>? <em>Returns</em>: For the first form, the <tt>bool</tt> component of the returned <tt>pair</tt> object indicates whether the
+-insertion took place and the iterator component - or for the second form the returned iterator - points to the element with key equivalent
+-to the key of <tt>value_type(x)</tt>.</ins>
+-</p><p>
+-<ins>? <em>Complexity</em>: Logarithmic in general, but amortized constant if <tt>x</tt> is inserted right before <tt>position</tt>.</ins>
+-</p><p>
+-<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
+-is implicitly convertible to <tt>value_type</tt>.</ins>
+-</p></blockquote></blockquote>
+-</li>
+-<li>Change 23.6.2.2 [multimap.modifiers] around p. 1 as indicated:
+-<blockquote><pre>template &lt;class P&gt; iterator insert(P&amp;&amp; x);
+-template &lt;class P&gt; iterator insert(const_iterator position, P&amp;&amp; x);
+-</pre><blockquote>
+-1 <em>Requires</em>: <del><tt>P</tt> shall be convertible to </del><tt>value_type</tt> <ins>is constructible from
+-<tt>std::forward&lt;P&gt;(x)</tt></ins>.
+-<p>
+-<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise
+-<tt>x</tt> is considered to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map.
+-Specifically, in such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt>
+-unless the conversion from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>,
+-then <tt>key_type</tt> must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters
+-does not require <tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced
+-<tt>InputIterator</tt> returns a non-const rvalue <tt>pair&lt;key_type, mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt>
+-is required for both <tt>key_type</tt> and <tt>mapped_type</tt>.</del><br>
+-<ins>? <em>Effects</em>: Inserts <tt>x</tt> converted to <tt>value_type</tt>. For the second form, the iterator <tt>position</tt>
+-is a hint pointing to where the search should start.</ins>
+-</p><p>
+-<ins>? <em>Returns</em>: An iterator that points to the element with key equivalent to the key of <tt>value_type(x)</tt>.</ins>
+-</p><p>
+-<ins>? <em>Complexity</em>: Logarithmic in general, but amortized constant if <tt>x</tt> is inserted right before <tt>position</tt>.</ins>
+-</p><p>
+-<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
+-is implicitly convertible to <tt>value_type</tt>.</ins>
+-</p></blockquote></blockquote>
+-</li>
+-</ol>
+-<p></p>
+-
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
+-
++<p><i>[2015-05, Lenexa]</i></p>
+
+ <p>
+-We need <tt>is_convertible</tt>, not <tt>is_constructible</tt>, both in ordered and unordered containers.
++TP: for the existing overloads there's no change to the code, just descriptions?<br/>
++STL: right.<br/>
++JW: I love it<br/>
++MC: in favor of moving to Ready and bringing up for vote on Friday<br/>
++7 in favor, none opposed
+ </p>
+
+
+-
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
+ <ol>
+-<li>Add a new Remarks element after 23.6.1.3 [map.modifiers] p. 1:
+-<blockquote><pre>template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
+-template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(const_iterator position, P&amp;&amp; x);
+-</pre><blockquote>
+-1 <em>Requires</em>: <tt>P</tt> shall be convertible to <tt>value_type</tt>.
+-<p>
+-If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise <tt>x</tt> is considered
+-to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map. Specifically, in
+-such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt> unless the conversion
+-from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>, then <tt>key_type</tt>
+-must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters does not require
+-<tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced <tt>InputIterator</tt> returns a
+-non-const rvalue <tt>pair&lt;key_type,mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt> is required for both
+-<tt>key_type</tt> and <tt>mapped_type</tt>.
+-</p><p>
+-<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
+-is implicitly convertible to <tt>value_type</tt>.</ins>
+-</p></blockquote></blockquote>
+-</li>
+-<li>Change 23.6.2.2 [multimap.modifiers] around p. 1 as indicated:
+-<blockquote><pre>template &lt;class P&gt; iterator insert(P&amp;&amp; x);
+-template &lt;class P&gt; iterator insert(const_iterator position, P&amp;&amp; x);
+-</pre><blockquote>
+-1 <em>Requires</em>: <tt>P</tt> shall be convertible to <tt>value_type</tt>.
+-<p>
+-If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise
+-<tt>x</tt> is considered to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map.
+-Specifically, in such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt>
+-unless the conversion from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>,
+-then <tt>key_type</tt> must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters
+-does not require <tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced
+-<tt>InputIterator</tt> returns a non-const rvalue <tt>pair&lt;key_type, mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt>
+-is required for both <tt>key_type</tt> and <tt>mapped_type</tt>.
+-</p><p>
+-<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
+-is implicitly convertible to <tt>value_type</tt>.</ins>
+-</p></blockquote></blockquote>
++<li><p>Change 20.2 [utility]/2 "Header <tt>&lt;utility&gt;</tt> synopsis" as depicted:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++template&lt;size_t I, class T1, class T2&gt;
++ constexpr tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;
++ get(pair&lt;T1, T2&gt;&amp;) noexcept;
++template&lt;size_t I, class T1, class T2&gt;
++ constexpr tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;&amp;
++ get(pair&lt;T1, T2&gt;&amp;&amp;) noexcept;
++template&lt;size_t I, class T1, class T2&gt;
++ constexpr const tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;
++ get(const pair&lt;T1, T2&gt;&amp;) noexcept;
++<ins>template&lt;size_t I, class T1, class T2&gt;
++ constexpr const tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;&amp;
++ get(const pair&lt;T1, T2&gt;&amp;&amp;) noexcept;</ins>
++template &lt;class T, class U&gt;
++ constexpr T&amp; get(pair&lt;T, U&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++ constexpr const T&amp; get(const pair&lt;T, U&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++ constexpr T&amp;&amp; get(pair&lt;T, U&gt;&amp;&amp; p) noexcept;
++<ins>template &lt;class T, class U&gt;
++ constexpr const T&amp;&amp; get(const pair&lt;T, U&gt;&amp;&amp; p) noexcept;</ins>
++template &lt;class T, class U&gt;
++ constexpr T&amp; get(pair&lt;U, T&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++ constexpr const T&amp; get(const pair&lt;U, T&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++ constexpr T&amp;&amp; get(pair&lt;U, T&gt;&amp;&amp; p) noexcept;
++<ins>template &lt;class T, class U&gt;
++ constexpr const T&amp;&amp; get(const pair&lt;U, T&gt;&amp;&amp; p) noexcept;</ins>
++[&hellip;]
++</pre>
++</blockquote>
+ </li>
+-</ol>
+
++<li><p>Change 20.4.1 [tuple.general]/2 "Header <tt>&lt;tuple&gt;</tt> synopsis" as depicted:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++<i>// 20.4.2.6, element access:</i>
++template &lt;size_t I, class... Types&gt;
++constexpr tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;&amp;
++get(tuple&lt;Types...&gt;&amp;) noexcept;
++template &lt;size_t I, class... Types&gt;
++constexpr tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;&amp;&amp;
++get(tuple&lt;Types...&gt;&amp;&amp;) noexcept;
++template &lt;size_t I, class... Types&gt;
++constexpr const tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;&amp;
++get(const tuple&lt;Types...&gt;&amp;) noexcept;
++<ins>template &lt;size_t I, class... Types&gt;
++constexpr const tuple_element_t&lt;I, tuple&lt;Types...&gt;&gt;&amp;&amp;
++get(const tuple&lt;Types...&gt;&amp;&amp;) noexcept;</ins>
++template &lt;class T, class... Types&gt;
++constexpr T&amp; get(tuple&lt;Types...&gt;&amp; t) noexcept;
++template &lt;class T, class... Types&gt;
++constexpr T&amp;&amp; get(tuple&lt;Types...>&amp;&amp; t) noexcept;
++template &lt;class T, class... Types&gt;
++constexpr const T&amp; get(const tuple&lt;Types...&gt;&amp; t) noexcept;
++<ins>template &lt;class T, class... Types&gt;
++constexpr const T&amp;&amp; get(const tuple&lt;Types...&gt;&amp;&amp; t) noexcept;</ins>
++[&hellip;]
++</pre>
++</blockquote>
++</li>
+
++<li><p>Change 23.3.1 [sequences.general]/2 "Header <tt>&lt;array&gt;</tt> synopsis" as depicted:</p>
+
++<blockquote>
++<pre>
++[&hellip;]
++template &lt;size_t I, class T, size_t N&gt;
++constexpr T&amp; get(array&lt;T, N&gt;&amp;) noexcept;
++template &lt;size_t I, class T, size_t N&gt;
++constexpr T&amp;&amp; get(array&lt;T, N&gt;&amp;&amp;) noexcept;
++template &lt;size_t I, class T, size_t N&gt;
++constexpr const T&amp; get(const array&lt;T, N&gt;&amp;) noexcept;
++<ins>template &lt;size_t I, class T, size_t N&gt;
++constexpr const T&amp;&amp; get(const array&lt;T, N&gt;&amp;&amp;) noexcept;</ins>
++[&hellip;]
++</pre>
++</blockquote>
++</li>
+
++<li><p>Change 20.3.4 [pair.astuple] as depicted:</p>
+
+-<hr>
+-<h3><a name="2006"></a>2006. <tt>emplace</tt> broken for associative containers</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">Tentatively NAD</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2010-10-18 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively NAD">Tentatively NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
++<blockquote>
++<pre>
++template&lt;size_t I, class T1, class T2&gt;
++constexpr tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;
++get(pair&lt;T1, T2&gt;&amp; p) noexcept;
++template&lt;size_t I, class T1, class T2&gt;
++constexpr const tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;
++get(const pair&lt;T1, T2&gt;&amp; p) noexcept;
++</pre>
++<blockquote>
+ <p>
+-The current definition of <tt>emplace(args)</tt> for associative containers as
+-described in Table 99 is:
+-</p><blockquote>
++<del>-3- <i>Returns</i>: If <tt>I == 0</tt> returns <tt>p.first</tt>; if <tt>I == 1</tt> returns <tt>p.second</tt>;
++otherwise the program is ill-formed.</del>
++</p>
++</blockquote>
++<pre>
++template&lt;size_t I, class T1, class T2&gt;
++constexpr tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;&amp;
++get(pair&lt;T1, T2&gt;&amp;&amp; p) noexcept;
++<ins>template&lt;size_t I, class T1, class T2&gt;
++constexpr const tuple_element_t&lt;I, pair&lt;T1, T2&gt;&gt;&amp;&amp;
++get(const pair&lt;T1, T2&gt;&amp;&amp; p) noexcept;</ins>
++</pre>
++<blockquote>
+ <p>
+-<i>Requires</i>: <tt>T</tt> shall be constructible from <tt>args</tt>.
++-4- <i>Returns</i>: If <tt>I == 0</tt> returns <ins>a reference to</ins>
++<tt><del>std::forward&lt;T1&amp;&amp;&gt;(</del>p.first<del>)</del></tt>; if <tt>I == 1</tt>
++returns <ins>a reference to</ins> <tt><del>std::forward&lt;T2&amp;&amp;&gt;(</del>p.second<del>)</del></tt>;
++otherwise the program is ill-formed.
+ </p>
++</blockquote>
++<pre>
++template &lt;class T, class U&gt;
++constexpr T&amp; get(pair&lt;T, U&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++constexpr const T&amp; get(const pair&lt;T, U&gt;&amp; p) noexcept;
++</pre>
++<blockquote>
+ <p>
+-<i>Effects</i>: Inserts a <tt>T</tt> object <tt>t</tt> constructed with
+-<tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element
+-in the container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt>
+-component of the returned <tt>pair</tt> is <tt>true</tt> if and only if the
+-insertion takes place, and the iterator component of the <tt>pair</tt>
+-points to the element with key equivalent to the key of <tt>t</tt>.
++<del>-5- Requires: <tt>T</tt> and <tt>U</tt> are distinct types. Otherwise, the program is ill-formed.</del>
++<p/>
++<del>-6- Returns: <tt>get&lt;0&gt;(p)</tt>;</del>
+ </p>
+ </blockquote>
+-<p></p>
++<pre>
++template &lt;class T, class U&gt;
++constexpr T&amp;&amp; get(pair&lt;T, U&gt;&amp;&amp; p) noexcept;
++<ins>template &lt;class T, class U&gt;
++constexpr const T&amp;&amp; get(const pair&lt;T, U&gt;&amp;&amp; p) noexcept;</ins>
++</pre>
++<blockquote>
++<p>
++-7- Requires: <tt>T</tt> and <tt>U</tt> are distinct types. Otherwise, the program is ill-formed.
++<p/>
++-8- Returns: <ins>A reference to <tt>p.first</tt>.</ins><del><tt>get&lt;0&gt;(std::move(p))</tt>;</del>
++</p>
++</blockquote>
++<pre>
++template &lt;class T, class U&gt;
++constexpr T&amp; get(pair&lt;U, T&gt;&amp; p) noexcept;
++template &lt;class T, class U&gt;
++constexpr const T&amp; get(const pair&lt;U, T&gt;&amp; p) noexcept;
++</pre>
++<blockquote>
++<p>
++<del>-9- Requires: <tt>T</tt> and <tt>U</tt> are distinct types. Otherwise, the program is ill-formed.</del>
++<p/>
++<del>-10- Returns: <tt>get&lt;1&gt;(p)</tt>;</del>
++</p>
++</blockquote>
++<pre>
++template &lt;class T, class U&gt;
++constexpr T&amp;&amp; get(pair&lt;U, T&gt;&amp;&amp; p) noexcept;
++<ins>template &lt;class T, class U&gt;
++constexpr const T&amp;&amp; get(const pair&lt;U, T&gt;&amp;&amp; p) noexcept;</ins>
++</pre>
++<blockquote>
+ <p>
+-There is similar language in Table 100 for unordered associative containers.
++-11- Requires: <tt>T</tt> and <tt>U</tt> are distinct types. Otherwise, the program is ill-formed.
++<p/>
++-12- Returns: <ins>A reference to <tt>p.second</tt>.</ins><del><tt>get&lt;1&gt;(std::move(p))</tt>;</del>
+ </p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.6 [tuple.elem] as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;size_t I, class... Types&gt;
++ constexpr tuple_element_t&lt;I, tuple&lt;Types...&gt; &gt;&amp; get(tuple&lt;Types...&gt;&amp; t) noexcept;
++</pre>
++<blockquote>
+ <p>
+-The first issue is editorial: <tt>T</tt> should be <tt>value_type</tt> throughout
+-both tables.
++<del>-1- <i>Requires</i>: <tt>I &lt; sizeof...(Types)</tt>. The program is ill-formed if <tt>I</tt> is out of bounds.</del>
++<p/>
++<del>-2- <i>Returns</i>: A reference to the <tt>I</tt>th element of <tt>t</tt>, where indexing is zero-based.</del>
+ </p>
++</blockquote>
++<pre>
++template &lt;size_t I, class... Types&gt;
++ constexpr tuple_element_t&lt;I, tuple&lt;Types...&gt; &gt;&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp; t) noexcept; <ins><i>// Note A</i></ins>
++</pre>
++<blockquote>
+ <p>
+-The major issue is that, if the container is <tt>map</tt>, <tt>multimap</tt>,
+-<tt>unordered_map</tt>, or <tt>unordered_multimap</tt>, then the only way to
+-construct an object of <tt>value_type</tt> is to supply exactly two arguments
+-for <tt>Key</tt> and <tt>Value</tt>, a <tt>pair&lt;Key,Value&gt;</tt>, or a
+-<tt>piecewise_construct_t</tt> followed by two <tt>tuple</tt>s. The original
+-<tt>emplace()</tt> proposal would have allowed you to specify a <tt>Key</tt>
+-value followed by any number of constructor arguments for <tt>Value</tt>.
+-When we removed the variadic constructor to <tt>pair</tt>, this ability went
+-away. I don't think that was deliberate.
++<del>-3- <i>Effects</i>: Equivalent to return std::forward&lt;typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;&amp;&gt;(get&lt;I&gt;(t));</del>
++<p/>
++<del>-4- <i>Note</i>: if a <tt>T</tt> in <tt>Types</tt> is some reference type <tt>X&amp;</tt>, the return type is <tt>X&amp;</tt>, not
++<tt>X&amp;&amp;</tt>. However, if the element type is a non-reference type <tt>T</tt>, the return type is <tt>T&amp;&amp;</tt>.</del>
+ </p>
++</blockquote>
++<pre>
++template &lt;size_t I, class... Types&gt;
++ constexpr tuple_element_t&lt;I, tuple&lt;Types...&gt; &gt; const&amp; get(const tuple&lt;Types...&gt;&amp; t) noexcept; <ins><i>// Note B</i></ins>
++<ins>template &lt;size_t I, class... Types&gt;
++ constexpr const tuple_element_t&lt;I, tuple&lt;Types...&gt; &gt;&amp;&amp; get(const tuple&lt;Types...&gt;&amp;&amp; t) noexcept;</ins>
++</pre>
++<blockquote>
+ <p>
+-Fixing this is non-trivial, I think. I think that <tt>emplace()</tt> for <tt>map</tt>
+-and <tt>multimap</tt> need several overloads: one for each overloaded constructor in
+-<tt>pair&lt;Key,Value&gt;</tt>, and one for the <tt>emplace(Key, valueargs...)</tt> case.
+-And it probably needs some SFINAE meta-programming to ensure that the last case
+-doesn't override any of the other ones. Alternatively, one could say that
+-there are exactly two cases: <tt>emplace(args)</tt> where <tt>pair&lt;Key,Value&gt;</tt>
+-is constructible from <tt>args</tt>, and <tt>emplace(args)</tt> where <tt>Key</tt> is
+-constructible form the first <tt>arg</tt> and <tt>Value</tt> is constructible from the
+-rest.
++-5- <i>Requires</i>: <tt>I &lt; sizeof...(Types)</tt>. The program is ill-formed if <tt>I</tt> is out of bounds.
++<p/>
++-6- <i>Returns</i>: A <del>const</del> reference to the <tt>I</tt>th element of <tt>t</tt>, where indexing is zero-based.
++<p/>
++<ins>-?- [<i>Note A</i>: if a <tt>T</tt> in <tt>Types</tt> is some reference type <tt>X&amp;</tt>, the return type is <tt>X&amp;</tt>,
++not <tt>X&amp;&amp;</tt>. However, if the element type is a non-reference type <tt>T</tt>, the return type is <tt>T&amp;&amp;</tt>.
++&mdash; <i>end note</i>]</ins>
++<p/>
++-7- [<i>Note <ins>B</ins></i>: Constness is shallow. If a <tt>T</tt> in <tt>Types</tt> is some reference type <tt>X&amp;</tt>,
++the return type is <tt>X&amp;</tt>, not <tt>const X&amp;</tt>. However, if the element type is non-reference type <tt>T</tt>,
++the return type is <tt>const T&amp;</tt>. This is consistent with how constness is defined to work for member variables of
++reference type. &mdash; <i>end note</i>]
+ </p>
++</blockquote>
++<pre>
++template &lt;class T, class... Types&gt;
++ constexpr T&amp; get(tuple&lt;Types...&gt;&amp; t) noexcept;
++template &lt;class T, class... Types&gt;
++ constexpr T&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp; t) noexcept;
++template &lt;class T, class... Types&gt;
++ constexpr const T&amp; get(const tuple&lt;Types...&gt;&amp; t) noexcept;
++<ins>template &lt;class T, class... Types&gt;
++ constexpr const T&amp;&amp; get(const tuple&lt;Types...&gt;&amp;&amp; t) noexcept;</ins>
++</pre>
++<blockquote>
+ <p>
+-Alternatively, the status quo is to use <tt>piecewise_construct_t</tt> if you want to
+-construct an object.
++-8- <i>Requires</i>: The type <tt>T</tt> occurs exactly once in <tt>Types...</tt>. Otherwise, the program is ill-formed.
++<p/>
++-9- <i>Returns</i>: A reference to the element of <tt>t</tt> corresponding to the type <tt>T</tt> in <tt>Types...</tt>.
++<p/>
++[&hellip;]
+ </p>
++</blockquote>
++</blockquote>
++</li>
+
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
+-
++<li><p>Change 23.3.2.9 [array.tuple] as depicted:</p>
+
++<blockquote>
++<pre>
++template &lt;size_t I, class T, size_t N&gt;
++<ins> </ins>constexpr T&amp; get(array&lt;T, N&gt;&amp; a) noexcept;
++</pre>
++<blockquote>
++<p>
++<del>-3- <i>Requires</i>: <tt>I &lt; N</tt>. The program is ill-formed if <tt>I</tt> is out of bounds.</del>
++<p/>
++<del>-4- <i>Returns</i>: A reference to the <tt>I</tt>th element of <tt>a</tt>, where indexing is zero-based.</del>
++</p>
++</blockquote>
++<pre>
++template &lt;size_t I, class T, size_t N&gt;
++<ins> </ins>constexpr T&amp;&amp; get(array&lt;T, N&gt;&amp;&amp; a) noexcept;
++</pre>
++<blockquote>
++<p>
++<del>-5- <i>Effects</i>: Equivalent to <tt>return std::move(get&lt;I&gt;(a));</tt></del>
++</p>
++</blockquote>
++<pre>
++template &lt;size_t I, class T, size_t N&gt;
++<ins> </ins>constexpr const T&amp; get(const array&lt;T, N&gt;&amp; a) noexcept;
++<ins>template &lt;size_t I, class T, size_t N&gt;
++ constexpr const T&amp;&amp; get(const array&lt;T, N&gt;&amp;&amp; a) noexcept;</ins>
++</pre>
++<blockquote>
+ <p>
+-N3178 was looked at in session and moved to NAD.
++-6- <i>Requires</i>: <tt>I &lt; N</tt>. The program is ill-formed if <tt>I</tt> is out of bounds.
++<p/>
++-7- <i>Returns</i>: A <del>const</del> reference to the <tt>I</tt>th element of <tt>a</tt>, where indexing is zero-based.
+ </p>
++</blockquote>
++</blockquote>
++</li>
+
+
+-<p><b>Proposed resolution:</b></p>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="2007"></a>2007. Incorrect specification of return value for <tt>map&lt;&gt;::at()</tt></h3>
+-<p><b>Section:</b> 23.6.1.2 [map.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Ready">Tentatively Ready</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2010-11-01 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map.access">issues</a> in [map.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Tentatively Ready">Tentatively Ready</a> status.</p>
++<h3><a name="2486"></a>2486. <tt>mem_fn()</tt> should be required to use perfect forwarding</h3>
++<p><b>Section:</b> 20.9.2 [func.require] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In [map.access]/9, the <i>Returns</i> clause for <tt>map&lt;Key, T&gt;::at(x)</tt> says
+-that it returns "a reference to the element whose key is equivalent to <tt>x</tt>." That can't be right.
+-The signature for <tt>at()</tt> says that its return type is <tt>T</tt>, but the elements
+-of <tt>map&lt;Key, T&gt;</tt> have type <tt>pair&lt;const K, T&gt;</tt>. (I checked [unord.map.elem]
+-and found that its specification of <tt>at()</tt> is correct. This is a problem for <tt>map</tt> only.)
++20.9.2 [func.require]/4 defines "simple call wrapper" and "forwarding call wrapper". Only <tt>mem_fn()</tt> is
++specified to be a "simple call wrapper", by 20.9.11 [func.memfn]/1: "A simple call wrapper (20.9.1) <tt>fn</tt>
++such that the expression <tt>fn(t, a2, ..., aN)</tt> is equivalent to <tt>INVOKE(pm, t, a2, ..., aN)</tt> (20.9.2)."
++<p/>
++This suggests, but doesn't outright state, that perfect forwarding is involved. It matters for PMFs like
++<tt>R (T::*)(Arg)</tt> where <tt>Arg</tt> is passed by value &mdash; if the <tt>mem_fn()</tt> wrapper's function call
++operator takes <tt>Arg</tt> by value, an extra copy/move will be observable. We should require perfect forwarding here.
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Change the wording in [map.access]/9 so it's identical to what we already say for <tt>operator[]</tt>,
+-which is unambiguous and correct.
++Move to Immediate.
+ </p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 20.9.2 [func.require] as depicted [<i>Editorial remark</i>: This simply adds "A simple call wrapper
++is a <ins>forwarding</ins> call wrapper", then moves the sentence. &mdash; <i>end of remark</i>]:</p>
++
+ <blockquote>
+-<i>Returns</i>: A reference to the <del>element whose key is equivalent</del><ins><tt>mapped_type</tt>
+-corresponding</ins> to <tt>x</tt><ins> in <tt>*this</tt></ins>.
++<p>
++-4- Every call wrapper (20.9.1) shall be <tt>MoveConstructible</tt>. <del>A <i>simple call wrapper</i> is a call wrapper that is
++<tt>CopyConstructible</tt> and <tt>CopyAssignable</tt> and whose copy constructor, move constructor, and assignment
++operator do not throw exceptions.</del> A <i>forwarding call wrapper</i> is a call wrapper that can be called with
++an arbitrary argument list and delivers the arguments to the wrapped callable object as references. This
++forwarding step shall ensure that rvalue arguments are delivered as rvalue-references and lvalue arguments
++are delivered as lvalue-references. <ins>A <i>simple call wrapper</i> is a forwarding call wrapper that is <tt>CopyConstructible</tt>
++and <tt>CopyAssignable</tt> and whose copy constructor, move constructor, and assignment operator do not throw exceptions.</ins>
++[<i>Note</i>: In a typical implementation [&hellip;] &mdash; <i>end note</i>]
++</p>
+ </blockquote>
++</li>
++
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="2008"></a>2008. Conflicting Error Conditions for <tt>packaged_task::operator()</tt></h3>
+-<p><b>Section:</b> 30.6.10.1 [futures.task.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2010-06-21 <b>Last modified:</b> 2010-11-07</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.task.members">active issues</a> in [futures.task.members].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2487"></a>2487. <tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</h3>
++<p><b>Section:</b> 20.9.10.3 [func.bind.bind] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The Throws clause for <tt>packaged_task::operator()</tt> says that it throws "a
+-<tt>future_error</tt> exception object if there is no associated asynchronous
+-state or the stored task has already been invoked." However, the Error
+-Conditions clause does not define an error condition when the stored task has
+-already been invoked, only when the associated state is already ready (i.e. the
+-invocation has completed).
++The Standard currently requires <tt>bind()</tt> to return something with a <i>cv</i>-overloaded function call operator.
++<tt>const</tt> is great, but <tt>volatile</tt> is not. First, the Library almost always ignores <tt>volatile</tt>'s
++existence (with <tt>&lt;type_traits&gt;</tt> and <tt>&lt;atomic&gt;</tt> being rare exceptions). Second, implementations
++typically store bound arguments in a <tt>tuple</tt>, but <tt>get()</tt> isn't overloaded for <tt>volatile tuple</tt>. Third,
++when a bound argument is a <tt>reference_wrapper</tt>, we have to call <tt>tid.get()</tt>, but that won't compile for a
++<tt>volatile reference_wrapper</tt>. Finally, <tt>const</tt> and <tt>volatile</tt> don't always have to be handled symmetrically
++&mdash; for example, lambda function call operators are <tt>const</tt> by default, but they can't ever be <tt>volatile</tt>.
++<p/>
++Implementers shouldn't be required to provide <i>cv</i>-overloading here. (They can provide it as a conforming extension if
++they want.)
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Change the first bullet item in 30.6.10.1 [futures.task.members] /22:
++JW: why would a <tt>reference_wrapper</tt> be volatile?<br/>
++STL: if a bound argument is a <tt>reference_wrapper</tt> then in a volatile-qualified operator() that
++member will be volatile so you can't call get() on it<br/>
++STL: worded like this it's a conforming extension to kep overloading on volatile<br/>
++HH: libc++ doesn't overload on volatile<br/>
++JW: libstdc++ does overload for volatile<br/>
++MC: move to Ready and bring motion on Friday<br/>
++10 in favor, none opposed
+ </p>
+
+-<blockquote><pre>void operator()(ArgTypes... args);
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 20.9.10.3 [func.bind.bind] as depicted:</p>
++
++<blockquote>
++<pre>
++template&lt;class F, class... BoundArgs&gt;
++ <i>unspecified</i> bind(F&amp;&amp; f, BoundArgs&amp;&amp;... bound_args);
+ </pre>
+ <blockquote>
+ <p>
+-20 ...
+-</p>
+-<p>
+-21 ...
++-2- <i>Requires</i>: <tt>is_constructible&lt;FD, F&gt;::value</tt> shall be <tt>true</tt>. For each <tt>Ti</tt>
++in <tt>BoundArgs</tt>, <tt>is_constructible&lt;TiD, Ti&gt;::value</tt> shall be <tt>true</tt>.
++<tt><i>INVOKE</i>(fd, w1, w2, ..., wN)</tt> (20.9.2) shall be a valid expression for some values <tt>w1</tt>, <tt>w2</tt>,
++..., <tt>wN</tt>, where <tt>N == sizeof...(bound_args)</tt>. <ins>The <i>cv</i>-qualifiers <i>cv</i> of the call
++wrapper <tt>g</tt>, as specified below, shall be neither <tt>volatile</tt> nor <tt>const volatile</tt>.</ins>
++<p/>
++[&hellip;]
+ </p>
++</blockquote>
++<pre>
++template&lt;class R, class F, class... BoundArgs&gt;
++ <i>unspecified</i> bind(F&amp;&amp; f, BoundArgs&amp;&amp;... bound_args);
++</pre>
++<blockquote>
+ <p>
+-22 <i>Error conditions:</i>
++-6- <i>Requires</i>: <tt>is_constructible&lt;FD, F&gt;::value</tt> shall be <tt>true</tt>. For each <tt>Ti</tt>
++in <tt>BoundArgs</tt>, <tt>is_constructible&lt;TiD, Ti&gt;::value</tt> shall be <tt>true</tt>.
++<tt><i>INVOKE</i>(fd, w1, w2, ..., wN)</tt> shall be a valid expression for some values <tt>w1</tt>, <tt>w2</tt>,
++..., <tt>wN</tt>, where <tt>N == sizeof...(bound_args)</tt>. <ins>The <i>cv</i>-qualifiers <i>cv</i> of the call
++wrapper <tt>g</tt>, as specified below, shall be neither <tt>volatile</tt> nor <tt>const volatile</tt>.</ins>
++<p/>
++[&hellip;]
+ </p>
+-<ul>
+-<li>
+-<tt>promise_already_satisfied</tt> if <del>the associated asynchronous state is
+-already ready</del> <ins><tt>operator()</tt> has already been called</ins>.
+-</li>
+-<li>
+-<tt>no_state</tt> if <tt>*this</tt> has no associated asynchronous state.
+-</li>
+-</ul>
+ </blockquote>
+ </blockquote>
++</li>
++
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="2009"></a>2009. Reporting out-of-bound values on numeric string conversions</h3>
+-<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Review">Review</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-07-19 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Review">Review</a> status.</p>
++<h3><a name="2489"></a>2489. <tt>mem_fn()</tt> should be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.9.11 [func.memfn] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.memfn">issues</a> in [func.memfn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The functions (<tt>w</tt>)<tt>stoi</tt> and (<tt>w</tt>)<tt>stof</tt>
+-are specified in terms of calling C library APIs for potentially wider
+-types. The integer and floating-point versions have subtly different
+-behaviour when reading values that are too large to convert. The
+-floating point case will throw <tt>out_of_bound</tt> if the read value
+-is too large to convert to the wider type used in the implementation,
+-but behaviour is undefined if the converted value cannot narrow to a
+-float. The integer case will throw <tt>out_of_bounds</tt> if the
+-converted value cannot be represented in the narrower type, but throws
+-<tt>invalid_argument</tt>, rather than <tt>out_of_bounds</tt>, if the
+-conversion to the wider type fails due to overflow.
++<tt>mem_fn()</tt> is wide contract and doesn't do anything that could throw exceptions, so it should be marked <tt>noexcept</tt>.
++<p/>
++Note that <tt>mem_fn()</tt> is perfectly happy to wrap a null PMF/PMD, it just can't be invoked later. This is exactly like
++<tt>std::function</tt>, which can be constructed from null PMFs/PMDs. Therefore, <tt>mem_fn()</tt> will remain wide contract forever.
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
++
+ <p>
+-Suggest that the Throws clause for both specifications should be
+-consistent, supporting the same set of fail-modes with the matching set
+-of exceptions.
++Move to Immediate.
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-21.5p3 [string.conversions]
+-</p>
+-
+-<blockquote><pre>int stoi(const string&amp; str, size_t *idx = 0, int base = 10);
+-long stol(const string&amp; str, size_t *idx = 0, int base = 10);
+-unsigned long stoul(const string&amp; str, size_t *idx = 0, int base = 10);
+-long long stoll(const string&amp; str, size_t *idx = 0, int base = 10);
+-unsigned long long stoull(const string&amp; str, size_t *idx = 0, int base = 10);
+-</pre>
++<p>This wording is relative to N4296.</p>
+
+-<blockquote>
+-<p>
+-...
+-</p>
+-<p>
+-3 <i>Throws:</i> <tt>invalid_argument</tt> if <tt>strtol</tt>,
+-<tt>strtoul</tt>, <tt>strtoll</tt>, or <tt>strtoull</tt> reports that no
+-conversion could be performed. Throws <tt>out_of_range</tt> if
+-<ins><tt>strtol</tt>, <tt>strtoul</tt>, <tt>strtoll</tt> or
+-<tt>strtoull</tt> sets <tt>errno</tt> to <tt>ERANGE</tt>, or if</ins>
+-the converted value is outside the range of representable values for the
+-return type.
+-</p>
+-</blockquote>
++<ol>
++<li><p>Change 20.9 [function.objects] p2 "Header <tt>&lt;functional&gt;</tt> synopsis" as depicted:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++<i>// 20.9.11, member function adaptors:</i>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::*) <ins>noexcept</ins>;
++[&hellip;]
++</pre>
+ </blockquote>
++</li>
+
+-<p>
+-21.5p6 [string.conversions]
+-</p>
++<li><p>Change 20.9.11 [func.memfn] as depicted:</p>
+
+-<blockquote><pre>float stof(const string&amp; str, size_t *idx = 0);
+-double stod(const string&amp; str, size_t *idx = 0);
+-long double stold(const string&amp; str, size_t *idx = 0);
++<blockquote>
++<pre>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm) <ins>noexcept</ins>;
+ </pre>
+-
+ <blockquote>
+ <p>
+-...
+-</p>
+-<p>
+-6 <i>Throws:</i> <tt>invalid_argument</tt> if <tt>strtod</tt> or
+-<tt>strtold</tt> reports that no conversion could be performed. Throws
+-<tt>out_of_range</tt> if <tt>strtod</tt> or <tt>strtold</tt> sets
+-<tt>errno</tt> to <tt>ERANGE</tt> <ins> or if the converted value is
+-outside the range of representable values for the return type</ins>.
++[&hellip;]
++<p/>
++<del>-4- <i>Throws</i>: Nothing.</del>
+ </p>
+ </blockquote>
+ </blockquote>
++</li>
++</ol>
+
+
+
+@@ -7528,51 +29482,60 @@ outside the range of representable values for the return type</ins>.
+
+
+ <hr>
+-<h3><a name="2010"></a>2010. <tt>is_* traits</tt> for binding operations can't be meaningfully specialized</h3>
+-<p><b>Section:</b> 20.8.10.1.1 [func.bind.isbind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2010-07-19 <b>Last modified:</b> 2010-11-16</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.bind.isbind">issues</a> in [func.bind.isbind].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2490"></a>2490. <tt>&lt;regex&gt;</tt> needs lots of <tt>noexcept</tt></h3>
++<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re">active issues</a> in [re].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re">issues</a> in [re].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.8.10.1.1 [func.bind.isbind] says for <tt>is_bind_expression</tt>:
++Only 4 functions are marked <tt>noexcept</tt> in all of Clause 28. Many more need to be marked &mdash; for example,
++<tt>regex_error::code()</tt>, <tt>basic_regex::swap()</tt>, and <tt>sub_match::length()</tt>.
+ </p>
+
+-<blockquote>
+-Users may specialize this template to indicate that a type should be
+-treated as a subexpression in a <tt>bind</tt> call.
+-</blockquote>
+
+-<p>
+-But it also says:
+-</p>
+
+-<blockquote>
+-If <tt>T</tt> is a type returned from <tt>bind</tt>,
+-<tt>is_bind_expression&lt;T&gt;</tt> shall be publicly derived from
+-<tt>integral_constant&lt;bool, true&gt;</tt>, otherwise from
+-<tt>integral_constant&lt;bool, false&gt;</tt>.
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
++
++
++
++
+
++<hr>
++<h3><a name="2491"></a>2491. <tt>std::less&lt;T*&gt;</tt> in constant expression</h3>
++<p><b>Section:</b> 20.9.6 [comparisons] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Agust&iacute;n K-ballo Berg&eacute; <b>Opened:</b> 2015-04-01 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#comparisons">active issues</a> in [comparisons].</p>
++<p><b>View all other</b> <a href="lwg-index.html#comparisons">issues</a> in [comparisons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-This means that while the user is free to specialize, any specialization
+-would have to be <tt>false</tt> to avoid violating the second
+-requirement. A similar problem exists for <tt>is_placeholder</tt>.
++It is not entirely clear if and when the specializations of <tt>std::less</tt> (and friends) for pointer types
++can be used in a constant expression. Consider the following code:
+ </p>
++<blockquote><pre>
++#include &lt;functional&gt;
+
++struct foo {};
++foo x, y;
++constexpr bool b = std::less&lt;foo*&gt;{}(&amp;x, &amp;y); // [1]
+
+-<p><i>[
+-2010 Batavia (post meeting session)
+-]</i></p>
+-
++foo z[] = {{}, {}};
++constexpr bool ba = std::less&lt;foo*&gt;{}(&amp;z[0], &amp;z[1]); // [2]
++</pre></blockquote>
+ <p>
+-Alisdair recognises this is clearly a bug introduced by some wording he
+-wrote, the sole purpose of this metafunction is as a customization point
+-for users to write their own <tt>bind</tt>-expression types that participate
+-in the standard library <tt>bind</tt> protocol. The consensus was that this
+-should be fixed in Madrid, moved to Open.
++Comparing the address of unrelated objects is not a constant expression since the result is unspecified, so
++it could be expected for [1] to fail and [2] to succeed. However, <tt>std::less</tt> specialization for pointer
++types is well-defined and yields a total order, so it could just as well be expected for [1] to succeed. Finally,
++since the implementation of such specializations is not mandated, [2] could fail as well (This could happen, if
++an implementation would provide such a specialization and if that would use built-in functions that would not be
++allowed in constant expressions, for example). In any case, the standard should be clear so as to avoid
++implementation-defined <tt>constexpr</tt>-ness.
+ </p>
+
++
++
+ <p><b>Proposed resolution:</b></p>
+
+
+@@ -7580,279 +29543,366 @@ should be fixed in Madrid, moved to Open.
+
+
+ <hr>
+-<h3><a name="2011"></a>2011. unexpected output required of strings</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Open">Open</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2010-07-23 <b>Last modified:</b> 2010-11-16</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Open">Open</a> status.</p>
++<h3><a name="2492"></a>2492. Clarify requirements for <tt>comp</tt></h3>
++<p><b>Section:</b> 25.4 [alg.sorting] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Anton Savin <b>Opened:</b> 2015-04-14 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.sorting">issues</a> in [alg.sorting].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-What should the following code output?
++N4296 25.4 [alg.sorting]/3 reads:
+ </p>
+-
+-<blockquote><pre>#include &lt;string&gt;
+-#include &lt;iostream&gt;
+-#include &lt;iomanip&gt;
+-
+-int
+-main()
+-{
+- std::string test("0X1Y2Z");
+- std::cout.fill('*');
+- std::cout.setf(std::ios::internal, std::ios::adjustfield);
+- std::cout &lt;&lt; std::setw(8) &lt;&lt; test &lt;&lt; std::endl;
+-}
+-</pre></blockquote>
+-
++<blockquote><p>
++For all algorithms that take <tt>Compare</tt>, there is a version that uses <tt>operator&lt;</tt> instead. That is,
++<tt>comp(*i,*j) != false</tt> defaults to <tt>*i &lt; *j != false</tt>. For algorithms other than those described in
++25.4.3 to work correctly, <tt>comp</tt> has to induce a strict weak ordering on the values.
++</p></blockquote>
+ <p>
+-I would expect "<tt>**0X1Y2Z</tt>", and this is what the compilers I have access
+-to (VC++, g++ and Sun CC) do. But according to the standard, it should be
+-"<tt>0X**1Y2Z</tt>":
++So it's not specified clearly what happens if <tt>comp</tt> or <tt>operator&lt;</tt> don't induce a strict weak ordering.
++Is it undefined or implementation-defined behavior? It seems that it should be stated more clearly that the behavior is
++undefined.
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
++
+ <p>
+-21.4.8.9 [string.io]/5:
++Move to Immediate.
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
+- basic_ostream&lt;charT, traits&gt;&amp;
+- operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
+-</pre><blockquote>
+-<i>Effects:</i> Behaves as a formatted output function (27.7.2.6.1 [ostream.formatted.reqmts]). After constructing a <tt>sentry</tt>
+-object, if this object returns <tt>true</tt> when converted to a value of type
+-<tt>bool</tt>, determines padding as described in 22.4.2.2.2 [facet.num.put.virtuals], then inserts the resulting sequence of
+-characters seq as if by calling <tt>os.rdbuf()-&gt;sputn(seq, n)</tt>, where
+-<tt>n</tt> is the larger of <tt>os.width()</tt> and <tt>str.size()</tt>; then
+-calls <tt>os.width(0)</tt>.
+-</blockquote>
+-</blockquote>
+
+-<p>
+-22.4.2.2.2 [facet.num.put.virtuals]/5:
+-</p>
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
+
++<ol>
++<li><p>Change 25.4 [alg.sorting]/3 to the following:</p>
+ <blockquote>
+ <p>
+-[...]
++For all algorithms that take <tt>Compare</tt>, there is a version that uses <tt>operator&lt;</tt> instead. That is, <tt>comp(*i,
++*j) != false</tt> defaults to <tt>*i &lt; *j != false</tt>. For algorithms other than those described in 25.4.3 <del>to work
++correctly</del>, <tt>comp</tt> <ins>shall</ins><del>has to</del> induce a strict weak ordering on the values.
+ </p>
++</blockquote>
++</li>
++</ol>
+
+-<p>
+-<b>Stage 3:</b> A local variable is initialized as
+-</p>
+
+-<blockquote><pre>fmtflags adjustfield= (flags &amp; (ios_base::adjustfield));
+-</pre></blockquote>
+
+-<p>
+-The location of any padding is determined according to Table 88.
+-</p>
+
++
++<hr>
++<h3><a name="2493"></a>2493. <tt>initializer_list</tt> supports incomplete classes</h3>
++<p><b>Section:</b> 18.9 [support.initlist] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2015-04-27 <b>Last modified:</b> 2015-05-04</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.initlist">active issues</a> in [support.initlist].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.initlist">issues</a> in [support.initlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-If <tt>str.width()</tt> is nonzero and the number of <tt>charT</tt>'s in the
+-sequence after stage 2 is less than <tt>str.width()</tt>, then enough fill
+-characters are added to the sequence at the position indicated for padding to
+-bring the length of the sequence to <tt>str.width()</tt>. <tt>str.width(0)</tt>
+-is called.
++The typical use-case of <tt>std::initializer_list&lt;T&gt;</tt> is for a pass-by-value parameter of <tt>T</tt>'s constructor.
++However, this contravenes 17.6.4.8 [res.on.functions]/2.5 because <tt>initializer_list</tt> doesn't specifically allow
++incomplete types (as do for example <tt>std::unique_ptr</tt> (20.8.1 [unique.ptr]/5) and
++<tt>std::enable_shared_from_this</tt> (20.8.2.5 [util.smartptr.enab]/2)).
++<p/>
++A resolution would be to copy-paste the relevant text from such a paragraph.
+ </p>
+
+-<table border="1">
+-<caption>Table 88 — Fill padding</caption>
+-<tbody><tr>
+-<th>State</th>
+-<th>Location</th>
+-</tr>
+
+-<tr>
+-<td><tt>adjustfield == ios_base::left</tt></td>
+-<td>pad after</td>
+-</tr>
+
+-<tr>
+-<td><tt>adjustfield == ios_base::right</tt></td>
+-<td>pad before</td>
+-</tr>
++<p><b>Proposed resolution:</b></p>
+
+-<tr>
+-<td><tt>adjustfield == internal</tt> and a sign occurs in the representation</td>
+-<td>pad after the sign</td>
+-</tr>
+
+-<tr>
+-<td><tt>adjustfield == internal</tt> and representation after stage 1 began with 0x or 0X</td>
+-<td>pad after x or X</td>
+-</tr>
+
+-<tr>
+-<td><i>otherwise</i></td>
+-<td>pad before</td>
+-</tr>
+-</tbody></table>
+
+-</blockquote>
+
++<hr>
++<h3><a name="2494"></a>2494. [fund.ts.v2] <tt>ostream_joiner</tt> needs <tt>noexcept</tt></h3>
++<p><b>Section:</b> X [iterator.ostream.joiner] <b>Status:</b> <a href="lwg-active.html#Ready">Ready</a>
++ <b>Submitter:</b> Nate Wilson <b>Opened:</b> 2015-05-03 <b>Last modified:</b> 2015-05-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Ready">Ready</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts.v2</b></p>
+ <p>
+-Although it's not 100% clear what "the sequence after stage 2" should mean here,
+-when there is no stage 2, the only reasonable assumption is that it is the
+-contents of the string being output. In the above code, the string being output
+-is "<tt>0X1Y2Z</tt>", which starts with "<tt>0X</tt>", so the padding should be
+-inserted "after x or X", and not before the string. I believe that this is a
+-defect in the standard, and not in the three compilers I tried.
++In Library Fundamentals 2
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4481.html#iterator.ostream.joiner.ops">N4481</a>,
++[iterator.ostream.joiner], all operations are no-ops other than the assignment operator.
++<p/>
++So, they should be marked as <tt>noexcept</tt>.
+ </p>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++Move to Immediate.
++</p>
+
+
+-<p><i>[
+-2010 Batavia (post meeting session)
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4481 in regard to fundamental-ts-2 changes.</p>
+
++<ol>
++<li><p>Change class template <tt>ostream_joiner</tt> synopsis, [iterator.ostream.joiner] p2, as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++namespace experimental {
++inline namespace fundamentals_v2 {
++
++template &lt;class DelimT, class charT = char, class traits = char_traits&lt;charT&gt; &gt;
++ class ostream_joiner {
++ public:
++ [&hellip;]
++ ostream_joiner&lt;DelimT, charT,traits&gt;&amp; operator*() <ins>noexcept</ins>;
++ ostream_joiner&lt;DelimT, charT,traits&gt;&amp; operator++() <ins>noexcept</ins>;
++ ostream_joiner&lt;DelimT, charT,traits&gt;&amp; operator++(int) <ins>noexcept</ins>;
++ [&hellip;]
++ };
++
++} // inline namespace fundamentals_v2
++} // namespace experimental
++} // namespace std
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change [iterator.ostream.joiner.ops] p3+5, as indicated:</p>
++
++<blockquote>
++<pre>
++ostream_joiner&lt;DelimT, charT, traits&gt;&amp; operator*() <ins>noexcept</ins>;
++</pre>
+ <p>
+-Consensus that all known implementations are consistent, and disagree with the
+-standard. Preference is to fix the standard before implementations start trying
+-to conform to the current spec, as the current implementations have the preferred
+-form. Howard volunteered to drught for Madrid, move to Open.
++[&hellip;]
+ </p>
++<pre>
++ostream_joiner&lt;DelimT, charT, traits&gt;&amp; operator++() <ins>noexcept</ins>;
++ostream_joiner&lt;DelimT, charT, traits&gt;&amp; operator++(int) <ins>noexcept</ins>;
++</pre>
++</blockquote>
+
+-<p><b>Proposed resolution:</b></p>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="2012"></a>2012. Associative maps should insert <tt>pair</tt>, not <tt>tuple</tt></h3>
+-<p><b>Section:</b> 23.6 [associative] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2010-10-29 <b>Last modified:</b> 2010-11-07</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative">issues</a> in [associative].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2495"></a>2495. There is no such thing as an <i>Exception Safety</i> element</h3>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2015-05-05 <b>Last modified:</b> 2015-05-20</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-I'm seeing something strange in the paragraphs 23.6.1.3 [map.modifiers] and 23.6.2.2 [multimap.modifiers]:
+-they both talk about <tt>tuple&lt;const key_type, mapped_type&gt;</tt> but I think they
+-should be talking about <tt>pair&lt;const key_type, mapped_type&gt;</tt> because, among
+-other reasons, a <tt>tuple</tt> is not convertible to a <tt>pair</tt>. If I replace <tt>tuple</tt>
+-with <tt>pair</tt> everything makes sense to me.
+-
+-The proposed resolution is obvious.
++20.8.2.2.1 [util.smartptr.shared.const] includes several "Exception safety"
++elements, but that is not one of the elements defined in 17.5.1.4
++17.5.1.4 [structure.specifications]. We should either define what it means, or
++just move those sentences into the <i>Effects:</i> clause.
+ </p>
+
+-<p><i>[
+-2010-11-07 Daniel comments
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<ol>
++<li><p>Change 20.8.2.2.1 [util.smartptr.shared.const] as follows:</p>
+
++<blockquote>
++<pre>
++template&lt;class Y&gt; explicit shared_ptr(Y* p);
++</pre>
++<blockquote>
+ <p>
+-This is by far not the only necessary fix within both sub-clauses. For details see the 2010-10-29 comment in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2005">2005</a>.
++[&hellip;]
++<p/>
++-4- <i>Effects</i>: Constructs a <tt>shared_ptr</tt> object that <i>owns</i> the pointer <tt>p</tt>. <ins>If an exception
++is thrown, <tt>delete p</tt> is called.</ins>
++<p/>
++[&hellip;]
++<p/>
++<del>-7- <i>Exception safety</i>: If an exception is thrown, <tt>delete p</tt> is called.</del>
+ </p>
++</blockquote>
++<pre>
++template &lt;class Y, class D&gt; shared_ptr(Y* p, D d);
++template &lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);
++template &lt;class D&gt; shared_ptr(nullptr_t p, D d);
++template &lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-9- <i>Effects</i>: Constructs a <tt>shared_ptr</tt> object that owns the object <tt>p</tt> and the deleter <tt>d</tt>.
++The second and fourth constructors shall use a copy of <tt>a</tt> to allocate memory for internal use. <ins>If an exception
++is thrown, <tt>d(p)</tt> is called.</ins>
++<p/>
++[&hellip;]
++<p/>
++<del>-12- <i>Exception safety</i>: If an exception is thrown, <tt>d(p)</tt> is called.</del>
++</p>
++</blockquote>
++[&hellip;]
++<pre>
++template &lt;class Y&gt; explicit shared_ptr(const weak_ptr&lt;Y&gt;&amp; r);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-24- <i>Effects</i>: Constructs a <tt>shared_ptr</tt> object that shares ownership with <tt>r</tt> and stores a copy of the pointer
++stored in <tt>r</tt>. <ins>If an exception is thrown, the constructor has no effect.</ins>
++<p/>
++[&hellip;]
++<p/>
++<del>-27- <i>Exception safety</i>: If an exception is thrown, the constructor has no effect.</del>
++</p>
++</blockquote>
++<pre>
++template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-29- <i>Effects</i>: Equivalent to <tt>shared_ptr(r.release(), r.get_deleter())</tt> when <tt>D</tt> is not a reference type,
++otherwise <tt>shared_ptr(r.release(), ref(r.get_deleter()))</tt>. <ins>If an exception is thrown, the constructor has no effect.</ins>
++<p/>
++<del>-30- <i>Exception safety</i>: If an exception is thrown, the constructor has no effect.</del>
++</p>
++</blockquote>
++</blockquote>
++</li>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-Apply the resolution proposed by the 2010-10-29 comment in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2005">2005</a>.
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="2013"></a>2013. Do library implementers have the freedom to add <tt>constexpr</tt>?</h3>
+-<p><b>Section:</b> 17.6.4.6 [constexpr.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2010-11-12 <b>Last modified:</b> 2010-11-13</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2496"></a>2496. Certain hard-to-avoid errors not in the immediate context are not allowed to be triggered by
++the evaluation of type traits</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Hubert Tong <b>Opened:</b> 2015-05-07 <b>Last modified:</b> 2015-05-20</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Suppose that a particular function is not tagged as constexpr in the standard,
+-but that, in some particular implementation, it is possible to write it within
+-the constexpr constraints. If an implementer tags such a function as constexpr,
+-is that a violation of the standard or is it a conforming extension?</p>
+-
+-<p>There are two questions to consider. First, is this allowed under the
+-as-if rule? Second, if it does not fall under as-if, is there
+-(and should there be) any special license granted to implementers
+-to do this anyway, sort of the way we allow elision of copy constructors
+-even though it is detectable by users?</p>
++<p>
++I do not believe that the wording in 20.10.4.3 [meta.unary.prop] paragraph 3 allows for the following program to be ill-formed:
++</p>
++<blockquote>
++<pre>
++#include &lt;type_traits&gt;
+
+-<p>I believe that this does not fall under "as-if", so implementers
+-probably don't have that freedom today. I suggest changing the WP
+-to grant it. Even if we decide otherwise, however, I suggest that
+-we make it explicit.</p>
++template &lt;typename T&gt; struct B : T { };
++template &lt;typename T&gt; struct A { A&amp; operator=(const B&lt;T&gt;&amp;); };
+
++std::is_assignable&lt;A&lt;int&gt;, int&gt; q;
++</pre>
++</blockquote>
++<p>
++In particular, I do not see where the wording allows for the "compilation of the expression"
++<tt>declval&lt;T&gt;() = declval&lt;U&gt;()</tt> to occur as a consequence of instantiating <tt>std::is_assignable&lt;T, U&gt;</tt>
++(where <tt>T</tt> and <tt>U</tt> are, respectively, <tt>A&lt;int&gt;</tt> and <tt>int</tt> in the example code).
++<p/>
++Instantiating <tt>A&lt;int&gt;</tt> as a result of requiring it to be a complete type does not trigger the instantiation of
++<tt>B&lt;int&gt;</tt>; however, the "compilation of the expression" in question does.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>In 17.6.4.6 [constexpr.functions], change paragraph 1 to:</i></p>
+-
+-<blockquote>
+-<ins>This standard explicitly requires that certain standard library functions
+-are <tt>constexpr</tt> [dcl.constexpr].
+-Additionally, an implementation may declare any function to be <tt>constexpr</tt>
+-if that function's definition satisfies the necessary constraints.</ins>
+-Within any header that provides any non-defining declarations of <tt>constexpr</tt>
+-functions or constructors an implementation shall provide corresponding definitions.
+-</blockquote>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="2014"></a>2014. More restrictions on macro names</h3>
+-<p><b>Section:</b> 17.6.3.3.1 [macro.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2010-11-17</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#macro.names">issues</a> in [macro.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2497"></a>2497. Use of <tt>uncaught_exception()</tt></h3>
++<p><b>Section:</b> 27.7.3.4 [ostream::sentry] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Roger Orr <b>Opened:</b> 2015-05-08 <b>Last modified:</b> 2015-05-20</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-A program is currently forbidden to use keywords as macro names. This restriction should be strengthened to include all identifiers
+-that could be used by the library as attribute-tokens (for example <tt>noreturn</tt>, which is used by header <tt>&lt;cstdlib&gt;</tt>)
+-and the special identifiers introduced recently for override control (these are not currently used in the library public interface,
+-but could potentially be used by the implementation or in future revisions of the library).
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>Modify 17.6.3.3.1 [macro.names] paragraph 2 as follows:</p>
+-
++<p>
++In the current 27.7.3.4 [ostream::sentry], p4 refers to the now deprecated <tt>std::uncaught_exception()</tt>:
++D.9 [depr.uncaught].
++</p>
+ <blockquote>
+-A translation unit shall not <tt>#define</tt> or <tt>#undef</tt> names lexically identical to keywords<ins>, to the identifiers
+-listed in Table X [Identifiers with special meaning] or to the <i>attribute-tokens</i> described in clause 7.6 [dcl.attr]</ins>.
++<p>
++If <tt>((os.flags() &amp; ios_base::unitbuf) &amp;&amp; !uncaught_exception() &amp;&amp; os.good())</tt> is true, calls
++<tt>os.rdbuf()->pubsync()</tt>.
++</p>
+ </blockquote>
++<p>
++This needs to be changed, for example to use <tt>std::uncaught_exceptions()</tt> and to capture the value on entry and
++compare with the saved value on exit.
++</p>
++
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="2015"></a>2015. Incorrect pre-conditions for some type traits</h3>
+-<p><b>Section:</b> 20.7.4 [meta.unary] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2010-11-08 <b>Last modified:</b> 2010-11-17</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2498"></a>2498. <tt>operator&gt;&gt;(basic_istream&amp;&amp;, T&amp;&amp;)</tt> returns <tt>basic_istream&amp;</tt>, but should probably return
++<tt>basic_istream&amp;&amp;</tt></h3>
++<p><b>Section:</b> 27.7.2.6 [istream.rvalue] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2015-05-08 <b>Last modified:</b> 2015-05-20</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.rvalue">active issues</a> in [istream.rvalue].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.rvalue">issues</a> in [istream.rvalue].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-According to N3126&nbsp;&#8209;&nbsp;3.9/9,
++<p>
++Consider:
++</p>
++<blockquote>
++<pre>
++auto&amp; is = make_istream() &gt;&gt; x; // oops, istream object is already gone
++</pre>
++</blockquote>
++<p>
++With a <tt>basic_istream&amp;&amp;</tt> return type, the above would be ill-formed, and generally we'd
++preserve the value category properly.
++</p>
+
+-<p>"Scalar types, trivial class types (Clause 9), arrays of such types
+-and <i>cv</i>&#8209;qualified versions of these types (3.9.3) are collectively
+-called <i>trivial types</i>."</p>
+
+-<p>Thus, an array (possibly of unknown bound) can be trivial type, non&#8209;trivial type,
+-or an array type whose triviality cannot be determined because its element type is incomplete.</p>
++<p><b>Proposed resolution:</b></p>
++
+
+-<p>According to N3126&nbsp;&#8209;&nbsp;Table 45, preconditions for <tt>std::is_trivial</tt> are
+-defined as follows:</p>
+
+-<p>"<tt>T</tt> shall be a complete type, (possibly <i>cv</i>-qualified) <tt>void</tt>,
+-or an array of unknown bound"</p>
+
+-<p>It seems that "an array of unknown bound" should be changed to "an
+-array of unknown bound of a complete element type". Preconditions for
+-some other templates (e.g., <tt>std::is_trivially_copyable</tt>,
+-<tt>std::is_standard_layout</tt>, <tt>std::is_pod</tt>, and <tt>std::is_literal_type</tt>) should
+-be changed similarly.</p>
+
+-<p>On the other hand, some preconditions look too restrictive. For
+-example, <tt>std::is_empty</tt> and <tt>std::is_polymorphic</tt> might accept any
+-incomplete non-class type.</p>
++<hr>
++<h3><a name="2499"></a>2499. <tt>operator&gt;&gt;(basic_istream&amp;, CharT*)</tt> makes it hard to avoid buffer overflows</h3>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2015-05-08 <b>Last modified:</b> 2015-05-21</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++We removed <tt>gets()</tt> (due to an NB comment and C11 &mdash; bastion of backwards compatibility &mdash; doing the same).
++Should we remove this too?
++<p/>
++Unlike <tt>gets()</tt>, there are legitimate uses:
++</p>
++<blockquote>
++<pre>
++char buffer[32];
++char text[32] = // ...
++ostream_for_buffer(text) &gt;&gt; buffer; // ok, can't overrun buffer
++</pre>
++</blockquote>
++<p>
++&hellip; but the risk from constructs like "<tt>std::cin &gt;&gt; buffer</tt>" seems to outweigh the benefit.
++<p/>
++The issue had been discussed on the library reflector starting around
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=35541">c++std-lib-35541</a>.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -7862,139 +29912,167 @@ incomplete non-class type.</p>
+
+
+ <hr>
+-<h3><a name="2016"></a>2016. <tt>Allocators</tt> must be no-throw <i>swappable</i></h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-11-17 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2500"></a>2500. [fund.ts.v2] fundts.memory.smartptr.shared.obs/6 should apply to <i>cv</i>-unqualified <tt>void</tt></h3>
++<p><b>Section:</b> X [memory.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2015-05-11 <b>Last modified:</b> 2015-05-20</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-During the Batavia meeting it turned out that there is a definition
+-hole for types satisfying the <tt>Allocators</tt> requirements: The problem
+-became obvious when it was discussed whether all <tt>swap</tt> functions
+-of <tt>Containers</tt> with internal data handles can be safely tagged
+-with <tt>noexcept</tt> or not. While it is correct that the implicit
+-<tt>swap</tt> function of an allocator is required to be a no-throw
+-operation (because move/copy-constructors and assignment operators are
+-required to be no-throw functions), there are no such requirements
+-for specialized <tt>swap</tt> overloads for a particular allocator.
+-
+-But this requirement is essential because the <tt>Containers</tt> are
+-required to support <i>swappable</i> <tt>Allocators</tt>, when the value
+-<tt>allocator_traits&lt;&gt;::propagate_on_container_swap</tt> evaluates
+-to <tt>true</tt>.
++<p><b>Addresses: fund.ts.v2</b></p>
++<p>
++S. B. Tam reported this <a href="https://github.com/cplusplus/fundamentals-ts/issues/51">here</a>.
++<p/>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3920.html">N3920</a> changed <tt>operator*()</tt> in
++[util.smartptr.shared.obs] as:
++</p>
++<blockquote>
++<p>
++<i>Remarks</i>: When <tt>T</tt> is <ins>an array type or <i>cv</i>-qualified</ins> <tt>void</tt>, it
++is unspecified whether this member function is declared. &hellip;
++</p>
++</blockquote>
++<p>
++This excludes <i>cv</i>-unqualified <tt>void</tt>, which is probably unintended.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>In the <a href="https://rawgit.com/cplusplus/fundamentals-ts/v2/fundamentals-ts.html#memory.smartptr.shared.obs.6">library
++fundamentals v2</a>, [memory.smartptr.shared.obs] p2, change as indicated:</p>
++<blockquote>
++<p>
++<i>Remarks</i>: When <tt>T</tt> is an array type or <ins>(possibly</ins> <i>cv</i>-qualified<ins>)</ins>
++<tt>void</tt>, it is unspecified whether this
++member function is declared. If it is declared, it is unspecified what
++its return type is, except that the declaration (although not
++necessarily the definition) of the function shall be well formed.
++</p>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="2017"></a>2017. <tt>std::reference_wrapper</tt> makes incorrect usage of <tt>std::result_of</tt></h3>
+-<p><b>Section:</b> 20.8.4 [refwrap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2010-11-15 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#refwrap">issues</a> in [refwrap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2501"></a>2501. <tt>std::function</tt> requires POCMA/POCCA</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2015-05-20 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<tt>std::reference_wrapper</tt>'s function call operator uses <em>wrong</em>
+-type encoding for rvalue-arguments. An rvalue-argument of type <tt>T</tt> must
+-be encoded as <tt>T&amp;&amp;</tt>, not as just <tt>T</tt>.
+-
+-<blockquote><pre>#include &lt;functional&gt;
++<p>
++The idea behind <tt>propagate_on_container_move_assignment</tt> is that you can keep an allocator attached to a container.
++But it's not really designed to work with polymorphism, which introduces the condition where the current allocator is non-POCMA
++and the RHS of assignment, being POCMA, wants to replace it. If function were to respect the literal meaning, any would-be
++attached allocator is at the mercy of every assignment operation. So, <tt>std::function</tt> is inherently POCMA, and passing
++a non-POCMA allocator should be ill-formed.
++<p/>
++The other alternative, and the status quo, is to ignore POCMA and assume it is true. This seems just dangerous enough to outlaw.
++It is, in theory, possible to properly support POCMA as far as I can see, albeit with difficulty and brittle results. It would
++require function to keep a throwing move constructor, which otherwise can be <tt>noexcept</tt>.
++<p/>
++The same applies to <tt>propagate_on_container_copy_assignment</tt>. This presents more difficulty because <tt>std::allocator</tt>
++does not set this to true. Perhaps it should. For function to respect this would require inspecting the POCCA of the source allocator,
++slicing the target from the erasure of the source, slicing the allocation from the erasure of the destination, and performing a
++copy with the destination's allocator with the source's target. This comes out of the blue for the destination allocator, which
++might not support the new type anyway. Theoretically possible, but brittle and not very practical. Again, current implementations
++quietly ignore the issue but this isn't very clean.
++<p/>
++The following code example is intended to demonstrate the issue here:
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
+ #include &lt;iostream&gt;
+-#include &lt;string&gt;
+-#include &lt;type_traits&gt;
+-#include &lt;utility&gt;
++#include &lt;vector&gt;
+
+-template &lt;class F, class... Types&gt;
+- typename std::result_of&lt;F (Types...)&gt;::type
+- f1(F f, Types&amp;&amp;... params)
++template &lt;typename T&gt;
++struct diag_alloc
+ {
+- return f(std::forward&lt;Types...&gt;(params...));
+-}
++ std::string name;
+
+-template &lt;class F, class... Types&gt;
+- typename std::result_of&lt;F (Types<b>&amp;&amp;</b>...)
+- f2(F f, Types&amp;&amp;... params)
+-{
+- return f(std::forward&lt;Types...&gt;(params...));
+-}
++ T* allocate(std::size_t n) const
++ {
++ std::cout &lt;&lt; '+' &lt;&lt; name &lt;&lt; '\n';
++ return static_cast&lt;T*&gt;(::operator new(n * sizeof(T)));
++ }
++
++ void deallocate(T* p, std::size_t) const
++ {
++ std::cout &lt;&lt; '-' &lt;&lt; name &lt;&lt; '\n';
++ return ::operator delete(p);
++ }
+
+-struct Functor
+-{
+- template &lt;class T&gt;
+- T&amp;&amp; operator()(T&amp;&amp; t) const
+- {
+- return static_cast&lt;T&amp;&amp;&gt;(t);
+- }
+-};
++ template &lt;typename U&gt;
++ operator diag_alloc&lt;U&gt;() const { return {name}; }
+
+-int main()
+-{
+- typedef std::string const Str;
+- std::cout &lt;&lt; f1(Functor(), Str("1")) &lt;&lt; std::endl; // (1)
+- std::cout &lt;&lt; f2(Functor(), Str("2")) &lt;&lt; std::endl; // (2)
+-}
+-</pre></blockquote>
++ friend bool operator==(const diag_alloc&amp; a, const diag_alloc&amp; b)
++ { return a.name == b.name; }
++
++ friend bool operator!=(const diag_alloc&amp; a, const diag_alloc&amp; b)
++ { return a.name != b.name; }
+
+-Lets consider the function template <tt>f1</tt> (which is similar to
+-<tt>std::reference_wrapper</tt>'s function call operator). In the invocation
+-(1) <tt>F</tt> is deduced as '<tt>Functor</tt>' and <tt>Types</tt> is deduced as type sequence
+-which consists of one type '<tt>std::string const</tt>'. After the substitution
+-we have the following equivalent:
++ typedef T value_type;
++
++ template &lt;typename U&gt;
++ struct rebind { typedef diag_alloc&lt;U&gt; other; };
++};
+
+-<blockquote><pre>template &lt;&gt;
+- std::result_of&lt;F (std::string const)&gt;::type
+- f1&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
+-{
+- return f(std::forward&lt;const std::string&gt;(params));
++int main() {
++ std::cout &lt;&lt; "VECTOR\n";
++ std::vector&lt;int, diag_alloc&lt;int&gt;&gt; foo({1, 2}, {"foo"}); // +foo
++ std::vector&lt;int, diag_alloc&lt;int&gt;&gt; bar({3, 4}, {"bar"}); // +bar
++
++ std::cout &lt;&lt; "move\n";
++ foo = std::move(bar); // no message
++
++ std::cout &lt;&lt; "more foo\n";
++ foo.reserve(40); // +foo -foo
++ std::cout &lt;&lt; "more bar\n";
++ bar.reserve(40); // +bar -bar
++
++ std::cout &lt;&lt; "\nFUNCTION\n";
++ int bigdata[100];
++ auto bigfun = [bigdata]{};
++ typedef decltype(bigfun) ft;
++ std::cout &lt;&lt; "make fizz\n";
++ std::function&lt;void()&gt; fizz(std::allocator_arg, diag_alloc&lt;ft&gt;{"fizz"}, bigfun); // +fizz
++ std::cout &lt;&lt; "another fizz\n";
++ std::function&lt;void()&gt; fizz2;
++ fizz2 = fizz; // +fizz as if POCCA
++ std::cout &lt;&lt; "make buzz\n";
++ std::function&lt;void()&gt; buzz(std::allocator_arg, diag_alloc&lt;ft&gt;{"buzz"}, bigfun); // +buzz
++ std::cout &lt;&lt; "move\n";
++ buzz = std::move(fizz); // -buzz as if POCMA
++
++ std::cout &lt;&lt; "\nCLEANUP\n";
+ }
+ </pre></blockquote>
+
+-The top-level <i>cv</i>-qualifier in the parameter type of '<tt>F (std::string const)</tt>' is removed, so we have
+
+-<blockquote><pre>template &lt;&gt;
+- std::result_of&lt;F (std::string)&gt;::type
+- f1&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
+-{
+- return f(std::forward&lt;const std::string&gt;(params));
+-}
+-</pre></blockquote>
+-
+-Let <tt>r</tt> be an rvalue of type '<tt>std::string</tt>' and <tt>cr</tt> be an rvalue of type
+-'<tt>std::string const</tt>'. The expression <tt>Str("1")</tt> is <tt>cr</tt>. The corresponding
+-return type for the invocation
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote><pre>Functor().operator()(r)
+-</pre></blockquote>
+
+-is '<tt>std::string &amp;&amp;</tt>'. The corresponding return type for the invocation
+
+
+-<blockquote><pre>Functor().operator()(cr)
+-</pre></blockquote>
+
+-is '<tt>std::string const &amp;&amp;</tt>'.
++<hr>
++<h3><a name="2502"></a>2502. <tt>std::function</tt> does not use <tt>allocator::construct</tt></h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> David Krauss <b>Opened:</b> 2015-05-20 <b>Last modified:</b> 2015-05-21</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-<tt>std::result_of&lt;Functor (std::string)&gt;::type</tt> is the same type as the
+-corresponding return type for the invocation <tt>Functor().operator()(r)</tt>,
+-i.e. it is '<tt>std::string &amp;&amp;</tt>'. As a consequence, we have wrong reference
+-binding in the return statement in <tt>f1</tt>.
+-</p><p>
+-Now lets consider the invocation (2) of the function template <tt>f2</tt>. When
+-the template arguments are substituted we have the following equivalent:
++It is impossible for <tt>std::function</tt> to construct its target object using the <tt>construct</tt> method of a type-erased
++allocator. More confusingly, it is possible when the allocator and the target are created at the same time. The means
++of target construction should be specified.
++</p>
+
+-</p><blockquote><pre>template &lt;&gt;
+- std::result_of&lt;F (std::string const &amp;&amp;)&gt;::type
+- f2&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
+-{
+- return f(std::forward&lt;const std::string&gt;(params));
+-}
+-</pre></blockquote>
+
+-<tt>std::result_of&lt;F (std::string const &amp;&amp;)&gt;::type</tt> is the same type as
+-'<tt>std::string const &amp;&amp;</tt>'. This is correct result.
+ <p><b>Proposed resolution:</b></p>
+
+
+@@ -8002,73 +30080,93 @@ the template arguments are substituted we have the following equivalent:
+
+
+ <hr>
+-<h3><a name="2018"></a>2018. <tt>regex_traits::isctype</tt> Returns clause is wrong</h3>
+-<p><b>Section:</b> 28.7 [re.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.traits">issues</a> in [re.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
++<h3><a name="2503"></a>2503. multiline option should be added to <tt>syntax_option_type</tt></h3>
++<p><b>Section:</b> 28.5.1 [re.synopt] <b>Status:</b> <a href="lwg-active.html#New">New</a>
++ <b>Submitter:</b> Nozomu Kat&#x14d; <b>Opened:</b> 2015-05-22 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.synopt">active issues</a> in [re.synopt].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.synopt">issues</a> in [re.synopt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#New">New</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>28.7 [re.traits] p12 says:</p>
+-<blockquote>
+-<p>returns true if f bitwise or’ed with the result of calling
+-lookup_classname with an iterator pair that designates the character
+-sequence "w" is not equal to 0 and c == ’_’</p>
+-</blockquote>
+-
+-<p>If the bitmask value corresponding to "w" has a non-zero value (which
+-it must do) then the bitwise or with any value is also non-zero, and
+-so isctype('_', f) returns true for any f. Obviously this is wrong,
+-since '_' is not in every ctype category.</p>
+-
+-<p>There's a similar problem with the following phrases discussing the
+-"blank" char class.
++<p>
++The specification of ECMAScript defines the Multiline property for its
++RegExp and the regular expressions ^ and $ behave differently according
++to the value of this property. Thus, this property should be available
++also in the ECMAScript compatible engine in <tt>std::regex</tt>.
+ </p>
+
++<p><i>[2015-05-22, Daniel comments]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+-<p>Replace the Returns clause with a description in terms of ctype
+-categories, rather than pseudocode in terms of bitwise operations.
+-(full replacement wording to follow)
+-
++<p>
++This issue interacts somewhat with LWG <a href="lwg-active.html#2343">2343</a>.
+ </p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
+
++<ol>
++<li><p>Change 28.5.1 [re.synopt] as indicated:</p>
++
++<blockquote><pre>
++namespace std::regex_constants {
++ typedef T1 syntax_option_type;
++ constexpr syntax_option_type icase = <i>unspecified</i> ;
++ constexpr syntax_option_type nosubs = <i>unspecified</i> ;
++ constexpr syntax_option_type optimize = <i>unspecified</i> ;
++ constexpr syntax_option_type collate = <i>unspecified</i> ;
++ constexpr syntax_option_type ECMAScript = <i>unspecified</i> ;
++ constexpr syntax_option_type basic = <i>unspecified</i> ;
++ constexpr syntax_option_type extended = <i>unspecified</i> ;
++ constexpr syntax_option_type awk = <i>unspecified</i> ;
++ constexpr syntax_option_type grep = <i>unspecified</i> ;
++ constexpr syntax_option_type egrep = <i>unspecified</i> ;
++ <ins>constexpr syntax_option_type multiline = <i>unspecified</i> ;</ins>
++}
++</pre></blockquote>
++</li>
+
++<li><p>Change 28.5.2 [re.matchflag], Table 138 &mdash; "<tt>syntax_option_type</tt> effects" as indicated:</p>
+
+-<hr>
+-<h3><a name="2019"></a>2019. <tt>isblank</tt> not supported by <tt>std::locale</tt></h3>
+-<p><b>Section:</b> 22.3.3.1 [classification] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#New">New</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#New">New</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>C99 added <tt>isblank</tt> and <tt>iswblank</tt> to <tt>&lt;locale.h&gt;</tt> but <tt>&lt;locale&gt;</tt> does not
+-provide any equivalent.</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>Add to 22.3.3.1 [classification] synopsis:</p>
+ <blockquote>
+-<pre>template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);
+-<ins>template &lt;class charT&gt; bool isblank (charT c, const locale&amp; loc);</ins>
+-</pre>
+-</blockquote>
++<table border="1">
++<caption>Table 138 &mdash; <tt>syntax_option_type</tt> effects</caption>
++<tr>
++<th align="center">Element</th>
++<th align="center">Effect(s) if set</th>
++</tr>
+
+-<p>Add to 22.4.1 [category.ctype] synopsis:</p>
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-<blockquote>
+-<pre>static const mask xdigit = 1 &lt;&lt; 8;
+-<ins>static const mask blank = 1 &lt;&lt; 9;</ins>
+-static const mask alnum = alpha | digit;
+-static const mask graph = alnum | punct;
+-</pre>
+-</blockquote>
++<tr>
++<td>
++<ins><tt>multiline</tt></ins>
++</td>
++<td>
++<ins>Specifies that <tt>^</tt> shall match the beginning of a line
++and <tt>$</tt> shall match the end of a line, if the ECMAScript engine is
++selected.</ins>
++</td>
++</tr>
+
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++</table>
++</blockquote>
+
++</li>
++</ol>
+
+
+
+
+
+-</body></html>
+\ No newline at end of file
++</body>
++</html>
+diff --git a/libstdc++-v3/doc/html/ext/lwg-closed.html b/libstdc++-v3/doc/html/ext/lwg-closed.html
+index c0848eb..b01c109 100644
+--- a/libstdc++-v3/doc/html/ext/lwg-closed.html
++++ b/libstdc++-v3/doc/html/ext/lwg-closed.html
+@@ -1,6 +1,7 @@
+-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+-<!-- saved from url=(0059)http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html -->
+-<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
++<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
++ "http://www.w3.org/TR/html4/strict.dtd">
++<html>
++<head>
+ <title>C++ Standard Library Closed Issues List</title>
+ <style type="text/css">
+ p {text-align:justify}
+@@ -19,13 +20,13 @@
+ </head>
+ <body>
+ <table>
+-<tbody><tr>
++<tr>
+ <td align="left">Doc. no.</td>
+- <td align="left">D3183=10-0173</td>
++ <td align="left">N4486</td>
+ </tr>
+ <tr>
+ <td align="left">Date:</td>
+- <td align="left">2010-11-29</td>
++ <td align="left">2015-05-23</td>
+ </tr>
+ <tr>
+ <td align="left">Project:</td>
+@@ -33,1089 +34,195 @@
+ </tr>
+ <tr>
+ <td align="left">Reply to:</td>
+- <td align="left">Alisdair Meredith &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
++ <td align="left">Marshall Clow &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
+ </tr>
+-</tbody></table>
+-<h1>C++ Standard Library Closed Issues List (Revision D73)</h1>
+-<p>Revised 2010-11-29 at 10:11:56 UTC</p>
+-
+- <p>Reference ISO/IEC IS 14882:2003(E)</p>
++</table>
++<h1>C++ Standard Library Closed Issues List (Revision R93)</h1>
++<p><p>Revised 2015-05-23 at 15:05:40 UTC</p>
++</p>
++ <p>Reference ISO/IEC IS 14882:2014(E)</p>
+ <p>Also see:</p>
+ <ul>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-toc.html">Table of Contents</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html">Index by Section</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html">Index by Status</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">Library Active Issues List</a></li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html">Library Defect Reports List</a></li>
++ <li><a href="lwg-toc.html">Table of Contents</a> for all library issues.</li>
++ <li><a href="lwg-index.html">Index by Section</a> for all library issues.</li>
++ <li><a href="lwg-status.html">Index by Status</a> for all library issues.</li>
++ <li><a href="lwg-active.html">Library Active Issues List</a></li>
++ <li><a href="lwg-defects.html">Library Defect Reports List</a></li>
+ </ul>
+
+ <p>This document contains only library issues which have been closed
+ by the Library Working Group as duplicates or not defects. That is,
+- issues which have a status of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a> or
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>. See the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">Library Active Issues List</a> active issues and more
+- information. See the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html">Library Defect Reports List</a> for issues considered
++ issues which have a status of <a href="lwg-active.html#Dup">Dup</a> or
++ <a href="lwg-active.html#NAD">NAD</a>. See the <a href="lwg-active.html">Library Active Issues List</a> active issues and more
++ information. See the <a href="lwg-defects.html">Library Defect Reports List</a> for issues considered
+ defects. The introductory material in that document also applies to
+ this document.</p>
+
+ <h2>Revision History</h2>
+ <ul>
+-<li>D73: Batavia meeting preview<ul>
+-<li><b>Summary:</b><ul>
+-<li>80 open issues, down by 126.</li>
+-<li>1459 closed issues, up by 145.</li>
+-<li>1539 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following 11 New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1521">1521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1523">1523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2012">2012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2013">2013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2014">2014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2015">2015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2016">2016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2017">2017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2018">2018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2019">2019</a>.</li>
+-<li>Added the following 5 Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2001">2001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2003">2003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2005">2005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Added the following Resolved issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2002">2002</a>.</li>
+-<li>Added the following Review issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>.</li>
+-<li>Added the following Tentatively NAD issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2006">2006</a>.</li>
+-<li>Added the following 3 Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2000">2000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2004">2004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2007">2007</a>.</li>
+-<li>Added the following WP issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1522">1522</a>.</li>
+-<li>Changed the following 3 issues from New to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>.</li>
+-<li>Changed the following issue from Open to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>.</li>
+-<li>Changed the following 14 issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>.</li>
+-<li>Changed the following issue from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>.</li>
+-<li>Changed the following 8 issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issue from WP to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following 11 issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>.</li>
+-<li>Changed the following issue from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issue from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>.</li>
+-<li>Changed the following 6 issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following 2 issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>.</li>
+-<li>Changed the following 3 issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>.</li>
+-<li>Changed the following 6 issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>.</li>
+-<li>Changed the following 42 issues from NAD Editorial to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>.</li>
+-<li>Changed the following 5 issues from New to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>.</li>
+-<li>Changed the following 46 issues from Open to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>.</li>
+-<li>Changed the following issue from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>.</li>
+-<li>Changed the following 2 issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>.</li>
+-<li>Changed the following issue from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>.</li>
+-<li>Changed the following 3 issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>.</li>
+-<li>Changed the following issue from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>.</li>
+-<li>Changed the following 24 issues from NAD Editorial to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>.</li>
+-<li>Changed the following issue from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>.</li>
+-<li>Changed the following 10 issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>.</li>
+-<li>Changed the following 2 issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following 33 issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R72:
+-2010-10-18 pre-Batavia mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>206 open issues, up by 141.</li>
+-<li>1314 closed issues, up by 36.</li>
+-<li>1520 issues total, up by 177.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1433">1433</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1444">1444</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1415">1415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1419">1419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1434">1434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1483">1483</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1500">1500</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1506">1506</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1345">1345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1348">1348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1349">1349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1353">1353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1358">1358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1364">1364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1369">1369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1374">1374</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1396">1396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1421">1421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1448">1448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1452">1452</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1456">1456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1457">1457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1459">1459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1460">1460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1461">1461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1478">1478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1479">1479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1485">1485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1486">1486</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1487">1487</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1494">1494</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1502">1502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1503">1503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1504">1504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1505">1505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1507">1507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1514">1514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1515">1515</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R71:
+-2010-08-25 post-Rapperswil mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>65 open issues, up by 2.</li>
+-<li>1278 closed issues, up by 7.</li>
+-<li>1343 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R70:
+-2010-03-26 post-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>63 open issues, down by 203.</li>
+-<li>1271 closed issues, up by 219.</li>
+-<li>1334 issues total, up by 16.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1329">1329</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>.</li>
+-<li>Changed the following issues from Tentatively Dup to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Concepts to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#446">446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>.</li>
+-<li>Changed the following issues from Ready to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#427">427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R69:
+-2010-02-12 pre-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>266 open issues, up by 61.</li>
+-<li>1052 closed issues, down by 3.</li>
+-<li>1318 issues total, up by 58.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>.</li>
+-<li>Added the following Tentatively NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#101">101</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from New to Tentatively Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>.</li>
+-<li>Changed the following issues from NAD to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R68:
+-2009-11-06 post-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>205 open issues, down by 77.</li>
+-<li>1055 closed issues, up by 120.</li>
+-<li>1260 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1230">1230</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1229">1229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1236">1236</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1243">1243</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1232">1232</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1235">1235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1242">1242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from NAD Concepts to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R67:
+-2009-09-25 pre-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>282 open issues, up by 32.</li>
+-<li>935 closed issues, down by 1.</li>
+-<li>1217 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>.</li>
+-<li>Changed the following issues from WP to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R66:
+-2009-07-31 post-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>250 open issues, down by 128.</li>
+-<li>936 closed issues, up by 171.</li>
+-<li>1186 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1164">1164</a>.</li>
+-<li>Added the following NAD Concepts issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1149">1149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1167">1167</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1168">1168</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#290">290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#343">343</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#394">394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#398">398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#417">417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#421">421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#459">459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#492">492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>.</li>
+-<li>Changed the following issues from New to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>.</li>
+-<li>Changed the following issues from Review to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#423">423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from CD1 to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>.</li>
+-<li>Changed the following issues from NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R65:
+-2009-06-19 pre-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>378 open issues, up by 32.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1143 issues total, up by 32.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R64:
+-2009-05-01 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>346 open issues, up by 19.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1111 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from DR to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#386">386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#406">406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#409">409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#413">413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#434">434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#438">438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#444">444</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#445">445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#455">455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#469">469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>.</li>
+-<li>Changed the following issues from Review to New: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R63:
+-2009-03-20 post-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>327 open issues, up by 96.</li>
+-<li>765 closed issues, up by 14.</li>
+-<li>1092 issues total, up by 110.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1022">1022</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1025">1025</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R62:
+-2009-02-06 pre-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>231 open issues, up by 44.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>982 issues total, up by 44.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R61:
+-2008-12-05 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>187 open issues, up by 20.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>938 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R60:
+-2008-10-03 post-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>167 open issues, down by 25.</li>
+-<li>751 closed issues, up by 65.</li>
+-<li>918 issues total, up by 40.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following CD1 issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#882">882</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from New to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>.</li>
+-<li>Changed the following issues from Ready to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Changed the following issues from Review to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from WP to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#44">44</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#98">98</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#123">123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#167">167</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#200">200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#231">231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#239">239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#240">240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#274">274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#282">282</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#291">291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#300">300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#305">305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#310">310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#315">315</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#316">316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#318">318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#319">319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#320">320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#321">321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#322">322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#324">324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#325">325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#327">327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#328">328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#329">329</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#331">331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#333">333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#334">334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#337">337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#338">338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#339">339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#340">340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#341">341</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#345">345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#346">346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#349">349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#352">352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#354">354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#355">355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#358">358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#359">359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#360">360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#363">363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#364">364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#365">365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#370">370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#373">373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#375">375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#379">379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#380">380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#381">381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#391">391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#395">395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#400">400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#403">403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#405">405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#407">407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#410">410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#411">411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#412">412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#414">414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#415">415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#420">420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#425">425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#426">426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#428">428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#435">435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#436">436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#442">442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#443">443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#448">448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#449">449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-<li>Changed the following issues from TC to TC1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1">1</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#5">5</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#7">7</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#11">11</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#13">13</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#14">14</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#15">15</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#16">16</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#18">18</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#20">20</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#21">21</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#22">22</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#24">24</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#25">25</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#27">27</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#28">28</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#30">30</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#32">32</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#33">33</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#34">34</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#35">35</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#36">36</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#37">37</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#39">39</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#40">40</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#41">41</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#42">42</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#46">46</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#47">47</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#48">48</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#50">50</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#51">51</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#52">52</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#53">53</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#54">54</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#56">56</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#57">57</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#59">59</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#62">62</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#66">66</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#68">68</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69">69</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#71">71</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#74">74</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#75">75</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#78">78</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#79">79</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#80">80</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#90">90</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#106">106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#119">119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#124">124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#125">125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#141">141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#148">148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#150">150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#151">151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#152">152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#154">154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#155">155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#156">156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#158">158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#161">161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#168">168</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#169">169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#172">172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#173">173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#174">174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#175">175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#176">176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#193">193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R59:
+-2008-08-22 pre-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>192 open issues, up by 9.</li>
+-<li>686 closed issues, up by 0.</li>
+-<li>878 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R58:
+-2008-07-28 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>183 open issues, up by 12.</li>
+-<li>686 closed issues, down by 4.</li>
+-<li>869 issues total, up by 8.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from WP to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R57:
+-2008-06-27 post-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>171 open issues, down by 20.</li>
+-<li>690 closed issues, up by 43.</li>
+-<li>861 issues total, up by 23.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#840">840</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R56:
+-2008-05-16 pre-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>191 open issues, up by 24.</li>
+-<li>647 closed issues, up by 1.</li>
+-<li>838 issues total, up by 25.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R55:
+-2008-03-14 post-Bellevue mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>167 open issues, down by 39.</li>
+-<li>646 closed issues, up by 65.</li>
+-<li>813 issues total, up by 26.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#795">795</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#790">790</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#791">791</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#796">796</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#797">797</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#799">799</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Open to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R54:
+-2008-02-01 pre-Bellevue mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>206 open issues, up by 23.</li>
+-<li>581 closed issues, up by 0.</li>
+-<li>787 issues total, up by 23.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R53:
+-2007-12-09 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>183 open issues, up by 11.</li>
+-<li>581 closed issues, down by 1.</li>
+-<li>764 issues total, up by 10.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R52:
+-2007-10-19 post-Kona mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>172 open issues, up by 4.</li>
+-<li>582 closed issues, up by 27.</li>
+-<li>754 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
+-<li>Changed the following issues from New to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R51:
+-2007-09-09 pre-Kona mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>168 open issues, up by 15.</li>
+-<li>555 closed issues, up by 0.</li>
+-<li>723 issues total, up by 15.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R50:
+-2007-08-05 post-Toronto mailing.
+-<ul>
++<li>R93: 2014-05-22 2015 post-Lenexa mailing<ul>
+ <li><b>Summary:</b><ul>
+-<li>153 open issues, down by 5.</li>
+-<li>555 closed issues, up by 17.</li>
+-<li>708 issues total, up by 12.</li>
++<li>256 open issues, down by 36.</li>
++<li>1770 closed issues, up by 48.</li>
++<li>2026 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from DR to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
++<li>Added the following 2 Ready issues: <a href="lwg-active.html#2492">2492</a>, <a href="lwg-active.html#2494">2494</a>.</li>
++<li>Added the following 10 New issues: <a href="lwg-active.html#2493">2493</a>, <a href="lwg-active.html#2495">2495</a>, <a href="lwg-active.html#2496">2496</a>, <a href="lwg-active.html#2497">2497</a>, <a href="lwg-active.html#2498">2498</a>, <a href="lwg-active.html#2499">2499</a>, <a href="lwg-active.html#2500">2500</a>, <a href="lwg-active.html#2501">2501</a>, <a href="lwg-active.html#2502">2502</a>, <a href="lwg-active.html#2503">2503</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-active.html#2111">2111</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 20 issues to Ready (from New): <a href="lwg-active.html#2244">2244</a>, <a href="lwg-active.html#2250">2250</a>, <a href="lwg-active.html#2259">2259</a>, <a href="lwg-active.html#2336">2336</a>, <a href="lwg-active.html#2353">2353</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2489">2489</a>.</li>
++<li>Changed the following 12 issues to Ready (from Open): <a href="lwg-active.html#1169">1169</a>, <a href="lwg-active.html#2072">2072</a>, <a href="lwg-active.html#2101">2101</a>, <a href="lwg-active.html#2119">2119</a>, <a href="lwg-active.html#2127">2127</a>, <a href="lwg-active.html#2133">2133</a>, <a href="lwg-active.html#2156">2156</a>, <a href="lwg-active.html#2181">2181</a>, <a href="lwg-active.html#2218">2218</a>, <a href="lwg-active.html#2219">2219</a>, <a href="lwg-active.html#2447">2447</a>, <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2224">2224</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2296">2296</a>.</li>
++<li>Changed the following issue to Review (from Open): <a href="lwg-active.html#2328">2328</a>.</li>
++<li>Changed the following 11 issues to Open (from New): <a href="lwg-active.html#2262">2262</a>, <a href="lwg-active.html#2289">2289</a>, <a href="lwg-active.html#2338">2338</a>, <a href="lwg-active.html#2348">2348</a>, <a href="lwg-active.html#2349">2349</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2456">2456</a>.</li>
++<li>Changed the following 8 issues to Open (from SG1): <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following issue to LEWG (from New): <a href="lwg-active.html#2372">2372</a>.</li>
++<li>Changed the following issue to EWG (from New): <a href="lwg-active.html#2432">2432</a>.</li>
++<li>Changed the following issue to Deferred (from Open): <a href="lwg-active.html#2202">2202</a>.</li>
++<li>Changed the following 14 issues to WP (from Ready): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following 18 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2059">2059</a>, <a href="lwg-defects.html#2076">2076</a>, <a href="lwg-defects.html#2239">2239</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2415">2415</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-defects.html#2458">2458</a>, <a href="lwg-defects.html#2459">2459</a>, <a href="lwg-defects.html#2463">2463</a>, <a href="lwg-defects.html#2467">2467</a>, <a href="lwg-defects.html#2470">2470</a>, <a href="lwg-defects.html#2482">2482</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-defects.html#2464">2464</a>, <a href="lwg-defects.html#2488">2488</a>.</li>
++<li>Changed the following issue to WP (from Open): <a href="lwg-defects.html#2063">2063</a>.</li>
++<li>Changed the following 2 issues to WP (from SG1): <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2442">2442</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2228">2228</a>.</li>
++<li>Changed the following 3 issues to Resolved (from Open): <a href="lwg-defects.html#1526">1526</a>, <a href="lwg-defects.html#2274">2274</a>, <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Changed the following 5 issues to NAD (from New): <a href="lwg-closed.html#2079">2079</a>, <a href="lwg-closed.html#2251">2251</a>, <a href="lwg-closed.html#2351">2351</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-closed.html#2386">2386</a>.</li>
++<li>Changed the following issue to NAD (from Open): <a href="lwg-closed.html#2388">2388</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R49:
+-2007-06-23 pre-Toronto mailing.
++<li>R92:
++2015-04-09 pre-Lenexa mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>158 open issues, up by 13.</li>
+-<li>538 closed issues, up by 7.</li>
+-<li>696 issues total, up by 20.</li>
++<li>292 open issues, up by 33.</li>
++<li>1722 closed issues, up by 0.</li>
++<li>2014 issues total, up by 33.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>.</li>
++<li>Added the following 5 Tentatively Ready issues: <a href="lwg-active.html#2459">2459</a>, <a href="lwg-active.html#2463">2463</a>, <a href="lwg-active.html#2467">2467</a>, <a href="lwg-active.html#2470">2470</a>, <a href="lwg-active.html#2482">2482</a>.</li>
++<li>Added the following 27 New issues: <a href="lwg-active.html#2460">2460</a>, <a href="lwg-active.html#2461">2461</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2464">2464</a>, <a href="lwg-active.html#2465">2465</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2468">2468</a>, <a href="lwg-active.html#2471">2471</a>, <a href="lwg-active.html#2472">2472</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2474">2474</a>, <a href="lwg-active.html#2475">2475</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2478">2478</a>, <a href="lwg-active.html#2479">2479</a>, <a href="lwg-active.html#2480">2480</a>, <a href="lwg-active.html#2481">2481</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2488">2488</a>, <a href="lwg-active.html#2489">2489</a>, <a href="lwg-active.html#2490">2490</a>, <a href="lwg-active.html#2491">2491</a>.</li>
++<li>Added the following Open issue: <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Review): <a href="lwg-active.html#2378">2378</a>.</li>
++<li>Changed the following 11 issues to Tentatively Ready (from New): <a href="lwg-active.html#2076">2076</a>, <a href="lwg-active.html#2239">2239</a>, <a href="lwg-active.html#2369">2369</a>, <a href="lwg-active.html#2410">2410</a>, <a href="lwg-active.html#2415">2415</a>, <a href="lwg-active.html#2418">2418</a>, <a href="lwg-active.html#2437">2437</a>, <a href="lwg-active.html#2448">2448</a>, <a href="lwg-active.html#2454">2454</a>, <a href="lwg-active.html#2455">2455</a>, <a href="lwg-active.html#2458">2458</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2059">2059</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-active.html#2337">2337</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from Open): <a href="lwg-active.html#760">760</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2312">2312</a>, <a href="lwg-active.html#2388">2388</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2447">2447</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-active.html#2451">2451</a>.</li>
++<li>Changed the following issue to EWG (from Open): <a href="lwg-active.html#2089">2089</a>.</li>
++<li>Changed the following issue to Core (from New): <a href="lwg-active.html#2452">2452</a>.</li>
++<li>Changed the following 13 issues to SG1 (from New): <a href="lwg-active.html#2236">2236</a>, <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2334">2334</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2407">2407</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2442">2442</a>, <a href="lwg-active.html#2445">2445</a>.</li>
++<li>Changed the following issue to SG1 (from Open): <a href="lwg-active.html#2441">2441</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R48:
+-2007-05-06 post-Oxford mailing.
++<li>R91:
++2014-11-23 post-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>145 open issues, down by 33.</li>
+-<li>531 closed issues, up by 53.</li>
+-<li>676 issues total, up by 20.</li>
++<li>259 open issues, up by 32.</li>
++<li>1722 closed issues, down by 20.</li>
++<li>1981 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#357">357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#368">368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>.</li>
+-<li>Changed the following issues from NAD_Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
++<li>Added the following 12 New issues: <a href="lwg-active.html#2447">2447</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-active.html#2449">2449</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2451">2451</a>, <a href="lwg-active.html#2452">2452</a>, <a href="lwg-active.html#2453">2453</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-active.html#2456">2456</a>, <a href="lwg-active.html#2457">2457</a>, <a href="lwg-defects.html#2458">2458</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2364">2364</a>.</li>
++<li>Changed the following 11 issues to Ready (from New): <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following issue to Ready (from Open): <a href="lwg-defects.html#2168">2168</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2424">2424</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2307">2307</a>, <a href="lwg-active.html#2310">2310</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following 2 issues to Open (from NAD Future): <a href="lwg-active.html#760">760</a>, <a href="lwg-active.html#1173">1173</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2419">2419</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>Changed the following 48 issues to LEWG (from NAD Future): <a href="lwg-active.html#255">255</a>, <a href="lwg-active.html#423">423</a>, <a href="lwg-active.html#484">484</a>, <a href="lwg-active.html#523">523</a>, <a href="lwg-active.html#532">532</a>, <a href="lwg-active.html#708">708</a>, <a href="lwg-active.html#839">839</a>, <a href="lwg-active.html#851">851</a>, <a href="lwg-active.html#877">877</a>, <a href="lwg-active.html#933">933</a>, <a href="lwg-active.html#935">935</a>, <a href="lwg-active.html#936">936</a>, <a href="lwg-active.html#961">961</a>, <a href="lwg-active.html#1025">1025</a>, <a href="lwg-active.html#1031">1031</a>, <a href="lwg-active.html#1041">1041</a>, <a href="lwg-active.html#1052">1052</a>, <a href="lwg-active.html#1053">1053</a>, <a href="lwg-active.html#1112">1112</a>, <a href="lwg-active.html#1120">1120</a>, <a href="lwg-active.html#1121">1121</a>, <a href="lwg-active.html#1150">1150</a>, <a href="lwg-active.html#1154">1154</a>, <a href="lwg-active.html#1184">1184</a>, <a href="lwg-active.html#1188">1188</a>, <a href="lwg-active.html#1201">1201</a>, <a href="lwg-active.html#1203">1203</a>, <a href="lwg-active.html#1217">1217</a>, <a href="lwg-active.html#1235">1235</a>, <a href="lwg-active.html#1238">1238</a>, <a href="lwg-active.html#1242">1242</a>, <a href="lwg-active.html#1282">1282</a>, <a href="lwg-active.html#1289">1289</a>, <a href="lwg-active.html#1317">1317</a>, <a href="lwg-active.html#1320">1320</a>, <a href="lwg-active.html#1396">1396</a>, <a href="lwg-active.html#1406">1406</a>, <a href="lwg-active.html#1422">1422</a>, <a href="lwg-active.html#1459">1459</a>, <a href="lwg-active.html#1484">1484</a>, <a href="lwg-active.html#1488">1488</a>, <a href="lwg-active.html#1493">1493</a>, <a href="lwg-active.html#1499">1499</a>, <a href="lwg-active.html#1521">1521</a>, <a href="lwg-active.html#2040">2040</a>, <a href="lwg-active.html#2055">2055</a>, <a href="lwg-active.html#2226">2226</a>, <a href="lwg-active.html#2232">2232</a>.</li>
++<li>Changed the following 2 issues to Pending NAD (from Tentatively NAD): <a href="lwg-closed.html#2302">2302</a>, <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 11 issues to WP (from Ready): <a href="lwg-defects.html#2016">2016</a>, <a href="lwg-defects.html#2170">2170</a>, <a href="lwg-defects.html#2340">2340</a>, <a href="lwg-defects.html#2354">2354</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Changed the following 12 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2217">2217</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>, <a href="lwg-defects.html#2266">2266</a>, <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Resolved (from Ready): <a href="lwg-defects.html#2319">2319</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2118">2118</a>.</li>
++<li>Changed the following issue to Resolved (from New): <a href="lwg-defects.html#2416">2416</a>.</li>
++<li>Changed the following issue to Resolved (from Open): <a href="lwg-defects.html#2108">2108</a>.</li>
++<li>Changed the following issue to NAD (from New): <a href="lwg-closed.html#2429">2429</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R47:
+-2007-03-09 pre-Oxford mailing.
++<li>R90:
++2014-10-13 pre-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>178 open issues, up by 37.</li>
+-<li>478 closed issues, up by 0.</li>
+-<li>656 issues total, up by 37.</li>
++<li>227 open issues, up by 31.</li>
++<li>1742 closed issues, up by 0.</li>
++<li>1969 issues total, up by 31.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>.</li>
++<li>Added the following 31 New issues: <a href="lwg-defects.html#2416">2416</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-active.html#2419">2419</a>, <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-active.html#2421">2421</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2423">2423</a>, <a href="lwg-active.html#2424">2424</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-closed.html#2429">2429</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2431">2431</a>, <a href="lwg-active.html#2432">2432</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>, <a href="lwg-active.html#2441">2441</a>, <a href="lwg-defects.html#2442">2442</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2445">2445</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>No issues changed.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R46:
+-2007-01-12 mid-term mailing.
++<li>R89:
++2014-07-08 post-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>141 open issues, up by 11.</li>
+-<li>478 closed issues, down by 1.</li>
+-<li>619 issues total, up by 10.</li>
++<li>196 open issues, up by 14.</li>
++<li>1742 closed issues, up by 12.</li>
++<li>1938 issues total, up by 26.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
++<li>Added the following 6 Ready issues: <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Added the following 15 New issues: <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2392">2392</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2394">2394</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2413">2413</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-defects.html#2415">2415</a>.</li>
++<li>Added the following Open issue: <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Added the following 3 WP issues: <a href="lwg-defects.html#2390">2390</a>, <a href="lwg-defects.html#2395">2395</a>, <a href="lwg-defects.html#2409">2409</a>.</li>
++<li>Added the following NAD issue: <a href="lwg-closed.html#2405">2405</a>.</li>
++<li>Changed the following issue to Ready (from New): <a href="lwg-defects.html#2377">2377</a>.</li>
++<li>Changed the following 2 issues to Ready (from Deferred): <a href="lwg-active.html#2253">2253</a>, <a href="lwg-active.html#2255">2255</a>.</li>
++<li>Changed the following 2 issues to Tentatively Ready (from New): <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 3 issues to Review (from New): <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 2 issues to Review (from Open): <a href="lwg-defects.html#2118">2118</a>, <a href="lwg-defects.html#2160">2160</a>.</li>
++<li>Changed the following 3 issues to Open (from New): <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-active.html#2238">2238</a>, <a href="lwg-active.html#2273">2273</a>.</li>
++<li>Changed the following 3 issues to Open (from Deferred): <a href="lwg-active.html#2254">2254</a>, <a href="lwg-active.html#2264">2264</a>, <a href="lwg-active.html#2277">2277</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 4 issues to Resolved (from Deferred): <a href="lwg-defects.html#2282">2282</a>, <a href="lwg-defects.html#2283">2283</a>, <a href="lwg-defects.html#2287">2287</a>, <a href="lwg-defects.html#2333">2333</a>.</li>
++<li>Changed the following issue to NAD (from Deferred): <a href="lwg-closed.html#2305">2305</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R45:
+-2006-11-03 post-Portland mailing.
++<li>R88:
++2014-05-24 pre-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>130 open issues, up by 0.</li>
+-<li>479 closed issues, up by 17.</li>
+-<li>609 issues total, up by 17.</li>
++<li>182 open issues, up by 29.</li>
++<li>1730 closed issues, up by 0.</li>
++<li>1912 issues total, up by 29.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a> to WP.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a> to NAD.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Dup.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a> to Open.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a> - <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a> to Review.</li>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>.</li>
++<li>Added the following 3 Tentatively Ready issues: <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>.</li>
++<li>Added the following 26 New issues: <a href="lwg-active.html#2362">2362</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-active.html#2366">2366</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2368">2368</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-active.html#2372">2372</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-active.html#2375">2375</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2380">2380</a>, <a href="lwg-active.html#2381">2381</a>, <a href="lwg-closed.html#2382">2382</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-closed.html#2386">2386</a>, <a href="lwg-defects.html#2387">2387</a>, <a href="lwg-closed.html#2388">2388</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 5 issues to Tentatively Ready (from Open): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R44:
+-2006-09-08 pre-Portland mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>130 open issues, up by 6.</li>
+-<li>462 closed issues, down by 1.</li>
+-<li>592 issues total, up by 5.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R43:
+-2006-06-23 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>124 open issues, up by 14.</li>
+-<li>463 closed issues, down by 1.</li>
+-<li>587 issues total, up by 13.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Tentatively Ready.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R42:
+-2006-04-21 post-Berlin mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>110 open issues, down by 16.</li>
+-<li>464 closed issues, up by 24.</li>
+-<li>574 issues total, up by 8.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#501">501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#517">517</a> to NAD.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a> to Open.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> to WP.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a> to Review.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R41:
+-2006-02-24 pre-Berlin mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>126 open issues, up by 31.</li>
+-<li>440 closed issues, up by 0.</li>
+-<li>566 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a> ,<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>.</li>
+-<li>Moved <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a> from Ready to Open.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R40:
+-2005-12-16 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>95 open issues.</li>
+-<li>440 closed issues.</li>
+-<li>535 issues total.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R39:
+-2005-10-14 post-Mont Tremblant mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a> from Ready to WP as per the vote from Mont Tremblant.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a> from Review to Ready.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a> from New to Open.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> from New to Ready.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#500">500</a> from New to NAD.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a> from New to Review.
+-</li>
+-<li>R38:
+-2005-07-03 pre-Mont Tremblant mailing.
+-Merged open TR1 issues in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>
+-</li>
+-<li>R37:
+-2005-06 mid-term mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>.
+-</li>
+-<li>R36:
+-2005-04 post-Lillehammer mailing. All issues in "ready" status except
+-for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a> were moved to "DR" status, and all issues
+-previously in "DR" status were moved to "WP".
+-</li>
+-<li>R35:
+-2005-03 pre-Lillehammer mailing.
+-</li>
+-<li>R34:
+-2005-01 mid-term mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#494">494</a>.
+-</li>
+-<li>R33:
+-2004-11 post-Redmond mailing. Reflects actions taken in Redmond.
+-</li>
+-<li>R32:
+-2004-09 pre-Redmond mailing: reflects new proposed resolutions and
+-new issues received after the 2004-07 mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#481">481</a>.
+-</li>
+-<li>R31:
+-2004-07 mid-term mailing: reflects new proposed resolutions and
+-new issues received after the post-Sydney mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>.
+-</li>
+-<li>R30:
+-Post-Sydney mailing: reflects decisions made at the Sydney meeting.
+-Voted all "Ready" issues from R29 into the working paper.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>.
+-</li>
+-<li>R29:
+-Pre-Sydney mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>.
+-</li>
+-<li>R28:
+-Post-Kona mailing: reflects decisions made at the Kona meeting.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#440">440</a>.
+-</li>
+-<li>R27:
+-Pre-Kona mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>.
+-</li>
+-<li>R26:
+-Post-Oxford mailing: reflects decisions made at the Oxford meeting.
+-All issues in Ready status were voted into DR status. All issues in
+-DR status were voted into WP status.
+-</li>
+-<li>R25:
+-Pre-Oxford mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>.
+-</li>
+-<li>R24:
+-Post-Santa Cruz mailing: reflects decisions made at the Santa Cruz
+-meeting. All Ready issues from R23 with the exception of <iref ref="253">, which has been given a new proposed resolution, were
+-moved to DR status. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>-<iref ref="389">. (Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a> were discussed
+-at the meeting.) Made progress on issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <iref ref="226">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a> and <iref ref="229"> have been moved to Ready status, and the only remaining
+-concerns with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a> involve wording.
+-</iref></iref></iref></iref></li>
+-<li>R23:
+-Pre-Santa Cruz mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#367">367</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>.
+-Moved issues in the TC to TC status.
+-</li>
+-<li>R22:
+-Post-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>-<iref ref="366">.
+-</iref></li>
+-<li>R21:
+-Pre-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>-<iref ref="361">.
+-</iref></li>
+-<li>R20:
+-Post-Redmond mailing; reflects actions taken in Redmond. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, of which issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a> were added since Redmond, hence
+-not discussed at the meeting.
+-
+-All Ready issues were moved to DR status, with the exception of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-
+-Noteworthy issues discussed at Redmond include
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.
+-</li>
+-<li>R19:
+-Pre-Redmond mailing. Added new issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>.
+-</li>
+-<li>R18:
+-Post-Copenhagen mailing; reflects actions taken in Copenhagen.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, and discussed
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>
+-to DR.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>
+-to Ready.
+-
+-Closed issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#279">279</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#287">287</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#289">289</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#293">293</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#302">302</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#313">313</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>
+-as NAD.
+-
+-</li>
+-<li>R17:
+-Pre-Copenhagen mailing. Converted issues list to XML. Added proposed
+-resolutions for issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <iref ref="91">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>.
+-</iref></li>
+-<li>R16:
+-post-Toronto mailing; reflects actions taken in Toronto. Added new
+-issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a>. Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a> to "DR". Reopened issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>. Reopened
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>. Changed issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#2">2</a> and
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD. Fixed a typo in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>. Fixed
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>: signature should be changed both places it
+-appears. Fixed issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>: previous version didn't fix
+-the bug in enough places.
+-</li>
+-<li>R15:
+-pre-Toronto mailing. Added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>. Some small HTML formatting
+-changes so that we pass Weblint tests.
+-</li>
+-<li>R14:
+-post-Tokyo II mailing; reflects committee actions taken in
+-Tokyo. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>. (00-0019R1/N1242)
+-</li>
+-<li>R13:
+-pre-Tokyo II updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.
+-</li>
+-<li>R12:
+-pre-Tokyo II mailing: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>. Added "and paragraph 5" to the proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>. Add further rationale to issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#178">178</a>.
+-</li>
+-<li>R11:
+-post-Kona mailing: Updated to reflect LWG and full committee actions
+-in Kona (99-0048/N1224). Note changed resolution of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#196">196</a>
+-to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>. Closed issues list split into "defects" and
+-"closed" documents. Changed the proposed resolution of issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD, and changed the wording of proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>.
+-</li>
+-<li>R10:
+-pre-Kona updated. Added proposed resolutions <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>. (99-0033/D1209, 14 Oct 99)
+-</li>
+-<li>R9:
+-pre-Kona mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>. Issues list split into separate "active" and
+-"closed" documents. (99-0030/N1206, 25 Aug 99)
+-</li>
+-<li>R8:
+-post-Dublin mailing. Updated to reflect LWG and full committee actions
+-in Dublin. (99-0016/N1193, 21 Apr 99)
+-</li>
+-<li>R7:
+-pre-Dublin updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#131">131</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#135">135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a> (31 Mar 99)
+-</li>
+-<li>R6:
+-pre-Dublin mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>,
+-and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>. (99-0007/N1194, 22 Feb 99)
+-</li>
+-<li>R5:
+-update issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>; added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>. Format revisions to prepare
+-for making list public. (30 Dec 98)
+-</li>
+-<li>R4:
+-post-Santa Cruz II updated: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#113">113</a> added, several
+-issues corrected. (22 Oct 98)
+-</li>
+-<li>R3:
+-post-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#94">94</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>
+-added, many issues updated to reflect LWG consensus (12 Oct 98)
+-</li>
+-<li>R2:
+-pre-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#73">73</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#93">93</a> added,
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a> updated. (29 Sep 98)
+-</li>
+-<li>R1:
+-Correction to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a> resolution, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a> code
+-format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a> title. (17 Sep 98)
+-</li>
+ </ul>
+
+ <h2>Closed Issues</h2>
+ <hr>
+ <h3><a name="2"></a>2. Auto_ptr conversions effects incorrect</h3>
+-<p><b>Section:</b> D.12.1.3 [auto.ptr.conv] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1997-12-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [auto.ptr.conv] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1997-12-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Paragraph 1 in "Effects", says "Calls
+-p-&gt;release()" where it clearly must be "Calls
+-p.release()". (As it is, it seems to require using
++<p>Paragraph 1 in &quot;Effects&quot;, says &quot;Calls
++p-&gt;release()&quot; where it clearly must be &quot;Calls
++p.release()&quot;. (As it is, it seems to require using
+ auto_ptr&lt;&gt;::operator-&gt; to refer to X::release, assuming that
+ exists.)</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 20.7.4.3 [meta.unary.prop] paragraph 1 Effects from
+-"Calls p-&gt;release()" to "Calls p.release()".</p>
++<p>Change 20.10.4.3 [meta.unary.prop] paragraph 1 Effects from
++&quot;Calls p-&gt;release()&quot; to &quot;Calls p.release()&quot;.</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -1128,10 +235,11 @@ exists.)</p>
+
+ <hr>
+ <h3><a name="4"></a>4. Basic_string size_type and difference_type should be implementation defined</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1997-11-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1997-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Morristown we changed the size_type and difference_type typedefs
+ for all the other containers to implementation defined with a
+@@ -1152,20 +260,20 @@ from implementation defined.</p>
+
+ <hr>
+ <h3><a name="6"></a>6. File position not an offset unimplementable</h3>
+-<p><b>Section:</b> 27.5.3 [fpos] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos">issues</a> in [fpos].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.4 [fpos] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos">issues</a> in [fpos].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Table 88, in I/O, is too strict; it's unimplementable on systems
+ where a file position isn't just an offset. It also never says just
+ what fpos&lt;&gt; is really supposed to be. [Here's my summary, which
+-Jerry agrees is more or less accurate. "I think I now know what
++Jerry agrees is more or less accurate. &quot;I think I now know what
+ the class really is, at this point: it's a magic cookie that
+ encapsulates an mbstate_t and a file position (possibly represented as
+ an fpos_t), it has syntactic support for pointer-like arithmetic, and
+ implementors are required to have real, not just syntactic, support
+-for arithmetic." This isn't standardese, of course.] </p>
++for arithmetic.&quot; This isn't standardese, of course.] </p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -1178,18 +286,18 @@ and that the above summary is what the Standard in effect says.</p>
+
+ <hr>
+ <h3><a name="10"></a>10. Codecvt&lt;&gt;::do unclear</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a></p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#19">19</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Section 22.2.1.5.2 says that codecvt&lt;&gt;::do_in and do_out
+-should return the value noconv if "no conversion was
+-needed". However, I don't see anything anywhere that defines what
++should return the value noconv if &quot;no conversion was
++needed&quot;. However, I don't see anything anywhere that defines what
+ it means for a conversion to be needed or not needed. I can think of
+ several circumstances where one might plausibly think that a
+-conversion is not "needed", but I don't know which one is
++conversion is not &quot;needed&quot;, but I don't know which one is
+ intended here. </p>
+
+
+@@ -1202,10 +310,11 @@ intended here. </p>
+
+ <hr>
+ <h3><a name="12"></a>12. Way objects hold allocators unclear</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1998-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1998-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>I couldn't find a statement in the standard saying whether the allocator object held by
+ a container is held as a copy of the constructor argument or whether a pointer of
+@@ -1227,11 +336,11 @@ clear.&nbsp; See 23.2 [container.requirements], paragraph 8.</p>
+
+ <hr>
+ <h3><a name="43"></a>43. Locale table correction</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Brendan Kehoe <b>Opened:</b> 1998-06-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#33">33</a></p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Brendan Kehoe <b>Opened:</b> 1998-06-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#33">33</a></p>
+ <p><b>Discussion:</b></p>
+
+
+@@ -1244,19 +353,20 @@ clear.&nbsp; See 23.2 [container.requirements], paragraph 8.</p>
+
+ <hr>
+ <h3><a name="45"></a>45. Stringstreams read/write pointers initial position unclear</h3>
+-<p><b>Section:</b> 27.8.3 [ostringstream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matthias Mueller <b>Opened:</b> 1998-05-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.8.4 [ostringstream] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matthias Mueller <b>Opened:</b> 1998-05-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostringstream">issues</a> in [ostringstream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In a comp.lang.c++.moderated Matthias Mueller wrote:</p>
+
+-<p>"We are not sure how to interpret the CD2 (see 27.3 [iostream.forward], 27.8.3.1 [ostringstream.cons], 27.8.1.1 [stringbuf.cons])
++<p>&quot;We are not sure how to interpret the CD2 (see 27.3 [iostream.forward], 27.8.4.1 [ostringstream.cons], 27.8.2.1 [stringbuf.cons])
+ with respect to the question as to what the correct initial positions
+ of the write and&nbsp; read pointers of a stringstream should
+-be."</p>
++be.&quot;</p>
+
+-<p>"Is it the same to output two strings or to initialize the stringstream with the
+-first and to output the second?"</p>
++<p>&quot;Is it the same to output two strings or to initialize the stringstream with the
++first and to output the second?&quot;</p>
+
+ <p><i>[PJ Plauger, Bjarne Stroustrup, Randy Smithey, Sean Corfield, and
+ Jerry Schwarz have all offered opinions; see reflector messages
+@@ -1277,10 +387,10 @@ behavior is known to be different from strstreams.</p>
+
+ <hr>
+ <h3><a name="58"></a>58. Extracting a char from a wide-oriented stream</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.6.1.2.3 has member functions for extraction of signed char and
+ unsigned char, both singly and as strings. However, it doesn't say
+@@ -1302,10 +412,10 @@ this is the intent of the LWG.</p>
+
+ <hr>
+ <h3><a name="65"></a>65. Underspecification of strstreambuf::seekoff</h3>
+-<p><b>Section:</b> D.9.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> D.7.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The standard says how this member function affects the current
+ stream position. (<tt>gptr</tt> or <tt>pptr</tt>) However, it does not
+@@ -1328,16 +438,16 @@ to invest effort in this deprecated feature.</p>
+
+ <hr>
+ <h3><a name="67"></a>67. Setw useless for strings</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-07-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#25">25</a></p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-07-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#25">25</a></p>
+ <p><b>Discussion:</b></p>
+ <p>In a comp.std.c++ posting Michel Michaud wrote: What
+ should be output by: </p>
+
+-<pre> string text("Hello");
++<pre> string text(&quot;Hello&quot;);
+ cout &lt;&lt; '[' &lt;&lt; setw(10) &lt;&lt; right &lt;&lt; text &lt;&lt; ']';
+ </pre>
+
+@@ -1367,15 +477,15 @@ parameters whatsoever.</p>
+
+ <hr>
+ <h3><a name="72"></a>72. Do_convert phantom member function</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#24">24</a></p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#24">24</a></p>
+ <p><b>Discussion:</b></p>
+ <p>In 22.4.1.4 [locale.codecvt] par 3, and in 22.4.1.4.2 [locale.codecvt.virtuals] par 8, a nonexistent member function
+-"do_convert" is mentioned. This member was replaced with
+-"do_in" and "do_out", the proper referents in the
++&quot;do_convert&quot; is mentioned. This member was replaced with
++&quot;do_in&quot; and &quot;do_out&quot;, the proper referents in the
+ contexts above.</p>
+
+
+@@ -1387,10 +497,10 @@ contexts above.</p>
+
+ <hr>
+ <h3><a name="73"></a>73. <tt>is_open</tt> should be const</h3>
+-<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fstreams">issues</a> in [fstreams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fstreams">issues</a> in [fstreams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Classes <tt>basic_ifstream</tt>, <tt>basic_ofstream</tt>, and
+ <tt>basic_fstream</tt> all have a member function <tt>is_open</tt>. It
+@@ -1407,36 +517,36 @@ meaningless.</p>
+
+ <hr>
+ <h3><a name="77"></a>77. Valarray operator[] const returning value</h3>
+-<p><b>Section:</b> 26.6.2.3 [valarray.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Levente Farkas <b>Opened:</b> 1998-09-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a></p>
+-<p><b>Discussion:</b></p>
+-<p>valarray:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; <tt>T operator[] (size_t) const;</tt><br>
+-<br>
+-why not <br>
+-<br>
+-&nbsp;&nbsp;&nbsp; <tt>const T&amp; operator[] (size_t) const;</tt><br>
+-<br>
+-as in vector ???<br>
+-<br>
+-One can't copy even from a const valarray eg:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; <tt>memcpy(ptr, &amp;v[0], v.size() * sizeof(double));<br>
+-</tt><br>
++<p><b>Section:</b> 26.6.2.4 [valarray.access] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Levente Farkas <b>Opened:</b> 1998-09-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#389">389</a></p>
++<p><b>Discussion:</b></p>
++<p>valarray:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; <tt>T operator[] (size_t) const;</tt><br/>
++<br/>
++why not <br/>
++<br/>
++&nbsp;&nbsp;&nbsp; <tt>const T&amp; operator[] (size_t) const;</tt><br/>
++<br/>
++as in vector ???<br/>
++<br/>
++One can't copy even from a const valarray eg:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; <tt>memcpy(ptr, &amp;v[0], v.size() * sizeof(double));<br/>
++</tt><br/>
+ [I] find this bug in valarray is very difficult.</p>
+
+
+ <p><b>Rationale:</b></p>
+ <p>The LWG believes that the interface was deliberately designed that
+ way. That is what valarray was designed to do; that's where the
+-"value array" name comes from. LWG members further comment
+-that "we don't want valarray to be a full STL container."
+-26.6.2.3 [valarray.access] specifies properties that indicate "an
+-absence of aliasing" for non-constant arrays; this allows
++&quot;value array&quot; name comes from. LWG members further comment
++that &quot;we don't want valarray to be a full STL container.&quot;
++26.6.2.4 [valarray.access] specifies properties that indicate &quot;an
++absence of aliasing&quot; for non-constant arrays; this allows
+ optimizations, including special hardware optimizations, that are not
+ otherwise possible. </p>
+
+@@ -1446,10 +556,10 @@ otherwise possible. </p>
+
+ <hr>
+ <h3><a name="81"></a>81. Wrong declaration of slice operations</h3>
+-<p><b>Section:</b> 26.6.5 [template.slice.array], 26.6.7 [template.gslice.array], 26.6.8 [template.mask.array], 26.6.9 [template.indirect.array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.slice.array">issues</a> in [template.slice.array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.6.5 [template.slice.array], 26.6.7 [template.gslice.array], 26.6.8 [template.mask.array], 26.6.9 [template.indirect.array] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.slice.array">issues</a> in [template.slice.array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Isn't the definition of copy constructor and assignment operators wrong?
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Instead of</p>
+@@ -1473,11 +583,11 @@ otherwise possible. </p>
+
+ <hr>
+ <h3><a name="82"></a>82. Missing constant for set elements</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 5 specifies:</p>
+
+@@ -1493,7 +603,7 @@ the value type is the same as the <b>constant</b> key type.</p>
+ <p><b>Rationale:</b></p>
+ <p>Not a defect. The Standard is correct as written; it uses a
+ different mechanism (const &amp;) for <tt>set</tt> and
+-<tt>multiset</tt>. See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> for a related
++<tt>multiset</tt>. See issue <a href="lwg-defects.html#103">103</a> for a related
+ issue.</p>
+
+
+@@ -1501,9 +611,10 @@ issue.</p>
+
+ <hr>
+ <h3><a name="84"></a>84. Ambiguity with string::insert()</h3>
+-<p><b>Section:</b> 21.4.5 [string.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21.4.5 [string.access] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.access">issues</a> in [string.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>If I try</p>
+ <pre> s.insert(0,1,' ');</pre>
+@@ -1518,14 +629,14 @@ issue.</p>
+ <pre> s.insert((char*)0, (InputIterator)1, (InputIterator)' ')</pre>
+
+ <p>which normally inserts characters from iterator 1 to iterator '
+-'. But according to 23.1.1.9 (the "do the right thing" fix)
++'. But according to 23.1.1.9 (the &quot;do the right thing&quot; fix)
+ it is equivalent to the second. However, it is still ambiguous,
+ because of course I mean the first!</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>Not a defect. The LWG believes this is a "genetic
+-misfortune" inherent in the design of string and thus not a
++<p>Not a defect. The LWG believes this is a &quot;genetic
++misfortune&quot; inherent in the design of string and thus not a
+ defect in the Standard as such .</p>
+
+
+@@ -1533,10 +644,10 @@ defect in the Standard as such .</p>
+
+ <hr>
+ <h3><a name="85"></a>85. String char types</h3>
+-<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#strings">issues</a> in [strings].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#strings">issues</a> in [strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The standard seems not to require that charT is equivalent to
+ traits::char_type. So, what happens if charT is not equivalent to
+@@ -1552,15 +663,16 @@ requires them to be the same.</p>
+
+ <hr>
+ <h3><a name="87"></a>87. Error in description of string::compare()</h3>
+-<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::swap">issues</a> in [string::swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#5">5</a></p>
++<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::swap">issues</a> in [string::swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#5">5</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The following compare() description is obviously a bug:</p>
+
+-<pre>int compare(size_type pos, size_type n1,
++<pre>
++int compare(size_type pos, size_type n1,
+ charT *s, size_type n2 = npos) const;
+ </pre>
+
+@@ -1577,10 +689,10 @@ exception) </p>
+
+ <hr>
+ <h3><a name="88"></a>88. Inconsistency between string::insert() and string::append()</h3>
+-<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.2 [string::append] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::insert">issues</a> in [string::insert].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.2 [string::append] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::insert">issues</a> in [string::insert].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Why does </p>
+ <pre> template&lt;class InputIterator&gt;
+@@ -1602,11 +714,11 @@ serious to constitute a defect.</p>
+
+ <hr>
+ <h3><a name="89"></a>89. Missing throw specification for string::insert() and string::replace()</h3>
+-<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.6 [string::replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::insert">issues</a> in [string::insert].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a></p>
++<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.6 [string::replace] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::insert">issues</a> in [string::insert].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#83">83</a></p>
+ <p><b>Discussion:</b></p>
+ <p>All insert() and replace() members for strings with an iterator as
+ first argument lack a throw specification. The throw
+@@ -1616,7 +728,7 @@ maximum. </p>
+
+ <p><b>Rationale:</b></p>
+ <p>Considered a duplicate because it will be solved by the resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>.</p>
++of issue <a href="lwg-defects.html#83">83</a>.</p>
+
+
+
+@@ -1624,10 +736,10 @@ of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8
+
+ <hr>
+ <h3><a name="93"></a>93. Incomplete Valarray Subset Definitions</h3>
+-<p><b>Section:</b> 26.6 [numarray] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numarray">issues</a> in [numarray].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.6 [numarray] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numarray">issues</a> in [numarray].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>You can easily create subsets, but you can't easily combine them
+ with other subsets. Unfortunately, you almost always needs an
+@@ -1661,9 +773,10 @@ creates a temporary objects, which could be avoided without the cast. </p>
+
+ <hr>
+ <h3><a name="94"></a>94. May library implementors add template parameters to Standard Library classes?</h3>
+-<p><b>Section:</b> 17.6.4 [conforming] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.5 [conforming] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#conforming">issues</a> in [conforming].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Is it a permitted extension for library implementors to add template parameters to
+ standard library classes, provided that those extra parameters have defaults? For example,
+@@ -1706,7 +819,7 @@ may be provided by a non-Standard implementation class:</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add a new subclause [presumably 17.4.4.9] following 17.6.4.12 [res.on.exception.handling]:</p>
++<p>Add a new subclause [presumably 17.4.4.9] following 17.6.5.12 [res.on.exception.handling]:</p>
+
+ <blockquote>
+ <p>17.4.4.9 Template Parameters</p> <p>A specialization of a
+@@ -1716,14 +829,14 @@ may be provided by a non-Standard implementation class:</p>
+ default values are thus permitted.</p>
+ </blockquote>
+
+-<p>Add "template parameters" to the list of subclauses at
+-the end of 17.6.4 [conforming] paragraph 1.</p>
++<p>Add &quot;template parameters&quot; to the list of subclauses at
++the end of 17.6.5 [conforming] paragraph 1.</p>
+
+ <p><i>[Kona: The LWG agreed the standard needs clarification. After
+ discussion with John Spicer, it seems added template parameters can be
+ detected by a program using template-template parameters. A straw vote
+-- "should implementors be allowed to add template
+-parameters?" found no consensus ; 5 - yes, 7 - no.]</i></p>
++- &quot;should implementors be allowed to add template
++parameters?&quot; found no consensus ; 5 - yes, 7 - no.]</i></p>
+
+
+
+@@ -1732,7 +845,7 @@ parameters?" found no consensus ; 5 - yes, 7 - no.]</i></p>
+ <p>
+ There is no ambiguity; the standard is clear as written. Library
+ implementors are not permitted to add template parameters to standard
+-library classes. This does not fall under the "as if" rule,
++library classes. This does not fall under the &quot;as if&quot; rule,
+ so it would be permitted only if the standard gave explicit license
+ for implementors to do this. This would require a change in the
+ standard.
+@@ -1750,9 +863,10 @@ of standard library class templates.
+
+ <hr>
+ <h3><a name="95"></a>95. Members added by the implementation</h3>
+-<p><b>Section:</b> 17.6.4.5 [member.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.5.5 [member.functions] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#member.functions">issues</a> in [member.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 17.3.4.4/2 vs 17.3.4.7/0 there is a hole; an implementation could add virtual
+ members a base class and break user derived classes.</p>
+@@ -1782,17 +896,17 @@ class vector_checking : public vector
+
+ <p><b>Rationale:</b></p>
+ <p>This is not a defect in the Standard.&nbsp; The example is already
+-illegal.&nbsp; See 17.6.4.5 [member.functions] paragraph 2.</p>
++illegal.&nbsp; See 17.6.5.5 [member.functions] paragraph 2.</p>
+
+
+
+
+ <hr>
+ <h3><a name="96"></a>96. Vector&lt;bool&gt; is not a container</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><tt>vector&lt;bool&gt;</tt> is not a container as its reference and
+ pointer types are not references and pointers. </p>
+@@ -1812,18 +926,18 @@ or not the optimization requirements constituted a defect.]</i></p>
+
+
+ <p><i>[The LWG looked at the following resolutions in some detail:
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; * Not A Defect.<br>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; * Not A Defect.<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp; * Add a note explaining that vector&lt;bool&gt; does not meet
+-Container requirements.<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; * Remove vector&lt;bool&gt;.<br>
++Container requirements.<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; * Remove vector&lt;bool&gt;.<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp; * Add a new category of container requirements which
+-vector&lt;bool&gt; would meet.<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; * Rename vector&lt;bool&gt;.<br>
+-<br>
++vector&lt;bool&gt; would meet.<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; * Rename vector&lt;bool&gt;.<br/>
++<br/>
+ No alternative had strong, wide-spread, support and every alternative
+-had at least one "over my dead body" response.<br>
+-<br>
++had at least one &quot;over my dead body&quot; response.<br/>
++<br/>
+ There was also mention of a transition scheme something like (1) add
+ vector_bool and deprecate vector&lt;bool&gt; in the next standard. (2)
+ Remove vector&lt;bool&gt; in the following standard.]</i></p>
+@@ -1840,7 +954,7 @@ allocator.]</i></p>
+
+
+ <p><i>[Kona: Herb Sutter presented his paper J16/99-0035==WG21/N1211,
+-vector&lt;bool&gt;: More Problems, Better Solutions. Much discussion
++<tt>vector&lt;bool&gt;</tt>: More Problems, Better Solutions. Much discussion
+ of a two step approach: a) deprecate, b) provide replacement under a
+ new name. LWG straw vote on that: 1-favor, 11-could live with, 2-over
+ my dead body. This resolution was mentioned in the LWG report to the
+@@ -1849,28 +963,28 @@ over-my-dead-body positions.]</i></p>
+
+
+ <p>Discussed at Lillehammer. General agreement that we should
+- deprecate vector&lt;bool&gt; and introduce this functionality under
+- a different name, e.g. bit_vector. This might make it possible to
+- remove the vector&lt;bool&gt; specialization in the standard that comes
++ deprecate <tt>vector&lt;bool&gt;</tt> and introduce this functionality under
++ a different name, e.g. <tt>bit_vector</tt>. This might make it possible to
++ remove the <tt>vector&lt;bool&gt;</tt> specialization in the standard that comes
+ after C++0x. There was also a suggestion that
+ in C++0x we could additional say that it's implementation defined
+- whether vector&lt;bool&gt; refers to the specialization or to the
++ whether <tt>vector&lt;bool&gt;</tt> refers to the specialization or to the
+ primary template, but there wasn't general agreement that this was a
+ good idea.</p>
+
+-<p>We need a paper for the new bit_vector class.</p>
++<p>We need a paper for the new <tt>bit_vector</tt> class.</p>
+
+ <p><i>[
+ Batavia:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The LWG feels we need something closer to SGI's <tt>bitvector</tt> to ease migration
+ from <tt>vector&lt;bool&gt;</tt>. Although some of the funcitonality from
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2050.pdf">N2050</a>
+ could well be used in such a template. The concern is easing the API migration for those
+ users who want to continue using a bit-packed container. Alan and Beman to work.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair adds:
+@@ -1910,11 +1024,11 @@ This is a clear extension request that may be handled via a future TR.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We note that most of this issue has become moot over time,
+ and agree with Alisdair's recommendations.
+ Move to NAD Future for reconsideration of part (ii).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-29 Alisdair reopens:
+@@ -1932,7 +1046,7 @@ to allow us to close this issue as NAD.
+ </p>
+
+ <p>
+-I recommend we spawn a separate issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>) requesting a dynamic length bitset
++I recommend we spawn a separate issue (<a href="lwg-active.html#1184">1184</a>) requesting a dynamic length bitset
+ and pre-emptively file it as NAD Future. It is difficult to resolve #96
+ when it effectively contains two separate sub-issues.
+ </p>
+@@ -1943,9 +1057,9 @@ when it effectively contains two separate sub-issues.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark as NAD, and give rationale.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -1979,10 +1093,11 @@ tractable. Therefore we are closing.
+
+ <hr>
+ <h3><a name="97"></a>97. Insert inconsistent definition</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><tt>insert(iterator, const value_type&amp;)</tt> is defined both on
+ sequences and on set, with unrelated semantics: insert here (in
+@@ -1999,9 +1114,9 @@ the design, for better or for worse.</p>
+
+ <hr>
+ <h3><a name="99"></a>99. Reverse_iterator comparisons completely wrong</h3>
+-<p><b>Section:</b> 24.5.1.3.13 [reverse.iter.op==] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.5.1.3.13 [reverse.iter.op==] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The &lt;, &gt;, &lt;=, &gt;= comparison operator are wrong: they
+ return the opposite of what they should.</p>
+@@ -2021,10 +1136,10 @@ exactly what the Standard says.</p>
+
+ <hr>
+ <h3><a name="100"></a>100. Insert iterators/ostream_iterators overconstrained</h3>
+-<p><b>Section:</b> 24.5.2 [insert.iterators], 24.6.4 [ostreambuf.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.5.2 [insert.iterators], 24.6.4 [ostreambuf.iterator] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Overspecified For an insert iterator it, the expression *it is
+ required to return a reference to it. This is a simple possible
+@@ -2043,10 +1158,10 @@ incorrect code to work, rather than the other way around.</p>
+
+ <hr>
+ <h3><a name="101"></a>101. No way to free storage for vector and deque</h3>
+-<p><b>Section:</b> 23.4.1 [vector], 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector], 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Reserve can not free storage, unlike string::reserve</p>
+
+@@ -2057,7 +1172,7 @@ incorrect code to work, rather than the other way around.</p>
+
+ <blockquote>
+ <p>
+-This issue has been revisited and addressed (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>). This issues should be reclassified to NAD Editorial to reflect
++This issue has been revisited and addressed (<a href="lwg-defects.html#755">755</a>, <a href="lwg-defects.html#850">850</a>). This issues should be reclassified to NAD Editorial to reflect
+ this action.
+ </p>
+ </blockquote>
+@@ -2082,12 +1197,12 @@ expressed in a single line of code (where <tt>v</tt> is
+
+ <hr>
+ <h3><a name="102"></a>102. Bug in insert range in associative containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#264">264</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Table 69 of Containers say that a.insert(i,j) is linear if [i, j) is ordered. It seems
+ impossible to implement, as it means that if [i, j) = [x], insert in an associative
+@@ -2099,7 +1214,7 @@ container is O(1)!</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>Subsumed by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>.</p>
++<p>Subsumed by issue <a href="lwg-defects.html#264">264</a>.</p>
+
+
+
+@@ -2107,10 +1222,10 @@ container is O(1)!</p>
+
+ <hr>
+ <h3><a name="104"></a>104. Description of basic_string::operator[] is unclear</h3>
+-<p><b>Section:</b> 21.4.4 [string.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.capacity">issues</a> in [string.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21.4.4 [string.capacity] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.capacity">issues</a> in [string.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It is not clear that undefined behavior applies when pos == size ()
+ for the non const version.</p>
+@@ -2130,14 +1245,14 @@ the Standard.</p>
+
+ <hr>
+ <h3><a name="105"></a>105. fstream ctors argument types desired</h3>
+-<p><b>Section:</b> 27.9 [file.streams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a></p>
++<p><b>Section:</b> 27.9 [file.streams] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#454">454</a></p>
+ <p><b>Discussion:</b></p>
+
+
+-<p>fstream ctors take a const char* instead of string.<br>
++<p>fstream ctors take a const char* instead of string.<br/>
+ fstream ctors can't take wchar_t</p>
+
+ <p>An extension to add a const wchar_t* to fstream would make the
+@@ -2153,10 +1268,10 @@ interesting extension for the next Standard. </p>
+
+ <hr>
+ <h3><a name="107"></a>107. Valarray constructor is strange</h3>
+-<p><b>Section:</b> 26.6.2 [template.valarray] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.valarray">issues</a> in [template.valarray].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.6.2 [template.valarray] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.valarray">issues</a> in [template.valarray].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The order of the arguments is (elem, size) instead of the normal
+ (size, elem) in the rest of the library. Since elem often has an
+@@ -2182,22 +1297,22 @@ perhaps other cases.</p>
+
+
+ <hr>
+-<h3><a name="111"></a>111. istreambuf_iterator::equal overspecified, inefficient</h3>
+-<p><b>Section:</b> 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istreambuf.iterator::equal">issues</a> in [istreambuf.iterator::equal].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="111"></a>111. <tt>istreambuf_iterator::equal</tt> overspecified, inefficient</h3>
++<p><b>Section:</b> 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istreambuf.iterator::equal">issues</a> in [istreambuf.iterator::equal].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The member istreambuf_iterator&lt;&gt;::equal is specified to be
++<p>The member <tt>istreambuf_iterator&lt;&gt;::equal</tt> is specified to be
+ unnecessarily inefficient. While this does not affect the efficiency
+ of conforming implementations of iostreams, because they can
+-"reach into" the iterators and bypass this function, it does
+-affect users who use istreambuf_iterators. </p>
++&quot;reach into&quot; the iterators and bypass this function, it does
++affect users who use <tt>istreambuf_iterators</tt>. </p>
+
+ <p>The inefficiency results from a too-scrupulous definition, which
+-requires a "true" result if neither iterator is at eof. In
++requires a &quot;true&quot; result if neither iterator is at eof. In
+ practice these iterators can only usefully be compared with the
+-"eof" value, so the extra test implied provides no benefit,
++&quot;eof&quot; value, so the extra test implied provides no benefit,
+ but slows down users' code. </p>
+
+ <p>The solution is to weaken the requirement on the function to return
+@@ -2208,9 +1323,9 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Reopened by Alisdair.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Daniel adds:
+@@ -2225,48 +1340,46 @@ and more specifically it would violate the explicit wording of
+ 24.2.3 [input.iterators]/7:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If two iterators <tt>a</tt> and <tt>b</tt> of the same type are equal, then either <tt>a</tt>
+-and <tt>b</tt> are both
+-dereferenceable or else neither is dereferenceable.
+-</blockquote>
++and <tt>b</tt> are both dereferenceable or else neither is dereferenceable.
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree NAD.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace 24.6.3.5 [istreambuf.iterator::equal],
+-paragraph 1, </p>
++<p>Replace 24.6.3.5 [istreambuf.iterator::equal], paragraph 1, </p>
+
+ <blockquote>
+- <p>-1- Returns: true if and only if both iterators are at end-of-stream, or neither is at
++ <p>-1- <i>Returns</i>: true if and only if both iterators are at end-of-stream, or neither is at
+ end-of-stream, regardless of what streambuf object they use. </p>
+ </blockquote>
+
+ <p>with</p>
+
+ <blockquote>
+- <p>-1- Returns: true if and only if both iterators are at
++ <p>-1- <i>Returns</i>: true if and only if both iterators are at
+ end-of-stream, regardless of what streambuf object they use. </p>
+ </blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+-<p>It is not clear that this is a genuine defect. Additionally, the
++<p>It is not clear that this is a genuine defect. Additionally, the
+ LWG was reluctant to make a change that would result in
+-operator== not being a equivalence relation. One consequence of
+-this change is that an algorithm that's passed the range [i, i)
++<tt>operator==</tt> not being a equivalence relation. One consequence of
++this change is that an algorithm that's passed the range <tt>[i, i)</tt>
+ would no longer treat it as an empty range.</p>
+
+
+@@ -2275,10 +1388,10 @@ would no longer treat it as an empty range.</p>
+
+ <hr>
+ <h3><a name="113"></a>113. Missing/extra iostream sync semantics</h3>
+-<p><b>Section:</b> 27.7.1.1 [istream], 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-10-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream">issues</a> in [istream].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.1 [istream], 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream">issues</a> in [istream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 27.6.1.1, class basic_istream has a member function sync, described in 27.6.1.3,
+ paragraph 36. </p>
+@@ -2314,11 +1427,12 @@ desired functionality.</p>
+
+ <hr>
+ <h3><a name="116"></a>116. bitset cannot be constructed with a const char*</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-11-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a></p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-11-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#778">778</a></p>
+ <p><b>Discussion:</b></p>
+
+
+@@ -2328,13 +1442,13 @@ desired functionality.</p>
+ <blockquote>
+ <pre>#include &lt;bitset&gt;
+ using namespace std;
+-bitset&lt;32&gt; b("111111111");</pre>
++bitset&lt;32&gt; b(&quot;111111111&quot;);</pre>
+ </blockquote>
+
+ <p>If you cast the ctor argument to a string, i.e.:</p>
+
+ <blockquote>
+- <pre>bitset&lt;32&gt; b(string("111111111"));</pre>
++ <pre>bitset&lt;32&gt; b(string(&quot;111111111&quot;));</pre>
+ </blockquote>
+
+ <p>then it will compile. The reason is that bitset has the following templatized
+@@ -2348,9 +1462,9 @@ explicit bitset (const basic_string&lt;charT, traits, Allocator&gt;&amp; str, ..
+ <p>According to the compiler vendor, Steve Adamcyk at EDG, the user
+ cannot pass this template constructor a <tt>const char*</tt> and
+ expect a conversion to <tt>basic_string</tt>. The reason is
+-"When you have a template constructor, it can get used in
++&quot;When you have a template constructor, it can get used in
+ contexts where type deduction can be done. Type deduction basically
+-comes up with exact matches, not ones involving conversions."
++comes up with exact matches, not ones involving conversions.&quot;
+ </p>
+
+ <p>I don't think the intention when this constructor became
+@@ -2359,17 +1473,17 @@ longer work.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add to 20.5 [template.bitset] a bitset constructor declaration</p>
++<p>Add to 20.6 [template.bitset] a bitset constructor declaration</p>
+
+ <blockquote>
+ <pre>explicit bitset(const char*);</pre>
+ </blockquote>
+
+-<p>and in Section 20.5.1 [bitset.cons] add:</p>
++<p>and in Section 20.6.1 [bitset.cons] add:</p>
+
+ <blockquote>
+ <pre>explicit bitset(const char* str);</pre>
+- <p>Effects: <br>
++ <p>Effects: <br/>
+ &nbsp;&nbsp;&nbsp; Calls <tt>bitset((string) str, 0, string::npos);</tt></p>
+ </blockquote>
+
+@@ -2386,10 +1500,10 @@ extension.</p>
+
+ <hr>
+ <h3><a name="121"></a>121. Detailed definition for ctype&lt;wchar_t&gt; specialization</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 22.1.1.1.1 has the following listed in Table 51: ctype&lt;char&gt; ,
+ ctype&lt;wchar_t&gt;. </p>
+@@ -2421,10 +1535,10 @@ ctype&lt;wchar_t&gt; specialization. </p>
+
+ <hr>
+ <h3><a name="128"></a>128. Need open_mode() function for file stream, string streams, file buffers, and string&nbsp; buffers</h3>
+-<p><b>Section:</b> 27.8 [string.streams], 27.9 [file.streams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-02-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.streams">issues</a> in [string.streams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.8 [string.streams], 27.9 [file.streams] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-02-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.streams">issues</a> in [string.streams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The following question came from Thorsten Herlemann:</p>
+
+@@ -2471,7 +1585,7 @@ Moved to NAD.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>For stream buffers, add a function to the base class as a non-virtual function
+-qualified as const to 27.6.2 [streambuf]:</p>
++qualified as const to 27.6.3 [streambuf]:</p>
+
+ <p>&nbsp;&nbsp;&nbsp;&nbsp;<tt>openmode mode() const</tt>;</p>
+
+@@ -2496,10 +1610,10 @@ retained for future reference.</p>
+
+ <hr>
+ <h3><a name="131"></a>131. list::splice throws nothing</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>What happens if a splice operation causes the size() of a list to grow
+ beyond max_size()?</p>
+@@ -2514,9 +1628,9 @@ beyond max_size()?</p>
+
+ <hr>
+ <h3><a name="135"></a>135. basic_iostream doubly initialized</h3>
+-<p><b>Section:</b> 27.7.1.5.1 [iostream.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.5.1 [iostream.cons] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>-1- Effects Constructs an object of class basic_iostream, assigning
+ initial values to the base classes by calling
+@@ -2545,14 +1659,14 @@ standard.</p>
+
+
+ <hr>
+-<h3><a name="138"></a>138. Class ctype_byname&lt;char&gt; redundant and misleading</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-03-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="138"></a>138. Class <tt>ctype_byname&lt;char&gt;</tt> redundant and misleading</h3>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-03-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 22.4.1.4 [locale.codecvt] specifies that
+-ctype_byname&lt;char&gt; must be a specialization of the ctype_byname
++<tt>ctype_byname&lt;char&gt;</tt> must be a specialization of the <tt>ctype_byname</tt>
+ template.</p>
+
+ <p>It is common practice in the standard that specializations of class templates are only
+@@ -2562,14 +1676,14 @@ instantiation is an actual instantiation or a specialization is left open as an
+ implementation detail. </p>
+
+ <p>Clause 22.2.1.4 deviates from that practice and for that reason is misleading. The
+-fact, that ctype_byname&lt;char&gt; is specified as a specialization suggests that there
+-must be something "special" about it, but it has the exact same interface as the
+-ctype_byname template. Clause 22.2.1.4 does not have any explanatory value, is at best
++fact, that <tt>ctype_byname&lt;char&gt;</tt> is specified as a specialization suggests that there
++must be something &quot;special&quot; about it, but it has the exact same interface as the
++<tt>ctype_byname</tt> template. Clause 22.2.1.4 does not have any explanatory value, is at best
+ redundant, at worst misleading - unless I am missing anything. </p>
+
+-<p>Naturally, an implementation will most likely implement ctype_byname&lt;char&gt; as a
+-specialization, because the base class ctype&lt;char&gt; is a specialization with an
+-interface different from the ctype template, but that's an implementation detail and need
++<p>Naturally, an implementation will most likely implement <tt>ctype_byname&lt;char&gt;</tt> as a
++specialization, because the base class <tt>ctype&lt;char&gt;</tt> is a specialization with an
++interface different from the <tt>ctype</tt> template, but that's an implementation detail and need
+ not be mentioned in the standard. </p>
+
+ <p><i>[
+@@ -2577,51 +1691,51 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Reopened by Alisdair.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+ <p> The standard as written is mildly misleading, but the correct fix
+-is to deal with the underlying problem in the ctype_byname base class,
+-not in the specialization. See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a>.</p>
++is to deal with the underlying problem in the <tt>ctype_byname</tt> base class,
++not in the specialization. See issue <a href="lwg-defects.html#228">228</a>.</p>
+
+
+
+
+ <hr>
+ <h3><a name="140"></a>140. map&lt;Key, T&gt;::value_type does not satisfy the assignable requirement</h3>
+-<p><b>Section:</b> 23.6.1 [map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Mark Mitchell <b>Opened:</b> 1999-04-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map">issues</a> in [map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Mark Mitchell <b>Opened:</b> 1999-04-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map">issues</a> in [map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <blockquote>
+- <p>23.2 [container.requirements]<br>
+- <br>
++ <p>23.2 [container.requirements]<br/>
++ <br/>
+ expression&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return type
+- &nbsp;&nbsp;&nbsp;&nbsp; pre/post-condition<br>
++ &nbsp;&nbsp;&nbsp;&nbsp; pre/post-condition<br/>
+ -------------&nbsp;&nbsp;&nbsp;&nbsp; ----------- &nbsp;&nbsp;&nbsp;&nbsp;
+- -------------------<br>
++ -------------------<br/>
+ X::value_type&nbsp;&nbsp;&nbsp; T
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+- T is assignable<br>
+- <br>
+- 23.6.1 [map]<br>
+- <br>
+- A map satisfies all the requirements of a container.<br>
+- <br>
++ T is assignable<br/>
++ <br/>
++ 23.4.4 [map]<br/>
++ <br/>
++ A map satisfies all the requirements of a container.<br/>
++ <br/>
+ For a map&lt;Key, T&gt; ... the value_type is pair&lt;const Key, T&gt;.</p>
+ </blockquote>
+
+@@ -2630,7 +1744,7 @@ T&gt;' is not assignable; the `const Key' cannot be assigned
+ to. So,&nbsp; map&lt;Key, T&gt;::value_type does not satisfy the
+ assignable requirement imposed by a container.</p>
+
+-<p><i>[See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> for the slightly related issue of
++<p><i>[See issue <a href="lwg-defects.html#103">103</a> for the slightly related issue of
+ modification of set keys.]</i></p>
+
+
+@@ -2645,9 +1759,9 @@ reconsider for the next standard.</p>
+
+ <hr>
+ <h3><a name="143"></a>143. C .h header wording unclear</h3>
+-<p><b>Section:</b> D.7 [depr.c.headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Christophe de Dinechin <b>Opened:</b> 1999-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> D.5 [depr.c.headers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Christophe de Dinechin <b>Opened:</b> 1999-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>[depr.c.headers] paragraph 2 reads:</p>
+
+@@ -2731,7 +1845,7 @@ int main() {
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Replace D.7 [depr.c.headers] paragraph 2 with:</p>
++<p>Replace D.5 [depr.c.headers] paragraph 2 with:</p>
+
+ <blockquote>
+
+@@ -2757,22 +1871,22 @@ write code that depends on Koenig lookup of C library functions.</p>
+
+ <hr>
+ <h3><a name="145"></a>145. adjustfield lacks default value</h3>
+-<p><b>Section:</b> 27.5.4.1 [basic.ios.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-05-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.5.2 [basic.ios.cons] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-05-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There is no initial value for the adjustfield defined, although
+ many people believe that the default adjustment were right. This is a
+ common misunderstanding. The standard only defines that, if no
+ adjustment is specified, all the predefined inserters must add fill
+-characters before the actual value, which is "as if" the
++characters before the actual value, which is &quot;as if&quot; the
+ right flag were set. The flag itself need not be set.</p>
+
+ <p>When you implement a user-defined inserter you cannot rely on right
+ being the default setting for the adjustfield. Instead, you must be
+ prepared to find none of the flags set and must keep in mind that in
+-this case you should make your inserter behave "as if" the
++this case you should make your inserter behave &quot;as if&quot; the
+ right flag were set. This is surprising to many people and complicates
+ matters more than necessary.</p>
+
+@@ -2791,15 +1905,15 @@ set. Consider Arabic or Hebrew, for example. See 22.4.2.2.2 [facet.num.put.virtu
+
+ <hr>
+ <h3><a name="157"></a>157. Meaningless error handling for <tt>pword()</tt> and <tt>iword()</tt></h3>
+-<p><b>Section:</b> 27.5.2.5 [ios.base.storage] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base.storage">issues</a> in [ios.base.storage].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#41">41</a></p>
+-<p><b>Discussion:</b></p>
+-<p>According to paragraphs 2 and 4 of 27.5.2.5 [ios.base.storage], the
+-functions <tt>iword()</tt> and <tt>pword()</tt> "set the
+-<tt>badbit</tt> (which might throw an exception)" on
++<p><b>Section:</b> 27.5.3.5 [ios.base.storage] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base.storage">issues</a> in [ios.base.storage].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#41">41</a></p>
++<p><b>Discussion:</b></p>
++<p>According to paragraphs 2 and 4 of 27.5.3.5 [ios.base.storage], the
++functions <tt>iword()</tt> and <tt>pword()</tt> &quot;set the
++<tt>badbit</tt> (which might throw an exception)&quot; on
+ failure. ... but what does it mean for <tt>ios_base</tt> to set the
+ <tt>badbit</tt>? The state facilities of the IOStream library are
+ defined in <tt>basic_ios</tt>, a derived class! It would be possible
+@@ -2814,24 +1928,24 @@ character type used...</p>
+
+
+ <hr>
+-<h3><a name="162"></a>162. Really "formatted input functions"?</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a></p>
++<h3><a name="162"></a>162. Really &quot;formatted input functions&quot;?</h3>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#60">60</a></p>
+ <p><b>Discussion:</b></p>
+ <p>It appears to be somewhat nonsensical to consider the functions
+-defined in the paragraphs 1 to 5 to be "Formatted input
+-function" but since these functions are defined in a section
+-labeled "Formatted input functions" it is unclear to me
++defined in the paragraphs 1 to 5 to be &quot;Formatted input
++function&quot; but since these functions are defined in a section
++labeled &quot;Formatted input functions&quot; it is unclear to me
+ whether these operators are considered formatted input functions which
+-have to conform to the "common requirements" from 27.7.1.2.1 [istream.formatted.reqmts]: If this is the case, all manipulators, not just
++have to conform to the &quot;common requirements&quot; from 27.7.2.2.1 [istream.formatted.reqmts]: If this is the case, all manipulators, not just
+ <tt>ws</tt>, would skip whitespace unless <tt>noskipws</tt> is set
+ (... but setting <tt>noskipws</tt> using the manipulator syntax would
+ also skip whitespace :-)</p>
+
+-<p>See also issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#166">166</a> for the same problem in formatted
++<p>See also issue <a href="lwg-closed.html#166">166</a> for the same problem in formatted
+ output</p>
+
+
+@@ -2843,26 +1957,27 @@ output</p>
+
+ <hr>
+ <h3><a name="163"></a>163. Return of <tt>gcount()</tt> after a call to <tt>gcount</tt></h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a></p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#60">60</a></p>
+ <p><b>Discussion:</b></p>
+ <p>It is not clear which functions are to be considered unformatted
+-input functions. As written, it seems that all functions in 27.7.1.3 [istream.unformatted] are unformatted input functions. However, it does not
++input functions. As written, it seems that all functions in 27.7.2.3 [istream.unformatted] are unformatted input functions. However, it does not
+ really make much sense to construct a sentry object for
+ <tt>gcount()</tt>, <tt>sync()</tt>, ... Also it is unclear what
+ happens to the <tt>gcount()</tt> if eg. <tt>gcount()</tt>,
+ <tt>putback()</tt>, <tt>unget()</tt>, or <tt>sync()</tt> is called:
+ These functions don't extract characters, some of them even
+-"unextract" a character. Should this still be reflected in
++&quot;unextract&quot; a character. Should this still be reflected in
+ <tt>gcount()</tt>? Of course, it could be read as if after a call to
+ <tt>gcount()</tt> <tt>gcount()</tt> return <tt>0</tt> (the last
+ unformatted input function, <tt>gcount()</tt>, didn't extract any
+ character) and after a call to <tt>putback()</tt> <tt>gcount()</tt>
+ returns <tt>-1</tt> (the last unformatted input function
+-<tt>putback()</tt> did "extract" back into the
++<tt>putback()</tt> did &quot;extract&quot; back into the
+ stream). Correspondingly for <tt>unget()</tt>. Is this what is
+ intended? If so, this should be clarified. Otherwise, a corresponding
+ clarification should be used.</p>
+@@ -2875,17 +1990,17 @@ clarification should be used.</p>
+
+
+ <hr>
+-<h3><a name="166"></a>166. Really "formatted output functions"?</h3>
+-<p><b>Section:</b> 27.7.2.6.3 [ostream.inserters] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a></p>
++<h3><a name="166"></a>166. Really &quot;formatted output functions&quot;?</h3>
++<p><b>Section:</b> 27.7.3.6.3 [ostream.inserters] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#60">60</a></p>
+ <p><b>Discussion:</b></p>
+-<p>From 27.7.2.6.1 [ostream.formatted.reqmts] it appears that all the functions
+-defined in 27.7.2.6.3 [ostream.inserters] have to construct a
++<p>From 27.7.3.6.1 [ostream.formatted.reqmts] it appears that all the functions
++defined in 27.7.3.6.3 [ostream.inserters] have to construct a
+ <tt>sentry</tt> object. Is this really intended?</p>
+
+-<p>This is basically the same problem as issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#162">162</a> but
++<p>This is basically the same problem as issue <a href="lwg-closed.html#162">162</a> but
+ for output instead of input.</p>
+
+
+@@ -2897,10 +2012,10 @@ for output instead of input.</p>
+
+ <hr>
+ <h3><a name="177"></a>177. Complex operators cannot be explicitly instantiated</h3>
+-<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1999-07-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1999-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>A user who tries to explicitly instantiate a complex non-member operator will
+ get compilation errors. Below is a simplified example of the reason why. The
+@@ -2940,8 +2055,8 @@ template std::complex&lt;float&gt; std::operator+&lt;float&gt;(const float&amp;,
+ <p>Implementors can make minor changes and the example will
+ work. Users are not affected in any case.</p> <p>According to John
+ Spicer, It is possible to explicitly instantiate these operators using
+-different syntax: change "std::operator+&lt;float&gt;" to
+-"std::operator+".</p>
++different syntax: change &quot;std::operator+&lt;float&gt;&quot; to
++&quot;std::operator+&quot;.</p>
+
+ <p>The proposed resolution of issue 120 is that users will not be able
+ to explicitly instantiate standard library templates. If that
+@@ -2954,13 +2069,13 @@ syntax.</p>
+
+ <hr>
+ <h3><a name="178"></a>178. Should clog and cerr initially be tied to cout?</h3>
+-<p><b>Section:</b> 27.4.1 [narrow.stream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1999-07-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#narrow.stream.objects">issues</a> in [narrow.stream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.4.2 [narrow.stream.objects] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1999-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#narrow.stream.objects">issues</a> in [narrow.stream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Section 27.3.1 says "After the object cerr is initialized,
++Section 27.3.1 says &quot;After the object cerr is initialized,
+ cerr.flags() &amp; unitbuf is nonzero. Its state is otherwise the same as
+ required for ios_base::init (lib.basic.ios.cons). It doesn't say
+ anything about the the state of clog. So this means that calling
+@@ -2976,9 +2091,9 @@ to &amp;cout. I would think that would be what users expect.
+
+ <p><b>Rationale:</b></p>
+ <p>The standard is clear as written.</p>
+-<p>27.3.1/5 says that "After the object cerr is initialized, cerr.flags()
++<p>27.3.1/5 says that &quot;After the object cerr is initialized, cerr.flags()
+ &amp; unitbuf is nonzero. Its state is otherwise the same as required for
+-ios_base::init (27.4.4.1)." Table 89 in 27.4.4.1, which gives the
++ios_base::init (27.4.4.1).&quot; Table 89 in 27.4.4.1, which gives the
+ postconditions of basic_ios::init(), says that tie() is 0. (Other issues correct
+ ios_base::init to basic_ios::init().)</p>
+
+@@ -2987,10 +2102,10 @@ ios_base::init to basic_ios::init().)</p>
+
+ <hr>
+ <h3><a name="188"></a>188. valarray helpers missing augmented assignment operators</h3>
+-<p><b>Section:</b> 26.6.2.6 [valarray.cassign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 1999-08-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cassign">issues</a> in [valarray.cassign].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.6.2.7 [valarray.cassign] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 1999-08-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cassign">issues</a> in [valarray.cassign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>26.5.2.6 defines augmented assignment operators
+ valarray&lt;T&gt;::op=(const T&amp;), but fails to provide
+@@ -3025,16 +2140,16 @@ operators.</p>
+
+ <hr>
+ <h3><a name="190"></a>190. min() and max() functions should be std::binary_functions</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Mark Rintoul <b>Opened:</b> 1999-08-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Mark Rintoul <b>Opened:</b> 1999-08-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Both std::min and std::max are defined as template functions. This
+ is very different than the definition of std::plus (and similar
+ structs) which are defined as function objects which inherit
+-std::binary_function.<br>
+-<br>
++std::binary_function.<br/>
++<br/>
+ This lack of inheritance leaves std::min and std::max somewhat useless in standard library algorithms which require
+ a function object that inherits std::binary_function.</p>
+
+@@ -3069,10 +2184,10 @@ function objects.</p>
+
+ <hr>
+ <h3><a name="191"></a>191. Unclear complexity for algorithms such as binary search</h3>
+-<p><b>Section:</b> 25.4.3 [alg.binary.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1999-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.binary.search">issues</a> in [alg.binary.search].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.4.3 [alg.binary.search] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1999-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.binary.search">issues</a> in [alg.binary.search].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The complexity of binary_search() is stated as "At most
+ log(last-first) + 2 comparisons", which seems to say that the
+@@ -3080,8 +2195,8 @@ algorithm has logarithmic complexity. However, this algorithms is
+ defined for forward iterators. And for forward iterators, the need to
+ step element-by-element results into linear complexity. But such a
+ statement is missing in the standard. The same applies to
+-lower_bound(), upper_bound(), and equal_range().&nbsp;<br>
+-<br>
++lower_bound(), upper_bound(), and equal_range().&nbsp;<br/>
++<br/>
+ However, strictly speaking the standard contains no bug here. So this
+ might considered to be a clarification or improvement.
+ </p>
+@@ -3098,17 +2213,17 @@ iterators.</p>
+
+ <hr>
+ <h3><a name="192"></a>192. a.insert(p,t) is inefficient and overconstrained</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Ed Brey <b>Opened:</b> 1999-06-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Ed Brey <b>Opened:</b> 1999-06-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#233">233</a></p>
+ <p><b>Discussion:</b></p>
+ <p>As defined in 23.1.2, paragraph 7 (table 69), a.insert(p,t) suffers from
+ several problems:</p>
+ <table border="1" cellpadding="5">
+- <tbody><tr>
++ <tr>
+ <td><b>expression</b></td>
+ <td><b>return type</b></td>
+ <td><b>pre/post-condition</b></td>
+@@ -3123,7 +2238,7 @@ several problems:</p>
+ the key of t . iterator p is a hint pointing to where the insert should start to search.</td>
+ <td>logarithmic in general, but amortized constant if t is inserted right after p .</td>
+ </tr>
+-</tbody></table>
++</table>
+ <p>1. For a container with unique keys, only logarithmic complexity is
+ guaranteed if no element is inserted, even though constant complexity is always
+ possible if p points to an element equivalent to t.</p>
+@@ -3148,7 +2263,7 @@ providing no disadvantage to the container implementation.</p>
+ <p>In 23.2.4 [associative.reqmts] paragraph 7, replace the row in table 69
+ for a.insert(p,t) with the following two rows:</p>
+ <table border="1" cellpadding="5">
+- <tbody><tr>
++ <tr>
+ <td><b>expression</b></td>
+ <td><b>return type</b></td>
+ <td><b>pre/post-condition</b></td>
+@@ -3172,7 +2287,7 @@ for a.insert(p,t) with the following two rows:</p>
+ <td>logarithmic in general, but amortized constant if t is inserted right
+ before p.</td>
+ </tr>
+-</tbody></table>
++</table>
+
+
+
+@@ -3186,9 +2301,9 @@ both before p and after p, and don't want to change this behavior.</p>
+
+ <hr>
+ <h3><a name="194"></a>194. rdbuf() functions poorly specified</h3>
+-<p><b>Section:</b> 27.5.4 [ios] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1999-09-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.5 [ios] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1999-09-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In classic iostreams, base class ios had an rdbuf function that returned a
+ pointer to the associated streambuf. Each derived class had its own rdbuf
+@@ -3232,28 +2347,28 @@ class <tt> rdbuf()</tt> always returns the original streambuf, whereas the base
+ <tt> rdbuf()</tt> will return the "current streambuf" if that has been changed by the variant you mention.</p>
+
+ <p>Permission is not required to add such an extension. See
+-17.6.4.5 [member.functions].</p>
++17.6.5.5 [member.functions].</p>
+
+
+
+
+ <hr>
+ <h3><a name="196"></a>196. Placement new example has alignment problems</h3>
+-<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a></p>
++<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#114">114</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The example in 18.6.1.3 [new.delete.placement] paragraph 4 reads: </p>
+
+ <blockquote>
+
+-<p>[Example: This can be useful for constructing an object at a known address:<br>
+-<br>
+-<tt>&nbsp;&nbsp; char place[sizeof(Something)];<br>
+-&nbsp;&nbsp; Something* p = new (place) Something();<br>
+-<br>
++<p>[Example: This can be useful for constructing an object at a known address:<br/>
++<br/>
++<tt>&nbsp;&nbsp; char place[sizeof(Something)];<br/>
++&nbsp;&nbsp; Something* p = new (place) Something();<br/>
++<br/>
+ </tt>end example] </p>
+
+ </blockquote>
+@@ -3269,10 +2384,11 @@ class <tt> rdbuf()</tt> always returns the original streambuf, whereas the base
+
+ <hr>
+ <h3><a name="197"></a>197. max_size() underspecified</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements], 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 1999-10-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 1999-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Must the value returned by max_size() be unchanged from call to call? </p>
+
+@@ -3284,20 +2400,20 @@ class <tt> rdbuf()</tt> always returns the original streambuf, whereas the base
+ case" conditions - i.e. assume the run-time platform is "configured to
+ the max", and no overhead from the program itself. This may possibly
+ be determined at the point the library is written, but certainly no
+-later than compile time.<br>
+-<br>
++later than compile time.<br/>
++<br/>
+ 2) The largest container the program could create, given "best case"
+ conditions - i.e. same platform assumptions as (1), but take into
+ account any overhead for executing the program itself. (or, roughly
+ "storage=storage-sizeof(program)"). This does NOT include any resource
+ allocated by the program. This may (or may not) be determinable at
+-compile time.<br>
+-<br>
++compile time.<br/>
++<br/>
+ 3) The largest container the current execution of the program could
+ create, given knowledge of the actual run-time platform, but again,
+ not taking into account any currently allocated resource. This is
+-probably best determined at program start-up.<br>
+-<br>
++probably best determined at program start-up.<br/>
++<br/>
+ 4) The largest container the current execution program could create at
+ the point max_size() is called (or more correctly at the point
+ max_size() returns :-), given it's current environment (i.e. taking
+@@ -3325,10 +2441,10 @@ called. </p>
+
+ <hr>
+ <h3><a name="203"></a>203. basic_istream::sentry::sentry() is uninstantiable with ctype&lt;user-defined type&gt;</h3>
+-<p><b>Section:</b> 27.7.1.1.3 [istream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt McClure and Dietmar Kühl <b>Opened:</b> 2000-01-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.1.3 [istream::sentry] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt McClure and Dietmar K&uuml;hl <b>Opened:</b> 2000-01-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.6.1.1.2 Paragraph 4 states:</p>
+ <blockquote>
+@@ -3383,20 +2499,20 @@ and is not a defect.</p>
+
+
+ <hr>
+-<h3><a name="204"></a>204. distance(first, last) when "last" is before "first"</h3>
+-<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Rintala Matti <b>Opened:</b> 2000-01-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="204"></a>204. distance(first, last) when &quot;last&quot; is before &quot;first&quot;</h3>
++<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Rintala Matti <b>Opened:</b> 2000-01-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 24.3.4 describes the function distance(first, last) (where first and
+-last are iterators) which calculates "the number of increments or
+-decrements needed to get from 'first' to 'last'".</p>
++last are iterators) which calculates &quot;the number of increments or
++decrements needed to get from 'first' to 'last'&quot;.</p>
+ <p>The function should work for forward, bidirectional and random access
+-iterators, and there is a requirement 24.3.4.5 which states that "'last'
+-must be reachable from 'first'".</p>
+-<p>With random access iterators the function is easy to implement as "last
+-- first".</p>
++iterators, and there is a requirement 24.3.4.5 which states that &quot;'last'
++must be reachable from 'first'&quot;.</p>
++<p>With random access iterators the function is easy to implement as &quot;last
++- first&quot;.</p>
+ <p>With forward iterators it's clear that 'first' must point to a place before
+ 'last', because otherwise 'last' would not be reachable from 'first'.</p>
+ <p>But what about bidirectional iterators? There 'last' is reachable from
+@@ -3404,22 +2520,22 @@ must be reachable from 'first'".</p>
+ 'first'. However, I cannot see how the distance() function could be implemented
+ if the implementation does not know which of the iterators points to an earlier
+ position (you cannot use ++ or -- on either iterator if you don't know which
+-direction is the "safe way to travel").</p>
+-<p>The paragraph 24.3.4.1 states that "for ... bidirectional iterators they
+-use ++ to provide linear time implementations". However, the ++ operator is
++direction is the &quot;safe way to travel&quot;).</p>
++<p>The paragraph 24.3.4.1 states that &quot;for ... bidirectional iterators they
++use ++ to provide linear time implementations&quot;. However, the ++ operator is
+ not mentioned in the reachability requirement. Furthermore 24.3.4.4 explicitly
+ mentions that distance() returns the number of increments _or decrements_,
+ suggesting that it could return a negative number also for bidirectional
+ iterators when 'last' points to a position before 'first'.</p>
+ <p>Is a further requirement is needed to state that for forward and
+-bidirectional iterators "'last' must be reachable from 'first' using the ++
+-operator". Maybe this requirement might also apply to random access
++bidirectional iterators &quot;'last' must be reachable from 'first' using the ++
++operator&quot;. Maybe this requirement might also apply to random access
+ iterators so that distance() would work the same way for every iterator
+ category?</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>"Reachable" is defined in the standard in X [iterator.concepts] paragraph 6.
++<p>&quot;Reachable&quot; is defined in the standard in X [iterator.concepts] paragraph 6.
+ The definition is only in terms of operator++(). The LWG sees no defect in
+ the standard.</p>
+
+@@ -3428,19 +2544,19 @@ the standard.</p>
+
+ <hr>
+ <h3><a name="205"></a>205. numeric_limits unclear on how to determine floating point types</h3>
+-<p><b>Section:</b> 18.3.1.2 [numeric.limits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-01-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.3.2.4 [numeric.limits.members] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-01-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In several places in 18.3.1.2 [numeric.limits.members], a member is
+-described as "Meaningful for all floating point types."
++<p>In several places in 18.3.2.4 [numeric.limits.members], a member is
++described as &quot;Meaningful for all floating point types.&quot;
+ However, no clear method of determining a floating point type is
+ provided.</p>
+
+-<p>In 18.3.1.5 [numeric.special], paragraph 1 states ". . . (for
++<p>In 18.3.2.7 [numeric.special], paragraph 1 states &quot;. . . (for
+ example, epsilon() is only meaningful if is_integer is
+-false). . ." which suggests that a type is a floating point type
++false). . .&quot; which suggests that a type is a floating point type
+ if is_specialized is true and is_integer is false; however, this is
+ unclear.</p>
+
+@@ -3460,11 +2576,11 @@ floating point type.</p>
+
+ <hr>
+ <h3><a name="207"></a>207. ctype&lt;char&gt; members return clause incomplete</h3>
+-<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 1999-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a></p>
++<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 1999-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#153">153</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>widen</tt> and <tt>narrow</tt> member functions are described
+@@ -3493,7 +2609,7 @@ respectively.</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>Subsumed by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>, which addresses the same
++<p>Subsumed by issue <a href="lwg-defects.html#153">153</a>, which addresses the same
+ paragraphs.</p>
+
+
+@@ -3503,10 +2619,11 @@ paragraphs.</p>
+
+ <hr>
+ <h3><a name="213"></a>213. Math function overloads ambiguous</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 2000-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 2000-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Due to the additional overloaded versions of numeric functions for
+ float and long double according to Section 26.5, calls such as int x;
+@@ -3529,11 +2646,11 @@ or write floating point expressions as arguments.</p>
+
+ <hr>
+ <h3><a name="215"></a>215. Can a map's key_type be const?</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>A user noticed that this doesn't compile with the Rogue Wave library because
+ the rb_tree class declares a key_allocator, and allocator&lt;const int&gt; is
+@@ -3554,7 +2671,7 @@ too.</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>The "key is assignable" requirement from table 69 in
++<p>The &quot;key is assignable&quot; requirement from table 69 in
+ 23.2.4 [associative.reqmts] already implies the key cannot be const.</p>
+
+
+@@ -3562,13 +2679,13 @@ too.</p>
+
+ <hr>
+ <h3><a name="216"></a>216. setbase manipulator description flawed</h3>
+-<p><b>Section:</b> 27.7.3 [std.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Hyman Rosen <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#std.manip">issues</a> in [std.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#193">193</a></p>
++<p><b>Section:</b> 27.7.4 [std.manip] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Hyman Rosen <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#std.manip">issues</a> in [std.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#193">193</a></p>
+ <p><b>Discussion:</b></p>
+-<p>27.7.3 [std.manip] paragraph 5 says:</p>
++<p>27.7.4 [std.manip] paragraph 5 says:</p>
+ <blockquote>
+ <pre>smanip setbase(int base);</pre>
+ <p> Returns: An object s of unspecified type such that if out is an
+@@ -3591,15 +2708,15 @@ description needs to say that out&lt;&lt;s and in&gt;&gt;s behave as if f(s,base
+ had been called. Second, f is has a parameter named base, but is written as if
+ the parameter was named n.</p>
+ <p>Actually, there's a third problem. The paragraph has grammatical errors.
+-There needs to be an "and" after the first comma, and the "Where
+-f" sentence fragment needs to be merged into its preceding sentence. You
++There needs to be an &quot;and&quot; after the first comma, and the &quot;Where
++f&quot; sentence fragment needs to be merged into its preceding sentence. You
+ may also want to format the function a little better. The formatting above is
+ more-or-less what the Standard contains.</p>
+
+
+ <p><b>Rationale:</b></p>
+ <p>The resolution of this defect is subsumed by the proposed resolution for
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#193">193</a>.</p>
++issue <a href="lwg-defects.html#193">193</a>.</p>
+
+ <p><i>[Tokyo: The LWG agrees that this is a defect and notes that it
+ occurs additional places in the section, all requiring fixes.]</i></p>
+@@ -3613,10 +2730,10 @@ occurs additional places in the section, all requiring fixes.]</i></p>
+
+ <hr>
+ <h3><a name="218"></a>218. Algorithms do not use binary predicate objects for default comparisons</h3>
+-<p><b>Section:</b> 25.4 [alg.sorting] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2000-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.sorting">issues</a> in [alg.sorting].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.4 [alg.sorting] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2000-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.sorting">issues</a> in [alg.sorting].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Many of the algorithms take an argument, pred, of template parameter type
+ BinaryPredicate or an argument comp of template parameter type Compare. These
+@@ -3648,28 +2765,28 @@ operator&lt;.</p>
+
+
+ <hr>
+-<h3><a name="219"></a>219. find algorithm missing version that takes a binary predicate argument</h3>
+-<p><b>Section:</b> 25.2.5 [alg.find] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2000-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.find">issues</a> in [alg.find].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="219"></a>219. <tt>find</tt> algorithm missing version that takes a binary predicate argument</h3>
++<p><b>Section:</b> 25.2.5 [alg.find] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2000-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.find">issues</a> in [alg.find].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The find function always searches for a value using operator== to compare the
++<p>The find function always searches for a value using <tt>operator==</tt> to compare the
+ value argument to each element in the input iterator range. This is inconsistent
+-with other find-related functions such as find_end and find_first_of, which
++with other find-related functions such as <tt>find_end</tt> and <tt>find_first_of</tt>, which
+ allow the caller to specify a binary predicate object to be used for determining
+-equality. The fact that this can be accomplished using a combination of find_if
+-and bind_1st or bind_2nd does not negate the desirability of a consistent,
+-simple, alternative interface to find.</p>
++equality. The fact that this can be accomplished using a combination of <tt>find_if</tt>
++and <tt>bind_1st</tt> or <tt>bind_2nd</tt> does not negate the desirability of a consistent,
++simple, alternative interface to <tt>find</tt>.</p>
+
+ <p><i>[
+ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Reopened by Alisdair.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -3678,7 +2795,7 @@ Reopened by Alisdair.
+
+ <blockquote>
+ <p>
+-The same thing can be achieved using find_if (as noted in the issue).
++The same thing can be achieved using <tt>find_if</tt> (as noted in the issue).
+ </p>
+ <p>
+ Moved to NAD.
+@@ -3697,34 +2814,34 @@ follows:</p>
+ const T&amp; value, BinaryPredicate bin_pred);</pre>
+ <p>Change the description of the return from:</p>
+ <blockquote>
+- <p>Returns: The first iterator i in the range [first, last) for which the following corresponding
+- conditions hold: *i == value, pred(*i) != false. Returns last if no such iterator is found.</p>
++ <p>Returns: The first iterator <tt>i</tt> in the range <tt>[first, last)</tt> for which the following corresponding
++ conditions hold: <tt>*i == value</tt>, <tt>pred(*i) != false</tt>. Returns <tt>last</tt> if no such iterator is found.</p>
+ </blockquote>
+ <p>&nbsp;to:</p>
+ <blockquote>
+- <p>Returns: The first iterator i in the range [first, last) for which the following&nbsp;
+- corresponding condition holds: *i == value, bin_pred(*i,value) != false, pred(*)
+- != false. Return last if no such iterator is found.</p>
++ <p>Returns: The first iterator <tt>i</tt> in the range <tt>[first, last)</tt> for which the following&nbsp;
++ corresponding condition holds: <tt>*i == value</tt>, <tt>bin_pred(*i,value) != false</tt>, <tt>pred(*)
++ != false</tt>. Return <tt>last</tt> if no such iterator is found.</p>
+ </blockquote>
+ </blockquote>
+
+
+ <p><b>Rationale:</b></p>
+ <p>This is request for a pure extension, so it is not a defect in the
+-current standard.&nbsp; As the submitter pointed out, "this can
+-be accomplished using a combination of find_if and bind_1st or
+-bind_2nd".</p>
++current standard.&nbsp; As the submitter pointed out, &quot;this can
++be accomplished using a combination of <tt>find_if</tt> and <tt>bind_1st</tt> or
++<tt>bind_2nd</tt>&quot;.</p>
+
+
+
+
+ <hr>
+ <h3><a name="236"></a>236. ctype&lt;char&gt;::is() member modifies facet</h3>
+-<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#28">28</a></p>
++<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#28">28</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the <tt>is()</tt> member in paragraph 4 of 22.4.1.3.2 [facet.ctype.char.members] is broken: According to this description, the
+ second form of the <tt>is()</tt> method modifies the masks in the
+@@ -3754,14 +2871,15 @@ ie. the <tt>do_is()</tt> method as described in 22.4.1.1.2 [locale.ctype.virtual
+
+ <hr>
+ <h3><a name="244"></a>244. Must <tt>find</tt>'s third argument be CopyConstructible?</h3>
+-<p><b>Section:</b> 25.2.5 [alg.find] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-05-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.find">issues</a> in [alg.find].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.2.5 [alg.find] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-05-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.find">issues</a> in [alg.find].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Is the following implementation of <tt>find</tt> acceptable?</p>
+
+-<pre> template&lt;class Iter, class X&gt;
++<pre>
++ template&lt;class Iter, class X&gt;
+ Iter find(Iter begin, Iter end, const X&amp; x)
+ {
+ X x1 = x; // this is the crucial statement
+@@ -3774,9 +2892,10 @@ ie. the <tt>do_is()</tt> method as described in 22.4.1.1.2 [locale.ctype.virtual
+ <p>If the answer is yes, then it is implementation-dependent as to
+ whether the following fragment is well formed:</p>
+
+-<pre> vector&lt;string&gt; v;
++<pre>
++ vector&lt;string&gt; v;
+
+- find(v.begin(), v.end(), "foo");
++ find(v.begin(), v.end(), &quot;foo&quot;);
+ </pre>
+
+ <p>At issue is whether there is a requirement that the third argument
+@@ -3795,15 +2914,16 @@ might reasonably pass an argument that is not Copy Constructible.</p>
+
+ <hr>
+ <h3><a name="245"></a>245. Which operations on <tt>istream_iterator</tt> trigger input operations?</h3>
+-<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-05-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-05-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>I do not think the standard specifies what operation(s) on istream
+ iterators trigger input operations. So, for example:</p>
+
+-<pre> istream_iterator&lt;int&gt; i(cin);
++<pre>
++ istream_iterator&lt;int&gt; i(cin);
+
+ int n = *i++;
+ </pre>
+@@ -3828,12 +2948,12 @@ how many times find may invoke operator++.</p>
+
+ <hr>
+ <h3><a name="246"></a>246. <tt>a.insert(p,t)</tt> is incorrectly specified</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Mark Rodgers <b>Opened:</b> 2000-05-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Mark Rodgers <b>Opened:</b> 2000-05-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#233">233</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Closed issue 192 raised several problems with the specification of
+ this function, but was rejected as Not A Defect because it was too big
+@@ -3894,18 +3014,18 @@ and with little or no consequent impact.</p>
+ the following changes in the row for a.insert(p,t):</p>
+
+ <p><i>assertion/note pre/post condition:</i>
+-<br>Change the last sentence from</p>
++<br/>Change the last sentence from</p>
+ <blockquote><p>
+- "iterator p is a hint pointing to where the insert should
+- start to search."
++ &quot;iterator p is a hint pointing to where the insert should
++ start to search.&quot;
+ </p></blockquote>
+ <p>to</p>
+ <blockquote><p>
+- "iterator p is a hint indicating that immediately before p
+- may be a correct location where the insertion could occur."
++ &quot;iterator p is a hint indicating that immediately before p
++ may be a correct location where the insertion could occur.&quot;
+ </p></blockquote>
+
+-<p><i>complexity:</i><br>
++<p><i>complexity:</i><br/>
+ Change the words "right after" to "immediately before".</p>
+
+
+@@ -3917,22 +3037,24 @@ Change the words "right after" to "immediately before".</p>
+
+ <hr>
+ <h3><a name="249"></a>249. Return Type of <tt>auto_ptr::operator=</tt></h3>
+-<p><b>Section:</b> D.12.1 [auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Joseph Gottman <b>Opened:</b> 2000-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [auto.ptr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Joseph Gottman <b>Opened:</b> 2000-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>According to section 20.4.5, the function
+ <tt>auto_ptr::operator=()</tt> returns a reference to an auto_ptr.
+ The reason that <tt>operator=()</tt> usually returns a reference is to
+ facilitate code like</p>
+
+-<pre> int x,y,z;
++<pre>
++ int x,y,z;
+ x = y = z = 1;
+ </pre>
+
+ <p>However, given analogous code for <tt>auto_ptr</tt>s,</p>
+-<pre> auto_ptr&lt;int&gt; x, y, z;
++<pre>
++ auto_ptr&lt;int&gt; x, y, z;
+ z.reset(new int(1));
+ x = y = z;
+ </pre>
+@@ -3958,116 +3080,11 @@ code.</p>
+
+
+ <hr>
+-<h3><a name="255"></a>255. Why do <tt>basic_streambuf&lt;&gt;::pbump()</tt> and <tt>gbump()</tt> take an int?</h3>
+-<p><b>Section:</b> 27.6.2 [streambuf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf">issues</a> in [streambuf].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The basic_streambuf members gbump() and pbump() are specified to take an
+-int argument. This requirement prevents the functions from effectively
+-manipulating buffers larger than std::numeric_limits&lt;int&gt;::max()
+-characters. It also makes the common use case for these functions
+-somewhat difficult as many compilers will issue a warning when an
+-argument of type larger than int (such as ptrdiff_t on LLP64
+-architectures) is passed to either of the function. Since it's often the
+-result of the subtraction of two pointers that is passed to the
+-functions, a cast is necessary to silence such warnings. Finally, the
+-usage of a native type in the functions signatures is inconsistent with
+-other member functions (such as sgetn() and sputn()) that manipulate the
+-underlying character buffer. Those functions take a streamsize argument.
+-</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-This is part of a bigger problem. If anyone cares enough, they should
+-write a paper solving the bigger problem of offset types in iostreams.
+-</p>
+-<p>
+-This is related to the paper about large file sizes. Beman has already
+-agreed to drop the section of that paper that deals with this.
+-</p>
+-<p>
+-int is big enough for reasonable buffers.
+-</p>
+-<p>
+-Move to NAD Future.
+-</p>
+-<p>
+-This is related to LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#423">423</a>.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change the signatures of these functions in the synopsis of template
+-class basic_streambuf (27.5.2) and in their descriptions (27.5.2.3.1, p4
+-and 27.5.2.3.2, p4) to take a streamsize argument.
+-</p>
+-
+-<p>
+-Although this change has the potential of changing the ABI of the
+-library, the change will affect only platforms where int is different
+-than the definition of streamsize. However, since both functions are
+-typically inline (they are on all known implementations), even on such
+-platforms the change will not affect any user code unless it explicitly
+-relies on the existing type of the functions (e.g., by taking their
+-address). Such a possibility is IMO quite remote.
+-</p>
+-
+-<p>
+-Alternate Suggestion from Howard Hinnant, c++std-lib-7780:
+-</p>
+-
+-<p>
+-This is something of a nit, but I'm wondering if streamoff wouldn't be a
+-better choice than streamsize. The argument to pbump and gbump MUST be
+-signed. But the standard has this to say about streamsize
+-(27.4.1/2/Footnote):
+-</p>
+-
+-<blockquote><p>
+- [Footnote: streamsize is used in most places where ISO C would use
+- size_t. Most of the uses of streamsize could use size_t, except for
+- the strstreambuf constructors, which require negative values. It
+- should probably be the signed type corresponding to size_t (which is
+- what Posix.2 calls ssize_t). --- end footnote]
+-</p></blockquote>
+-
+-<p>
+-This seems a little weak for the argument to pbump and gbump. Should we
+-ever really get rid of strstream, this footnote might go with it, along
+-with the reason to make streamsize signed.
+-</p>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>The LWG believes this change is too big for now. We may wish to
+-reconsider this for a future revision of the standard. One
+-possibility is overloading pbump, rather than changing the
+-signature.</p>
+-<p><i>[
+-[2006-05-04: Reopened at the request of Chris (Krzysztof ?elechowski)]
+-]</i></p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="257"></a>257. STL functional object and iterator inheritance.</h3>
+-<p><b>Section:</b> X [base], 24.4.2 [iterator.basic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Robert Dick <b>Opened:</b> 2000-08-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#base">issues</a> in [base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [depr.base], 24.4.2 [iterator.basic] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Robert Dick <b>Opened:</b> 2000-08-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.base">issues</a> in [depr.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to the November 1997 Draft Standard, the results of deleting an
+@@ -4077,14 +3094,14 @@ potentially dangerous to publicly inherit from such base classes.
+ </p>
+
+ <p>Defect:
+-<br>
++<br/>
+ The STL design encourages users to publicly inherit from a number of classes
+ which do nothing but specify interfaces, and which contain non-virtual
+ destructors.
+ </p>
+
+ <p>Attribution:
+-<br>
++<br/>
+ Wil Evers and William E. Kempf suggested this modification for functional
+ objects.
+ </p>
+@@ -4103,7 +3120,8 @@ or space penalties (on any implementation I'm aware of).
+ As an example, replace...
+ </p>
+
+-<pre> template &lt;class Arg, class Result&gt;
++<pre>
++ template &lt;class Arg, class Result&gt;
+ struct unary_function {
+ typedef Arg argument_type;
+ typedef Result result_type;
+@@ -4114,7 +3132,8 @@ As an example, replace...
+ ... with...
+ </p>
+
+-<pre> template &lt;class Arg, class Result&gt;
++<pre>
++ template &lt;class Arg, class Result&gt;
+ struct unary_function {
+ typedef Arg argument_type;
+ typedef Result result_type;
+@@ -4125,9 +3144,9 @@ As an example, replace...
+
+ <p>
+ Affected definitions:
+-<br>
++<br/>
+ &nbsp;20.3.1 [lib.function.objects] -- unary_function, binary_function
+- <br>
++ <br/>
+ &nbsp;24.3.2 [lib.iterator.basic] -- iterator
+ </p>
+
+@@ -4148,10 +3167,10 @@ want to pass temporaries as traits or tag types in generic code.
+
+ <hr>
+ <h3><a name="267"></a>267. interaction of strstreambuf::overflow() and seekoff()</h3>
+-<p><b>Section:</b> D.9.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-10-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> D.7.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It appears that the interaction of the strstreambuf members overflow()
+@@ -4160,7 +3179,8 @@ behavior could reasonably be expected. The following program
+ demonstrates this behavior:
+ </p>
+
+-<pre> #include &lt;strstream&gt;
++<pre>
++ #include &lt;strstream&gt;
+
+ int main ()
+ {
+@@ -4212,7 +3232,7 @@ behavior of the program is undefined.
+ <p><b>Proposed resolution:</b></p>
+
+
+- <p>Change the last sentence of D.9.1 [depr.strstreambuf] paragraph 4 from</p>
++ <p>Change the last sentence of D.7.1 [depr.strstreambuf] paragraph 4 from</p>
+
+ <blockquote><p>
+ Otherwise, seeklow equals gbeg and seekhigh is either pend, if
+@@ -4241,8 +3261,8 @@ behavior of the program is undefined.
+
+
+ <p><b>Rationale:</b></p>
+-<p>This is related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#65">65</a>: it's not clear what it
+-means to seek beyond the current area. Without resolving issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#65">65</a> we can't resolve this. As with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#65">65</a>,
++<p>This is related to issue <a href="lwg-closed.html#65">65</a>: it's not clear what it
++means to seek beyond the current area. Without resolving issue <a href="lwg-closed.html#65">65</a> we can't resolve this. As with issue <a href="lwg-closed.html#65">65</a>,
+ the library working group does not wish to invest time nailing down
+ corner cases in a deprecated feature.</p>
+
+@@ -4252,16 +3272,17 @@ corner cases in a deprecated feature.</p>
+
+ <hr>
+ <h3><a name="269"></a>269. cstdarg and unnamed parameters</h3>
+-<p><b>Section:</b> 18.8 [support.exception] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> J. Stephen Adamczyk <b>Opened:</b> 2000-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.exception">issues</a> in [support.exception].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8 [support.exception] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> J. Stephen Adamczyk <b>Opened:</b> 2000-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.exception">issues</a> in [support.exception].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ One of our customers asks whether this is valid C++:
+ </p>
+
+-<pre> #include &lt;cstdarg&gt;
++<pre>
++ #include &lt;cstdarg&gt;
+
+ void bar(const char *, va_list);
+
+@@ -4277,10 +3298,10 @@ One of our customers asks whether this is valid C++:
+
+ <p>
+ The issue being whether it is valid to use cstdarg when the final
+-parameter before the "..." is unnamed. cstdarg is, as far
++parameter before the &quot;...&quot; is unnamed. cstdarg is, as far
+ as I can tell, inherited verbatim from the C standard. and the
+-definition there (7.8.1.1 in the ISO C89 standard) refers to "the
+-identifier of the rightmost parameter". What happens when there
++definition there (7.8.1.1 in the ISO C89 standard) refers to &quot;the
++identifier of the rightmost parameter&quot;. What happens when there
+ is no such identifier?
+ </p>
+
+@@ -4293,7 +3314,7 @@ might be required in the C++ standard.
+ <p><b>Rationale:</b></p>
+ <p>
+ Not a defect, the C and C++ standards are clear. It is impossible to
+-use varargs if the parameter immediately before "..." has no
++use varargs if the parameter immediately before &quot;...&quot; has no
+ name, because that is the parameter that must be passed to va_start.
+ The example given above is broken, because va_start is being passed
+ the wrong parameter.
+@@ -4313,16 +3334,17 @@ necessary.
+
+ <hr>
+ <h3><a name="277"></a>277. Normative encouragement in allocator requirements unclear</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-11-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-11-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.1.5, paragraph 5, the standard says that "Implementors are
++In 20.1.5, paragraph 5, the standard says that &quot;Implementors are
+ encouraged to supply libraries that can accept allocators that
+ encapsulate more general memory models and that support non-equal
+-instances." This is intended as normative encouragement to
++instances.&quot; This is intended as normative encouragement to
+ standard library implementors. However, it is possible to interpret
+ this sentence as applying to nonstandard third-party libraries.
+ </p>
+@@ -4330,9 +3352,9 @@ this sentence as applying to nonstandard third-party libraries.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.1.5, paragraph 5, change "Implementors" to
+-"Implementors of the library described in this International
+-Standard".
++In 20.1.5, paragraph 5, change &quot;Implementors&quot; to
++&quot;Implementors of the library described in this International
++Standard&quot;.
+ </p>
+
+
+@@ -4347,21 +3369,22 @@ even if it is misunderstood.</p>
+
+ <hr>
+ <h3><a name="279"></a>279. const and non-const iterators should have equivalent typedefs</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+ This came from an email from Steve Cleary to Fergus in reference to
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>. The library working group briefly discussed
++issue <a href="lwg-defects.html#179">179</a>. The library working group briefly discussed
+ this in Toronto and believes it should be a separate issue.
+ </p>
+
+ <p>
+-Steve said: "We may want to state that the const/non-const iterators must have
+-the same difference type, size_type, and category."
++Steve said: &quot;We may want to state that the const/non-const iterators must have
++the same difference type, size_type, and category.&quot;
+ </p>
+
+ <p>
+@@ -4406,7 +3429,7 @@ does not see this as a defect: it's possible to imagine cases in which
+ it would be useful for the categories to be different.</p>
+
+ <p>It may be desirable to require X::iterator and X::const_iterator to
+-have the same value type, but that is a new issue. (Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#322">322</a>.)</p>
++have the same value type, but that is a new issue. (Issue <a href="lwg-defects.html#322">322</a>.)</p>
+
+
+
+@@ -4415,14 +3438,14 @@ have the same value type, but that is a new issue. (Issue <a href="http://www.op
+
+ <hr>
+ <h3><a name="287"></a>287. conflicting ios_base fmtflags</h3>
+-<p><b>Section:</b> 27.5.2.2 [fmtflags.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fmtflags.state">issues</a> in [fmtflags.state].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.3.2 [fmtflags.state] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fmtflags.state">issues</a> in [fmtflags.state].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The Effects clause for ios_base::setf(fmtflags fmtfl) says
+-"Sets fmtfl in flags()". What happens if the user first calls
++&quot;Sets fmtfl in flags()&quot;. What happens if the user first calls
+ ios_base::scientific and then calls ios_base::fixed or vice-versa?
+ This is an issue for all of the conflicting flags, i.e. ios_base::left
+ and ios_base::right or ios_base::dec, ios_base::hex and ios_base::oct.
+@@ -4438,7 +3461,7 @@ flag with one previously explicitly set. If the constructor is
+ supposed to set ios_base::dec (see discussion below), then
+ the user setting hex or oct format after construction will not
+ set failbit. </li>
+-<li>The last call to setf "wins", i.e. it clears any conflicting
++<li>The last call to setf &quot;wins&quot;, i.e. it clears any conflicting
+ previous setting.</li>
+ <li>All the flags that the user specifies are set, but when actually
+ interpreting them, fixed always override scientific, right always
+@@ -4484,10 +3507,11 @@ version of <tt>setf</tt>, to avoid unexpected behavior.
+
+ <hr>
+ <h3><a name="289"></a>289. &lt;cmath&gt; requirements missing C float and long double versions</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In ISO/IEC 9899:1990 Programming Languages C we find the following
+@@ -4496,7 +3520,7 @@ version of <tt>setf</tt>, to avoid unexpected behavior.
+
+ <blockquote><p>
+ 7.13.4 Mathematics &lt;math.h&gt;
+- <br>
++ <br/>
+ The names of all existing functions declared in the &lt;math.h&gt;
+ header, suffixed with f or l, are reserved respectively for
+ corresponding functions with float and long double arguments
+@@ -4525,7 +3549,8 @@ Add these Functions to Table 80, section 26.5 and to Table 99,
+ section C.2:
+ </p>
+
+-<pre> acosf asinf atanf atan2f ceilf cosf coshf
++<pre>
++ acosf asinf atanf atan2f ceilf cosf coshf
+ expf fabsf floorf fmodf frexpf ldexpf
+ logf log10f modff powf sinf sinhf sqrtf
+ tanf tanhf
+@@ -4555,18 +3580,18 @@ never referred to by the C++ standard.</p>
+
+ <hr>
+ <h3><a name="290"></a>290. Requirements to for_each and its function object</h3>
+-<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2001-01-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2001-01-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The specification of the for_each algorithm does not have a
+-"Requires" section, which means that there are no
++&quot;Requires&quot; section, which means that there are no
+ restrictions imposed on the function object whatsoever. In essence it
+ means that I can provide any function object with arbitrary side
+ effects and I can still expect a predictable result. In particular I
+ can expect that the function object is applied exactly last - first
+-times, which is promised in the "Complexity" section.
++times, which is promised in the &quot;Complexity&quot; section.
+ </p>
+
+ <p>I don't see how any implementation can give such a guarantee
+@@ -4618,17 +3643,17 @@ of the library.
+
+ <hr>
+ <h3><a name="293"></a>293. Order of execution in transform algorithm</h3>
+-<p><b>Section:</b> 25.3.4 [alg.transform] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2001-01-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.transform">issues</a> in [alg.transform].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.3.4 [alg.transform] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2001-01-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.transform">issues</a> in [alg.transform].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>This issue is related to issue 242. In case that the resolution
+ proposed for issue 242 is accepted, we have have the following
+ situation: The 4 numeric algorithms (accumulate and consorts) as well
+ as transform would allow a certain category of side effects. The
+-numeric algorithms specify that they invoke the functor "for
+-every iterator i in the range [first, last) in order". transform,
++numeric algorithms specify that they invoke the functor &quot;for
++every iterator i in the range [first, last) in order&quot;. transform,
+ in contrast, would not give any guarantee regarding order of
+ invocation of the functor, which means that the functor can be invoked
+ in any arbitrary order.
+@@ -4636,12 +3661,12 @@ in any arbitrary order.
+
+ <p>Why would that be a problem? Consider an example: say the
+ transformator that is a simple enumerator ( or more generally
+-speaking, "is order-sensitive" ). Since a standard
++speaking, &quot;is order-sensitive&quot; ). Since a standard
+ compliant implementation of transform is free to invoke the enumerator
+ in no definite order, the result could be a garbled enumeration.
+ Strictly speaking this is not a problem, but it is certainly at odds
+ with the prevalent understanding of transform as an algorithms that
+-assigns "a new _corresponding_ value" to the output
++assigns &quot;a new _corresponding_ value&quot; to the output
+ elements.
+ </p>
+
+@@ -4687,36 +3712,36 @@ wrapping it in an Input Iterator adaptor.</p>
+
+ <hr>
+ <h3><a name="299"></a>299. Incorrect return types for iterator dereference</h3>
+-<p><b>Section:</b> 24.2.6 [bidirectional.iterators], 24.2.7 [random.access.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> John Potter <b>Opened:</b> 2001-01-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 24.2.6 [bidirectional.iterators], 24.2.7 [random.access.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> John Potter <b>Opened:</b> 2001-01-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In section 24.2.6 [bidirectional.iterators],
+-Table 75 gives the return type of *r-- as convertible to T. This is
+-not consistent with Table 74 which gives the return type of *r++ as
+-T&amp;. *r++ = t is valid while *r-- = t is invalid.
++Table 75 gives the return type of <tt>*r--</tt> as convertible to <tt>T</tt>. This is
++not consistent with Table 74 which gives the return type of <tt>*r++</tt> as
++<tt>T&amp;</tt>. <tt>*r++ = t</tt> is valid while <tt>*r-- = t</tt> is invalid.
+ </p>
+
+ <p>
+ In section 24.2.7 [random.access.iterators],
+-Table 76 gives the return type of a[n] as convertible to T. This is
+-not consistent with the semantics of *(a + n) which returns T&amp; by
+-Table 74. *(a + n) = t is valid while a[n] = t is invalid.
++Table 76 gives the return type of <tt>a[n]</tt> as convertible to <tt>T</tt>. This is
++not consistent with the semantics of <tt>*(a + n)</tt> which returns <tt>T&amp;</tt> by
++Table 74. <tt>*(a + n) = t</tt> is valid while <tt>a[n] = t</tt> is invalid.
+ </p>
+
+ <p>
+ Discussion from the Copenhagen meeting: the first part is
+-uncontroversial. The second part, operator[] for Random Access
++uncontroversial. The second part, <tt>operator[]</tt> for Random Access
+ Iterators, requires more thought. There are reasonable arguments on
+-both sides. Return by value from operator[] enables some potentially
++both sides. Return by value from <tt>operator[]</tt> enables some potentially
+ useful iterators, e.g. a random access "iota iterator" (a.k.a
+ "counting iterator" or "int iterator"). There isn't any obvious way
+ to do this with return-by-reference, since the reference would be to a
+ temporary. On the other hand, <tt>reverse_iterator</tt> takes an
+ arbitrary Random Access Iterator as template argument, and its
+-operator[] returns by reference. If we decided that the return type
++<tt>operator[]</tt> returns by reference. If we decided that the return type
+ in Table 76 was correct, we would have to change
+ <tt>reverse_iterator</tt>. This change would probably affect user
+ code.
+@@ -4728,12 +3753,12 @@ Random Access Iterator requirements has been present from an early
+ stage. In both the STL proposal adopted by the committee
+ (N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by
+ Stepanov and Lee), the Random Access Iterator requirements say that
+-operator[]'s return value is "convertible to T". In N0527
+-reverse_iterator's operator[] returns by value, but in HPL-95-11
++<tt>operator[]</tt>'s return value is "convertible to <tt>T</tt>". In N0527
++reverse_iterator's <tt>operator[]</tt> returns by value, but in HPL-95-11
+ (R.1), and in the STL implementation that HP released to the public,
+-reverse_iterator's operator[] returns by reference. In 1995, the
++reverse_iterator's <tt>operator[]</tt> returns by reference. In 1995, the
+ standard was amended to reflect the contents of HPL-95-11 (R.1). The
+-original intent for operator[] is unclear.
++original intent for <tt>operator[]</tt> is unclear.
+ </p>
+
+ <p>
+@@ -4767,7 +3792,7 @@ Note that the compromise resolution necessitates a change to
+ Note also there is one kind of mutable random access iterator that
+ will no longer meet the new requirements. Currently, iterators that
+ return an r-value from <tt>operator[]</tt> meet the requirements for a
+-mutable random access iterartor, even though the expression <tt>a[n] =
++mutable random access iterator, even though the expression <tt>a[n] =
+ t</tt> will only modify a temporary that goes away. With this proposed
+ resolution, <tt>a[n] = t</tt> will be required to have the same
+ operational semantics as <tt>*(a + n) = t</tt>.
+@@ -4785,7 +3810,7 @@ operational semantics as <tt>*(a + n) = t</tt>.
+
+ <blockquote>
+ <p>
+-Why can't we write through the reference returned from operator[] on a
++Why can't we write through the reference returned from <tt>operator[]</tt> on a
+ random access iterator?
+ </p>
+
+@@ -4794,13 +3819,13 @@ Recommended solution:
+ </p>
+
+ <p>
+-In table Table 104 -- Random access iterator requirements, replace
++In table Table 104 &mdash; Random access iterator requirements, replace
+ </p>
+
+-<blockquote>
+-a[n] : convertible to <del><tt>const T &amp;</tt></del>
++<blockquote><p>
++<tt>a[n]</tt> : convertible to <del><tt>const T &amp;</tt></del>
+ <ins><tt>T&amp;</tt> if <tt>X</tt> is mutable, otherwise convertible to <tt>const T&amp;</tt></ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -4808,9 +3833,9 @@ a[n] : convertible to <del><tt>const T &amp;</tt></del>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open. Alisdair to spearhead a paper on revivification.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+@@ -4830,15 +3855,15 @@ Solved by
+
+ <p>
+ In section 24.1.4 [lib.bidirectdional.iterators], change the return
+-type in table 75 from "convertible to <tt>T</tt>" to
++type in table 75 from &quot;convertible to <tt>T</tt>&quot; to
+ <tt>T&amp;</tt>.
+ </p>
+
+ <p>
+ In section 24.1.5 [lib.random.access.iterators], change the
+-operational semantics for <tt>a[n]</tt> to " the r-value of
++operational semantics for <tt>a[n]</tt> to &quot; the r-value of
+ <tt>a[n]</tt> is equivalent to the r-value of <tt>*(a +
+-n)</tt>". Add a new row in the table for the expression <tt>a[n] = t</tt>
++n)</tt>&quot;. Add a new row in the table for the expression <tt>a[n] = t</tt>
+ with a return type of convertible to <tt>T</tt> and operational semantics of
+ <tt>*(a + n) = t</tt>.
+ </p>
+@@ -4855,10 +3880,10 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2758.pdf">N2758</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -4868,15 +3893,15 @@ Solved by
+
+ <hr>
+ <h3><a name="302"></a>302. Need error indication from codecvt&lt;&gt;::do_length</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Gregory Bumgardner <b>Opened:</b> 2001-01-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Gregory Bumgardner <b>Opened:</b> 2001-01-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The effects of <tt>codecvt&lt;&gt;::do_length()</tt> are described in
+ 22.2.1.5.2, paragraph 10. As implied by that paragraph, and clarified
+-in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#75">75</a>, <tt>codecvt&lt;&gt;::do_length()</tt> must
++in issue <a href="lwg-defects.html#75">75</a>, <tt>codecvt&lt;&gt;::do_length()</tt> must
+ process the source data and update the <tt>stateT</tt> argument just
+ as if the data had been processed by <tt>codecvt&lt;&gt;::in()</tt>.
+ However, the standard does not specify how <tt>do_length()</tt> would
+@@ -4885,7 +3910,7 @@ untranslatable or illegal character sequences.
+ </p>
+
+ <p>
+-The other conversion methods return an "error" result value
++The other conversion methods return an &quot;error&quot; result value
+ to indicate that an untranslatable character has been encountered, but
+ <tt>do_length()</tt> already has a return value (the number of source
+ characters that have been processed by the method).
+@@ -4907,7 +3932,8 @@ character sequence. This argument would have a default value that would
+ allow it to be ignored:
+ </p>
+
+-<pre> int length(stateT&amp; state,
++<pre>
++ int length(stateT&amp; state,
+ const externT* from,
+ const externT* from_end,
+ size_t max,
+@@ -4939,13 +3965,13 @@ external characters, it stops.</p>
+
+ <hr>
+ <h3><a name="304"></a>304. Must <tt>*a</tt> return an lvalue when <tt>a</tt> is an input iterator?</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-02-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-02-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-We all "know" that input iterators are allowed to produce
++We all &quot;know&quot; that input iterators are allowed to produce
+ values when dereferenced of which there is no other in-memory copy.
+ </p>
+
+@@ -4956,14 +3982,15 @@ the case if the value_type has no members (e.g. is a built-in type).
+
+ <p>The problem occurs in the following entry:</p>
+
+-<pre> a-&gt;m pre: (*a).m is well-defined
++<pre>
++ a->m pre: (*a).m is well-defined
+ Equivalent to (*a).m
+ </pre>
+
+ <p>
+ <tt>*a.m</tt> can be well-defined if <tt>*a</tt> is not a reference
+-type, but since <tt>operator-&gt;()</tt> must return a pointer for
+-<tt>a-&gt;m</tt> to be well-formed, it needs something to return a
++type, but since <tt>operator->()</tt> must return a pointer for
++<tt>a->m</tt> to be well-formed, it needs something to return a
+ pointer <i>to</i>. This seems to indicate that <tt>*a</tt> must be
+ buffered somewhere to make a legal input iterator.
+ </p>
+@@ -4974,7 +4001,7 @@ buffered somewhere to make a legal input iterator.
+ <p><b>Rationale:</b></p>
+ <p>The current standard is clear and consistent. Input iterators that
+ return rvalues are in fact implementable. They may in some cases
+- require extra work, but it is still possible to define an operator-&gt;
++ require extra work, but it is still possible to define an operator->
+ in such cases: it doesn't have to return a T*, but may return a
+ proxy type. No change to the standard is justified.</p>
+
+@@ -4984,15 +4011,15 @@ buffered somewhere to make a legal input iterator.
+
+ <hr>
+ <h3><a name="309"></a>309. Does sentry catch exceptions?</h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The descriptions of the constructors of basic_istream&lt;&gt;::sentry
+-(27.7.1.1.3 [istream::sentry]) and basic_ostream&lt;&gt;::sentry
+-(27.7.2.4 [ostream::sentry]) do not explain what the functions do in
++(27.7.2.1.3 [istream::sentry]) and basic_ostream&lt;&gt;::sentry
++(27.7.3.4 [ostream::sentry]) do not explain what the functions do in
+ case an exception is thrown while they execute. Some current
+ implementations allow all exceptions to propagate, others catch them
+ and set ios_base::badbit instead, still others catch some but let
+@@ -5003,16 +4030,16 @@ others propagate.
+ The text also mentions that the functions may call setstate(failbit)
+ (without actually saying on what object, but presumably the stream
+ argument is meant). That may have been fine for
+-basic_istream&lt;&gt;::sentry prior to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>, since
++basic_istream&lt;&gt;::sentry prior to issue <a href="lwg-defects.html#195">195</a>, since
+ the function performs an input operation which may fail. However,
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a> amends 27.7.1.1.3 [istream::sentry], p2 to
++issue <a href="lwg-defects.html#195">195</a> amends 27.7.2.1.3 [istream::sentry], p2 to
+ clarify that the function should actually call setstate(failbit |
+ eofbit), so the sentence in p3 is redundant or even somewhat
+ contradictory.
+ </p>
+
+ <p>
+-The same sentence that appears in 27.7.2.4 [ostream::sentry], p3
++The same sentence that appears in 27.7.3.4 [ostream::sentry], p3
+ doesn't seem to be very meaningful for basic_istream&lt;&gt;::sentry
+ which performs no input. It is actually rather misleading since it
+ would appear to guide library implementers to calling
+@@ -5076,7 +4103,7 @@ do not behave consistently, suggesting that implementors are
+ not quite clear on the exception handling in istream::sentry,
+ despite the fact that some LWG members might feel otherwise.
+ (As documented by the parenthetical comment here:
+-http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1480.html#309)
++http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1480.html#309)
+ </p>
+
+ <p>
+@@ -5085,7 +4112,7 @@ felt that "a sentry's constructor should not catch exceptions,
+ because sentries should only be used within (un)formatted input
+ functions and that exception handling is the responsibility of
+ those functions, not of the sentries," as noted here
+-http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1310.html#309
++http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2001/n1310.html#309
+ would in effect be either arguing for the behavior described
+ in [1] or for extractors implemented along the lines of [3].
+ </p>
+@@ -5104,7 +4131,8 @@ badbit is also set in exceptions().
+ <p>[1] Extractor that catches exceptions thrown from sentry:</p>
+
+ <blockquote>
+-<pre>struct S { long i; };
++<pre>
++struct S { long i; };
+
+ istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
+ {
+@@ -5140,7 +4168,8 @@ istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
+ <p>[2] Extractor that propagates exceptions thrown from sentry:</p>
+
+ <blockquote>
+-<pre>istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
++<pre>
++istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
+ {
+ istream::sentry guard (strm, false);
+ if (guard) {
+@@ -5178,7 +4207,8 @@ result of a call to strm.clear().
+ </p>
+
+ <blockquote>
+-<pre>istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
++<pre>
++istream&amp; operator&gt;&gt; (istream &amp;strm, S &amp;s)
+ {
+ const ios::iostate state = strm.rdstate ();
+ const ios::iostate except = strm.exceptions ();
+@@ -5251,10 +4281,10 @@ requested exceptions. I refer to 27.6.1.1. P4.
+ </p>
+ <p>
+ However, this was not the case on at least two implementations -- if
+-the first thing I did with an istream was call operator&gt;&gt;( T&amp; ) for T
++the first thing I did with an istream was call operator>>( T&amp; ) for T
+ among the basic arithmetic types and std::string. Looking further I
+ found that the sentry's constructor was invoking the exception when it
+-pre-scanned for whitespace, and the extractor function (operator&gt;&gt;())
++pre-scanned for whitespace, and the extractor function (operator>>())
+ was not catching exceptions in this situation.
+ </p>
+ <p>
+@@ -5307,10 +4337,10 @@ reopened, agreed with the rationale.
+
+ <hr>
+ <h3><a name="313"></a>313. set_terminate and set_unexpected question</h3>
+-<p><b>Section:</b> 18.8.3.3 [terminate] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2001-04-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#terminate">issues</a> in [terminate].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8.3.4 [terminate] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2001-04-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#terminate">issues</a> in [terminate].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to section 18.7.3.3 of the standard, std::terminate() is
+@@ -5325,7 +4355,8 @@ std::terminate?
+
+ <p>For example:</p>
+
+-<pre> #include &lt;exception&gt;
++<pre>
++ #include &lt;exception&gt;
+
+ int main () {
+ std::set_terminate(std::terminate);
+@@ -5357,10 +4388,10 @@ to call itself.</p>
+
+ <hr>
+ <h3><a name="314"></a>314. Is the stack unwound when terminate() is called?</h3>
+-<p><b>Section:</b> 18.8.3.3 [terminate] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-04-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#terminate">issues</a> in [terminate].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8.3.4 [terminate] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-04-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#terminate">issues</a> in [terminate].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -5403,16 +4434,18 @@ about when terminate() is called; it merely specifies which
+
+
+ <hr>
+-<h3><a name="323"></a>323. abs() overloads in different headers</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-06-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="323"></a>323. <tt>abs()</tt> overloads in different headers</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-06-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Currently the standard mandates the following overloads of
+ abs():</p>
+
+-<pre> abs(long), abs(int) in &lt;cstdlib&gt;
++<pre>
++ abs(long), abs(int) in &lt;cstdlib&gt;
+
+ abs(float), abs(double), abs(long double) in &lt;cmath&gt;
+
+@@ -5440,19 +4473,19 @@ the correct headers are #included.
+
+ <p>The same issue may exist for other functions in the library.</p>
+
+-<p>Redmond: PJP reports that C99 adds two new kinds of abs: complex,
+-and int_max_abs.</p>
++<p>Redmond: PJP reports that C99 adds two new kinds of <tt>abs</tt>: <tt>complex</tt>,
++and <tt>int_max_abs</tt>.</p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#343">343</a>.</p>
++<p>Related issue: <a href="lwg-defects.html#343">343</a>.</p>
+
+ <p><i>[
+ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The situation is not sufficiently severe to warrant a change.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -5483,9 +4516,9 @@ The situation is not sufficiently severe to warrant a change.
+
+ <hr>
+ <h3><a name="326"></a>326. Missing typedef in moneypunct_byname</h3>
+-<p><b>Section:</b> 22.4.6.4 [locale.moneypunct.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.6.4 [locale.moneypunct.byname] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The definition of the moneypunct facet contains the typedefs char_type
+ and string_type. Only one of these names, string_type, is defined in
+@@ -5508,10 +4541,10 @@ the typedef, because it is inherited from the base class.</p>
+
+ <hr>
+ <h3><a name="330"></a>330. Misleading "exposition only" value in class locale definition</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The "exposition only" value of the std::locale::none constant shown in
+@@ -5531,7 +4564,8 @@ For instance, the following code will (presumably) incorrectly copy facets
+ belonging to the collate category from the German locale on AIX:
+ </p>
+
+-<pre> std::locale l (std::locale ("C"), "de_DE", std::locale::none);
++<pre>
++ std::locale l (std::locale ("C"), "de_DE", std::locale::none);
+ </pre>
+
+
+@@ -5550,7 +4584,7 @@ could give library implementors proper guidance in such a delicate
+ matter. The non-normative example we're giving is no worse than
+ any other choice would be.</p>
+
+-<p>See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>.</p>
++<p>See issue <a href="lwg-defects.html#347">347</a>.</p>
+
+
+
+@@ -5558,14 +4592,14 @@ any other choice would be.</p>
+
+ <hr>
+ <h3><a name="332"></a>332. Consider adding increment and decrement operators to std::fpos&lt; T &gt; </h3>
+-<p><b>Section:</b> 27.5.3 [fpos] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos">issues</a> in [fpos].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.4 [fpos] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos">issues</a> in [fpos].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Increment and decrement operators are missing from
+-Table 88 -- Position type requirements in 27.5.3 [fpos].
++Table 88 -- Position type requirements in 27.5.4 [fpos].
+ </p>
+
+
+@@ -5575,7 +4609,8 @@ Table 88 (section 27.4.3) -- Position type requirements
+ be updated to include increment and decrement operators.
+ </p>
+
+-<pre>expression return type operational note
++<pre>
++expression return type operational note
+
+ ++p fpos&amp; p += O(1)
+ p++ fpos { P tmp = p;
+@@ -5600,15 +4635,16 @@ report. Additionally, nobody saw a clear need for this extension;
+
+ <hr>
+ <h3><a name="342"></a>342. seek and eofbit</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-10-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>I think we have a defect.</p>
+
+-<p>According to lwg issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a> which is now a dr, the
+-description of seekg in 27.7.1.3 [istream.unformatted] paragraph 38 now looks
++<p>According to lwg issue <a href="lwg-defects.html#60">60</a> which is now a dr, the
++description of seekg in 27.7.2.3 [istream.unformatted] paragraph 38 now looks
+ like:</p>
+
+ <blockquote><p>
+@@ -5616,10 +4652,10 @@ Behaves as an unformatted input function (as described in 27.6.1.3,
+ paragraph 1), except that it does not count the number of characters
+ extracted and does not affect the value returned by subsequent calls to
+ gcount(). After constructing a sentry object, if fail() != true,
+-executes rdbuf()-&gt;pubseekpos( pos).
++executes rdbuf()->pubseekpos( pos).
+ </p></blockquote>
+
+-<p>And according to lwg issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a> which is also now a dr,
++<p>And according to lwg issue <a href="lwg-defects.html#243">243</a> which is also now a dr,
+ 27.6.1.3, paragraph 1 looks like:</p>
+
+ <blockquote><p>
+@@ -5676,7 +4712,7 @@ Ready state:
+ <li>It should apply to both overloads of seekg.</li>
+ <li>tellg has similar issues, except that it should not call clear().</li>
+ <li>The point about clear() seems to apply to seekp().</li>
+-<li>Depending on the outcome of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>
++<li>Depending on the outcome of <a href="lwg-defects.html#419">419</a>
+ if the sentry
+ sets <tt>failbit</tt> when it finds <tt>eofbit</tt> already set, then
+ you can never seek away from the end of stream.</li>
+@@ -5697,14 +4733,14 @@ Moved to NAD. Will reopen if proposed resolution is supplied.
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Change 27.7.1.3 [istream.unformatted] to:</p>
++<p>Change 27.7.2.3 [istream.unformatted] to:</p>
+ <blockquote><p>
+ Behaves as an unformatted input function (as described in 27.6.1.3,
+ paragraph 1), except that it does not count the number of characters
+ extracted, does not affect the value returned by subsequent calls to
+ gcount(), and does not examine the value returned by the sentry
+ object. After constructing a sentry object, if <tt>fail() !=
+-true</tt>, executes <tt>rdbuf()-&gt;pubseekpos(pos)</tt>. In
++true</tt>, executes <tt>rdbuf()->pubseekpos(pos)</tt>. In
+ case of success, the function calls clear().
+ In case of failure, the function calls <tt>setstate(failbit)</tt>
+ (which may throw <tt>ios_base::failure</tt>).
+@@ -5728,258 +4764,10 @@ In case of failure, the function calls <tt>setstate(failbit)</tt>
+
+
+ <hr>
+-<h3><a name="343"></a>343. Unspecified library header dependencies</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-10-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The synopses of the C++ library headers clearly show which names are
+-required to be defined in each header. Since in order to implement the
+-classes and templates defined in these headers declarations of other
+-templates (but not necessarily their definitions) are typically
+-necessary the standard in 17.4.4, p1 permits library implementers to
+-include any headers needed to implement the definitions in each header.
+-</p>
+-
+-<p>
+-For instance, although it is not explicitly specified in the synopsis of
+-&lt;string&gt;, at the point of definition of the std::basic_string template
+-the declaration of the std::allocator template must be in scope. All
+-current implementations simply include &lt;memory&gt; from within &lt;string&gt;,
+-either directly or indirectly, to bring the declaration of
+-std::allocator into scope.
+-</p>
+-
+-<p>
+-Additionally, however, some implementation also include &lt;istream&gt; and
+-&lt;ostream&gt; at the top of &lt;string&gt; to bring the declarations of
+-std::basic_istream and std::basic_ostream into scope (which are needed
+-in order to implement the string inserter and extractor operators
+-(21.3.7.9 [lib.string.io])). Other implementations only include
+-&lt;iosfwd&gt;, since strictly speaking, only the declarations and not the
+-full definitions are necessary.
+-</p>
+-
+-<p>
+-Obviously, it is possible to implement &lt;string&gt; without actually
+-providing the full definitions of all the templates std::basic_string
+-uses (std::allocator, std::basic_istream, and std::basic_ostream).
+-Furthermore, not only is it possible, doing so is likely to have a
+-positive effect on compile-time efficiency.
+-</p>
+-
+-<p>
+-But while it may seem perfectly reasonable to expect a program that uses
+-the std::basic_string insertion and extraction operators to also
+-explicitly include &lt;istream&gt; or &lt;ostream&gt;, respectively, it doesn't seem
+-reasonable to also expect it to explicitly include &lt;memory&gt;. Since
+-what's reasonable and what isn't is highly subjective one would expect
+-the standard to specify what can and what cannot be assumed.
+-Unfortunately, that isn't the case.
+-</p>
+-
+-<p>The examples below demonstrate the issue.</p>
+-
+-<p>Example 1:</p>
+-
+-<p>It is not clear whether the following program is complete:</p>
+-
+-<pre>#include &lt;string&gt;
+-
+-extern std::basic_ostream&lt;char&gt; &amp;strm;
+-
+-int main () {
+- strm &lt;&lt; std::string ("Hello, World!\n");
+-}
+-</pre>
+-
+-<p>or whether one must explicitly include &lt;memory&gt; or
+-&lt;ostream&gt; (or both) in addition to &lt;string&gt; in order for
+-the program to compile.</p>
+-
+-
+-<p>Example 2:</p>
+-
+-<p>Similarly, it is unclear whether the following program is complete:</p>
+-
+-<pre>#include &lt;istream&gt;
+-
+-extern std::basic_iostream&lt;char&gt; &amp;strm;
+-
+-int main () {
+- strm &lt;&lt; "Hello, World!\n";
+-}
+-</pre>
+-
+-<p>
+-or whether one needs to explicitly include &lt;ostream&gt;, and
+-perhaps even other headers containing the definitions of other
+-required templates:</p>
+-
+-<pre>#include &lt;ios&gt;
+-#include &lt;istream&gt;
+-#include &lt;ostream&gt;
+-#include &lt;streambuf&gt;
+-
+-extern std::basic_iostream&lt;char&gt; &amp;strm;
+-
+-int main () {
+- strm &lt;&lt; "Hello, World!\n";
+-}
+-</pre>
+-
+-<p>Example 3:</p>
+-
+-<p>Likewise, it seems unclear whether the program below is complete:</p>
+-<pre>#include &lt;iterator&gt;
+-
+-bool foo (std::istream_iterator&lt;int&gt; a, std::istream_iterator&lt;int&gt; b)
+-{
+- return a == b;
+-}
+-
+-int main () { }
+-</pre>
+-
+-<p>or whether one should be required to include &lt;istream&gt;.</p>
+-
+-<p>There are many more examples that demonstrate this lack of a
+-requirement. I believe that in a good number of cases it would be
+-unreasonable to require that a program explicitly include all the
+-headers necessary for a particular template to be specialized, but I
+-think that there are cases such as some of those above where it would
+-be desirable to allow implementations to include only as much as
+-necessary and not more.</p>
+-
+-<p><i>[
+-post Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-Position taken in prior reviews is that the idea of a table of header
+-dependencies is a good one. Our view is that a full paper is needed to
+-do justice to this, and we've made that recommendation to the issue
+-author.
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD. Handled by LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-For every C++ library header, supply a minimum set of other C++ library
+-headers that are required to be included by that header. The proposed
+-list is below (C++ headers for C Library Facilities, table 12 in
+-17.4.1.2, p3, are omitted):
+-</p>
+-
+-<pre>+------------+--------------------+
+-| C++ header |required to include |
+-+============+====================+
+-|&lt;algorithm&gt; | |
+-+------------+--------------------+
+-|&lt;bitset&gt; | |
+-+------------+--------------------+
+-|&lt;complex&gt; | |
+-+------------+--------------------+
+-|&lt;deque&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-|&lt;exception&gt; | |
+-+------------+--------------------+
+-|&lt;fstream&gt; |&lt;ios&gt; |
+-+------------+--------------------+
+-|&lt;functional&gt;| |
+-+------------+--------------------+
+-|&lt;iomanip&gt; |&lt;ios&gt; |
+-+------------+--------------------+
+-|&lt;ios&gt; |&lt;streambuf&gt; |
+-+------------+--------------------+
+-|&lt;iosfwd&gt; | |
+-+------------+--------------------+
+-|&lt;iostream&gt; |&lt;istream&gt;, &lt;ostream&gt;|
+-+------------+--------------------+
+-|&lt;istream&gt; |&lt;ios&gt; |
+-+------------+--------------------+
+-|&lt;iterator&gt; | |
+-+------------+--------------------+
+-|&lt;limits&gt; | |
+-+------------+--------------------+
+-|&lt;list&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-|&lt;locale&gt; | |
+-+------------+--------------------+
+-|&lt;map&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-|&lt;memory&gt; | |
+-+------------+--------------------+
+-|&lt;new&gt; |&lt;exception&gt; |
+-+------------+--------------------+
+-|&lt;numeric&gt; | |
+-+------------+--------------------+
+-|&lt;ostream&gt; |&lt;ios&gt; |
+-+------------+--------------------+
+-|&lt;queue&gt; |&lt;deque&gt; |
+-+------------+--------------------+
+-|&lt;set&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-|&lt;sstream&gt; |&lt;ios&gt;, &lt;string&gt; |
+-+------------+--------------------+
+-|&lt;stack&gt; |&lt;deque&gt; |
+-+------------+--------------------+
+-|&lt;stdexcept&gt; | |
+-+------------+--------------------+
+-|&lt;streambuf&gt; |&lt;ios&gt; |
+-+------------+--------------------+
+-|&lt;string&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-|&lt;strstream&gt; | |
+-+------------+--------------------+
+-|&lt;typeinfo&gt; |&lt;exception&gt; |
+-+------------+--------------------+
+-|&lt;utility&gt; | |
+-+------------+--------------------+
+-|&lt;valarray&gt; | |
+-+------------+--------------------+
+-|&lt;vector&gt; |&lt;memory&gt; |
+-+------------+--------------------+
+-</pre>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>The portability problem is real. A program that works correctly on
+-one implementation might fail on another, because of different header
+-dependencies. This problem was understood before the standard was
+-completed, and it was a conscious design choice.</p>
+-<p>One possible way to deal with this, as a library extension, would
+-be an &lt;all&gt; header.</p>
+-
+-<p>
+-Hinnant: It's time we dealt with this issue for C++0X. Reopened.
+-</p>
+-
+-
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="344"></a>344. grouping + showbase</h3>
+-<p><b>Section:</b> 22.4.2 [category.numeric] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-10-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.2 [category.numeric] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ When both grouping and showbase are active and the basefield is octal,
+@@ -6021,11 +4809,11 @@ consensus in the LWG for action.
+
+ <hr>
+ <h3><a name="348"></a>348. Minor issue with std::pair operator&lt;</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a></p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-active.html#532">532</a></p>
+ <p><b>Discussion:</b></p>
+
+
+@@ -6036,12 +4824,14 @@ operator&lt; on any pair type which contains a pointer.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.3.5 [pairs] paragraph 6, replace:</p>
+-<pre> Returns: x.first &lt; y.first || (!(y.first &lt; x.first) &amp;&amp; x.second &lt;
++<p>In 20.3 [pairs] paragraph 6, replace:</p>
++<pre>
++ Returns: x.first &lt; y.first || (!(y.first &lt; x.first) &amp;&amp; x.second &lt;
+ y.second).
+ </pre>
+ <p>With:</p>
+-<pre> Returns: std::less&lt;T1&gt;()( x.first, y.first ) ||
++<pre>
++ Returns: std::less&lt;T1&gt;()( x.first, y.first ) ||
+ (!std::less&lt;T1&gt;()( y.first, x.first) &amp;&amp;
+ std::less&lt;T2&gt;()( x.second, y.second ) )
+ </pre>
+@@ -6069,11 +4859,11 @@ operator&lt; on any pair type which contains a pointer.
+
+ <hr>
+ <h3><a name="350"></a>350. allocator&lt;&gt;::address</h3>
+-<p><b>Section:</b> 20.9.5.1 [allocator.members], 20.2.5 [allocator.requirements], 17.6.1.1 [contents] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2001-10-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a></p>
++<p><b>Section:</b> 20.7.9.1 [allocator.members], 17.6.3.5 [allocator.requirements], 17.6.1.1 [contents] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2001-10-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#634">634</a></p>
+ <p><b>Discussion:</b></p>
+ <p>See c++std-lib-9006 and c++std-lib-9007. This issue is taken
+ verbatim from -9007.</p>
+@@ -6084,7 +4874,8 @@ to any non-builtin type makes that operator often unsafe to use in
+ implementing libraries, including the Standard Library. The result
+ is that many library facilities fail for legal user code, such as
+ the fragment</p>
+-<pre> class A { private: A* operator&amp;(); };
++<pre>
++ class A { private: A* operator&amp;(); };
+ std::vector&lt;A&gt; aa;
+
+ class B { };
+@@ -6119,7 +4910,8 @@ In 20.1.6, Table 32, add to the Notes column of the a.address(r) and
+ a.address(s) lines, respectively:
+ </p>
+
+-<pre> allocator&lt;T&gt;::address(r)
++<pre>
++ allocator&lt;T&gt;::address(r)
+ allocator&lt;T&gt;::address(s)
+ </pre>
+
+@@ -6134,7 +4926,7 @@ a.address(s) lines, respectively:
+
+ <p><b>Rationale:</b></p>
+ <p>The LWG believes both examples are ill-formed. The contained type
+-is required to be CopyConstructible (20.2.1 [utility.arg.requirements]), and that
++is required to be CopyConstructible (17.6.3.1 [utility.arg.requirements]), and that
+ includes the requirement that &amp;t return the usual types and
+ values. Since allocators are intended to be used in conjunction with
+ containers, and since the CopyConstructible requirements appear to
+@@ -6154,15 +4946,15 @@ exhibiting a problem.</p>
+
+ <hr>
+ <h3><a name="351"></a>351. unary_negate and binary_negate: struct or class?</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Dale Riley <b>Opened:</b> 2001-11-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Dale Riley <b>Opened:</b> 2001-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.8 [function.objects] the header &lt;functional&gt; synopsis declares
++In 20.9 [function.objects] the header &lt;functional&gt; synopsis declares
+ the unary_negate and binary_negate function objects as struct.
+-However in 20.8.9 [negators] the unary_negate and binary_negate
++However in 20.9.9 [negators] the unary_negate and binary_negate
+ function objects are defined as class. Given the context, they are
+ not "basic function objects" like negate, so this is either a typo or
+ an editorial oversight.
+@@ -6173,9 +4965,9 @@ an editorial oversight.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change the synopsis to reflect the useage in 20.8.9 [negators]</p>
++<p>Change the synopsis to reflect the useage in 20.9.9 [negators]</p>
+
+-<p><i>[Curaçao: Since the language permits "struct", the LWG
++<p><i>[Cura&ccedil;ao: Since the language permits &quot;struct&quot;, the LWG
+ views this as NAD. They suggest, however, that the Project Editor
+ might wish to make the change as editorial.]</i></p>
+
+@@ -6187,15 +4979,16 @@ might wish to make the change as editorial.]</i></p>
+
+ <hr>
+ <h3><a name="356"></a>356. Meaning of ctype_base::mask enumerators</h3>
+-<p><b>Section:</b> 22.4.1 [category.ctype] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#category.ctype">issues</a> in [category.ctype].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.1 [category.ctype] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#category.ctype">issues</a> in [category.ctype].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>What should the following program print?</p>
+
+-<pre> #include &lt;locale&gt;
++<pre>
++ #include &lt;locale&gt;
+ #include &lt;iostream&gt;
+
+ class my_ctype : public std::ctype&lt;char&gt;
+@@ -6260,8 +5053,8 @@ lib-9224, lib-9226, lib-9229, lib-9270, lib-9272, lib-9273, lib-9274,
+ lib-9277, lib-9279.
+ </p>
+
+-<p>Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#339">339</a> is related, but not identical. The
+-proposed resolution if issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#339">339</a> says that
++<p>Issue <a href="lwg-defects.html#339">339</a> is related, but not identical. The
++proposed resolution if issue <a href="lwg-defects.html#339">339</a> says that
+ ctype_base::mask must be a bitmask type. It does not say that the
+ ctype_base::mask elements are bitmask elements, so it doesn't
+ directly affect this issue.</p>
+@@ -6271,7 +5064,8 @@ that C99 compatibility essentially requires what we're
+ calling option 1 below.</p>
+
+ <blockquote>
+-<pre>I think the C99 standard is clear, that isspace -&gt; !isalpha.
++<pre>
++I think the C99 standard is clear, that isspace -&gt; !isalpha.
+ --------
+
+ #include &lt;locale&gt;
+@@ -6342,10 +5136,11 @@ to see which interpretation is being used.</p>
+
+ <hr>
+ <h3><a name="357"></a>357. &lt;cmath&gt; float functions cannot return HUGE_VAL</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The float versions of the math functions have no meaningful value to return
+@@ -6368,7 +5163,7 @@ positive double expression, not necessarily representable as a float."
+
+ <p>
+ Therefore, the float versions of the math functions have no way to
+-signal a range error. <i>[Curaçao: The LWG notes that this isn't
++signal a range error. <i>[Cura&ccedil;ao: The LWG notes that this isn't
+ strictly correct, since errno is set.]</i> The semantics require that they
+ return HUGE_VAL, but they cannot because HUGE_VAL might not be
+ representable as a float.
+@@ -6384,11 +5179,11 @@ long double function to return a double (HUGE_VAL) for a range error.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Curaçao: C99 was faced with a similar problem, which they fixed by
++<p>Cura&ccedil;ao: C99 was faced with a similar problem, which they fixed by
+ adding HUGE_VALF and HUGE_VALL in addition to HUGE_VAL.</p>
+
+ <p>C++ must also fix, but it should be done in the context of the
+-general C99 based changes to C++, not via DR. Thus the LWG in Curaçao
++general C99 based changes to C++, not via DR. Thus the LWG in Cura&ccedil;ao
+ felt the resolution should be NAD, FUTURE, but the issue is being held
+ open for one more meeting to ensure LWG members not present during the
+ discussion concur.</p>
+@@ -6403,10 +5198,10 @@ discussion concur.</p>
+
+ <hr>
+ <h3><a name="361"></a>361. num_get&lt;&gt;::do_get (..., void*&amp;) checks grouping</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.2.2.2.2, p12 specifies that <tt>thousands_sep</tt> is to be inserted only
+@@ -6457,10 +5252,10 @@ Change the first sentence of 22.2.2.2.2, p12 from
+
+ <hr>
+ <h3><a name="366"></a>366. Excessive const-qualification</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The following member functions are declared const, yet return non-const
+@@ -6483,86 +5278,106 @@ those terms, does not appear in the standard.]</i></p>
+ <p><b>Proposed resolution:</b></p>
+ <p>In 27.4.4 and 27.4.4.2</p>
+ <p>Replace</p>
+-<pre> basic_ostream&lt;charT,traits&gt;* tie() const;
++<pre>
++ basic_ostream&lt;charT,traits&gt;* tie() const;
+ </pre>
+ <p>with</p>
+-<pre> basic_ostream&lt;charT,traits&gt;* tie();
++<pre>
++ basic_ostream&lt;charT,traits&gt;* tie();
+ const basic_ostream&lt;charT,traits&gt;* tie() const;
+ </pre>
+
+ <p>and replace</p>
+-<pre> basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
++<pre>
++ basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
+ </pre>
+ <p>with</p>
+-<pre> basic_streambuf&lt;charT,traits&gt;* rdbuf();
++<pre>
++ basic_streambuf&lt;charT,traits&gt;* rdbuf();
+ const basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
+ </pre>
+
+ <p>In 27.5.2 and 27.5.2.3.1</p>
+ <p>Replace</p>
+-<pre> char_type* eback() const;
++<pre>
++ char_type* eback() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* eback();
++<pre>
++ char_type* eback();
+ const char_type* eback() const;
+ </pre>
+
+ <p>Replace</p>
+-<pre> char_type gptr() const;
++<pre>
++ char_type gptr() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* gptr();
++<pre>
++ char_type* gptr();
+ const char_type* gptr() const;
+ </pre>
+
+ <p>Replace</p>
+-<pre> char_type* egptr() const;
++<pre>
++ char_type* egptr() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* egptr();
++<pre>
++ char_type* egptr();
+ const char_type* egptr() const;
+ </pre>
+
+ <p>In 27.5.2 and 27.5.2.3.2</p>
+ <p>Replace</p>
+-<pre> char_type* pbase() const;
++<pre>
++ char_type* pbase() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* pbase();
++<pre>
++ char_type* pbase();
+ const char_type* pbase() const;
+ </pre>
+
+ <p>Replace</p>
+-<pre> char_type* pptr() const;
++<pre>
++ char_type* pptr() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* pptr();
++<pre>
++ char_type* pptr();
+ const char_type* pptr() const;
+ </pre>
+
+ <p>Replace</p>
+-<pre> char_type* epptr() const;
++<pre>
++ char_type* epptr() const;
+ </pre>
+ <p>with</p>
+-<pre> char_type* epptr();
++<pre>
++ char_type* epptr();
+ const char_type* epptr() const;
+ </pre>
+
+ <p>In 27.7.2, 27.7.2.2, 27.7.3 27.7.3.2, 27.7.4, and 27.7.6</p>
+ <p>Replace</p>
+-<pre> basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
++<pre>
++ basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
+ </pre>
+ <p>with</p>
+-<pre> basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf();
++<pre>
++ basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf();
+ const basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
+ </pre>
+
+ <p>In 27.8.1.5, 27.8.1.7, 27.8.1.8, 27.8.1.10, 27.8.1.11, and 27.8.1.13</p>
+ <p>Replace</p>
+-<pre> basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
++<pre>
++ basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
+ </pre>
+ <p>with</p>
+-<pre> basic_filebuf&lt;charT,traits&gt;* rdbuf();
++<pre>
++ basic_filebuf&lt;charT,traits&gt;* rdbuf();
+ const basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
+ </pre>
+
+@@ -6581,10 +5396,10 @@ those terms, does not appear in the standard.]</i></p>
+
+ <hr>
+ <h3><a name="367"></a>367. remove_copy/remove_copy_if and Input Iterators</h3>
+-<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2002-05-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2002-05-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ remove_copy and remove_copy_if (25.3.8 [alg.remove]) permit their
+@@ -6618,10 +5433,10 @@ constructible. Otherwise copy constructible is not required." to
+
+ <hr>
+ <h3><a name="368"></a>368. basic_string::replace has two "Throws" paragraphs</h3>
+-<p><b>Section:</b> 21.4.6.6 [string::replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2002-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::replace">issues</a> in [string::replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 21.4.6.6 [string::replace] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2002-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::replace">issues</a> in [string::replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 21.4.6.6 [string::replace] basic_string::replace, second
+@@ -6651,13 +5466,13 @@ part of the "Effects" paragraph.
+
+ <hr>
+ <h3><a name="372"></a>372. Inconsistent description of stdlib exceptions</h3>
+-<p><b>Section:</b> 17.6.4.12 [res.on.exception.handling], 18.7.1 [type.info] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Randy Maddox <b>Opened:</b> 2002-07-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.exception.handling">issues</a> in [res.on.exception.handling].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.5.12 [res.on.exception.handling], 18.7.1 [type.info] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Randy Maddox <b>Opened:</b> 2002-07-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.exception.handling">issues</a> in [res.on.exception.handling].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>Paragraph 3 under clause 17.6.4.12 [res.on.exception.handling], Restrictions on
++<p>Paragraph 3 under clause 17.6.5.12 [res.on.exception.handling], Restrictions on
+ Exception Handling, states that "Any other functions defined in the
+ C++ Standard Library that do not have an exception-specification may
+ throw implementation-defined exceptions unless otherwise specified."
+@@ -6691,9 +5506,9 @@ Standard library components ...".</p>
+
+ <hr>
+ <h3><a name="374"></a>374. moneypunct::frac_digits returns int not unsigned</h3>
+-<p><b>Section:</b> 22.4.6.3.1 [locale.moneypunct.members], 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.6.3.1 [locale.moneypunct.members], 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In section 22.4.6.3.1 [locale.moneypunct.members], frac_digits() returns type
+@@ -6724,14 +5539,14 @@ checks.</p>
+
+ <hr>
+ <h3><a name="377"></a>377. basic_string::insert and length_error</h3>
+-<p><b>Section:</b> 21.4.6.4 [string::insert] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::insert">issues</a> in [string::insert].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 21.4.6.4 [string::insert] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::insert">issues</a> in [string::insert].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 21.4.6.4 [string::insert], paragraph 4, contains the following,
+-"Then throws length_error if size() &gt;= npos - rlen."
++"Then throws length_error if size() >= npos - rlen."
+ </p>
+
+ <p>
+@@ -6750,23 +5565,25 @@ needed.</p>
+
+ <hr>
+ <h3><a name="378"></a>378. locale immutability and locale::operator=()</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a></p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#31">31</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I think there is a problem with 22.1.1, p6 which says that
+ </p>
+-<pre> -6- An instance of locale is immutable; once a facet reference
++<pre>
++ -6- An instance of locale is immutable; once a facet reference
+ is obtained from it, that reference remains usable as long
+ as the locale value itself exists.
+ </pre>
+ <p>
+ and 22.1.1.2, p4:
+ </p>
+-<pre> const locale&amp; operator=(const locale&amp; other) throw();
++<pre>
++ const locale&amp; operator=(const locale&amp; other) throw();
+
+ -4- Effects: Creates a copy of other, replacing the current value.
+ </pre>
+@@ -6775,10 +5592,11 @@ How can a reference to a facet obtained from a locale object remain
+ valid after an assignment that clearly must replace all the facets
+ in the locale object? Imagine a program such as this
+ </p>
+-<pre> std::locale loc ("de_DE");
+- const std::ctype&lt;char&gt; &amp;r0 = std::use_facet&lt;std::ctype&lt;char&gt; &gt;(loc);
++<pre>
++ std::locale loc ("de_DE");
++ const std::ctype&lt;char> &amp;r0 = std::use_facet&lt;std::ctype&lt;char> >(loc);
+ loc = std::locale ("en_US");
+- const std::ctype&lt;char&gt; &amp;r1 = std::use_facet&lt;std::ctype&lt;char&gt; &gt;(loc);
++ const std::ctype&lt;char> &amp;r1 = std::use_facet&lt;std::ctype&lt;char> >(loc);
+ </pre>
+ <p>
+ Is r0 really supposed to be preserved and destroyed only when loc goes
+@@ -6788,7 +5606,7 @@ out of scope?
+
+ <p><b>Proposed resolution:</b></p>
+ <p><i>[Summer '04 mid-meeting mailing: Martin and Dietmar believe this
+- is a duplicate of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a> and recommend that it be
++ is a duplicate of issue <a href="lwg-defects.html#31">31</a> and recommend that it be
+ closed.
+ ]</i></p>
+
+@@ -6799,10 +5617,10 @@ out of scope?
+
+ <hr>
+ <h3><a name="382"></a>382. codecvt do_in/out result</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It seems that the descriptions of codecvt do_in() and do_out() leave
+@@ -6939,11 +5757,11 @@ NAD without prejudice. Will reopen if proposed resolution is supplied.
+
+ <hr>
+ <h3><a name="385"></a>385. Does call by value imply the CopyConstructible requirement?</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Many function templates have parameters that are passed by value;
+@@ -6982,7 +5800,7 @@ not be allowed.
+ <p><i>[
+ 2007-01-12, Howard: First, despite the note above, references <b>are</b>
+ copy constructible. They just aren't assignable. Second, this is very
+-closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a> and should be consistent with that.
++closely related to <a href="lwg-defects.html#92">92</a> and should be consistent with that.
+ That issue already says that implementations are allowed to copy
+ function objects. If one passes in a reference, it is copyable, but
+ susceptible to slicing if one passes in a reference to a base. Third,
+@@ -6993,8 +5811,8 @@ CopyConstructible). Finally (and fwiw), if we wanted to, it is easy to
+ code all of the std::algorithms such that they do not copy function
+ objects internally. One merely passes them by reference internally if
+ desired (this has been fully implemented and shipped for several years).
+- If this were mandated, it would reverse <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>, allowing
+-function objects to reliably maintain state. E.g. the example in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a> would reliably remove only the third element.
++ If this were mandated, it would reverse <a href="lwg-defects.html#92">92</a>, allowing
++function objects to reliably maintain state. E.g. the example in <a href="lwg-defects.html#92">92</a> would reliably remove only the third element.
+ ]</i></p>
+
+
+@@ -7017,35 +5835,36 @@ then precisely describe and enforce the precise requirements.
+
+
+ <hr>
+-<h3><a name="388"></a>388. Use of complex as a key in associative containers</h3>
+-<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="388"></a>388. Use of <tt>complex</tt> as a key in associative containers</h3>
++<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#complex.numbers">active issues</a> in [complex.numbers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Practice with std::complex&lt;&gt; and the associative containers
++Practice with <tt>std::complex&lt;&gt;</tt> and the associative containers
+ occasionally reveals artificial and distracting issues with constructs
+-resembling: std::set&lt;std::complex&lt;double&gt; &gt; s;
++resembling: <tt>std::set&lt;std::complex&lt;double&gt; &gt; s;</tt>
+ </p>
+
+ <p>
+-The main reason for the above to fail is the absence of an approriate
+-definition for std::less&lt;std::complex&lt;T&gt; &gt;. That in turn comes from
+-the definition of the primary template std::less&lt;&gt; in terms of
+-operator&lt;.
++The main reason for the above to fail is the absence of an appropriate
++definition for <tt>std::less&lt;std::complex&lt;T&gt; &gt;</tt>. That in turn comes from
++the definition of the primary template <tt>std::less&lt;&gt;</tt> in terms of
++<tt>operator&lt;</tt>.
+ </p>
+
+ <p>
+ The usual argument goes as follows: Since there is no ordering over
+ the complex field compatible with field operations it makes little
+-sense to define a function operator&lt; operating on the datatype
+-std::complex&lt;T&gt;. That is fine. However, that reasoning does not carry
+-over to std::less&lt;T&gt; which is used, among other things, by associative
++sense to define a function <tt>operator&lt;</tt> operating on the datatype
++<tt>std::complex&lt;T&gt;</tt>. That is fine. However, that reasoning does not carry
++over to <tt>std::less&lt;T&gt;</tt> which is used, among other things, by associative
+ containers as an ordering useful to meet complexity requirements.
+ </p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>.</p>
++<p>Related issue: <a href="lwg-closed.html#348">348</a>.</p>
+
+ <p><i>[
+ Pre Bellevue: Reopened at the request of Alisdair.
+@@ -7057,7 +5876,7 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This is a request for a design change, and not a defect in the standard.
+ It is in scope to consider, but the group feels that it is not a change
+ that we need to do. Is there a total ordering for floating point values,
+@@ -7065,13 +5884,13 @@ including NaN? There is not a clear enough solution or big enough
+ problem for us to solve. Solving this problem would require solving the
+ problem for floating point, which is equally unclear. The LWG noted that
+ users who want to put objects into an associative container for which
+-operator&lt; isn't defined can simply provide their own comparison function
+-object. NAD
+-</blockquote>
++<tt>operator&lt;</tt> isn't defined can simply provide their own comparison
++function object. NAD
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Informally: Add a specialization of std::less for std::complex.</p>
++<p>Informally: Add a specialization of <tt>std::less</tt> for <tt>std::complex</tt>.</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -7079,7 +5898,7 @@ object. NAD
+ believes this should not be treated a DR: it's a request for a design
+ change, not a defect in the existing standard. Most people (10-3)
+ believed that we probably don't want this change, period: as with
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>, it's hard to know where to draw the line.
++issue <a href="lwg-closed.html#348">348</a>, it's hard to know where to draw the line.
+ The LWG noted that users who want to put objects into an associative
+ container for which <tt>operator&lt;</tt> isn't defined can simply
+ provide their own comparison function object.</p>
+@@ -7090,24 +5909,26 @@ provide their own comparison function object.</p>
+
+ <hr>
+ <h3><a name="390"></a>390. CopyConstructible requirements too strict</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2002-10-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2002-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The CopyConstructible requirements in Table 30 state that for an
+ object t of type T (where T is CopyConstructible), the expression &amp;t
+ returns the address of t (with type T*). This requirement is overly
+ strict, in that it disallows types that overload operator&amp; to not
+-return a value of type T*. This occurs, for instance, in the <a href="http://www.boost.org/libs/lambda">Boost.Lambda</a> library, where
++return a value of type T*. This occurs, for instance, in the <a
++href="http://www.boost.org/libs/lambda">Boost.Lambda</a> library, where
+ operator&amp; is overloaded for a Boost.Lambda function object to return
+ another function object.
+ </p>
+
+ <p>Example:</p>
+
+-<pre> std::vector&lt;int&gt; u, v;
++<pre>
++ std::vector&lt;int&gt; u, v;
+ int x;
+ // ...
+ std::transform(u.begin(), u.end(), std::back_inserter(v), _1 * x);
+@@ -7126,7 +5947,8 @@ For reference, the address of an object can be retrieved without using
+ the address-of operator with the following function template:
+ </p>
+
+-<pre> template &lt;typename T&gt; T* addressof(T&amp; v)
++<pre>
++ template &lt;typename T&gt; T* addressof(T&amp; v)
+ {
+ return reinterpret_cast&lt;T*&gt;(
+ &amp;const_cast&lt;char&amp;&gt;(reinterpret_cast&lt;const volatile char &amp;&gt;(v)));
+@@ -7134,7 +5956,7 @@ the address-of operator with the following function template:
+ </pre>
+
+ <p>
+-Note: this relates directly to library issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, which
++Note: this relates directly to library issue <a href="lwg-closed.html#350">350</a>, which
+ will need to be reexamined if the CopyConstructible requirements
+ change.
+ </p>
+@@ -7157,10 +5979,10 @@ that &amp;t and &amp;u return the address of t and u, respectively.
+
+ <hr>
+ <h3><a name="392"></a>392. 'equivalence' for input iterators</h3>
+-<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Corwin Joy <b>Opened:</b> 2002-12-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Corwin Joy <b>Opened:</b> 2002-12-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -7183,7 +6005,8 @@ are incorrect. (Or both).
+ </p>
+
+ <p>Consider the following example:</p>
+-<pre> #include &lt;iostream&gt;
++<pre>
++ #include &lt;iostream&gt;
+ #include &lt;fstream&gt;
+ #include &lt;iterator&gt;
+ using namespace std;
+@@ -7222,10 +6045,10 @@ of input iterators.</p>
+
+ <hr>
+ <h3><a name="393"></a>393. do_in/do_out operation on state unclear</h3>
+-<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alberto Barbati <b>Opened:</b> 2002-12-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alberto Barbati <b>Opened:</b> 2002-12-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ this DR follows the discussion on the previous thread "codecvt::do_in
+@@ -7284,9 +6107,9 @@ correct. Proposed Disposition: NAD, Editorial
+
+ <hr>
+ <h3><a name="394"></a>394. behavior of formatted output on failure</h3>
+-<p><b>Section:</b> 27.7.2.6.1 [ostream.formatted.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-12-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.3.6.1 [ostream.formatted.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-12-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is a contradiction in Formatted output about what bit is
+@@ -7297,7 +6120,8 @@ badbit and another that it's failbit.
+ 27.6.2.5.1, p1 says in the Common Requirements on Formatted output
+ functions:
+ </p>
+-<pre> ... If the generation fails, then the formatted output function
++<pre>
++ ... If the generation fails, then the formatted output function
+ does setstate(ios::failbit), which might throw an exception.
+ </pre>
+ <p>
+@@ -7307,9 +6131,10 @@ functions:
+ ... The formatting conversion occurs as if it performed the
+ following code fragment:
+ </p>
+-<pre> bool failed =
+- use_facet&lt;num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt;
+- &gt; &gt;
++<pre>
++ bool failed =
++ use_facet&lt;num_put&lt;charT,ostreambuf_iterator&lt;charT,traits>
++ > >
+ (getloc()).put(*this, *this, fill(), val). failed();
+
+ ... If failed is true then does setstate(badbit) ...
+@@ -7380,9 +6205,9 @@ functions should be changed as proposed below.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. This issue is already fixed.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -7397,11 +6222,11 @@ NAD. This issue is already fixed.
+
+
+ <hr>
+-<h3><a name="397"></a>397. ostream::sentry dtor throws exceptions</h3>
+-<p><b>Section:</b> 27.7.2.4 [ostream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="397"></a>397. <tt>ostream::sentry</tt> dtor throws exceptions</h3>
++<p><b>Section:</b> 27.7.3.4 [ostream::sentry] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 17.4.4.8, p3 prohibits library dtors from throwing exceptions.
+@@ -7409,13 +6234,15 @@ NAD. This issue is already fixed.
+ <p>
+ 27.6.2.3, p4 says this about the ostream::sentry dtor:
+ </p>
+- <pre> -4- If ((os.flags() &amp; ios_base::unitbuf) &amp;&amp; !uncaught_exception())
++ <pre>
++ -4- If ((os.flags() &amp; ios_base::unitbuf) &amp;&amp; !uncaught_exception())
+ is true, calls os.flush().
+ </pre>
+ <p>
+ 27.6.2.6, p7 that describes ostream::flush() says:
+ </p>
+- <pre> -7- If rdbuf() is not a null pointer, calls rdbuf()-&gt;pubsync().
++ <pre>
++ -7- If rdbuf() is not a null pointer, calls rdbuf()->pubsync().
+ If that function returns ?-1 calls setstate(badbit) (which
+ may throw ios_base::failure (27.4.4.3)).
+ </pre>
+@@ -7435,7 +6262,7 @@ sentry::~sentry() should internally catch any exceptions it might cause.
+
+
+ <p><i>[
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">418</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a> for related issues.
++See <a href="lwg-closed.html#418">418</a> and <a href="lwg-defects.html#622">622</a> for related issues.
+ ]</i></p>
+
+
+@@ -7446,7 +6273,7 @@ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">41
+
+ <blockquote>
+ <p>
+-Move to Review. Add "Throws: nothing" to the specification of ostream::sentry::~sentry().
++Move to Review. Add "Throws: nothing" to the specification of <tt>ostream::sentry::~sentry()</tt>.
+ </p>
+ </blockquote>
+
+@@ -7455,19 +6282,19 @@ Move to Review. Add "Throws: nothing" to the specification of ostream::sentry::~
+ ]</i></p>
+
+
+-<blockquote>
+-The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a> is written to match the outcome
++<blockquote><p>
++The proposed resolution of <a href="lwg-defects.html#835">835</a> is written to match the outcome
+ of this issue.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to Open. Our intent is to solve this issue with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>.
+-</blockquote>
++<blockquote><p>
++Move to Open. Our intent is to solve this issue with <a href="lwg-defects.html#835">835</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-06 Martin updates wording.
+@@ -7479,25 +6306,26 @@ Move to Open. Our intent is to solve this issue with <a href="http://www.open-s
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+ <p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>.
++Solved by <a href="lwg-defects.html#835">835</a>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add after 27.7.2.4 [ostream::sentry] p17:
++Add after 27.7.3.4 [ostream::sentry] p17:
+ </p>
+
+ <blockquote>
+-<pre>~sentry();
++<pre>
++~sentry();
+ </pre>
+ <blockquote>
+ <p>
+@@ -7517,10 +6345,10 @@ is <tt>true</tt>, calls <tt>os.flush()</tt>.
+
+ <hr>
+ <h3><a name="398"></a>398. effects of end-of-file on unformatted input functions</h3>
+-<p><b>Section:</b> 27.7.2.4 [ostream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.3.4 [ostream::sentry] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ While reviewing unformatted input member functions of istream
+@@ -7535,40 +6363,47 @@ The following unformatted input member functions set eofbit if they
+ encounter an end-of-file (this is the expected behavior, and also
+ the behavior of all major implementations):
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ get (char_type*, streamsize, char_type);
+ </pre>
+ <p>
+ Also sets failbit if it fails to extract any characters.
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ get (char_type*, streamsize);
+ </pre>
+ <p>
+ Also sets failbit if it fails to extract any characters.
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ getline (char_type*, streamsize, char_type);
+ </pre>
+ <p>
+ Also sets failbit if it fails to extract any characters.
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ getline (char_type*, streamsize);
+ </pre>
+ <p>
+ Also sets failbit if it fails to extract any characters.
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ ignore (int, int_type);
+ </pre>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ read (char_type*, streamsize);
+ </pre>
+ <p>
+ Also sets failbit if it encounters end-of-file.
+ </p>
+- <pre> streamsize readsome (char_type*, streamsize);
++ <pre>
++ streamsize readsome (char_type*, streamsize);
+ </pre>
+
+ <p>
+@@ -7579,9 +6414,11 @@ failure from a failure due to end-of-file; the requirement is
+ also in conflict with all major implementation which set both
+ eofbit and failbit):
+ </p>
+- <pre> int_type get();
++ <pre>
++ int_type get();
+ </pre>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
+ get (char_type&amp;);
+ </pre>
+ <p>
+@@ -7591,18 +6428,21 @@ inconsistency quite unexpected; the requirement is also in
+ conflict with all major implementations which set eofbit
+ whenever they encounter end-of-file):
+ </p>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
+- get (basic_streambuf&lt;charT, traits&gt;&amp;, char_type);
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
++ get (basic_streambuf&lt;charT, traits>&amp;, char_type);
+ </pre>
+- <pre> basic_istream&lt;charT, traits&gt;&amp;
+- get (basic_streambuf&lt;charT, traits&gt;&amp;);
++ <pre>
++ basic_istream&lt;charT, traits>&amp;
++ get (basic_streambuf&lt;charT, traits>&amp;);
+ </pre>
+ <p>
+ This function sets no bits (all implementations except for
+ STLport and Classic Iostreams set eofbit when they encounter
+ end-of-file):
+ </p>
+- <pre> int_type peek ();
++ <pre>
++ int_type peek ();
+ </pre>
+ <p>Informally, what we want is a global statement of intent saying
+ that eofbit gets set if we trip across EOF, and then we can take
+@@ -7616,9 +6456,9 @@ end-of-file):
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to NAD. See 27.7.1.1 [istream] p3.
+-</blockquote>
++<blockquote><p>
++Moved to NAD. See 27.7.2.1 [istream] p3.
++</p></blockquote>
+
+
+
+@@ -7629,10 +6469,11 @@ Moved to NAD. See 27.7.1.1 [istream] p3.
+
+ <hr>
+ <h3><a name="399"></a>399. volations of unformatted input function requirements</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The Effects clauses for the two functions below violate the
+@@ -7648,9 +6489,9 @@ Note that in light of 27.6.1.1, p3 and p4, the fact that the
+ functions allow exceptions thrown from widen() to propagate
+ may not strictly speaking be a defect (but the fact that the
+ functions do not start by constructing a sentry object still
+-is). However, since an exception thrown from ctype&lt;charT&gt;
++is). However, since an exception thrown from ctype&lt;charT>
+ ::widen() during any other input operation (say, from within
+-a call to num_get&lt;charT&gt;::get()) will be caught and cause
++a call to num_get&lt;charT>::get()) will be caught and cause
+ badbit to be set, these two functions should not be treated
+ differently for the sake of consistency.
+ </p>
+@@ -7675,11 +6516,11 @@ can use alternative signatures that don't call widen.
+
+
+ <hr>
+-<h3><a name="408"></a>408. Is vector&lt;reverse_iterator&lt;char*&gt; &gt; forbidden?</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="408"></a>408. Is <tt>vector&lt;reverse_iterator&lt;char*&gt; &gt;</tt> forbidden?</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I've been discussing iterator semantics with Dave Abrahams, and a
+@@ -7691,10 +6532,11 @@ X [iterator.concepts] says that the only operation that can be performed on "sin
+ iterator values is to assign a non-singular value to them. (It
+ doesn't say they can be destroyed, and that's probably a defect.)
+ Some implementations have taken this to imply that there is no need
+-to initialize the data member of a reverse_iterator&lt;&gt; in the default
++to initialize the data member of a <tt>reverse_iterator&lt;&gt;</tt> in the default
+ constructor. As a result, code like
+ </p>
+-<blockquote><pre> std::vector&lt;std::reverse_iterator&lt;char*&gt; &gt; v(7);
++<blockquote><pre>
++ std::vector&lt;std::reverse_iterator&lt;char*&gt; &gt; v(7);
+ v.reserve(1000);
+ </pre></blockquote>
+ <p>
+@@ -7718,7 +6560,8 @@ One question is whether the standard iterator adaptors have defined
+ copy semantics. Another is whether they have defined destructor
+ semantics: is
+ </p>
+-<blockquote><pre> { std::vector&lt;std::reverse_iterator&lt;char*&gt; &gt; v(7); }
++<blockquote><pre>
++ { std::vector&lt;std::reverse_iterator&lt;char*&gt; &gt; v(7); }
+ </pre></blockquote>
+ <p>
+ undefined too?
+@@ -7730,12 +6573,12 @@ rely on copy semantics for arbitrary iterators, just whether the
+ types we actually supply support those operations. I believe the
+ resolution must be expressed in terms of the semantics of the
+ adapter's argument type. It should make clear that, e.g., the
+-reverse_iterator&lt;T&gt; constructor is actually required to execute
+-T(), and so copying is defined if the result of T() is copyable.
++<tt>reverse_iterator&lt;T&gt;</tt> constructor is actually required to execute
++<tt>T()</tt>, and so copying is defined if the result of <tt>T()</tt> is copyable.
+ </p>
+
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, which defines reverse_iterator's default
++Issue <a href="lwg-defects.html#235">235</a>, which defines <tt>reverse_iterator</tt>'s default
+ constructor more precisely, has some relevance to this issue.
+ However, it is not the whole story.
+ </p>
+@@ -7743,37 +6586,40 @@ However, it is not the whole story.
+ <p>
+ The issue was whether
+ </p>
+-<blockquote><pre> reverse_iterator() { }
++<blockquote><pre>
++ reverse_iterator() { }
+ </pre></blockquote>
+ <p>
+ is allowed, vs.
+ </p>
+-<blockquote><pre> reverse_iterator() : current() { }
++<blockquote><pre>
++ reverse_iterator() : current() { }
+ </pre></blockquote>
+
+ <p>
+-The difference is when T is char*, where the first leaves the member
++The difference is when <tt>T</tt> is <tt>char*</tt>, where the first leaves the member
+ uninitialized, and possibly equal to an existing pointer value, or
+ (on some targets) may result in a hardware trap when copied.
+ </p>
+
+ <p>
+ 8.5 paragraph 5 seems to make clear that the second is required to
+-satisfy DR <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, at least for non-class Iterator argument
++satisfy DR <a href="lwg-defects.html#235">235</a>, at least for non-class Iterator argument
+ types.
+ </p>
+
+ <p>
+-But that only takes care of reverse_iterator, and doesn't establish
++But that only takes care of <tt>reverse_iterator</tt>, and doesn't establish
+ a policy for all iterators. (The reverse iterator adapter was just
+ an example.) In particular, does my function
+ </p>
+-<blockquote><pre> template &lt;typename Iterator&gt;
++<blockquote><pre>
++ template &lt;typename Iterator&gt;
+ void f() { std::vector&lt;Iterator&gt; v(7); }
+ </pre></blockquote>
+ <p>
+ evoke undefined behavior for some conforming iterator definitions?
+-I think it does, now, because vector&lt;&gt; will destroy those singular
++I think it does, now, because <tt>vector&lt;&gt;</tt> will destroy those singular
+ iterator values, and that's explicitly disallowed.
+ </p>
+
+@@ -7785,7 +6631,7 @@ are default-initialized, and it should explicitly allow destroying any
+ iterator value, singular or not, default-initialized or not.
+ </p>
+
+-<p>Related issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#407">407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a></p>
++<p>Related issues: <a href="lwg-defects.html#407">407</a>, <a href="lwg-defects.html#1012">1012</a></p>
+ <p><i>[
+ We don't want to require all singular iterators to be copyable,
+ because that is not the case for pointers. However, default
+@@ -7802,10 +6648,10 @@ wrong to impose so strict a requirement for iterators.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The comments regarding destroying singular iterators have already been
+ resolved. That just leaves copying (with moving implied).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -7814,18 +6660,18 @@ resolved. That just leaves copying (with moving implied).
+
+ <blockquote>
+ <p>
+-This is related to LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>.
++This is related to LWG <a href="lwg-defects.html#1012">1012</a>.
+ </p>
+ <p>
+-Note that there is a bug in the proposed resolution to LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>. The
++Note that there is a bug in the proposed resolution to LWG <a href="lwg-defects.html#1012">1012</a>. The
+ change to [reverse.iter.con] should be modified so that the word
+ "default" in the second sentence of the Effects clause is replaced by
+ "value."
+ </p>
+ <p>
+-We believe that the proposed fix to LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a> (now corrected) is
++We believe that the proposed fix to LWG <a href="lwg-defects.html#1012">1012</a> (now corrected) is
+ sufficient to solve the problem for reverse_iterator. However, Alisdair
+-pointed out that LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a> does not solve the general problem for authors
++pointed out that LWG <a href="lwg-defects.html#1012">1012</a> does not solve the general problem for authors
+ of iterator adaptors.
+ </p>
+ <p>
+@@ -7845,7 +6691,7 @@ Move to Review after Alisdair updates the wording.
+
+ <p><i>[
+ 2009-08-17 Alisdair and Daniel collaborate on slightly revised wording.
+-This issue depends upon <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>
++This issue depends upon <a href="lwg-defects.html#724">724</a>
+ ]</i></p>
+
+
+@@ -7854,20 +6700,20 @@ This issue depends upon <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg
+ ]</i></p>
+
+
+-<blockquote>
+-There is a clear dependency on <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, because the term "singular",
++<blockquote><p>
++There is a clear dependency on <a href="lwg-active.html#1213">1213</a>, because the term "singular",
+ which is used as part of the resolution, is not properly defined yet.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Open. Alisdair will provide improved wording to make
+ this have "value semantics" and otherwise behave like a valid iterator.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+@@ -7899,7 +6745,7 @@ Values of an iterator <tt>i</tt> for which the expression <tt>*i</tt> is defined
+ dereferenceable. Iterators can also have singular values that are not
+ associated with any container. [<i>Example:</i> After the declaration of an
+ uninitialized pointer <tt>x</tt> (as with <tt>int* x;</tt>), <tt>x</tt> must always be assumed to
+-have a singular value of a pointer. — <i>end example</i>] Results of most
++have a singular value of a pointer. &mdash; <i>end example</i>] Results of most
+ expressions are undefined for singular values; the only exceptions are
+ destroying an iterator that holds a singular value and the assignment of
+ a non-singular value to an iterator that holds a singular value. In this
+@@ -7913,7 +6759,7 @@ when used <ins>as</ins> the
+ source of a copy or move operation, even if it would
+ otherwise be singular. [<i>Note:</i> This guarantee is not offered for
+ default-initialization (8.5 [dcl.init]), although the distinction only
+-matters for types with trivial default constructors such as pointers. —
++matters for types with trivial default constructors such as pointers. &mdash;
+ <i>end note</i>]
+ </ins></p>
+
+@@ -7926,24 +6772,24 @@ matters for types with trivial default constructors such as pointers.
+
+
+ <hr>
+-<h3><a name="417"></a>417. what does ctype::do_widen() return on failure</h3>
+-<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="417"></a>417. what does <tt>ctype::do_widen()</tt> return on failure</h3>
++<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The Effects and Returns clauses of the do_widen() member function of
+-the ctype facet fail to specify the behavior of the function on failure.
++The Effects and Returns clauses of the <tt>do_widen()</tt> member function of
++the <tt>ctype</tt> facet fail to specify the behavior of the function on failure.
+ That the function may not be able to simply cast the narrow character
+ argument to the type of the result since doing so may yield the wrong value
+-for some wchar_t encodings. Popular implementations of ctype&lt;wchar_t&gt; that
+-use mbtowc() and UTF-8 as the native encoding (e.g., GNU glibc) will fail
++for some <tt>wchar_t</tt> encodings. Popular implementations of <tt>ctype&lt;wchar_t&gt;</tt> that
++use <tt>mbtowc()</tt> and UTF-8 as the native encoding (e.g., GNU glibc) will fail
+ when the argument's MSB is set. There is no way for the the rest of locale
+ and iostream to reliably detect this failure.
+ </p>
+ <p><i>[Kona: This is a real problem. Widening can fail. It's unclear
+- what the solution should be. Returning WEOF works for the wchar_t
++ what the solution should be. Returning <tt>WEOF</tt> works for the <tt>wchar_t</tt>
+ specialization, but not in general. One option might be to add a
+ default, like <i>narrow</i>. But that's an incompatible change.
+ Using <i>traits::eof</i> might seem like a good idea, but facets
+@@ -7958,10 +6804,10 @@ and iostream to reliably detect this failure.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. The behavior is specified for all of the facets that an
+ implementation is required to provide, for the basic character set.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -7972,14 +6818,15 @@ implementation is required to provide, for the basic character set.
+
+ <hr>
+ <h3><a name="418"></a>418. exceptions thrown during iostream cleanup</h3>
+-<p><b>Section:</b> 27.5.2.1.6 [ios::Init] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios::Init">issues</a> in [ios::Init].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.3.1.6 [ios::Init] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios::Init">issues</a> in [ios::Init].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The dtor of the ios_base::Init object is supposed to call flush() on the
+-6 standard iostream objects cout, cerr, clog, wcout, wcerr, and wclog.
++The dtor of the <tt>ios_base::Init</tt> object is supposed to call <tt>flush()</tt> on the
++6 standard iostream objects <tt>cout</tt>, <tt>cerr</tt>, <tt>clog</tt>, <tt>wcout</tt>,
++<tt>wcerr</tt>, and <tt>wclog</tt>.
+ This call may cause an exception to be thrown.
+ </p>
+
+@@ -7989,21 +6836,21 @@ This call may cause an exception to be thrown.
+
+ <p>
+ The question is: What should this dtor do if one or more of these calls
+-to flush() ends up throwing an exception? This can happen quite easily
++to <tt>flush()</tt> ends up throwing an exception? This can happen quite easily
+ if one of the facets installed in the locale imbued in the iostream
+ object throws.
+ </p>
+ <p><i>[Kona: We probably can't do much better than what we've got, so
+ the LWG is leaning toward NAD. At the point where the standard
+ stream objects are being cleaned up, the usual error reporting
+- mechanism are all unavailable. And exception from flush at this
++ mechanism are all unavailable. And exception from <tt>flush</tt> at this
+ point will definitely cause problems. A quality implementation
+- might reasonably swallow the exception, or call abort, or do
++ might reasonably swallow the exception, or call <tt>abort</tt>, or do
+ something even more drastic.]</i></p>
+
+
+ <p><i>[
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a> for related issues.
++See <a href="lwg-closed.html#397">397</a> and <a href="lwg-defects.html#622">622</a> for related issues.
+ ]</i></p>
+
+
+@@ -8012,9 +6859,9 @@ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">39
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD, no consensus for change.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -8024,15 +6871,15 @@ Moved to NAD, no consensus for change.
+
+
+ <hr>
+-<h3><a name="421"></a>421. is basic_streambuf copy-constructible?</h3>
+-<p><b>Section:</b> 27.6.2.1 [streambuf.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf.cons">issues</a> in [streambuf.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="421"></a>421. is <tt>basic_streambuf</tt> copy-constructible?</h3>
++<p><b>Section:</b> 27.6.3.1 [streambuf.cons] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf.cons">issues</a> in [streambuf.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The reflector thread starting with c++std-lib-11346 notes that the class
+-template basic_streambuf, along with basic_stringbuf and basic_filebuf,
++template <tt>basic_streambuf</tt>, along with <tt>basic_stringbuf</tt> and <tt>basic_filebuf</tt>,
+ is copy-constructible but that the semantics of the copy constructors
+ are not defined anywhere. Further, different implementations behave
+ differently in this respect: some prevent copy construction of objects
+@@ -8048,7 +6895,7 @@ of the standard provide a compiler-generated copy ctor and assignment
+ operator yet fail to specify their semantics. It's believed that the
+ only types for which this is actually a problem (i.e. types where the
+ compiler-generated default may be inappropriate and may not have been
+-intended) are locale facets. See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#439">439</a>.
++intended) are locale facets. See issue <a href="lwg-closed.html#439">439</a>.
+ </p>
+
+ <p><i>[
+@@ -8056,9 +6903,9 @@ intended) are locale facets. See issue <a href="http://www.open-std.org/jtc1/sc
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. Option B is already in the Working Draft.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -8068,19 +6915,22 @@ NAD. Option B is already in the Working Draft.
+ </p>
+
+ <blockquote>
+-<pre>basic_streambuf(const basic_streambuf&amp; sb);
++<pre>
++basic_streambuf(const basic_streambuf&amp; sb);
+ basic_streambuf&amp; operator=(const basic_streambuf&amp; sb);
+ </pre>
+ </blockquote>
+
+ <p>Insert after 27.5.2.1, paragraph 2:</p>
+ <blockquote>
+-<pre>basic_streambuf(const basic_streambuf&amp; sb);
++<pre>
++basic_streambuf(const basic_streambuf&amp; sb);
+ </pre>
+
+-<p>Constructs a copy of sb.</p>
++<p>Constructs a copy of <tt>sb</tt>.</p>
+ <p>Postcondtions:</p>
+-<pre> eback() == sb.eback()
++<pre>
++ eback() == sb.eback()
+ gptr() == sb.gptr()
+ egptr() == sb.egptr()
+ pbase() == sb.pbase()
+@@ -8089,13 +6939,15 @@ basic_streambuf&amp; operator=(const basic_streambuf&amp; sb);
+ getloc() == sb.getloc()
+ </pre>
+
+-<pre>basic_streambuf&amp; operator=(const basic_streambuf&amp; sb);
++<pre>
++basic_streambuf&amp; operator=(const basic_streambuf&amp; sb);
+ </pre>
+
+-<p>Assigns the data members of sb to this.</p>
++<p>Assigns the data members of <tt>sb</tt> to this.</p>
+
+ <p>Postcondtions:</p>
+-<pre> eback() == sb.eback()
++<pre>
++ eback() == sb.eback()
+ gptr() == sb.gptr()
+ egptr() == sb.egptr()
+ pbase() == sb.pbase()
+@@ -8112,9 +6964,10 @@ basic_streambuf&amp; operator=(const basic_streambuf&amp; sb);
+ <p><b>Option A:</b></p>
+
+ <blockquote>
+-<p>Insert into the basic_stringbuf synopsis in the private section:</p>
++<p>Insert into the <tt>basic_stringbuf</tt> synopsis in the private section:</p>
+
+-<pre>basic_stringbuf(const basic_stringbuf&amp;); // not defined
++<pre>
++basic_stringbuf(const basic_stringbuf&amp;); // not defined
+ basic_stringbuf&amp; operator=(const basic_stringbuf&amp;); // not defined
+ </pre>
+ </blockquote>
+@@ -8122,9 +6975,10 @@ basic_stringbuf&amp; operator=(const basic_stringbuf&amp;); // not defined
+ <p><b>Option B:</b></p>
+
+ <blockquote>
+-<p>Insert into the basic_stringbuf synopsis in the public section:</p>
++<p>Insert into the <tt>basic_stringbuf</tt> synopsis in the public section:</p>
+
+-<pre>basic_stringbuf(const basic_stringbuf&amp; sb);
++<pre>
++basic_stringbuf(const basic_stringbuf&amp; sb);
+ basic_stringbuf&amp; operator=(const basic_stringbuf&amp; sb);
+ </pre>
+
+@@ -8133,11 +6987,12 @@ basic_stringbuf&amp; operator=(const basic_stringbuf&amp; sb);
+ <pre>basic_stringbuf(const basic_stringbuf&amp; sb);</pre>
+
+ <p>
+-Constructs an independent copy of sb as if with sb.str(), and with the openmode that sb was constructed with.
++Constructs an independent copy of <tt>sb</tt> as if with <tt>sb.str()</tt>, and with the openmode that <tt>sb</tt> was constructed with.
+ </p>
+
+ <p>Postcondtions: </p>
+-<pre> str() == sb.str()
++<pre>
++ str() == sb.str()
+ gptr() - eback() == sb.gptr() - sb.eback()
+ egptr() - eback() == sb.egptr() - sb.eback()
+ pptr() - pbase() == sb.pptr() - sb.pbase()
+@@ -8145,42 +7000,46 @@ Constructs an independent copy of sb as if with sb.str(), and with the openmode
+ </pre>
+
+ <p>
+-Note: The only requirement on epptr() is that it point beyond the initialized range if an output sequence exists. There is no requirement that epptr() - pbase() == sb.epptr() - sb.pbase().
++Note: The only requirement on <tt>epptr()</tt> is that it point beyond the initialized range if an
++output sequence exists. There is no requirement that <tt>epptr() - pbase() == sb.epptr() - sb.pbase()</tt>.
+ </p>
+
+ <pre>basic_stringbuf&amp; operator=(const basic_stringbuf&amp; sb);</pre>
+ <p>
+-After assignment the basic_stringbuf has the same state as if it were initially copy constructed from sb, except that the basic_stringbuf is allowed to retain any excess capacity it might have, which may in turn effect the value of epptr().
++After assignment the <tt>basic_stringbuf</tt> has the same state as if it were initially copy constructed
++from <tt>sb</tt>, except that the <tt>basic_stringbuf</tt> is allowed to retain any excess capacity it
++might have, which may in turn effect the value of <tt>epptr()</tt>.
+ </p>
+ </blockquote>
+
+ <p>27.8.1.1 [lib.filebuf]</p>
+
+-<p>Insert at the bottom of the basic_filebuf synopsis:</p>
++<p>Insert at the bottom of the <tt>basic_filebuf</tt> synopsis:</p>
+
+ <blockquote>
+-<pre>private:
++<pre>
++private:
+ basic_filebuf(const basic_filebuf&amp;); // not defined
+ basic_filebuf&amp; operator=(const basic_filebuf&amp;); // not defined
+ </pre>
+ </blockquote>
+-<p><i>[Kona: this is an issue for basic_streambuf itself and for its
+- derived classes. We are leaning toward allowing basic_streambuf to
++<p><i>[Kona: this is an issue for <tt>basic_streambuf</tt> itself and for its
++ derived classes. We are leaning toward allowing <tt>basic_streambuf</tt> to
+ be copyable, and specifying its precise semantics. (Probably the
+ obvious: copying the buffer pointers.) We are less sure whether
+- the streambuf derived classes should be copyable. Howard will
++ the <tt>streambuf</tt> derived classes should be copyable. Howard will
+ write up a proposal.]</i></p>
+
+
+-<p><i>[Sydney: Dietmar presented a new argument against basic_streambuf
+- being copyable: it can lead to an encapsulation violation. Filebuf
+- inherits from streambuf. Now suppose you inhert a my_hijacking_buf
+- from streambuf. You can copy the streambuf portion of a filebuf to a
+- my_hijacking_buf, giving you access to the pointers into the
+- filebuf's internal buffer. Perhaps not a very strong argument, but
++<p><i>[Sydney: Dietmar presented a new argument against <tt>basic_streambuf</tt>
++ being copyable: it can lead to an encapsulation violation. <tt>filebuf</tt>
++ inherits from <tt>streambuf</tt>. Now suppose you inherit a <tt>my_hijacking_buf</tt>
++ from <tt>streambuf</tt>. You can copy the <tt>streambuf</tt> portion of a <tt>filebuf</tt> to a
++ <tt>my_hijacking_buf</tt>, giving you access to the pointers into the
++ <tt>filebuf</tt>'s internal buffer. Perhaps not a very strong argument, but
+ it was strong enough to make people nervous. There was weak
+- preference for having streambuf not be copyable. There was weak
+- preference for having stringbuf not be copyable even if streambuf
++ preference for having <tt>streambuf</tt> not be copyable. There was weak
++ preference for having <tt>stringbuf</tt> not be copyable even if <tt>streambuf</tt>
+ is. Move this issue to open for now.
+ ]</i></p>
+
+@@ -8202,7 +7061,7 @@ move semantics less tedious and error prone.
+
+ <p><b>Rationale:</b></p>
+ <p>
+-27.5.2 [lib.streambuf]: The proposed basic_streambuf copy constructor
++27.5.2 [lib.streambuf]: The proposed <tt>basic_streambuf</tt> copy constructor
+ and assignment operator are the same as currently implied by the lack
+ of declarations: public and simply copies the data members. This
+ resolution is not a change but a clarification of the current
+@@ -8211,10 +7070,10 @@ standard.
+
+ <p>
+ 27.7.1 [lib.stringbuf]: There are two reasonable options: A) Make
+-basic_stringbuf not copyable. This is likely the status-quo of
++<tt>basic_stringbuf</tt> not copyable. This is likely the status-quo of
+ current implementations. B) Reasonable copy semantics of
+-basic_stringbuf can be defined and implemented. A copyable
+-basic_streambuf is arguably more useful than a non-copyable one. This
++<tt>basic_stringbuf</tt> can be defined and implemented. A copyable
++<tt>basic_streambuf</tt> is arguably more useful than a non-copyable one. This
+ should be considered as new functionality and not the fixing of a
+ defect. If option B is chosen, ramifications from issue 432 are taken
+ into account.
+@@ -8222,7 +7081,7 @@ into account.
+
+ <p>
+ 27.8.1.1 [lib.filebuf]: There are no reasonable copy semantics for
+-basic_filebuf.
++<tt>basic_filebuf</tt>.
+ </p>
+
+
+@@ -8231,115 +7090,58 @@ basic_filebuf.
+
+
+ <hr>
+-<h3><a name="423"></a>423. effects of negative streamsize in iostreams</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p>
+-A third party test suite tries to exercise istream::ignore(N) with
+-a negative value of N and expects that the implementation will treat
+-N as if it were 0. Our implementation asserts that (N &gt;= 0) holds and
+-aborts the test.
+-</p>
+-
+-<p>
+-I can't find anything in section 27 that prohibits such values but I don't
+-see what the effects of such calls should be, either (this applies to
+-a number of unformatted input functions as well as some member functions
+-of the basic_streambuf template).
+-</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-This is related to LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>.
+-</p>
+-<p>
+-Move to NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-I propose that we add to each function in clause 27 that takes an argument,
+-say N, of type streamsize a Requires clause saying that "N &gt;= 0." The intent
+-is to allow negative streamsize values in calls to precision() and width()
+-but disallow it in calls to streambuf::sgetn(), istream::ignore(), or
+-ostream::write().
+-</p>
+-
+-<p><i>[Kona: The LWG agreed that this is probably what we want. However, we
+- need a review to find all places where functions in clause 27 take
+- arguments of type streamsize that shouldn't be allowed to go
+- negative. Martin will do that review.]</i></p>
+-
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="424"></a>424. normative notes</h3>
+-<p><b>Section:</b> 17.5.1.2 [structure.summary] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 17.5.1.2 [structure.summary] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+ The text in 17.3.1.1, p1 says:
+-<br>
++<br/>
+
+ "Paragraphs labelled "Note(s):" or "Example(s):" are informative, other
+ paragraphs are normative."
+-<br>
++<br/>
+
+ The library section makes heavy use of paragraphs labeled "Notes(s),"
+ some of which are clearly intended to be normative (see list 1), while
+ some others are not (see list 2). There are also those where the intent
+ is not so clear (see list 3).
+-<br><br>
++<br/><br/>
+
+ List 1 -- Examples of (presumably) normative Notes:
+-<br>
+-
+-20.9.5.1 [allocator.members], p3,<br>
+-20.9.5.1 [allocator.members], p10,<br>
+-21.4.2 [string.cons], p11,<br>
+-22.3.1.2 [locale.cons], p11,<br>
+-23.3.2.3 [deque.modifiers], p2,<br>
+-25.4.7 [alg.min.max], p3,<br>
+-26.4.6 [complex.ops], p15,<br>
+-27.6.2.4.3 [streambuf.virt.get], p7.<br>
+-<br>
++<br/>
++
++20.7.9.1 [allocator.members], p3,<br/>
++20.7.9.1 [allocator.members], p10,<br/>
++21.4.2 [string.cons], p11,<br/>
++22.3.1.2 [locale.cons], p11,<br/>
++23.3.3.4 [deque.modifiers], p2,<br/>
++25.4.7 [alg.min.max], p3,<br/>
++26.4.6 [complex.ops], p15,<br/>
++27.6.3.4.3 [streambuf.virt.get], p7.<br/>
++<br/>
+
+ List 2 -- Examples of (presumably) informative Notes:
+-<br>
++<br/>
+
+-18.6.1.3 [new.delete.placement], p3,<br>
+-21.4.6.6 [string::replace], p14,<br>
+-22.4.1.4.2 [locale.codecvt.virtuals], p3,<br>
+-25.2.4 [alg.foreach], p4,<br>
+-26.4.5 [complex.member.ops], p1,<br>
+-27.5.2.5 [ios.base.storage], p6.<br>
+-<br>
++18.6.1.3 [new.delete.placement], p3,<br/>
++21.4.6.6 [string::replace], p14,<br/>
++22.4.1.4.2 [locale.codecvt.virtuals], p3,<br/>
++25.2.4 [alg.foreach], p4,<br/>
++26.4.5 [complex.member.ops], p1,<br/>
++27.5.3.5 [ios.base.storage], p6.<br/>
++<br/>
+
+ List 3 -- Examples of Notes that are not clearly either normative
+ or informative:
+-<br>
++<br/>
+
+-22.3.1.2 [locale.cons], p8,<br>
+-22.3.1.5 [locale.statics], p6,<br>
+-27.6.2.4.5 [streambuf.virt.put], p4.<br>
+-<br>
++22.3.1.2 [locale.cons], p8,<br/>
++22.3.1.5 [locale.statics], p6,<br/>
++27.6.3.4.5 [streambuf.virt.put], p4.<br/>
++<br/>
+
+ None of these lists is meant to be exhaustive.
+ </p>
+@@ -8400,11 +7202,11 @@ Move to NAD Editorial.
+
+ <hr>
+ <h3><a name="429"></a>429. typo in basic_ios::clear(iostate)</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#412">412</a></p>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#412">412</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -8421,13 +7223,13 @@ holds would not result in an exception being thrown.
+ <p>
+
+ The text ought to be changed from
+-<br>
++<br/>
+
+ "If (rdstate() &amp; exceptions()) == 0, returns. ..."
+-<br>
++<br/>
+
+ to
+-<br>
++<br/>
+
+ "If (state &amp; exceptions()) == 0, returns. ..."
+ </p>
+@@ -8442,9 +7244,9 @@ to
+
+ <hr>
+ <h3><a name="433"></a>433. Contradiction in specification of unexpected()</h3>
+-<p><b>Section:</b> D.13.3 [unexpected] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Vyatcheslav Sysoltsev <b>Opened:</b> 2003-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> D.8.4 [unexpected] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Vyatcheslav Sysoltsev <b>Opened:</b> 2003-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Clause 15.5.2 [except.unexpected] paragraph 1 says that "void unexpected();
+@@ -8475,15 +7277,16 @@ ambiguity in understanding.
+
+ <hr>
+ <h3><a name="437"></a>437. Formatted output of function pointers is confusing</h3>
+-<p><b>Section:</b> 27.7.2.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Ivan Godard <b>Opened:</b> 2003-10-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.3.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Ivan Godard <b>Opened:</b> 2003-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Given:
+ </p>
+-<pre>void f(int) {}
++<pre>
++void f(int) {}
+ void(*g)(int) = f;
+ cout &lt;&lt; g;
+ </pre>
+@@ -8521,10 +7324,10 @@ conversions from C and the function pointer is converted to bool.
+
+ <hr>
+ <h3><a name="439"></a>439. Should facets be copyable?</h3>
+-<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The following facets classes have no copy constructors described in
+ the standard, which, according to the standard, means that they are
+@@ -8532,13 +7335,14 @@ conversions from C and the function pointer is converted to bool.
+ behavior is probably inappropriate. We should either make these
+ classes uncopyable or else specify exactly what their constructors do.</p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#421">421</a>.</p>
++<p>Related issue: <a href="lwg-closed.html#421">421</a>.</p>
+
+-<pre> ctype_base
++<pre>
++ ctype_base
+ ctype
+ ctype_byname
+- ctype&lt;char&gt;
+- ctype_byname&lt;char&gt;
++ ctype&lt;char>
++ ctype_byname&lt;char>
+ codecvt_base
+ codecvt
+ codecvt_byname
+@@ -8577,9 +7381,9 @@ conversions from C and the function pointer is converted to bool.
+
+ <hr>
+ <h3><a name="440"></a>440. Should std::complex use unqualified transcendentals?</h3>
+-<p><b>Section:</b> 26.4.8 [complex.transcendentals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-11-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.4.8 [complex.transcendentals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-11-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Operations like <tt>pow</tt> and <tt>exp</tt> on
+@@ -8592,7 +7396,7 @@ unqualified <tt>sin</tt>?
+ <p>The issue, of course, is whether we want to use
+ argument-dependent lookup in the case where <tt>T</tt> is a
+ user-defined type. This is similar to the issue of valarray
+-transcendentals, as discussed in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>.</p>
++transcendentals, as discussed in issue <a href="lwg-defects.html#226">226</a>.</p>
+
+ <p>This issue differs from valarray transcendentals in two important
+ ways. First, "the effect of instantiating the template
+@@ -8617,16 +7421,16 @@ are off.</p>
+
+ <hr>
+ <h3><a name="446"></a>446. Iterator equality between different containers</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements], 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Andy Koenig <b>Opened:</b> 2003-12-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 24.2 [iterator.requirements], 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Andy Koenig <b>Opened:</b> 2003-12-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ What requirements does the standard place on equality comparisons between
+ iterators that refer to elements of different containers. For example, if
+-v1 and v2 are empty vectors, is v1.end() == v2.end() allowed to yield true?
+-Is it allowed to throw an exception?
++<tt>v1</tt> and <tt>v2</tt> are empty vectors, is <tt>v1.end() == v2.end()</tt>
++allowed to yield true? Is it allowed to throw an exception?
+ </p>
+
+ <p>
+@@ -8648,9 +7452,9 @@ reachability.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Daniel volunteered to work on this.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-09-20 Daniel provided wording.
+@@ -8662,9 +7466,9 @@ Daniel volunteered to work on this.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as Open. Alisdair has volunteered to refine the wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+@@ -8708,19 +7512,20 @@ described otherwise.</ins>
+
+ <hr>
+ <h3><a name="447"></a>447. Wrong template argument for time facets</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2003-12-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#327">327</a></p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2003-12-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#327">327</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.1.1.1.1/4, table 52, "Required Instantiations", lists, among others:
+ </p>
+-<pre> time_get&lt;char,InputIterator&gt;
+- time_get_byname&lt;char,InputIterator&gt;
+- time_get&lt;wchar_t,OutputIterator&gt;
+- time_get_byname&lt;wchar_t,OutputIterator&gt;
++<pre>
++ time_get&lt;char,InputIterator>
++ time_get_byname&lt;char,InputIterator>
++ time_get&lt;wchar_t,OutputIterator>
++ time_get_byname&lt;wchar_t,OutputIterator>
+ </pre>
+
+ <p>
+@@ -8744,15 +7549,16 @@ Change the second template argument to InputIterator.
+
+ <hr>
+ <h3><a name="450"></a>450. set::find is inconsistent with associative container requirements</h3>
+-<p><b>Section:</b> 23.6.3 [set] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#set">issues</a> in [set].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a></p>
++<p><b>Section:</b> 23.4.6 [set] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#set">issues</a> in [set].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#214">214</a></p>
+ <p><b>Discussion:</b></p>
+ <p>map/multimap have:</p>
+
+-<pre> iterator find(const key_type&amp; x) const;
++<pre>
++ iterator find(const key_type&amp; x) const;
+ const_iterator find(const key_type&amp; x) const;
+ </pre>
+
+@@ -8760,7 +7566,8 @@ Change the second template argument to InputIterator.
+ which is consistent with the table of associative container requirements.
+ But set/multiset have:
+ </p>
+-<pre> iterator find(const key_type&amp;) const;
++<pre>
++ iterator find(const key_type&amp;) const;
+ </pre>
+
+ <p>
+@@ -8781,21 +7588,23 @@ table, in this regard.
+
+ <hr>
+ <h3><a name="451"></a>451. Associative erase should return an iterator</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.6 [associative] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.4 [associative] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#130">130</a></p>
+ <p><b>Discussion:</b></p>
+ <p>map/multimap/set/multiset have:</p>
+-<pre> void erase(iterator);
++<pre>
++ void erase(iterator);
+ void erase(iterator, iterator);
+ </pre>
+
+ <p>But there's no good reason why these can't return an iterator, as for
+ vector/deque/list:</p>
+-<pre> iterator erase(iterator);
++<pre>
++ iterator erase(iterator);
+ iterator erase(iterator, iterator);
+ </pre>
+
+@@ -8818,12 +7627,13 @@ first element beyond the erased subrange.
+
+ <hr>
+ <h3><a name="452"></a>452. locale::combine should be permitted to generate a named locale</h3>
+-<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.members">issues</a> in [locale.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.members">issues</a> in [locale.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<pre>template&lt;class Facet&gt;
++<pre>
++template&lt;class Facet>
+ locale::combine(const locale&amp;) const;
+ </pre>
+ <p>
+@@ -8858,19 +7668,21 @@ standard facets.
+
+
+ <hr>
+-<h3><a name="454"></a>454. basic_filebuf::open should accept wchar_t names</h3>
+-<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a></p>
++<h3><a name="454"></a>454. <tt>basic_filebuf::open</tt> should accept <tt>wchar_t</tt> names</h3>
++<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#105">105</a></p>
+ <p><b>Discussion:</b></p>
+-<pre> basic_filebuf *basic_filebuf::open(const char *, ios_base::open_mode);
++<pre>
++ basic_filebuf *basic_filebuf::open(const char *, ios_base::open_mode);
+ </pre>
+
+ <p>should be supplemented with the overload:</p>
+
+-<pre> basic_filebuf *basic_filebuf::open(const wchar_t *, ios_base::open_mode);
++<pre>
++ basic_filebuf *basic_filebuf::open(const wchar_t *, ios_base::open_mode);
+ </pre>
+
+ <p>
+@@ -8879,7 +7691,7 @@ the other requires an implementation-defined mapping to determine the
+ actual filename.
+ </p>
+
+-<p><i>[Sydney: Yes, we want to allow wchar_t filenames. Bill will
++<p><i>[Sydney: Yes, we want to allow <tt>wchar_t</tt> filenames. Bill will
+ provide wording.]</i></p>
+
+
+@@ -8913,9 +7725,9 @@ Martin adds pre-Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Please see <a href="http://wiki.dinkumware.com/twiki/pub/Wg21sophiaAntipolis/LibraryWorkingGroup/issue-454.html">issue 454: problems and solutions</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+@@ -8946,7 +7758,8 @@ problems and solutions.
+
+ <p>Change from:</p>
+ <blockquote>
+-<pre>basic_filebuf&lt;charT,traits&gt;* open(
++<pre>
++basic_filebuf&lt;charT,traits>* open(
+ const char* s,
+ ios_base::openmode mode );
+ </pre>
+@@ -8961,22 +7774,23 @@ by calling std::fopen(s,modstr)).</p>
+ <p>to:</p>
+
+ <blockquote>
+-<pre>basic_filebuf&lt;charT,traits&gt;* open(
++<pre>
++basic_filebuf&lt;charT,traits>* open(
+ const char* s,
+ ios_base::openmode mode );
+
+-basic_filebuf&lt;charT,traits&gt;* open(
++basic_filebuf&lt;charT,traits>* open(
+ const wchar_t* ws,
+ ios_base::openmode mode );
+ </pre>
+
+ <p>
+-Effects: If is_open() != false, returns a null pointer.
+-Otherwise, initializes the filebuf as required. It then
+-opens a file, if possible, whose name is the NTBS s ("as if"
+-by calling std::fopen(s,modstr)).
+-For the second signature, the NTBS s is determined from the
+-WCBS ws in an implementation-defined manner.
++<i>Effects</i>: If <tt>is_open() != false</tt>, returns a null pointer.
++Otherwise, initializes the <tt>filebuf</tt> as required. It then
++opens a file, if possible, whose name is the NTBS <tt>s</tt> ("as if"
++by calling <tt>std::fopen(s,modstr)</tt>).
++For the second signature, the NTBS <tt>s</tt> is determined from the
++WCBS <tt>ws</tt> in an implementation-defined manner.
+ </p>
+
+ <p>
+@@ -9037,11 +7851,11 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Some existing implementations provide overload already. Expected
+ filesystem "path" object overloads neatly, without surprises; implying
+ NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -9050,16 +7864,16 @@ NAD.
+
+
+ <hr>
+-<h3><a name="458"></a>458. 24.1.5 contains unintended limitation for operator-</h3>
+-<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2004-02-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="458"></a>458. 24.1.5 contains unintended limitation for <tt>operator-</tt></h3>
++<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2004-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 24.1.5 [lib.random.access.iterators], table 76 the operational
+-semantics for the expression "r -= n" are defined as "return r += -n".
+-This means, that the expression -n must be valid, which is not the case
++semantics for the expression "<tt>r -= n</tt>" are defined as "<tt>return r += -n</tt>".
++This means, that the expression <tt>-n</tt> must be valid, which is not the case
+ for unsigned types.
+ </p>
+
+@@ -9110,9 +7924,9 @@ Need to look at again without concepts.
+ </p>
+ <p>
+ There was a question about this phrase in the discussion: "the
+-expression -n must be valid, which is not the case for unsigned types."
+-If n is an object ofthe iterator difference_type (eg ptrdiff_t), then it
+-is never unsigned.
++expression <tt>-n</tt> must be valid, which is not the case for unsigned types."
++If <tt>n</tt> is an object of the iterator <tt>difference_type</tt> (eg <tt>ptrdiff_t</tt>),
++then it is never unsigned.
+ </p>
+ </blockquote>
+
+@@ -9121,11 +7935,11 @@ is never unsigned.
+ ]</i></p>
+
+
+-<blockquote>
+-The group reviewed the wording in the draft and agreed that n is of
++<blockquote><p>
++The group reviewed the wording in the draft and agreed that <tt>n</tt> is of
+ difference type, the difference type is signed, and the current wording
+ is correct. Moved to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -9134,8 +7948,9 @@ is correct. Moved to NAD.
+ To remove this limitation, I suggest to change the
+ operational semantics for this column to:
+ </p>
+-<blockquote><pre> { Distance m = n;
+- if (m &gt;= 0)
++<blockquote><pre>
++ { Distance m = n;
++ if (m >= 0)
+ while (m--) --r;
+ else
+ while (m++) ++r;
+@@ -9149,10 +7964,11 @@ operational semantics for this column to:
+
+ <hr>
+ <h3><a name="459"></a>459. Requirement for widening in stage 2 is overspecification</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-03-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-03-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>When parsing strings of wide-character digits, the standard
+ requires the library to widen narrow-character "atoms" and compare
+@@ -9171,12 +7987,13 @@ widen() allows, i.e. without making a virtual call to do_narrow every
+ time, is as follows:
+ </p>
+
+-<pre> inline char ctype&lt;wchar_t&gt;::narrow (wchar_t wc, char dflt) const
++<pre>
++ inline char ctype&lt;wchar_t>::narrow (wchar_t wc, char dflt) const
+ {
+ const unsigned wi = unsigned (wc);
+
+- if (wi &gt; UCHAR_MAX)
+- return typeid (*this) == typeid (ctype&lt;wchar_t&gt;) ?
++ if (wi > UCHAR_MAX)
++ return typeid (*this) == typeid (ctype&lt;wchar_t>) ?
+ dflt : do_narrow (wc, dflt);
+
+ if (narrow_ [wi] &lt; 0) {
+@@ -9197,14 +8014,14 @@ drastic. Existing implementations with the exception of libstdc++
+ currently already use narrow() so the impact of the change on programs
+ would presumably be isolated to just a single implementation. Further,
+ since narrow() is not required to translate alternate wide digit
+-representations such as those mentioned in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a> to
++representations such as those mentioned in issue <a href="lwg-defects.html#303">303</a> to
+ their narrow equivalents (i.e., the portable source characters '0'
+ through '9'), the change does not necessarily imply that these
+ alternate digits would be treated as ordinary digits and accepted as
+ part of numbers during parsing. In fact, the requirement in 22.4.1.1.2 [locale.ctype.virtuals], p13 forbids narrow() to translate an alternate
+ digit character, wc, to an ordinary digit in the basic source
+ character set unless the expression
+-(ctype&lt;charT&gt;::is(ctype_base::digit, wc) == true) holds. This in
++(ctype&lt;charT>::is(ctype_base::digit, wc) == true) holds. This in
+ turn is prohibited by the C standard (7.25.2.1.5, 7.25.2.1.5, and
+ 5.2.1, respectively) for charT of either char or wchar_t.
+ </p>
+@@ -9222,9 +8039,9 @@ codecvt instead.]</i></p>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. The standard is clear enough as written.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -9233,7 +8050,7 @@ NAD. The standard is clear enough as written.
+ technique to perform the comparison:</p>
+ <ol>
+ <li> call widen on the atoms and compare (either by using
+- operator== or char_traits&lt;charT&gt;::eq) the input with
++ operator== or char_traits&lt;charT>::eq) the input with
+ the widened atoms, or</li>
+ <li> call narrow on the input and compare the narrow input
+ with the atoms</li>
+@@ -9248,9 +8065,9 @@ technique to perform the comparison:</p>
+
+ <hr>
+ <h3><a name="462"></a>462. Destroying objects with static storage duration</h3>
+-<p><b>Section:</b> 3.6.3 [basic.start.term], 18.4 [cstdint] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-03-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 3.6.3 [basic.start.term], 18.4 [cstdint] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-03-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 3.6.3 Termination spells out in detail the interleaving of static
+@@ -9290,7 +8107,7 @@ destruction but not require it.
+
+ <p><i>[
+ Howard: The course of action recommended in Batavia would undo LWG
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a> and break current code implementing the "phoenix
++issue <a href="lwg-defects.html#3">3</a> and break current code implementing the "phoenix
+ singleton". Search the net for "phoenix singleton atexit" to get a feel
+ for the size of the adverse impact this change would have. Below is
+ sample code which implements the phoenix singleton and would break if
+@@ -9298,7 +8115,8 @@ sample code which implements the phoenix singleton and would break if
+ ]</i></p>
+
+
+-<blockquote><pre>#include &lt;cstdlib&gt;
++<blockquote><pre>
++#include &lt;cstdlib&gt;
+ #include &lt;iostream&gt;
+ #include &lt;type_traits&gt;
+ #include &lt;new&gt;
+@@ -9372,7 +8190,8 @@ int main()
+ The correct output is:
+ </p>
+
+-<blockquote><pre>A()
++<blockquote><pre>
++A()
+ Using A from main()
+ A is alive
+ ~A()
+@@ -9401,16 +8220,16 @@ Bill agrees issue is no longer serious, and accepts NAD.
+
+
+ <hr>
+-<h3><a name="463"></a>463. auto_ptr usability issues</h3>
+-<p><b>Section:</b> D.12.1 [auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Rani Sharoni <b>Opened:</b> 2003-12-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="463"></a>463. <tt>auto_ptr</tt> usability issues</h3>
++<p><b>Section:</b> X [auto.ptr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Rani Sharoni <b>Opened:</b> 2003-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-TC1 CWG DR #84 effectively made the template&lt;class Y&gt; operator auto_ptr&lt;Y&gt;()
+-member of auto_ptr (20.4.5.3/4) obsolete.
++TC1 CWG DR #84 effectively made the <tt>template&lt;class Y&gt; operator auto_ptr&lt;Y&gt;()</tt>
++member of <tt>auto_ptr</tt> (20.4.5.3/4) obsolete.
+ </p>
+
+ <p>
+@@ -9418,7 +8237,8 @@ The sole purpose of this obsolete conversion member is to enable copy
+ initialization base from r-value derived (or any convertible types like
+ cv-types) case:
+ </p>
+-<pre>#include &lt;memory&gt;
++<pre>
++#include &lt;memory&gt;
+ using std::auto_ptr;
+
+ struct B {};
+@@ -9431,11 +8251,11 @@ int x1 = sink( source() ); // #1 EDG - no suitable copy constructor
+
+ <p>
+ The excellent analysis of conversion operations that was given in the final
+-auto_ptr proposal
+-(http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf)
++<tt>auto_ptr</tt> proposal
++(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf)
+ explicitly specifies this case analysis (case 4). DR #84 makes the analysis
+ wrong and actually comes to forbid the loophole that was exploited by the
+-auto_ptr designers.
++<tt>auto_ptr</tt> designers.
+ </p>
+
+ <p>
+@@ -9448,13 +8268,14 @@ conversions and in fact current compilers conform to DR #84.
+ I was surprised to discover that the obsolete conversion member actually has
+ negative impact of the copy initialization base from l-value derived
+ case:</p>
+-<pre>auto_ptr&lt;D&gt; dp;
++<pre>
++auto_ptr&lt;D&gt; dp;
+ int x2 = sink(dp); // #2 EDG - more than one user-defined conversion applies
+ </pre>
+
+ <p>
+ I'm sure that the original intention was allowing this initialization using
+-the template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp; a) constructor (20.4.5.1/4) but
++the <tt>template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp; a)</tt> constructor (20.4.5.1/4) but
+ since in this copy initialization it's merely user defined conversion (UDC)
+ and the obsolete conversion member is UDC with the same rank (for the early
+ overloading stage) there is an ambiguity between them.
+@@ -9464,35 +8285,38 @@ overloading stage) there is an ambiguity between them.
+ Removing the obsolete member will have impact on code that explicitly
+ invokes it:
+ </p>
+-<pre>int y = sink(source().operator auto_ptr&lt;B&gt;());
++<pre>
++int y = sink(source().operator auto_ptr&lt;B>());
+ </pre>
+
+ <p>
+ IMHO no one ever wrote such awkward code and the reasonable workaround for
+ #1 is:
+ </p>
+-<pre>int y = sink( auto_ptr&lt;B&gt;(source()) );
++<pre>
++int y = sink( auto_ptr&lt;B>(source()) );
+ </pre>
+
+ <p>
+ I was even more surprised to find out that after removing the obsolete
+ conversion member the initialization was still ill-formed:
+-int x3 = sink(dp); // #3 EDG - no suitable copy constructor
++<tt>int x3 = sink(dp); // #3 EDG - no suitable copy constructor</tt>
+ </p>
+
+ <p>
+ This copy initialization semantically requires copy constructor which means
+-that both template conversion constructor and the auto_ptr_ref conversion
++that both template conversion constructor and the <tt>auto_ptr_ref</tt> conversion
+ member (20.4.5.3/3) are required which is what was explicitly forbidden in
+ DR #84. This is a bit amusing case in which removing ambiguity results with
+ no candidates.
+ </p>
+
+ <p>
+-I also found exception safety issue with auto_ptr related to auto_ptr_ref:
++I also found exception safety issue with <tt>auto_ptr</tt> related to <tt>auto_ptr_ref</tt>:
+ </p>
+-<pre>int f(auto_ptr&lt;B&gt;, std::string);
+-auto_ptr&lt;B&gt; source2();
++<pre>
++int f(auto_ptr&lt;B>, std::string);
++auto_ptr&lt;B> source2();
+
+ // string constructor throws while auto_ptr_ref
+ // "holds" the pointer
+@@ -9503,52 +8327,53 @@ int x4 = f(source2(), "xyz"); // #4
+ The theoretic execution sequence that will cause a leak:
+ </p>
+ <ol>
+-<li>call auto_ptr&lt;B&gt;::operator auto_ptr_ref&lt;B&gt;()</li>
++<li>call auto_ptr&lt;B>::operator auto_ptr_ref&lt;B>()</li>
+ <li>call string::string(char const*) and throw</li>
+ </ol>
+
+ <p>
+-According to 20.4.5.3/3 and 20.4.5/2 the auto_ptr_ref conversion member
+-returns auto_ptr_ref&lt;Y&gt; that holds *this and this is another defect since
+-the type of *this is auto_ptr&lt;X&gt; where X might be different from Y. Several
+-library vendors (e.g. SGI) implement auto_ptr_ref&lt;Y&gt; with Y* as member which
+-is much more reasonable. Other vendor implemented auto_ptr_ref as
++According to 20.4.5.3/3 and 20.4.5/2 the <tt>auto_ptr_ref</tt> conversion member
++returns <tt>auto_ptr_ref&lt;Y&gt;</tt> that holds <tt>*this</tt> and this is another defect since
++the type of <tt>*this</tt> is <tt>auto_ptr&lt;X&gt;</tt> where <tt>X</tt> might
++be different from <tt>Y</tt>. Several library vendors (e.g. SGI) implement
++<tt>auto_ptr_ref&lt;Y&gt;</tt> with <tt>Y*</tt> as member which
++is much more reasonable. Other vendor implemented <tt>auto_ptr_ref</tt> as
+ defectively required and it results with awkward and catastrophic code:
+-int oops = sink(auto_ptr&lt;B&gt;(source())); // warning recursive on all control
+-paths
++<tt>int oops = sink(auto_ptr&lt;B>(source())); // warning recursive on all control paths</tt>
+ </p>
+
+ <p>
+ Dave Abrahams noticed that there is no specification saying that
+-auto_ptr_ref copy constructor can't throw.
++<tt>auto_ptr_ref</tt> copy constructor can't throw.
+ </p>
+
+ <p>
+ My proposal comes to solve all the above issues and significantly simplify
+-auto_ptr implementation. One of the fundamental requirements from auto_ptr
+-is that it can be constructed in an intuitive manner (i.e. like ordinary
+-pointers) but with strict ownership semantics which yield that source
+-auto_ptr in initialization must be non-const. My idea is to add additional
++<tt>auto_ptr</tt> implementation. One of the fundamental requirements from
++<tt>auto_ptr</tt> is that it can be constructed in an intuitive manner (i.e.
++like ordinary pointers) but with strict ownership semantics which yield that source
++<tt>auto_ptr</tt> in initialization must be non-const. My idea is to add additional
+ constructor template with sole propose to generate ill-formed, diagnostic
+ required, instance for const auto_ptr arguments during instantiation of
+ declaration. This special constructor will not be instantiated for other
+ types which is achievable using 14.8.2/2 (SFINAE). Having this constructor
+-in hand makes the constructor template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt; const&amp;)
++in hand makes the constructor <tt>template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y> const&amp;)</tt>
+ legitimate since the actual argument can't be const yet non const r-value
+ are acceptable.
+ </p>
+
+ <p>
+ This implementation technique makes the "private auxiliary class"
+-auto_ptr_ref obsolete and I found out that modern C++ compilers (e.g. EDG,
++<tt>auto_ptr_ref</tt> obsolete and I found out that modern C++ compilers (e.g. EDG,
+ GCC and VC) consume the new implementation as expected and allow all
+ intuitive initialization and assignment cases while rejecting illegal cases
+-that involve const auto_ptr arguments.
++that involve const <tt>auto_ptr</tt> arguments.
+ </p>
+
+ <p>The proposed auto_ptr interface:</p>
+
+-<pre>namespace std {
++<pre>
++namespace std {
+ template&lt;class X&gt; class auto_ptr {
+ public:
+ typedef X element_type;
+@@ -9563,7 +8388,7 @@ that involve const auto_ptr arguments.
+
+ // 20.4.5.2 members:
+ X&amp; operator*() const throw();
+- X* operator-&gt;() const throw();
++ X* operator->() const throw();
+ X* get() const throw();
+ X* release() throw();
+ void reset(X* p=0) throw();
+@@ -9577,11 +8402,12 @@ unspecified_error_on_const_auto_ptr&lt;U&gt;::type = 0);
+ </pre>
+
+ <p>
+-One compliant technique to implement the unspecified_error_on_const_auto_ptr
+-helper class is using additional private auto_ptr member class template like
++One compliant technique to implement the <tt>unspecified_error_on_const_auto_ptr</tt>
++helper class is using additional private <tt>auto_ptr</tt> member class template like
+ the following:
+ </p>
+-<pre>template&lt;typename T&gt; struct unspecified_error_on_const_auto_ptr;
++<pre>
++template&lt;typename T&gt; struct unspecified_error_on_const_auto_ptr;
+
+ template&lt;typename T&gt;
+ struct unspecified_error_on_const_auto_ptr&lt;auto_ptr&lt;T&gt; const&gt;
+@@ -9601,58 +8427,60 @@ verifying this with core language experts.
+ <p>Remove section 20.4.5.3</p>
+
+ <p>Change 20.4.5/2 to read something like:
+-Initializing auto_ptr&lt;X&gt; from const auto_ptr&lt;Y&gt; will result with unspecified
++Initializing <tt>auto_ptr&lt;X&gt;</tt> from <tt>const auto_ptr&lt;Y&gt;</tt> will result with unspecified
+ ill-formed declaration that will require unspecified diagnostic.</p>
+
+ <p>Change 20.4.5.1/4,5,6 to read:</p>
+
+ <pre>template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt; const&amp; a) throw();</pre>
+-<p> 4 Requires: Y* can be implicitly converted to X*.</p>
+-<p> 5 Effects: Calls const_cast&lt;auto_ptr&lt;Y&gt;&amp;&gt;(a).release().</p>
+-<p> 6 Postconditions: *this holds the pointer returned from a.release().</p>
++<p> 4 <i>Requires</i>: <tt>Y*</tt> can be implicitly converted to <tt>X*</tt>.</p>
++<p> 5 <i>Effects</i>: Calls <tt>const_cast&lt;auto_ptr&lt;Y&gt;&amp;&gt;(a).release()</tt>.</p>
++<p> 6 <i>Postconditions</i>: <tt>*this</tt> holds the pointer returned from <tt>a.release()</tt>.</p>
+
+ <p>Change 20.4.5.1/10</p>
+-<pre>template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt; a) throw();
++<pre>
++template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt; a) throw();
+ </pre>
+ <p>
+-10 Requires: Y* can be implicitly converted to X*. The expression delete
+-get() is well formed.
++10 <i>Requires</i>: <tt>Y*</tt> can be implicitly converted to <tt>X*</tt>. The expression <tt>delete
++get()</tt> is well formed.
+ </p>
+
+ <p>LWG TC DR #127 is obsolete.</p>
+
+ <p>
+ Notice that the copy constructor and copy assignment operator should remain
+-as before and accept non-const auto_ptr&amp; since they have effect on the form
++as before and accept non-<tt>const auto_ptr&amp;</tt> since they have effect on the form
+ of the implicitly declared copy constructor and copy assignment operator of
+ class that contains auto_ptr as member per 12.8/5,10:
+ </p>
+-<pre>struct X {
++<pre>
++struct X {
+ // implicit X(X&amp;)
+ // implicit X&amp; operator=(X&amp;)
+- auto_ptr&lt;D&gt; aptr_;
++ auto_ptr&lt;D> aptr_;
+ };
+ </pre>
+
+ <p>
+ In most cases this indicates about sloppy programming but preserves the
+-current auto_ptr behavior.
++current <tt>auto_ptr</tt> behavior.
+ </p>
+
+ <p>
+ Dave Abrahams encouraged me to suggest fallback implementation in case that
+-my suggestion that involves removing of auto_ptr_ref will not be accepted.
+-In this case removing the obsolete conversion member to auto_ptr&lt;Y&gt; and
++my suggestion that involves removing of <tt>auto_ptr_ref</tt> will not be accepted.
++In this case removing the obsolete conversion member to <tt>auto_ptr&lt;Y&gt;</tt> and
+ 20.4.5.3/4,5 is still required in order to eliminate ambiguity in legal
+ cases. The two constructors that I suggested will co exist with the current
+-members but will make auto_ptr_ref obsolete in initialization contexts.
+-auto_ptr_ref will be effective in assignment contexts as suggested in DR
++members but will make <tt>auto_ptr_ref</tt> obsolete in initialization contexts.
++<tt>auto_ptr_ref</tt> will be effective in assignment contexts as suggested in DR
+ #127 and I can't see any serious exception safety issues in those cases
+-(although it's possible to synthesize such). auto_ptr_ref&lt;X&gt; semantics will
+-have to be revised to say that it strictly holds pointer of type X and not
+-reference to an auto_ptr for the favor of cases in which auto_ptr_ref&lt;Y&gt; is
+-constructed from auto_ptr&lt;X&gt; in which X is different from Y (i.e. assignment
+-from r-value derived to base).
++(although it's possible to synthesize such). <tt>auto_ptr_ref&lt;X&gt;</tt> semantics will
++have to be revised to say that it strictly holds pointer of type <tt>X</tt> and not
++reference to an <tt>auto_ptr</tt> for the favor of cases in which <tt>auto_ptr_ref&lt;Y&gt;</tt> is
++constructed from <tt>auto_ptr&lt;X&gt;</tt> in which <tt>X</tt> is different from
++<tt>Y</tt> (i.e. assignment from r-value derived to base).
+ </p>
+
+ <p><i>[Redmond: punt for the moment. We haven't decided yet whether we
+@@ -9677,13 +8505,13 @@ tool.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This is a complicated issue, so we agreed to defer discussion until
+ later in the week so that interested parties can read up on it.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-209-10-04 Daniel adds:
++2009-10-04 Daniel adds:
+ ]</i></p>
+
+
+@@ -9696,7 +8524,8 @@ another - but better - form of hack. Second, either following the suggested
+ resolution or the now more natural alternative via the added member set
+ </p>
+
+-<blockquote><pre>template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp;&amp;) throw();
++<blockquote><pre>
++template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp;&amp;) throw();
+ template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;&amp;) throw();
+ </pre></blockquote>
+
+@@ -9706,7 +8535,7 @@ references <tt>auto_ptr_ref</tt>. This risk seems to indicate that a
+ decision which would not touch the current spec of <tt>auto_ptr</tt> at
+ all (but deprecating it) and instead recommending to use
+ <tt>unique_ptr</tt> for new code instead might have the best
+-cost-benefit ratio. IMO the current solution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a> can
++cost-benefit ratio. IMO the current solution of <a href="lwg-defects.html#1100">1100</a> can
+ be considered as an active user-support for this transition.
+ </p>
+ </blockquote>
+@@ -9716,19 +8545,20 @@ be considered as an active user-support for this transition.
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as NAD. Alisdair will open a new issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>) with
++<blockquote><p>
++Mark as NAD. Alisdair will open a new issue (<a href="lwg-defects.html#1247">1247</a>) with
+ proposed wording to handle <tt>auto_ptr_ref</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in D.12.1 [auto.ptr]:
++Change the synopsis in X [auto.ptr]:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ <del>template &lt;class Y&gt; struct auto_ptr_ref {};</del>
+
+ <ins>// exposition only</ins>
+@@ -9779,14 +8609,14 @@ Change the synopsis in D.12.1 [auto.ptr]:
+ </pre></blockquote>
+
+ <p>
+-Remove D.12.1.3 [auto.ptr.conv].
++Remove X [auto.ptr.conv].
+ </p>
+
+ <p>
+-Change D.12.1 [auto.ptr], p3:
++Change X [auto.ptr], p3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>auto_ptr</tt> provides a semantics of strict ownership. An
+ <tt>auto_ptr</tt> owns the object it holds a pointer to. Copying an
+ <tt>auto_ptr</tt> copies the pointer and transfers ownership to the
+@@ -9804,14 +8634,15 @@ function. <tt>auto_ptr</tt> does not meet the <tt>CopyConstructible</tt>
+ and <tt>Assignable</tt> requirements for Standard Library container
+ elements and thus instantiating a Standard Library container with an
+ <tt>auto_ptr</tt> results in undefined behavior. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change D.12.1.1 [auto.ptr.cons], p5:
++Change [auto.ptr.cons], p5:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;<ins> const</ins>&amp; a) throw();
++<pre>
++template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;<ins> const</ins>&amp; a) throw();
+ </pre>
+ <blockquote>
+ <p>
+@@ -9827,11 +8658,12 @@ Change D.12.1.1 [auto.ptr.cons], p5:
+ </blockquote>
+
+ <p>
+-Change D.12.1.1 [auto.ptr.cons], p10:
++Change [auto.ptr.cons], p10:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;<del>&amp;</del> a) throw();
++<pre>
++template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;<del>&amp;</del> a) throw();
+ </pre>
+ <blockquote>
+ <p>
+@@ -9853,18 +8685,19 @@ The expression <tt>delete get()</tt> is well formed.
+
+
+ <hr>
+-<h3><a name="466"></a>466. basic_string ctor should prevent null pointer error</h3>
+-<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2004-06-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.require">issues</a> in [string.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="466"></a>466. <tt>basic_string</tt> ctor should prevent null pointer error</h3>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2004-06-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Today, my colleagues and me wasted a lot of time. After some time, I
+ found the problem. It could be reduced to the following short example:
+ </p>
+
+-<pre> #include &lt;string&gt;
++<pre>
++ #include &lt;string&gt;
+ int main() { std::string( 0 ); }
+ </pre>
+
+@@ -9873,8 +8706,8 @@ Comeau online) compile the above without errors or warnings! The
+ programs (at least for the GCC) resulted in a SEGV.</p>
+
+ <p>I know that the standard explicitly states that the ctor of string
+-requires a char* which is not zero. STLs could easily detect the above
+-case with a private ctor for basic_string which takes a single 'int'
++requires a <tt>char*</tt> which is not zero. STLs could easily detect the above
++case with a private ctor for <tt>basic_string</tt> which takes a single '<tt>int</tt>'
+ argument. This would catch the above code at compile time and would not
+ ambiguate any other legal ctors.</p>
+
+@@ -9897,13 +8730,13 @@ designed to solve exactly this kind of problem.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We are unable to achieve consensus on an approach to a resolution.
+ There is some sentiment for treating this as a QOI matter.
+ It is also possible
+ that when <tt>string</tt> is brought into the concepts world,
+ this issue might be addressed in that context.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -9933,7 +8766,8 @@ The consensus was NAD.
+ Add to the synopsis in 21.4 [basic.string]
+ </p>
+
+-<blockquote><pre><ins>basic_string( nullptr_t ) = delete;</ins>
++<blockquote><pre>
++<ins>basic_string( nullptr_t ) = delete;</ins>
+ </pre></blockquote>
+
+
+@@ -9942,10 +8776,11 @@ Add to the synopsis in 21.4 [basic.string]
+
+ <hr>
+ <h3><a name="470"></a>470. accessing containers from their elements' special functions</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -9966,7 +8801,8 @@ in some surprising (i.e., undefined) behavior.
+
+ <p>Add to Container Requirements the following new paragraph:</p>
+
+-<pre> Unless otherwise specified, the behavior of a program that
++<pre>
++ Unless otherwise specified, the behavior of a program that
+ invokes a container member function f from a member function
+ g of the container's value_type on a container object c that
+ called g from its mutating member function h, is undefined.
+@@ -9995,11 +8831,11 @@ corner cases.
+
+ <hr>
+ <h3><a name="472"></a>472. Missing "Returns" clause in std::equal_range</h3>
+-<p><b>Section:</b> 25.4.3.3 [equal.range] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Prateek R Karandikar <b>Opened:</b> 2004-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#equal.range">issues</a> in [equal.range].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a></p>
++<p><b>Section:</b> 25.4.3.3 [equal.range] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Prateek R Karandikar <b>Opened:</b> 2004-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#equal.range">issues</a> in [equal.range].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#270">270</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is no "Returns:" clause for std::equal_range, which returns non-void.
+@@ -10010,7 +8846,7 @@ There is no "Returns:" clause for std::equal_range, which returns non-void.
+
+
+ <p><b>Rationale:</b></p>
+-<p>Fixed as part of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>.</p>
++<p>Fixed as part of issue <a href="lwg-defects.html#270">270</a>.</p>
+
+
+
+@@ -10019,10 +8855,10 @@ There is no "Returns:" clause for std::equal_range, which returns non-void.
+
+ <hr>
+ <h3><a name="476"></a>476. Forward Iterator implied mutability</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>24.1/3 says:</p>
+@@ -10039,7 +8875,7 @@ iterators non-conforming. I think we need to sever the refinement
+ relationship between forward iterator and output iterator.
+ </p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#200">200</a>. But this is not a dup.</p>
++<p>Related issue: <a href="lwg-defects.html#200">200</a>. But this is not a dup.</p>
+
+
+
+@@ -10058,23 +8894,24 @@ overhaul.)</p>
+
+
+ <hr>
+-<h3><a name="477"></a>477. Operator-&gt; for const forward iterators</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a></p>
++<h3><a name="477"></a>477. Operator-> for const forward iterators</h3>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#478">478</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The Forward Iterator requirements table contains the following:
+ </p>
+-<pre> expression return type operational precondition
++<pre>
++ expression return type operational precondition
+ semantics
+ ========== ================== =========== ==========================
+- a-&gt;m U&amp; if X is mutable, (*a).m pre: (*a).m is well-defined.
++ a->m U&amp; if X is mutable, (*a).m pre: (*a).m is well-defined.
+ otherwise const U&amp;
+
+- r-&gt;m U&amp; (*r).m pre: (*r).m is well-defined.
++ r->m U&amp; (*r).m pre: (*r).m is well-defined.
+ </pre>
+
+ <p>
+@@ -10094,7 +8931,7 @@ of referenced members. But Paragraph 11 of [lib.iterator.requirements] says:
+ <p>AFAICT if we need the second line at all, it should read the same
+ as the first line.</p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a></p>
++<p>Related issue: <a href="lwg-defects.html#478">478</a></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -10103,7 +8940,7 @@ as the first line.</p>
+ <p><b>Rationale:</b></p>
+ <p>The LWG agrees that this is a real problem. Marked as a DUP
+ because the LWG chose to adopt the solution proposed in
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>.
++ <a href="lwg-defects.html#478">478</a>.
+ </p>
+
+
+@@ -10112,21 +8949,23 @@ as the first line.</p>
+
+ <hr>
+ <h3><a name="479"></a>479. Container requirements and placement new</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2004-08-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a></p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2004-08-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#580">580</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Nothing in the standard appears to make this program ill-formed:</p>
+
+-<pre> struct C {
++<pre>
++ struct C {
+ void* operator new( size_t s ) { return ::operator new( s ); }
+ // NOTE: this hides in-place and nothrow new
+ };
+
+ int main() {
+- vector&lt;C&gt; v;
++ vector&lt;C> v;
+ v.push_back( C() );
+ }
+ </pre>
+@@ -10160,15 +8999,15 @@ support that the eventual solution should make this code well formed.
+
+ <hr>
+ <h3><a name="480"></a>480. unary_function and binary_function should have protected nonvirtual destructors</h3>
+-<p><b>Section:</b> X [base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2004-08-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#base">issues</a> in [base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [depr.base] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2004-08-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.base">issues</a> in [depr.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The classes std::unary_function and std::binary_function are both
+ designed to be inherited from but contain no virtual functions. This
+ makes it too easy for a novice programmer to write code like
+-binary_function&lt;int, int, int&gt; *p = new plus&lt;int&gt;; delete p;</p>
++binary_function&lt;int, int, int> *p = new plus&lt;int>; delete p;</p>
+
+ <p>There are two common ways to prevent this source of undefined
+ behavior: give the base class a public virtual destructor, or give it
+@@ -10181,13 +9020,14 @@ nonvirtual destructors.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change Paragraph 20.3.1 of the Standard from</p>
+-<pre> template &lt;class Arg, class Result&gt;
++<pre>
++ template &lt;class Arg, class Result>
+ struct unary_function {
+ typedef Arg argument_type;
+ typedef Result result_type;
+ };
+
+- template &lt;class Arg1, class Arg2, class Result&gt;
++ template &lt;class Arg1, class Arg2, class Result>
+ struct binary_function {
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+@@ -10196,7 +9036,8 @@ nonvirtual destructors.</p>
+ </pre>
+
+ <p>to</p>
+-<pre> template &lt;class Arg, class Result&gt;
++<pre>
++ template &lt;class Arg, class Result>
+ struct unary_function {
+ typedef Arg argument_type;
+ typedef Result result_type;
+@@ -10204,7 +9045,7 @@ nonvirtual destructors.</p>
+ ~unary_function() {}
+ };
+
+- template &lt;class Arg1, class Arg2, class Result&gt;
++ template &lt;class Arg1, class Arg2, class Result>
+ struct binary_function {
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+@@ -10225,10 +9066,10 @@ nonvirtual destructors.</p>
+
+ <hr>
+ <h3><a name="481"></a>481. unique's effects on the range [result, last)</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2004-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2004-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard says that unique(first, last) "eliminates all but the
+@@ -10262,16 +9103,17 @@ explicit, but it's hard to think that's a major problem.</p>
+
+ <hr>
+ <h3><a name="483"></a>483. Heterogeneous equality and EqualityComparable</h3>
+-<p><b>Section:</b> 25.2 [alg.nonmodifying], 25.3 [alg.modifying.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2004-09-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a></p>
++<p><b>Section:</b> 25.2 [alg.nonmodifying], 25.3 [alg.modifying.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2004-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#283">283</a></p>
+ <p><b>Discussion:</b></p>
+ <p>c++std-lib-14262</p>
+
+ <p>[lib.alg.find] requires T to be EqualityComparable:</p>
+
+-<pre>template &lt;class InputIterator, class T&gt;
++<pre>
++template &lt;class InputIterator, class T>
+ InputIterator find(InputIterator first, InputIterator last,
+ const T&amp; value);
+ </pre>
+@@ -10358,303 +9200,8 @@ operator that takes a T, or a T may be convertible to the type of *i.
+
+
+ <p><b>Rationale:</b></p>
+-<p>Duplicate of (a subset of) issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a>.</p>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="484"></a>484. Convertible to T</h3>
+-<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-09-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>From comp.std.c++:</p>
+-
+-<p>
+-I note that given an input iterator a for type T,
+-then *a only has to be "convertable to T", not actually of type T.
+-</p>
+-
+-<p>Firstly, I can't seem to find an exact definition of "convertable to T".
+-While I assume it is the obvious definition (an implicit conversion), I
+-can't find an exact definition. Is there one?</p>
+-
+-<p>Slightly more worryingly, there doesn't seem to be any restriction on
+-the this type, other than it is "convertable to T". Consider two input
+-iterators a and b. I would personally assume that most people would
+-expect *a==*b would perform T(*a)==T(*b), however it doesn't seem that
+-the standard requires that, and that whatever type *a is (call it U)
+-could have == defined on it with totally different symantics and still
+-be a valid inputer iterator.</p>
+-
+-<p>Is this a correct reading? When using input iterators should I write
+-T(*a) all over the place to be sure that the object i'm using is the
+-class I expect?</p>
+-
+-<p>This is especially a nuisance for operations that are defined to be
+- "convertible to bool". (This is probably allowed so that
+- implementations could return say an int and avoid an unnessary
+- conversion. However all implementations I have seen simply return a
+- bool anyway. Typical implemtations of STL algorithms just write
+- things like <tt>while(a!=b &amp;&amp; *a!=0)</tt>. But strictly
+- speaking, there are lots of types that are convertible to T but
+- that also overload the appropriate operators so this doesn't behave
+- as expected.</p>
+-
+-<p>If we want to make code like this legal (which most people seem to
+- expect), then we'll need to tighten up what we mean by "convertible
+- to T".</p>
+-
+-<p><i>[Lillehammer: The first part is NAD, since "convertible" is
+- well-defined in core. The second part is basically about pathological
+- overloads. It's a minor problem but a real one. So leave open for
+- now, hope we solve it as part of iterator redesign.]</i></p>
+-
+-
+-<p><i>[
+-2009-07-28 Reopened by Alisdair. No longer solved by concepts.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD Future. We agree there's an issue, but there is no
+-proposed solution at this time and this will be solved by concepts in
+-the future.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2758.pdf">N2758</a>.
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="485"></a>485. output iterator insufficiently constrained</h3>
+-<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-10-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The note on 24.1.2 Output iterators insufficiently limits what can be
+-performed on output iterators. While it requires that each iterator is
+-progressed through only once and that each iterator is written to only
+-once, it does not require the following things:</p>
+-
+-<p>Note: Here it is assumed that x is an output iterator of type X which
+-has not yet been assigned to.</p>
+-
+-<p>a) That each value of the output iterator is written to:
+-The standard allows:
+-++x; ++x; ++x;
+-</p>
+-
+-<p>
+-b) That assignments to the output iterator are made in order
+-X a(x); ++a; *a=1; *x=2; is allowed
+-</p>
+-
+-<p>
+-c) Chains of output iterators cannot be constructed:
+-X a(x); ++a; X b(a); ++b; X c(b); ++c; is allowed, and under the current
+-wording (I believe) x,a,b,c could be written to in any order.
+-</p>
+-
+-<p>I do not believe this was the intension of the standard?</p>
+-<p><i>[Lillehammer: Real issue. There are lots of constraints we
+- intended but didn't specify. Should be solved as part of iterator
+- redesign.]</i></p>
+-
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Bill provided wording according to consensus.
+-</blockquote>
+-
+-<p><i>[
+-2009-07-21 Alisdair requests change from Review to Open. See thread starting
+-with c++std-lib-24459 for discussion.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Modified wording. Set to Review.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to Ready after looking at again in a larger group in Santa Cruz.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by N3066.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change Table 101 — Output iterator requirements in 24.2.4 [output.iterators]:
+-</p>
+-<blockquote>
+-<table border="1">
+-<caption>Table 101 — Output iterator requirements</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Operational semantics</th>
+-<th>Assertion/note pre-/post-condition</th>
+-</tr>
++<p>Duplicate of (a subset of) issue <a href="lwg-defects.html#283">283</a>.</p>
+
+-<tr>
+-<td>
+-<tt>X(a)</tt>
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-<tt>a = t</tt> is equivalent to <tt>X(a) = t</tt>. note: a destructor is assumed.
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>X u(a);</tt><br>
+-<tt>X u = a;</tt>
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>*r = o</tt>
+-</td>
+-<td>
+-result is not used
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-<ins>
+-Post: <tt>r</tt> is not required to be dereferenceable. <tt>r</tt> is incrementable.
+-</ins>
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>++r</tt>
+-</td>
+-<td>
+-<tt>X&amp;</tt>
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-<tt>&amp;r == &amp;++r</tt>
+-<ins>
+-Post: <tt>r</tt> is dereferenceable, unless otherwise specified. <tt>r</tt> is not required to be incrementable.
+-</ins>
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>r++</tt>
+-</td>
+-<td>
+-convertible to <tt>const X&amp;</tt>
+-</td>
+-<td>
+-<tt>{X tmp = r;<br>++r;<br>return tmp;}</tt>
+-</td>
+-<td>
+-<ins>
+-Post: <tt>r</tt> is dereferenceable, unless otherwise specified. <tt>r</tt> is not required to be incrementable.
+-</ins>
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>*r++ = o;</tt>
+-</td>
+-<td>
+-result is not used
+-</td>
+-<td>
+-&nbsp;
+-</td>
+-<td>
+-
+-</td>
+-</tr>
+-
+-</tbody></table>
+-</blockquote>
+
+
+
+@@ -10662,11 +9209,11 @@ result is not used
+
+ <hr>
+ <h3><a name="486"></a>486. min/max CopyConstructible requirement is too strict</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-10-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a></p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#281">281</a></p>
+ <p><b>Discussion:</b></p>
+ <p>A straightforward implementation of these algorithms does not need to
+ copy T.</p>
+@@ -10685,10 +9232,11 @@ copy T.</p>
+
+ <hr>
+ <h3><a name="487"></a>487. Allocator::construct is too limiting</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Dhruv Matani <b>Opened:</b> 2004-10-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dhruv Matani <b>Opened:</b> 2004-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard's version of allocator::construct(pointer,
+@@ -10701,9 +9249,10 @@ manually constructed. Now it may not always be possible to copy
+ construct a socket eh! So, I feel that the changes should go in the
+ allocator::construct(), making it:
+ </p>
+-<pre> template&lt;typename T&gt;
++<pre>
++ template&lt;typename T>
+ struct allocator{
+- template&lt;typename T1&gt;
++ template&lt;typename T1>
+ void construct(pointer T1 const&amp; rt1);
+ };
+ </pre>
+@@ -10729,10 +9278,10 @@ be called! Doesn't that sound great?
+
+ <hr>
+ <h3><a name="489"></a>489. std::remove / std::remove_if wrongly specified</h3>
+-<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Section 25.2.7 [lib.alg.remove], paragraphs 1 to 5 describe the
+ behavior of the mutating sequence operations std::remove and
+@@ -10928,10 +9477,10 @@ ISO/IEC 14882:2003.
+
+ <hr>
+ <h3><a name="490"></a>490. std::unique wrongly specified</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Section 25.2.8 [lib.alg.unique], paragraphs 1 to 3 describe the
+ behavior of the mutating sequence operation std::unique. However, the
+@@ -11178,14 +9727,14 @@ change, so there is no real-world harm here.</p>
+
+
+ <hr>
+-<h3><a name="491"></a>491. std::list&lt;&gt;::unique incorrectly specified</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="491"></a>491. std::list&lt;>::unique incorrectly specified</h3>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In Section 23.3.4.4 [list.ops], paragraphs 19 to 21 describe the
+-behavior of the std::list&lt;T, Allocator&gt;::unique operation. However, the
++<p>In Section 23.3.5.5 [list.ops], paragraphs 19 to 21 describe the
++behavior of the std::list&lt;T, Allocator>::unique operation. However, the
+ current wording is defective for various reasons.</p>
+
+
+@@ -11194,7 +9743,7 @@ current wording is defective for various reasons.</p>
+ 1) Analysis of current wording:
+ </p>
+
+-<p>23.3.4.4 [list.ops], paragraph 19:</p>
++<p>23.3.5.5 [list.ops], paragraph 19:</p>
+
+ <p>
+ Current wording says:
+@@ -11208,7 +9757,7 @@ predicate argument) holds."</p>
+ This sentences makes use of the undefined term "Eliminates". Although it
+ is, to a certain degree, reasonable to consider the term "eliminate"
+ synonymous with "erase", using "Erase" in the first place, as the
+-wording of 23.3.4.4 [list.ops], paragraph 15 does, would be clearer.</p>
++wording of 23.3.5.5 [list.ops], paragraph 15 does, would be clearer.</p>
+
+ <p>
+ The range of the elements referred to by iterator i is "[first + 1,
+@@ -11225,7 +9774,7 @@ The same problems as pointed out in DR 202 (equivalence relation / order
+ of arguments for pred()) apply to this paragraph.</p>
+
+ <p>
+-23.3.4.4 [list.ops], paragraph 20:
++23.3.5.5 [list.ops], paragraph 20:
+ </p>
+
+ <p>
+@@ -11242,7 +9791,7 @@ expressions ( "*i == *(i - 1)", "pred(*i, *(i -1))" ).
+ </p>
+
+ <p>
+-23.3.4.4 [list.ops], paragraph 21:</p>
++23.3.5.5 [list.ops], paragraph 21:</p>
+
+ <p>
+ Current wording says:
+@@ -11281,7 +9830,7 @@ of DR 202, no impact on current code is expected.</p>
+ 3) Proposed fixes:</p>
+
+ <p>
+-Change 23.3.4.4 [list.ops], paragraph 19 to:</p>
++Change 23.3.5.5 [list.ops], paragraph 19 to:</p>
+
+ <p>
+ "Effect: Erases all but the first element from every consecutive group
+@@ -11300,7 +9849,7 @@ wording need also additional review.
+ b) "Erases" refers in the author's opinion unambiguously to the member
+ function "erase". In case there is doubt this might not be unamgibuous,
+ a direct reference to the member function "erase" is suggested [Note:
+-This would also imply a change of 23.3.4.4 [list.ops], paragraph
++This would also imply a change of 23.3.5.5 [list.ops], paragraph
+ 15.].
+ c) The expression "(i - 1)" was left, but is expected that DR submitted
+ by Thomas Mang regarding invalid iterator arithmetic expressions will
+@@ -11320,7 +9869,7 @@ elements consists of only a single element, this element is also
+ considered the first element."</p>
+
+ <p>
+-Change 23.3.4.4 [list.ops], paragraph 20 to:</p>
++Change 23.3.5.5 [list.ops], paragraph 20 to:</p>
+
+ <p>
+ "Throws: Nothing unless an exception is thrown by *(i-1) == *i or
+@@ -11331,7 +9880,7 @@ Comments to the new wording:</p>
+
+ <p>
+ a) The wording regarding the conditions is identical to proposed
+-23.3.4.4 [list.ops], paragraph 19. If 23.3.4.4 [list.ops],
++23.3.5.5 [list.ops], paragraph 19. If 23.3.5.5 [list.ops],
+ paragraph 19 is resolved in another way, the proposed wording need also
+ additional review.
+ b) The expression "(i - 1)" was left, but is expected that DR submitted
+@@ -11340,7 +9889,7 @@ take this into account.
+ c) Typos fixed.</p>
+
+ <p>
+-Change 23.3.4.4 [list.ops], paragraph 21 to:</p>
++Change 23.3.5.5 [list.ops], paragraph 21 to:</p>
+
+ <p>
+ "Complexity: If empty() == false, exactly size() - 1 applications of the
+@@ -11381,10 +9930,10 @@ harm.</p>
+
+ <hr>
+ <h3><a name="492"></a>492. Invalid iterator arithmetic expressions</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Mang <b>Opened:</b> 2004-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Various clauses other than clause 25 make use of iterator arithmetic not
+ supported by the iterator category in question.
+@@ -11434,7 +9983,8 @@ neither of these four cases:</p>
+ "In the description of the algorithms operator + and - are used for some
+ of the iterator categories for which they do not have to be defined. In
+ these cases the semantics of a+n is the same as that of</p>
+-<pre>{X tmp = a;
++<pre>
++{X tmp = a;
+ advance(tmp, n);
+ return tmp;
+ }
+@@ -11484,7 +10034,8 @@ of the iterator categories for which they do not have to be defined. In
+ this paragraph, a and b denote values of an iterator type, and n denotes
+ a value of a distance type between two iterators. In these cases the
+ semantics of a+n is the same as that of</p>
+-<pre>{X tmp = a;
++<pre>
++{X tmp = a;
+ advance(tmp, n);
+ return tmp;
+ }
+@@ -11550,18 +10101,18 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Keep open and ask Bill to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>.
+-</blockquote>
++<blockquote><p>
++This issue is related to <a href="lwg-defects.html#997">997</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -11598,10 +10149,10 @@ it doesn't cover. Bill will provide wording.]</i></p>
+
+ <hr>
+ <h3><a name="493"></a>493. Undefined Expression in Input Iterator Note Title</h3>
+-<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-12-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-12-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>1) In 24.1.1/3, the following text is currently present.</p>
+
+@@ -11638,11 +10189,11 @@ not guarantee the substitution property or referential transparency).</p>
+
+ <hr>
+ <h3><a name="494"></a>494. Wrong runtime complexity for associative container's insert and delete</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Hans B os <b>Opened:</b> 2004-12-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Hans B os <b>Opened:</b> 2004-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>According to [lib.associative.reqmts] table 69, the runtime comlexity
+ of insert(p, t) and erase(q) can be done in amortized constant time.</p>
+@@ -11697,9 +10248,9 @@ last) and insert(first, last).</p>
+
+ <hr>
+ <h3><a name="499"></a>499. Std. doesn't seem to require stable_sort() to be stable!</h3>
+-<p><b>Section:</b> 25.4.1.2 [stable.sort] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Prateek Karandikar <b>Opened:</b> 2005-04-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 25.4.1.2 [stable.sort] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Prateek Karandikar <b>Opened:</b> 2005-04-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <blockquote><p>
+ 17.3.1.1 Summary</p>
+@@ -11720,7 +10271,8 @@ other paragraphs are normative.
+ <blockquote><p>
+ 25.3.1.2 stable_sort
+ </p>
+-<pre>template&lt;class RandomAccessIterator&gt;
++<pre>
++template&lt;class RandomAccessIterator&gt;
+ void stable_sort(RandomAccessIterat or first, RandomAccessIterator last);
+
+ template&lt;class RandomAccessIterator, class Compare&gt;
+@@ -11767,10 +10319,10 @@ This change has already been made.
+
+ <hr>
+ <h3><a name="500"></a>500. do_length cannot be implemented correctly</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Krzysztof &#379;elechowski <b>Opened:</b> 2005-05-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Krzysztof &#379;elechowski <b>Opened:</b> 2005-05-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <ol>
+ <li>codecvt::do_length is of type int;</li>
+@@ -11792,10 +10344,10 @@ Contradiction.
+
+ <hr>
+ <h3><a name="501"></a>501. Proposal: strengthen guarantees of lib.comparisons</h3>
+-<p><b>Section:</b> X [base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Me &lt;anti_spam_email2003@yahoo.com&gt; <b>Opened:</b> 2005-06-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#base">issues</a> in [base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [depr.base] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Me &lt;anti_spam_email2003@yahoo.com&gt; <b>Opened:</b> 2005-06-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.base">issues</a> in [depr.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <blockquote><p>
+ "For templates greater, less, greater_equal, and less_equal,
+@@ -11864,10 +10416,10 @@ to detect overlapping memory situations.
+
+ <hr>
+ <h3><a name="502"></a>502. Proposition: Clarification of the interaction between a facet and an iterator</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Christopher Conrade Zseleghovski <b>Opened:</b> 2005-06-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Christopher Conrade Zseleghovski <b>Opened:</b> 2005-06-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Motivation:
+@@ -11925,10 +10477,10 @@ Bill.
+
+ <hr>
+ <h3><a name="503"></a>503. more on locales</h3>
+-<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2005-06-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2005-06-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ a) In 22.2.1.1 para. 2 we refer to "the instantiations required in Table
+@@ -12052,10 +10604,10 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="504"></a>504. Integer types in pseudo-random number engine requirements</h3>
+-<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req">issues</a> in [rand.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req">issues</a> in [rand.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In [tr.rand.req], Paragraph 2 states that "... s is a value of integral type,
+@@ -12121,10 +10673,10 @@ Portland: Subsumed by N2111.
+
+ <hr>
+ <h3><a name="506"></a>506. Requirements of Distribution parameter for variate_generator</h3>
+-<p><b>Section:</b> 26.5 [rand], TR1 5.1.3 [tr.rand.var] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5 [rand], TR1 5.1.3 [tr.rand.var] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 3 requires that template argument U (which corresponds to template
+@@ -12162,10 +10714,10 @@ Marc supports having min and max to satisfy generic programming interface.
+
+ <hr>
+ <h3><a name="509"></a>509. Uniform_int template parameters</h3>
+-<p><b>Section:</b> 26.5.8.1 [rand.dist.uni], TR1 5.1.7.1 [tr.rand.dist.iunif] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.uni">issues</a> in [rand.dist.uni].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.2 [rand.dist.uni], TR1 5.1.7.1 [tr.rand.dist.iunif] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.uni">issues</a> in [rand.dist.uni].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In [tr.rand.dist.iunif] the uniform_int distribution currently has a single
+@@ -12181,7 +10733,8 @@ We recommend that there be a second template parameter to
+ reflect the distribution's input_type, and that the existing first template
+ parameter continue to reflect (solely) the result_type:
+ </p>
+-<blockquote><pre>template&lt; class IntType = int, UIntType = unsigned int &gt;
++<blockquote><pre>
++template&lt; class IntType = int, UIntType = unsigned int &gt;
+ class uniform_int
+ {
+ public:
+@@ -12203,14 +10756,15 @@ eliminated.
+
+ <hr>
+ <h3><a name="510"></a>510. Input_type for bernoulli_distribution</h3>
+-<p><b>Section:</b> 26.5.8.2 [rand.dist.bern], TR1 5.1.7.2 [tr.rand.dist.bern] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.3 [rand.dist.bern], TR1 5.1.7.2 [tr.rand.dist.bern] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In [tr.rand.dist.bern] the distribution currently requires;
+ </p>
+-<blockquote><pre>typedef int input_type;
++<blockquote><pre>
++typedef int input_type;
+ </pre></blockquote>
+
+
+@@ -12218,7 +10772,8 @@ In [tr.rand.dist.bern] the distribution currently requires;
+ <p>
+ We believe this is an unfortunate choice, and recommend instead:
+ </p>
+-<blockquote><pre>typedef unsigned int input_type;
++<blockquote><pre>
++typedef unsigned int input_type;
+ </pre></blockquote>
+
+ <p><i>[
+@@ -12234,10 +10789,10 @@ eliminated.
+
+ <hr>
+ <h3><a name="511"></a>511. Input_type for binomial_distribution</h3>
+-<p><b>Section:</b> 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist">issues</a> in [rand.dist].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist">issues</a> in [rand.dist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Unlike all other distributions in TR1, this binomial_distribution has an
+@@ -12245,7 +10800,8 @@ implementation-defined input_type. We believe this is an unfortunate choice,
+ because it hinders users from writing portable code. It also hinders the
+ writing of compliance tests. We recommend instead:
+ </p>
+-<blockquote><pre>typedef RealType input_type;
++<blockquote><pre>
++typedef RealType input_type;
+ </pre></blockquote>
+ <p>
+ While this choice is somewhat arbitrary (as it was for some of the other
+@@ -12309,7 +10865,8 @@ in each case as having some real type.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<blockquote><pre>typedef RealType input_type;
++<blockquote><pre>
++typedef RealType input_type;
+ </pre></blockquote>
+
+ <p><i>[
+@@ -12323,14 +10880,14 @@ eliminated.
+
+
+ <hr>
+-<h3><a name="512"></a>512. Seeding subtract_with_carry_01 from a single unsigned long</h3>
+-<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="512"></a>512. Seeding <tt>subtract_with_carry_01</tt> from a single unsigned long</h3>
++<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Paragraph 8 specifies the algorithm by which a subtract_with_carry_01 engine
++Paragraph 8 specifies the algorithm by which a <tt>subtract_with_carry_01</tt> engine
+ is to be seeded given a single unsigned long. This algorithm is seriously
+ flawed in the case where the engine parameter w (also known as word_size)
+ exceeds 31 [bits]. The key part of the paragraph reads:
+@@ -12345,12 +10902,12 @@ and so forth.
+ Since the specified linear congruential engine, lcg, delivers numbers with
+ a maximum of 2147483563 (just a shade under 31 bits), then when w is, for
+ example, 48, each of the x(i) will be less than 2**-17. The consequence
+-is that roughly the first 400 numbers delivered will be conspicuously
++is that roughly the first 400 numbers delivered will be conspicuously
+ close to either zero or one.
+ </p>
+ <p>
+ Unfortunately, this is not an innocuous flaw: One of the predefined engines
+-in [tr.rand.predef], namely ranlux64_base_01, has w = 48 and would exhibit
++in [tr.rand.predef], namely <tt>ranlux64_base_01</tt>, has w = 48 and would exhibit
+ this poor behavior, while the original N1378 proposal states that these
+ pre-defined engines are intended to be of "known good properties."
+ </p>
+@@ -12367,7 +10924,7 @@ void seed(unsigned long value = 19780503) by
+ case, <del>with a linear congruential generator <tt>lcg</tt>(i) having parameters
+ <tt><i>m<sub>lcg</sub></i> = 2147483563</tt>, <tt><i>a<sub>lcg</sub></i> = 40014</tt>,
+ <tt><i>c<sub>lcg</sub></i> = 0</tt>, and <tt><i>lcg</i>(0) = value</tt>,</del>
+-sets <ins>carry<tt>(-1)</tt> and</ins> <tt>x(-r) … x(-1)</tt>
++sets <ins>carry<tt>(-1)</tt> and</ins> <tt>x(-r) &hellip; x(-1)</tt>
+ <ins>as if executing</ins></p>
+
+ <blockquote><pre><ins>
+@@ -12376,8 +10933,8 @@ seed(lcg);
+ </ins></pre></blockquote>
+
+ <p>
+-<del>to <tt>(<i>lcg</i>(1) · 2<sup>-<i>w</i></sup>) mod 1
+-… (<i>lcg</i>(<i>r</i>) · 2<sup>-<i>w</i></sup>) mod 1</tt>,
++<del>to <tt>(<i>lcg</i>(1) &middot; 2<sup>-<i>w</i></sup>) mod 1
++&hellip; (<i>lcg</i>(<i>r</i>) &middot; 2<sup>-<i>w</i></sup>) mod 1</tt>,
+ respectively. If <tt><i>x</i>(-1) == 0</tt>, sets carry<tt>(-1) = 2<sup>-<i>w</i></sup></tt>,
+ else sets carry<tt>(-1) = 0</tt>.</del></p>
+ </blockquote>
+@@ -12399,12 +10956,12 @@ intended. Moved to Ready.
+ <p><b>Rationale:</b></p>
+ <p>
+ Jens: I'm using an explicit type here, because fixing the
+-prose would probably not qualify for the (with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a> even
++prose would probably not qualify for the (with issue <a href="lwg-closed.html#504">504</a> even
+ stricter) requirements we have for seed(Gen&amp;).
+ </p>
+
+ <p><i>[
+-Portland: Subsumed by N2111.
++Portland: Subsumed by N2111.
+ ]</i></p>
+
+
+@@ -12414,10 +10971,10 @@ Portland: Subsumed by N2111.
+
+ <hr>
+ <h3><a name="513"></a>513. Size of state for subtract_with_carry_01</h3>
+-<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 3 begins:
+@@ -12467,9 +11024,9 @@ Berlin: N1932 adopts the proposed NAD.
+
+ <hr>
+ <h3><a name="514"></a>514. Size of state for subtract_with_carry</h3>
+-<p><b>Section:</b> 26.5.3.3 [rand.eng.sub], TR1 5.1.4.3 [tr.rand.eng.sub] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.3.3 [rand.eng.sub], TR1 5.1.4.3 [tr.rand.eng.sub] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 2 begins:
+@@ -12512,17 +11069,18 @@ Berlin: N1932 adopts the proposed NAD.
+
+ <hr>
+ <h3><a name="515"></a>515. Random number engine traits</h3>
+-<p><b>Section:</b> 26.5.2 [rand.synopsis], TR1 5.1.2 [tr.rand.synopsis] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.synopsis">issues</a> in [rand.synopsis].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.2 [rand.synopsis], TR1 5.1.2 [tr.rand.synopsis] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.synopsis">issues</a> in [rand.synopsis].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ To accompany the concept of a pseudo-random number engine as defined in Table 17,
+ we propose and recommend an adjunct template, engine_traits, to be declared in
+ [tr.rand.synopsis] as:
+ </p>
+-<blockquote><pre>template&lt; class PSRE &gt;
++<blockquote><pre>
++template&lt; class PSRE &gt;
+ class engine_traits;
+ </pre></blockquote>
+ <p>
+@@ -12538,7 +11096,8 @@ For example, today it is not possible to write an efficient generic function tha
+ requires any specific number of random bits. More specifically, consider a
+ cryptographic application that internally needs 256 bits of randomness per call:
+ </p>
+-<blockquote><pre>template&lt; class Eng, class InIter, class OutIter &gt;
++<blockquote><pre>
++template&lt; class Eng, class InIter, class OutIter &gt;
+ void crypto( Eng&amp; e, InIter in, OutIter out );
+ </pre></blockquote>
+ <p>
+@@ -12549,7 +11108,8 @@ engine, the algorithm has no means of determining how many times to call the eng
+ In a new section [tr.rand.eng.traits], we proposed to define the engine_traits
+ template as:
+ </p>
+-<blockquote><pre>template&lt; class PSRE &gt;
++<blockquote><pre>
++template&lt; class PSRE &gt;
+ class engine_traits
+ {
+ static std::size_t bits_of_randomness = 0u;
+@@ -12586,10 +11146,10 @@ covers this. Already in WP.
+
+ <hr>
+ <h3><a name="516"></a>516. Seeding subtract_with_carry_01 using a generator</h3>
+-<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.3 [rand.eng], TR1 5.1.4.4 [tr.rand.eng.sub1] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 6 says:
+@@ -12624,10 +11184,10 @@ Portland: Subsumed by N2111.
+
+ <hr>
+ <h3><a name="517"></a>517. Should include name in external representation</h3>
+-<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req">issues</a> in [rand.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req">issues</a> in [rand.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The last two rows of Table 16 deal with the i/o requirements of an engine,
+@@ -12661,164 +11221,11 @@ Berlin: N1932 considers this NAD. This is a QOI issue.
+
+
+ <hr>
+-<h3><a name="523"></a>523. regex case-insensitive character ranges are unimplementable as specified</h3>
+-<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2005-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re">issues</a> in [re].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-A problem with TR1 regex is currently being discussed on the Boost
+-developers list. It involves the handling of case-insensitive matching
+-of character ranges such as [Z-a]. The proper behavior (according to the
+-ECMAScript standard) is unimplementable given the current specification
+-of the TR1 regex_traits&lt;&gt; class template. John Maddock, the author of
+-the TR1 regex proposal, agrees there is a problem. The full discussion
+-can be found at http://lists.boost.org/boost/2005/06/28850.php (first
+-message copied below). We don't have any recommendations as yet.
+-</p>
+-<p>
+--- Begin original message --
+-</p>
+-<p>
+-The situation of interest is described in the ECMAScript specification
+-(ECMA-262), section 15.10.2.15:
+-</p>
+-<p>
+-"Even if the pattern ignores case, the case of the two ends of a range
+-is significant in determining which characters belong to the range.
+-Thus, for example, the pattern /[E-F]/i matches only the letters E, F,
+-e, and f, while the pattern /[E-f]/i matches all upper and lower-case
+-ASCII letters as well as the symbols [, \, ], ^, _, and `."
+-</p>
+-<p>
+-A more interesting case is what should happen when doing a
+-case-insentitive match on a range such as [Z-a]. It should match z, Z,
+-a, A and the symbols [, \, ], ^, _, and `. This is not what happens with
+-Boost.Regex (it throws an exception from the regex constructor).
+-</p>
+-<p>
+-The tough pill to swallow is that, given the specification in TR1, I
+-don't think there is any effective way to handle this situation.
+-According to the spec, case-insensitivity is handled with
+-regex_traits&lt;&gt;::translate_nocase(CharT) -- two characters are equivalent
+-if they compare equal after both are sent through the translate_nocase
+-function. But I don't see any way of using this translation function to
+-make character ranges case-insensitive. Consider the difficulty of
+-detecting whether "z" is in the range [Z-a]. Applying the transformation
+-to "z" has no effect (it is essentially std::tolower). And we're not
+-allowed to apply the transformation to the ends of the range, because as
+-ECMA-262 says, "the case of the two ends of a range is significant."
+-</p>
+-<p>
+-So AFAICT, TR1 regex is just broken, as is Boost.Regex. One possible fix
+-is to redefine translate_nocase to return a string_type containing all
+-the characters that should compare equal to the specified character. But
+-this function is hard to implement for Unicode, and it doesn't play nice
+-with the existing ctype facet. What a mess!
+-</p>
+-<p>
+--- End original message --
+-</p>
+-
+-<p><i>[
+-John Maddock adds:
+-]</i></p>
+-
+-
+-<p>
+-One small correction, I have since found that ICU's regex package does
+-implement this correctly, using a similar mechanism to the current
+-TR1.Regex.
+-</p>
+-<p>
+-Given an expression [c1-c2] that is compiled as case insensitive it:
+-</p>
+-<p>
+-Enumerates every character in the range c1 to c2 and converts it to it's
+-case folded equivalent. That case folded character is then used a key to a
+-table of equivalence classes, and each member of the class is added to the
+-list of possible matches supported by the character-class. This second step
+-isn't possible with our current traits class design, but isn't necessary if
+-the input text is also converted to a case-folded equivalent on the fly.
+-</p>
+-<p>
+-ICU applies similar brute force mechanisms to character classes such as
+-[[:lower:]] and [[:word:]], however these are at least cached, so the impact
+-is less noticeable in this case.
+-</p>
+-<p>
+-Quick and dirty performance comparisons show that expressions such as
+-"[X-\\x{fff0}]+" are indeed very slow to compile with ICU (about 200 times
+-slower than a "normal" expression). For an application that uses a lot of
+-regexes this could have a noticeable performance impact. ICU also has an
+-advantage in that it knows the range of valid characters codes: code points
+-outside that range are assumed not to require enumeration, as they can not
+-be part of any equivalence class. I presume that if we want the TR1.Regex
+-to work with arbitrarily large character sets enumeration really does become
+-impractical.
+-</p>
+-<p>
+-Finally note that Unicode has:
+-</p>
+-<p>
+-Three cases (upper, lower and title).
+-One to many, and many to one case transformations.
+-Character that have context sensitive case translations - for example an
+-uppercase sigma has two different lowercase forms - the form chosen depends
+-on context(is it end of a word or not), a caseless match for an upper case
+-sigma should match either of the lower case forms, which is why case folding
+-is often approximated by tolower(toupper(c)).
+-</p>
+-<p>
+-Probably we need some way to enumerate character equivalence classes,
+-including digraphs (either as a result or an input), and some way to tell
+-whether the next character pair is a valid digraph in the current locale.
+-</p>
+-<p>
+-Hoping this doesn't make this even more complex that it was already,
+-</p>
+-
+-<p><i>[
+-Portland: Alisdair: Detect as invalid, throw an exception.
+-Pete: Possible general problem with case insensitive ranges.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-We agree that this is a problem, but we do not know the answer.
+-</p>
+-<p>
+-We are going to declare this NAD until existing practice leads us in some direction.
+-</p>
+-<p>
+-No objection to NAD Future.
+-</p>
+-<p>
+-Move to NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="526"></a>526. Is it undefined if a function in the standard changes in parameters?</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2005-09-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2005-09-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Problem: There are a number of places in the C++ standard library where
+@@ -12965,10 +11372,10 @@ template insert functions from self referencing.</li>
+
+ <hr>
+ <h3><a name="528"></a>528. <tt>const_iterator</tt> <tt>iterator</tt> issue when they are the same type</h3>
+-<p><b>Section:</b> 23.7 [unord], TR1 6.3.4 [tr.unord.unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2005-10-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord">issues</a> in [unord].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.5 [unord], TR1 6.3.4 [tr.unord.unord] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2005-10-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ while implementing the resolution of issue 6.19 I'm noticing the
+@@ -13030,20 +11437,20 @@ Post-Berlin: Beman supplied wording.
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Toronto: The first issue has been fixed by N2350 (the insert and erase members
+ are collapsed into one signature). Alisdair to open a separate issue on the
+ chapter 17 wording.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="529"></a>529. The standard encourages redundant and confusing preconditions</h3>
+-<p><b>Section:</b> 17.6.3.11 [res.on.required] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2005-10-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 17.6.4.11 [res.on.required] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2005-10-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 17.4.3.8/1 says:
+@@ -13069,7 +11476,8 @@ example to set, but it encourages needless complication and redundancy
+ in the standard. For example:
+ </p>
+
+-<blockquote><pre> 21 Strings library
++<blockquote><pre>
++ 21 Strings library
+ 21.3.3 basic_string capacity
+
+ void resize(size_type n, charT c);
+@@ -13134,116 +11542,13 @@ Alan provided the survey
+
+
+ <hr>
+-<h3><a name="532"></a>532. Tuple comparison</h3>
+-<p><b>Section:</b> 20.4.2.7 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2005-11-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a></p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Where possible, tuple comparison operators &lt;,&lt;=,=&gt;, and &gt; ought to be
+-defined in terms of std::less rather than operator&lt;, in order to
+-support comparison of tuples of pointers.
+-</p>
+-
+-<p><i>[
+-2009-07-28 Reopened by Alisdair. No longer solved by concepts.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-If we solve this for <tt>tuple</tt> we would have to solve it for <tt>pair</tt>
+-algorithms, etc. It is too late to do that at this time. Move to NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-change 6.1.3.5/5 from:
+-</p>
+-
+-<blockquote><p>
+- Returns: The result of a lexicographical comparison between t and
+- u. The result is defined as: (bool)(get&lt;0&gt;(t) &lt; get&lt;0&gt;(u)) ||
+- (!(bool)(get&lt;0&gt;(u) &lt; get&lt;0&gt;(t)) &amp;&amp; ttail &lt; utail), where rtail for
+- some tuple r is a tuple containing all but the first element of
+- r. For any two zero-length tuples e and f, e &lt; f returns false.
+-</p></blockquote>
+-
+-<p>
+-to:
+-</p>
+-
+-<blockquote>
+-<p>
+- Returns: The result of a lexicographical comparison between t and
+- u. For any two zero-length tuples e and f, e &lt; f returns false.
+- Otherwise, the result is defined as: cmp( get&lt;0&gt;(t), get&lt;0&gt;(u)) ||
+- (!cmp(get&lt;0&gt;(u), get&lt;0&gt;(t)) &amp;&amp; ttail &lt; utail), where rtail for some
+- tuple r is a tuple containing all but the first element of r, and
+- cmp(x,y) is an unspecified function template defined as follows.
+-</p>
+-<p>
+- Where T is the type of x and U is the type of y:
+-</p>
+-
+-<p>
+- if T and U are pointer types and T is convertible to U, returns
+- less&lt;U&gt;()(x,y)
+-</p>
+-
+-<p>
+- otherwise, if T and U are pointer types, returns less&lt;T&gt;()(x,y)
+-</p>
+-
+-<p>
+- otherwise, returns (bool)(x &lt; y)
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Berlin: This issue is much bigger than just tuple (pair, containers,
+-algorithms). Dietmar will survey and work up proposed wording.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Recommend NAD. This will be fixed with the next revision of concepts.
+-</p>
+-
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2770.pdf">N2770</a>.
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="536"></a>536. Container iterator constructor and explicit convertibility</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Joaquín M López Muñoz <b>Opened:</b> 2005-12-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a></p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2005-12-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#589">589</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The iterator constructor X(i,j) for containers as defined in 23.1.1 and
+@@ -13277,7 +11582,8 @@ Dietmar.
+ Valid code below?
+ </p>
+
+-<blockquote><pre>#include &lt;vector&gt;
++<blockquote><pre>
++#include &lt;vector&gt;
+ #include &lt;iterator&gt;
+ #include &lt;iostream&gt;
+
+@@ -13310,10 +11616,10 @@ Berlin: Some support, not universal, for respecting the explicit qualifier.
+
+ <hr>
+ <h3><a name="544"></a>544. minor NULL problems in C.2</h3>
+-<p><b>Section:</b> C.2 [diff.library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-11-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#diff.library">issues</a> in [diff.library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> C.5 [diff.library] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-11-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#diff.library">issues</a> in [diff.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to C.2.2.3, p1, "the macro NULL, defined in any of &lt;clocale&gt;,
+@@ -13355,9 +11661,9 @@ Portland: Resolution is considered editorial. It will be incorporated into the
+
+ <hr>
+ <h3><a name="546"></a>546. _Longlong and _ULonglong are integer types</h3>
+-<p><b>Section:</b> TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The TR sneaks in two new integer types, _Longlong and _Ulonglong, in [tr.c99].
+@@ -13401,10 +11707,10 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="547"></a>547. division should be floating-point, not integer</h3>
+-<p><b>Section:</b> 26.5 [rand], TR1 5.1 [tr.rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5 [rand], TR1 5.1 [tr.rand] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 10 describes how a variate generator uses numbers produced by an
+@@ -13434,10 +11740,10 @@ Recommend NAD as the affected section is now gone and so the issue is moot.
+
+ <hr>
+ <h3><a name="548"></a>548. May random_device block?</h3>
+-<p><b>Section:</b> 26.5.6 [rand.device], TR1 5.1.6 [tr.rand.device] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.device">issues</a> in [rand.device].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.6 [rand.device], TR1 5.1.6 [tr.rand.device] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.device">issues</a> in [rand.device].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Class random_device "produces non-deterministic random numbers", using some
+@@ -13477,10 +11783,10 @@ Adopt the proposed resolution in
+
+ <hr>
+ <h3><a name="549"></a>549. Undefined variable in binomial_distribution</h3>
+-<p><b>Section:</b> 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist">issues</a> in [rand.dist].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.8 [rand.dist], TR1 5.1.7.5 [tr.rand.dist.bin] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist">issues</a> in [rand.dist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 1 says that "A binomial distributon random distribution produces
+@@ -13505,18 +11811,18 @@ Portland: Subsumed by N2111.
+
+
+ <hr>
+-<h3><a name="553"></a>553. very minor editorial change intptr_t / uintptr_t</h3>
+-<p><b>Section:</b> 18.4.1 [cstdint.syn], TR1 8.22.1 [tr.c99.cstdint.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cstdint.syn">issues</a> in [cstdint.syn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="553"></a>553. very minor editorial change <tt>intptr_t</tt> / <tt>uintptr_t</tt></h3>
++<p><b>Section:</b> 18.4.1 [cstdint.syn], TR1 8.22.1 [tr.c99.cstdint.syn] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cstdint.syn">issues</a> in [cstdint.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In the synopsis, some types are identified as optional: int8_t, int16_t,
++In the synopsis, some types are identified as optional: <tt>int8_t</tt>, <tt>int16_t</tt>,
+ and so on, consistently with C99, indeed.
+ </p>
+ <p>
+-On the other hand, intptr_t and uintptr_t, are not marked as such and
++On the other hand, <tt>intptr_t</tt> and <tt>uintptr_t</tt>, are not marked as such and
+ probably should, consistently with C99, 7.18.1.4.
+ </p>
+
+@@ -13526,7 +11832,8 @@ probably should, consistently with C99, 7.18.1.4.
+ Change 18.4.1 [cstdint.syn]:
+ </p>
+
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ typedef <i>signed integer type</i> intptr_t; <ins><i>// optional</i></ins>
+ ...
+ typedef <i>unsigned integer type</i> uintptr_t; <ins><i>// optional</i></ins>
+@@ -13535,19 +11842,19 @@ typedef <i>unsigned integer type</i> uintptr_t; <ins><i>// optional</i></ins>
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Recommend NAD and fix as editorial with the proposed resolution.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="554"></a>554. Problem with lwg DR 184 numeric_limits&lt;bool&gt;</h3>
+-<p><b>Section:</b> 18.3.1.5 [numeric.special] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.3.2.7 [numeric.special] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I believe we have a bug in the resolution of:
+@@ -13559,14 +11866,16 @@ I believe we have a bug in the resolution of:
+ The resolution spells out each member of <tt>numeric_limits&lt;bool&gt;</tt>.
+ The part I'm having a little trouble with is:
+ </p>
+-<blockquote><pre>static const bool traps = false;
++<blockquote><pre>
++static const bool traps = false;
+ </pre></blockquote>
+
+ <p>
+ Should this not be implementation defined? Given:
+ </p>
+
+-<blockquote><pre>int main()
++<blockquote><pre>
++int main()
+ {
+ bool b1 = true;
+ bool b2 = false;
+@@ -13587,7 +11896,8 @@ Change 18.2.1.5p3:
+
+ <blockquote><p>
+ -3- The specialization for <tt>bool</tt> shall be provided as follows: </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;&gt; class numeric_limits&lt;bool&gt; {
+ ...
+ static const bool traps = <del>false</del> <ins><i>implementation-defined</i></ins>;
+@@ -13610,9 +11920,9 @@ value that will trap.
+
+ <hr>
+ <h3><a name="555"></a>555. TR1, 8.21/1: typo</h3>
+-<p><b>Section:</b> TR1 8.21 [tr.c99.boolh] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> TR1 8.21 [tr.c99.boolh] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This one, if nobody noticed it yet, seems really editorial:
+@@ -13641,10 +11951,10 @@ Redmond: Editorial.
+
+ <hr>
+ <h3><a name="557"></a>557. TR1: div(_Longlong, _Longlong) vs div(intmax_t, intmax_t)</h3>
+-<p><b>Section:</b> 18.4 [cstdint], TR1 8.22 [tr.c99.cstdint] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cstdint">issues</a> in [cstdint].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 18.4 [cstdint], TR1 8.22 [tr.c99.cstdint] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cstdint">issues</a> in [cstdint].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I'm seeing a problem with such overloads: when, _Longlong == intmax_t ==
+@@ -13680,7 +11990,8 @@ Portland: no consensus.
+ Batavia, Bill: The <tt>&lt;cstdint&gt;</tt> synopsis in TR1 8.11.1 [tr.c99.cinttypes.syn] contains:
+ ]</i></p>
+
+-<blockquote><pre>intmax_t imaxabs(intmax_t i);
++<blockquote><pre>
++intmax_t imaxabs(intmax_t i);
+ intmax_t abs(intmax_t i);
+
+ imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+@@ -13732,10 +12043,10 @@ may not be unique if intmax_t==_longlong.
+
+ <hr>
+ <h3><a name="558"></a>558. lib.input.iterators Defect</h3>
+-<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2006-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2006-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <blockquote>
+ <p>
+@@ -13780,10 +12091,11 @@ Portland: Editorial.
+
+ <hr>
+ <h3><a name="560"></a>560. User-defined allocators without default constructor</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sergey P. Derevyago <b>Opened:</b> 2006-02-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sergey P. Derevyago <b>Opened:</b> 2006-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <h4>1. The essence of the problem.</h4>
+ <p>
+@@ -13807,7 +12119,8 @@ the user-defined allocators without default constructor.
+ 2) Some container operations are obviously underspecified. In particular,
+ 21.3.7.1p2 tells:
+ </p>
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt; operator+(
+ const charT* lhs,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs
+@@ -13842,7 +12155,8 @@ through the get_allocator() call but default Allocator() gets passed instead.
+ <p>
+ Let's suppose that the following memory pool is available:
+ </p>
+-<blockquote><pre>class mem_pool {
++<blockquote><pre>
++class mem_pool {
+ // ...
+ void* allocate(size_t size);
+ void deallocate(void* ptr, size_t size);
+@@ -13851,7 +12165,8 @@ Let's suppose that the following memory pool is available:
+ <p>
+ So the following allocator can be implemented via this pool:
+ </p>
+-<blockquote><pre>class stl_allocator {
++<blockquote><pre>
++class stl_allocator {
+ mem_pool&amp; pool;
+
+ public:
+@@ -13878,7 +12193,8 @@ So the following allocator can be implemented via this pool:
+ Then the following code works well on some implementations and doesn't work on
+ another:
+ </p>
+-<blockquote><pre>typedef basic_string&lt;char, char_traits&lt;char&gt;, stl_allocator&lt;char&gt; &gt;
++<blockquote><pre>
++typedef basic_string&lt;char, char_traits&lt;char&gt;, stl_allocator&lt;char&gt; &gt;
+ tl_string;
+ mem_pool mp;
+ tl_string s1("abc", stl_allocator&lt;int&gt;(mp));
+@@ -13892,7 +12208,8 @@ default stl_allocator() constructor.
+ The obvious way to solve the compile-time problems is to intentionally define
+ a NULL pointer dereferencing default constructor
+ </p>
+-<blockquote><pre>stl_allocator() : pool(*static_cast&lt;mem_pool*&gt;(0)) {}
++<blockquote><pre>
++stl_allocator() : pool(*static_cast&lt;mem_pool*&gt;(0)) {}
+ </pre></blockquote>
+ <p>
+ in a hope that it will not be called. The problem is that it really gets
+@@ -13917,10 +12234,10 @@ semantics of copying the allocator from one of the strings (<i>lhs</i> when ther
+
+
+ <hr>
+-<h3><a name="568"></a>568. log2 overloads missing</h3>
+-<p><b>Section:</b> TR1 8.16.4 [tr.c99.cmath.over] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-03-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="568"></a>568. <tt>log2</tt> overloads missing</h3>
++<p><b>Section:</b> TR1 8.16.4 [tr.c99.cmath.over] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-03-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>log2</tt> is missing from the list of "additional overloads" in TR1 8.16.4 [tr.c99.cmath.over] p1.
+@@ -13934,10 +12251,10 @@ Hinnant: This is a TR1 issue only. It is fixed in the current (N2135) WD.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree this has been fixed in the Working Draft.
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -13951,11 +12268,11 @@ Add <tt>log2</tt> to the list of functions in TR1 8.16.4 [tr.c99.cmath.over] p1.
+
+ <hr>
+ <h3><a name="569"></a>569. Postcondition for basic_ios::clear(iostate) incorrectly stated</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2006-03-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a></p>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2006-03-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#272">272</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section: 27.4.4.3 [lib.iostate.flags]
+@@ -13964,7 +12281,8 @@ Section: 27.4.4.3 [lib.iostate.flags]
+ Paragraph 4 says:
+ </p>
+ <blockquote>
+-<blockquote><pre>void clear(iostate <i>state</i> = goodbit);
++<blockquote><pre>
++void clear(iostate <i>state</i> = goodbit);
+ </pre></blockquote>
+ <p>
+ <i>Postcondition:</i> If <tt>rdbuf()!=0</tt> then <tt><i>state</i> == rdstate();</tt>
+@@ -13989,18 +12307,19 @@ committee meant.
+
+
+ <hr>
+-<h3><a name="570"></a>570. Request adding additional explicit specializations of char_traits</h3>
+-<p><b>Section:</b> 21.2 [char.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Jack Reeves <b>Opened:</b> 2006-04-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits">issues</a> in [char.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="570"></a>570. Request adding additional explicit specializations of <tt>char_traits</tt></h3>
++<p><b>Section:</b> 21.2 [char.traits] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jack Reeves <b>Opened:</b> 2006-04-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits">issues</a> in [char.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Currently, the Standard Library specifies only a declaration for template class
+-char_traits&lt;&gt; and requires the implementation provide two explicit
+-specializations: char_traits&lt;char&gt; and char_traits&lt;wchar_t&gt;. I feel the Standard
+-should require explicit specializations for all built-in character types, i.e.
+-char, wchar_t, unsigned char, and signed char.
++<tt>char_traits&lt;&gt;</tt> and requires the implementation provide two explicit
++specializations: <tt>char_traits&lt;char&gt;</tt> and <tt>char_traits&lt;wchar_t&gt;</tt>.
++I feel the Standard should require explicit specializations for all built-in
++character types, i.e. <tt>char</tt>, <tt>wchar_t</tt>, <tt>unsigned char</tt>,
++and <tt>signed char</tt>.
+ </p>
+ <p>
+ I have put together a paper
+@@ -14034,8 +12353,8 @@ but our recommendation is NAD.
+ </p>
+ <p>
+ Note: the issue statement should be updated, as the Toronto comment has
+-already been resolved. E.g., char_traits specializations for char16_t
+-and char32_t are now in the working paper.
++already been resolved. E.g., char_traits specializations for <tt>char16_t</tt>
++and <tt>char32_t</tt> are now in the working paper.
+ </p>
+ </blockquote>
+
+@@ -14044,9 +12363,9 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Nobody has submitted the requested paper, so we move to NAD, as suggested by the decision at the last meeting.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -14057,10 +12376,10 @@ Nobody has submitted the requested paper, so we move to NAD, as suggested by the
+
+ <hr>
+ <h3><a name="571"></a>571. Update C90 references to C99?</h3>
+-<p><b>Section:</b> 1.2 [intro.refs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-04-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#intro.refs">issues</a> in [intro.refs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 1.2 [intro.refs] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-04-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#intro.refs">issues</a> in [intro.refs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 1.2 Normative references [intro.refs] of the WP currently refers to ISO/IEC
+@@ -14084,19 +12403,19 @@ In 1.2/1 [intro.refs] of the WP, change:
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Recommend NAD, fixed editorially.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="572"></a>572. Oops, we gave 507 WP status</h3>
+-<p><b>Section:</b> 26.5 [rand], TR1 5.1 [tr.rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-04-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5 [rand], TR1 5.1 [tr.rand] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-04-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In Berlin, as a working group, we voted in favor of N1932 which makes issue 507 moot:
+@@ -14129,10 +12448,10 @@ is adopted.
+
+ <hr>
+ <h3><a name="573"></a>573. C++0x file positioning should handle modern file sizes</h3>
+-<p><b>Section:</b> 27.5.3 [fpos] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-04-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos">issues</a> in [fpos].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.5.4 [fpos] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-04-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos">issues</a> in [fpos].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There are two deficiencies related to file sizes:
+@@ -14142,27 +12461,28 @@ There are two deficiencies related to file sizes:
+ a way that handles modern file sizes, which are often too
+ large to be represented by an unsigned long.</li>
+
+-<li>The std::fpos class does not currently have the ability to
++<li>The <tt>std::fpos</tt> class does not currently have the ability to
+ set/get file positions.</li>
+ </ol>
+ <p>
+ The Dinkumware implementation of the Standard Library as shipped with the Microsoft compiler copes with these issues by:
+ </p>
+-<ol type="A">
+-<li>Defining fpos_t be long long, which is large enough to
++<ol style="list-style-type:upper-alpha">
++<li>Defining <tt>fpos_t</tt> be <tt>long long</tt>, which is large enough to
+ represent any file position likely in the foreseeable future.</li>
+
+-<li>Adding member functions to class fpos. For example,
+-<blockquote><pre>fpos_t seekpos() const;
++<li>Adding member functions to class <tt>fpos</tt>. For example,
++<blockquote><pre>
++fpos_t seekpos() const;
+ </pre></blockquote>
+ </li>
+ </ol>
+ <p>
+-Because there are so many types relating to file positions and offsets (fpos_t,
+-fpos, pos_type, off_type, streamoff, streamsize, streampos, wstreampos, and
+-perhaps more), it is difficult to know if the Dinkumware extensions are
+-sufficient. But they seem a useful starting place for discussions, and they do
+-represent existing practice.
++Because there are so many types relating to file positions and offsets (<tt>fpos_t</tt>,
++<tt>fpos</tt>, <tt>pos_type</tt>, <tt>off_type</tt>, <tt>streamoff</tt>, <tt>streamsize</tt>,
++<tt>streampos</tt>, <tt>wstreampos</tt>, and perhaps more), it is difficult to know if
++the Dinkumware extensions are sufficient. But they seem a useful starting place for
++discussions, and they do represent existing practice.
+ </p>
+
+ <p><i>[
+@@ -14200,13 +12520,15 @@ Move to NAD.
+
+
+ <hr>
+-<h3><a name="579"></a>579. erase(iterator) for unordered containers should not return an iterator</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Joaquín M López Muñoz <b>Opened:</b> 2006-06-13 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="579"></a>579. <tt>erase(iterator)</tt> for unordered containers should not return an iterator</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2006-06-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses ES-2</b></p>
++
+ <p>
+ See
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2023.pdf">N2023</a>
+@@ -14218,17 +12540,17 @@ for full discussion.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I'm asking for DR 579 to be re-opened, basing on recent discussions on the
+ library reflector, see Message c++std-lib-26040 and replies.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-07 Paolo updates wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ As pointed out by Chris in c++std-lib-26040, that an
+ <tt>erase(unordered_container, iterator)</tt> returning an <tt>iterator</tt> can
+ easily implemented in user code, if needed; that actually returning an
+@@ -14240,7 +12562,7 @@ uniformly returns an <tt>iterator</tt>); that, also in thread started by Chris'
+ message, Alberto pointed out that the proxy idea isn't a good one; that users
+ both of the GNU and Boost implementations are reporting serious performance
+ problems with the current version returning an <tt>iterator</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-07 Original wording saved here:
+@@ -14268,14 +12590,16 @@ the technique consists in returning a proxy object implicitly convertible to <tt
+ that
+ </p>
+
+-<blockquote><pre>iterator q1=a.erase(q);
++<blockquote><pre>
++iterator q1=a.erase(q);
+ </pre></blockquote>
+
+ <p>
+ works as expected, while
+ </p>
+
+-<blockquote><pre>a.erase(q);
++<blockquote><pre>
++a.erase(q);
+ </pre></blockquote>
+
+ <p>
+@@ -14290,7 +12614,7 @@ code.
+ </blockquote>
+
+ <p><i>[
+-2010-03-27 Joaquín adds:
++2010-03-27 Joaqu&iacute;n adds:
+ ]</i></p>
+
+
+@@ -14377,14 +12701,14 @@ No consensus for a change.
+
+ <hr>
+ <h3><a name="580"></a>580. unused allocator members</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a></p>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#479">479</a></p>
+ <p><b>Discussion:</b></p>
+- <p>
++<p>
+
+ C++ Standard Library templates that take an allocator as an argument
+ are required to call the <code>allocate()</code> and
+@@ -14427,7 +12751,7 @@ pre-Oxford: Martin provided wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2554.pdf">N2554</a>
+ (scoped allocators),
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2768.pdf">N2768</a>
+@@ -14436,28 +12760,28 @@ pre-Oxford: Martin provided wording.
+ (allocator defects), address all of these points EXCEPT <tt>max_size()</tt>.
+ So, I would add a note to that affect and re-class the defect as belonging
+ to section 23.2.1 [container.requirements.general].
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The comment in the description of this issue that this "would be"
+ rendered editorial by the adoption of N2257 is confusing. It appears
+ that N2257 was never adopted.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD Editorial. Addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -14539,7 +12863,7 @@ destroy temporaries.
+
+
+ <p><i>[
+-Howard: This same paragraph will need some work to accommodate <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>.
++Howard: This same paragraph will need some work to accommodate <a href="lwg-defects.html#431">431</a>.
+ ]</i></p>
+
+
+@@ -14554,13 +12878,13 @@ post Oxford: This would be rendered NAD Editorial by acceptance of
+
+ <hr>
+ <h3><a name="582"></a>582. specialized algorithms and volatile storage</h3>
+-<p><b>Section:</b> 20.9.8.2 [uninitialized.copy] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#uninitialized.copy">issues</a> in [uninitialized.copy].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.7.12.2 [uninitialized.copy] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#uninitialized.copy">issues</a> in [uninitialized.copy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a></p>
++<p>Related to <a href="lwg-closed.html#1029">1029</a></p>
+ <p>
+
+ The specialized algorithms [lib.specialized.algorithms] are specified
+@@ -14568,6 +12892,7 @@ as having the general effect of invoking the following expression:
+
+ </p>
+ <pre>
++
+ new (static_cast&lt;void*&gt;(&amp;*i))
+ typename iterator_traits&lt;ForwardIterator&gt;::value_type (x)
+
+@@ -14594,9 +12919,9 @@ properly expressed if iterator returns rvalue.
+
+ <blockquote>
+
+-<p>Propose that Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a> be closed NAD.</p>
++<p>Propose that Issue <a href="lwg-closed.html#582">582</a> be closed NAD.</p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a> asks that <tt>uninitialized_copy</tt>,
++Issue <a href="lwg-closed.html#582">582</a> asks that <tt>uninitialized_copy</tt>,
+ <tt>uninitialized_fill</tt>, and <tt>uninitialized_fill_n</tt> should be
+ well-formed if the result type is volatile. My feeling is that the
+ standard does not, and should not, guarantee any useful behavior when
+@@ -14606,10 +12931,11 @@ possible editorial change would be to put my previous sentence into a
+ non-normative note.
+ </p>
+ <p>
+-Note that the three sections starting with 20.9.8.2 [uninitialized.copy] do not
++Note that the three sections starting with 20.7.12.2 [uninitialized.copy] do not
+ yet have concepts. Here's a first crack at the first one:
+ </p>
+-<blockquote><pre>template &lt;InputIterator InIter, OutputIterator OutIter&gt;
++<blockquote><pre>
++template &lt;InputIterator InIter, OutputIterator OutIter&gt;
+ requires ExplicitConvertible&lt;HasDereference&lt;OutIter::reference&gt;::result,
+ OutIter::value_type&amp;&gt;
+ &amp;&amp; Convertible&lt;OutIter::value_type*, void*&gt;
+@@ -14620,7 +12946,8 @@ requires ExplicitConvertible&lt;HasDereference&lt;OutIter::reference&gt;::result
+ <p>
+ Effects:
+ </p>
+-<blockquote><pre>while (first != last) {
++<blockquote><pre>
++while (first != last) {
+ typedef OutIter::value_type value_type;
+ value_type&amp; outRef = static_cast&lt;value_type&amp;&gt;(*result++);
+ ::new (static_cast&lt;void*&gt;(addressof(outRef))) value_type(*first++);
+@@ -14693,6 +13020,7 @@ changes to clauses 20 and 24. Change 20.6.4.1, p1 to read:
+
+ </p>
+ <pre>
++
+ <i>Effects</i>:
+
+ typedef typename iterator_traits&lt;ForwardIterator&gt;::pointer pointer;
+@@ -14709,6 +13037,7 @@ change 20.6.4.2, p1 to read
+
+ </p>
+ <pre>
++
+ <i>Effects</i>:
+
+ typedef typename iterator_traits&lt;ForwardIterator&gt;::pointer pointer;
+@@ -14725,6 +13054,7 @@ and change 20.6.4.3, p1 to read
+
+ </p>
+ <pre>
++
+ <i>Effects</i>:
+
+ typedef typename iterator_traits&lt;ForwardIterator&gt;::pointer pointer;
+@@ -14749,6 +13079,7 @@ and for pointers to volatile as
+
+ </p>
+ <pre>
++
+ namespace std {
+ template&lt;class T&gt; struct iterator_traits&lt;volatile T*&gt; {
+ typedef ptrdiff_t difference_type;
+@@ -14775,14 +13106,15 @@ effect by means of function template overloading.
+
+
+ <hr>
+-<h3><a name="583"></a>583. div() for unsigned integral types</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="583"></a>583. <tt>div()</tt> for unsigned integral types</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-There is no div() function for unsigned integer types.
++There is no <tt>div()</tt> function for unsigned integer types.
+ </p>
+ <p>
+ There are several possible resolutions. The simplest one is noted below. Other
+@@ -14795,32 +13127,34 @@ possibilities include a templated solution.
+ Add to 26.7 [lib.c.math] paragraph 8:
+ </p>
+
+-<blockquote><pre>struct udiv_t div(unsigned, unsigned);
++<blockquote><pre>
++struct udiv_t div(unsigned, unsigned);
+ struct uldiv_t div(unsigned long, unsigned long);
+ struct ulldiv_t div(unsigned long long, unsigned long long);
+ </pre></blockquote>
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Toronto: C99 does not have these unsigned versions because
+ the signed version exist just to define the implementation-defined behavior
+ of signed integer division. Unsigned integer division has no implementation-defined
+ behavior and thus does not need this treatment.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="584"></a>584. missing int pow(int,int) functionality</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="584"></a>584. missing int <tt>pow(int,int)</tt> functionality</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-There is no pow() function for any integral type.
++There is no <tt>pow()</tt> function for any integral type.
+ </p>
+
+
+@@ -14829,25 +13163,26 @@ There is no pow() function for any integral type.
+ Add something like:
+ </p>
+
+-<blockquote><pre>template&lt; typename T&gt;
++<blockquote><pre>
++template&lt; typename T&gt;
+ T power( T x, int n );
+ // requires: n &gt;=0
+ </pre></blockquote>
+
+
+-<p><b>Rationale:</b></p>
+-Toronto: We already have double pow(integral, integral) from 26.8 [c.math] p11.
+-
++<p><b>Rationale:</b></p><p>
++Toronto: We already have <tt>double pow(<i>integral</i>, <i>integral</i>)</tt> from 26.8 [c.math] p11.
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="585"></a>585. facet error reporting</h3>
+-<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor, Paolo Carlini <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor, Paolo Carlini <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -14907,9 +13242,9 @@ with<code>ios_base::eofbit | ios_base::failbit</code>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -14975,9 +13310,9 @@ Proposed Disposition: Open
+
+ <hr>
+ <h3><a name="587"></a>587. iststream ctor missing description</h3>
+-<p><b>Section:</b> D.9.2.1 [depr.istrstream.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> D.7.2.1 [depr.istrstream.cons] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -15007,11 +13342,12 @@ post Oxford: Noted that it is already fixed in
+
+
+ <hr>
+-<h3><a name="588"></a>588. requirements on zero sized tr1::arrays and other details</h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Gennaro Prota <b>Opened:</b> 2006-07-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="588"></a>588. requirements on zero sized <tt>tr1::arrays</tt> and other details</h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Gennaro Prota <b>Opened:</b> 2006-07-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The wording used for section 23.2.1 [lib.array] seems to be subtly
+@@ -15035,7 +13371,8 @@ end() == unique value."
+ What does "unique" mean in this context? Let's consider the following
+ possible implementations, all relying on a partial specialization:
+ </p>
+-<blockquote><pre>a)
++<blockquote><pre>
++a)
+ template&lt; typename T &gt;
+ class array&lt; T, 0 &gt; {
+
+@@ -15053,7 +13390,8 @@ had to be unique to the specific array object and that array couldn't
+ store any T. Note that, besides relying on a reinterpret_cast, has
+ (more than potential) alignment problems.
+ </p>
+-<blockquote><pre>b)
++<blockquote><pre>
++b)
+ template&lt; typename T &gt;
+ class array&lt; T, 0 &gt; {
+
+@@ -15073,7 +13411,8 @@ mistakenly provide an initializer list with one element.
+ <p>
+ A slight variant could be returning *the* null pointer of type T
+ </p>
+-<blockquote><pre> return static_cast&lt;T*&gt;(0);
++<blockquote><pre>
++ return static_cast&lt;T*&gt;(0);
+ </pre></blockquote>
+ <p>
+ In this case the value would be unique to the type array&lt;T, 0&gt; but not
+@@ -15093,12 +13432,14 @@ d) to avoid storing a T *directly* while disallowing the possibility
+ to use a one-element initializer list a non-aggregate nested class
+ could be defined
+ </p>
+-<blockquote><pre> struct holder { holder() {} T t; } h;
++<blockquote><pre>
++ struct holder { holder() {} T t; } h;
+ </pre></blockquote>
+ <p>
+ and then begin be defined as
+ </p>
+-<blockquote><pre> iterator begin() { return &amp;h.t; }
++<blockquote><pre>
++ iterator begin() { return &amp;h.t; }
+ </pre></blockquote>
+ <p>
+ But then, it's arguable whether the array stores a T or not.
+@@ -15147,27 +13488,27 @@ which, again, doesn't seem to consider fixed size containers
+
+
+ <blockquote>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ star bullet 1 ("what's the effect of calling <tt>assign(T&amp;)</tt> on a
+ zero-sized array?[..]");
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>assign</tt> has been renamed to <tt>fill</tt> and the semantic of <tt>fill</tt> is now
+ defined in terms of
+ the free algorithm <tt>fill_n</tt>, which is well-defined for this situation.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+ star bullet 3 ("it would be desiderable to have a static const data
+ member..."):
+ </p>
+-<blockquote>
+-It seems that <tt>tuple_size&lt;array&lt;T, N&gt; &gt;::value</tt> as of 23.3.1.8 [array.tuple] does
++<blockquote><p>
++It seems that <tt>tuple_size&lt;array&lt;T, N&gt; &gt;::value</tt> as of 23.3.2.9 [array.tuple] does
+ provide this functionality now.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </blockquote>
+@@ -15191,9 +13532,9 @@ Moved to Tentatively NAD.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -15214,10 +13555,11 @@ requirements? Alisdair will prepare a paper. Proposed Disposition: Open
+
+ <hr>
+ <h3><a name="590"></a>590. Type traits implementation latitude should be removed for C++0x</h3>
+-<p><b>Section:</b> 20.7 [meta], TR1 4.9 [tr.meta.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-08-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.10 [meta], TR1 4.9 [tr.meta.req] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2006-08-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 20.4.9 [lib.meta.req], Implementation requirements, provides latitude for type
+@@ -15255,10 +13597,10 @@ current working draft.
+
+ <hr>
+ <h3><a name="591"></a>591. Misleading "built-in</h3>
+-<p><b>Section:</b> 18.3.1.2 [numeric.limits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> whyglinux <b>Opened:</b> 2006-08-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 18.3.2.4 [numeric.limits.members] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> whyglinux <b>Opened:</b> 2006-08-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 18.2.1.2 numeric_limits members [lib.numeric.limits.members]
+@@ -15323,11 +13665,11 @@ Recommend NAD / Editorial. The proposed resolution is accepted as editorial.
+
+
+ <hr>
+-<h3><a name="592"></a>592. Incorrect treatment of rdbuf()-&gt;close() return type</h3>
+-<p><b>Section:</b> 27.9.1.9 [ifstream.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Christopher Kohlhoff <b>Opened:</b> 2006-08-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="592"></a>592. Incorrect treatment of rdbuf()->close() return type</h3>
++<p><b>Section:</b> 27.9.1.9 [ifstream.members] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Christopher Kohlhoff <b>Opened:</b> 2006-08-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I just spotted a minor problem in 27.8.1.7
+@@ -15335,7 +13677,8 @@ I just spotted a minor problem in 27.8.1.7
+ [lib.fstream.members] para 4. In both places it says:
+ </p>
+ <blockquote>
+-<pre>void close();
++<pre>
++void close();
+ </pre>
+ <p>
+ Effects: Calls rdbuf()-&gt;close() and, if that function returns false, ...
+@@ -15384,10 +13727,10 @@ Kona (2007): Proposed Disposition: NAD, Editorial
+
+ <hr>
+ <h3><a name="597"></a>597. Decimal: The notion of 'promotion' cannot be emulated by user-defined types.</h3>
+-<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daveed Vandevoorde <b>Opened:</b> 2006-04-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daveed Vandevoorde <b>Opened:</b> 2006-04-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In a private email, Daveed writes:
+@@ -15404,6 +13747,7 @@ Here is an example:
+ </p>
+ </blockquote>
+ <pre>
++
+ struct S {
+ S(_Decimal32 const&amp;); // Converting constructor
+ };
+@@ -15435,7 +13779,8 @@ Robert comments:
+ <p>
+ In general, a library of arithmetic types cannot exactly emulate the behavior of the intrinsic numeric types. There are several ways to tell whether an implementation of the decimal types uses compiler intrinisics or a library. For example:
+ </p>
+-<pre> _Decimal32 d1;
++<pre>
++ _Decimal32 d1;
+ d1.operator+=(5); // If d1 is a builtin type, this won't compile.
+ </pre>
+ <p>
+@@ -15480,10 +13825,10 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="606"></a>606. Decimal: allow narrowing conversions</h3>
+-<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In c++std-lib-17205, Martin writes:
+@@ -15491,7 +13836,8 @@ In c++std-lib-17205, Martin writes:
+ <blockquote><p>
+ ...was it a deliberate design choice to make narrowing assignments ill-formed while permitting narrowing compound assignments? For instance:
+ </p></blockquote>
+-<pre> decimal32 d32;
++<pre>
++ decimal32 d32;
+ decimal64 d64;
+
+ d32 = 64; // error
+@@ -15524,7 +13870,8 @@ Move to NAD.
+ <p>
+ 1. In "3.2.2 Class <code>decimal32</code>" synopsis, remove the <code>explicit</code> specifier from the narrowing conversions:
+ </p>
+-<pre> // <i>3.2.2.2 conversion from floating-point type:</i>
++<pre>
++ // <i>3.2.2.2 conversion from floating-point type:</i>
+ <del>explicit</del> decimal32(decimal64 <i>d64</i>);
+ <del>explicit</del> decimal32(decimal128 <i>d128</i>);
+ </pre>
+@@ -15534,7 +13881,8 @@ Move to NAD.
+ <p>
+ 3. In "3.2.3 Class <code>decimal64</code>" synopsis, remove the <code>explicit</code> specifier from the narrowing conversion:
+ </p>
+-<pre> // <i>3.2.3.2 conversion from floating-point type:</i>
++<pre>
++ // <i>3.2.3.2 conversion from floating-point type:</i>
+ <del>explicit</del> decimal64(decimal128 <i>d128</i>);
+ </pre>
+ <p>
+@@ -15551,11 +13899,12 @@ Redmond: We prefer explicit conversions for narrowing and implicit for widening.
+
+
+ <hr>
+-<h3><a name="614"></a>614. std::string allocator requirements still inconsistent</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="614"></a>614. <tt>std::string</tt> allocator requirements still inconsistent</h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This is based on N2134, where 21.3.1/2 states:
+@@ -15567,7 +13916,8 @@ object."
+ <p>
+ Section 21.3.2/1 lists two constructors:
+ </p>
+-<blockquote><pre>basic_string(const basic_string&lt;charT,traits,Allocator&gt;&amp; str );
++<blockquote><pre>
++basic_string(const basic_string&lt;charT,traits,Allocator&gt;&amp; str );
+
+ basic_string(const basic_string&lt;charT,traits,Allocator&gt;&amp; str ,
+ size_type pos , size_type n = npos,
+@@ -15595,16 +13945,16 @@ rules (substr, operator+, etc.). Howard to supply wording.
+ <p><i>[
+ Bo adds: The new container constructor which takes only a <tt>size_type</tt> is not
+ consistent with 23.2 [container.requirements], p9 which says in part:
++]</i></p>
+
+-</i></p><blockquote><i>
++
++<blockquote><p>
+ All other constructors for these container types take an
+ <tt>Allocator&amp;</tt> argument (20.1.2), an allocator whose value type
+ is the same as the container's value type. A copy of this argument is
+ used for any memory allocation performed, by these constructors and by
+ all member functions, during the lifetime of each container object.
+-</i></blockquote><i>
+-]</i><p></p>
+-
++</p></blockquote>
+
+ <p><i>[
+ post Bellevue: We re-confirm that the issue is real. Pablo will provide wording.
+@@ -15616,9 +13966,9 @@ post Bellevue: We re-confirm that the issue is real. Pablo will provide wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -15632,10 +13982,11 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="615"></a>615. Inconsistencies in Section 21.4</h3>
+-<p><b>Section:</b> 21.7 [c.strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.strings">issues</a> in [c.strings].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 21.8 [c.strings] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.strings">active issues</a> in [c.strings].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.strings">issues</a> in [c.strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the current draft N2134, 21.4/1 says
+@@ -15670,28 +14021,29 @@ Recommend NAD, editorial. Send to Pete.
+
+
+ <hr>
+-<h3><a name="617"></a>617. std::array is a sequence that doesn't satisfy the sequence requirements?</h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="617"></a>617. <tt>std::array</tt> is a sequence that doesn't satisfy the sequence requirements?</h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>&lt;array&gt;</tt> header is given under 23.3 [sequences].
+-23.3.1 [array]/paragraph 3 says:
++23.3.2 [array]/paragraph 3 says:
+ </p>
+ <blockquote><p>
+ "Unless otherwise specified, all array operations are as described in
+ 23.2 [container.requirements]".
+ </p></blockquote>
+ <p>
+-However, array isn't mentioned at all in section 23.2 [container.requirements].
++However, <tt>array</tt> isn't mentioned at all in section 23.2 [container.requirements].
+ In particular, Table 82 "Sequence requirements" lists several operations (insert, erase, clear)
+-that std::array does not have in 23.3.1 [array].
++that <tt>std::array</tt> does not have in 23.3.2 [array].
+ </p>
+ <p>
+ Also, Table 83 "Optional sequence operations" lists several operations that
+-std::array does have, but array isn't mentioned.
++<tt>std::array</tt> does have, but array isn't mentioned.
+ </p>
+
+ <p><i>[
+@@ -15702,7 +14054,7 @@ std::array does have, but array isn't mentioned.
+ <blockquote>
+ <p>
+ The real issue seems to be different than what is described here.
+-Non-normative text says that std::array is a sequence container, but
++Non-normative text says that <tt>std::array</tt> is a sequence container, but
+ there is disagreement about what that really means. There are two
+ possible interpretations:
+ </p>
+@@ -15724,7 +14076,7 @@ Move to Tentatively NAD.
+ </blockquote>
+
+ <p><i>[
+-2009-07-15 Loïc Joly adds:
++2009-07-15 Lo&iuml;c Joly adds:
+ ]</i></p>
+
+
+@@ -15746,26 +14098,26 @@ Say that array is a container, that in addition follows only some of the
+ sequence requirements, as described in the array section:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The library provides <del>five</del> <ins>three</ins> basic kinds of sequence containers: <del><tt>array</tt></del>,
+ <tt>vector</tt>,
+ <del><tt>forward_list</tt></del>, <tt>list</tt>, and <tt>deque</tt>. <ins>In addition, <tt>array</tt>
+ and <tt>forward_list</tt> follows some of the requirements
+ of sequences, as described in their respective sections.</ins>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+ <p>
+ Proposed resolution 2 (most descriptive description, no full wording provided):
+ </p>
+-<blockquote>
++<blockquote><p>
+ Introduce the notion of a Fixed Size Sequence, with it requirement table
+ that would be a subset of the current Sequence container. array would be
+ the only Fixed Size Sequence (but dynarray is in the queue for TR2).
+ Sequence requirements would now be requirements in addition to Fixed
+ Size Sequence requirements (it is currently in addition to container).
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -15773,20 +14125,20 @@ Size Sequence requirements (it is currently in addition to container).
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD Editorial
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This will require a lot of reorganization. Editor doesn't think this is really
+ an issue, since the description of array can be considered as overriding
+ what's specified about sequences. Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -15800,10 +14152,10 @@ what's specified about sequences. Move to NAD.
+
+ <hr>
+ <h3><a name="626"></a>626. new <i>Remark</i> clauses not documented</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -15841,10 +14193,10 @@ Bellevue: Already resolved in current working paper.
+
+ <hr>
+ <h3><a name="627"></a>627. Low memory and exceptions</h3>
+-<p><b>Section:</b> 18.6.1.1 [new.delete.single] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.6.1.1 [new.delete.single] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I recognize the need for nothrow guarantees in the exception reporting
+@@ -15875,10 +14227,11 @@ its resource limits", so no further escape hatch is necessary.
+
+ <hr>
+ <h3><a name="631"></a>631. conflicting requirements for <tt>BinaryPredicate</tt></h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2007-01-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2007-01-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The general requirements for <tt><tt>BinaryPredicate</tt></tt> (in 25 [algorithms]/8) contradict the implied specific requirements for
+@@ -15945,13 +14298,13 @@ and <tt>upper_bound</tt> to work withoutt these changes.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review. The small problem with the "iterator type"
+ will be fixed. The cited functions (<tt>lower_bound</tt>, <tt>uppwer_bound</tt>,
+ <tt>equal_range</tt>) don't actually use <tt>BinaryPredicate</tt> , and where it is used,
+ it is consistent with [algorithm]/8, so the main complaint of the issue
+ is moot.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-01-16 Beman clarified wording.
+@@ -15981,7 +14334,7 @@ Solved by
+
+ <p>
+ 2010-01-31: The draft standard is well specified as is, and this specification
+-is desired. Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a> solve the remaining
++is desired. Issues <a href="lwg-defects.html#556">556</a> and <a href="lwg-defects.html#870">870</a> solve the remaining
+ unclearness regarding the meaning of BinaryPredicate.
+ </p>
+
+@@ -16012,7 +14365,7 @@ not apply any non-constant function through the dereferenced iterators.</del>
+ <ins>[<i>Note:</i> if the two types are not identical, and neither is
+ convertable to the other, this may require that the <tt>BinaryPredicate</tt> be
+ a functional object with two overloaded <tt>operator()()</tt> functions.
+-— <i>end note</i>]</ins>
++&mdash; <i>end note</i>]</ins>
+ </p>
+
+ </blockquote>
+@@ -16023,11 +14376,12 @@ a functional object with two overloaded <tt>operator()()</tt> functions.
+
+
+ <hr>
+-<h3><a name="632"></a>632. Time complexity of size() for std::set</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Lionel B <b>Opened:</b> 2007-02-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="632"></a>632. Time complexity of <tt>size()</tt> for <tt>std::set</tt></h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Lionel B <b>Opened:</b> 2007-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A recent news group discussion:
+@@ -16035,12 +14389,12 @@ A recent news group discussion:
+ <blockquote>
+ <p>
+ Anyone know if the Standard has anything to say about the time complexity
+-of size() for std::set? I need to access a set's size (/not/ to know if it is empty!) heavily
+-during an algorithm and was thus wondering whether I'd be better off
+-tracking the size "manually" or whether that'd be pointless.
++of <tt>size()</tt> for <tt>std::set</tt>? I need to access a set's size (<em>not</em>
++to know if it is empty!) heavily during an algorithm and was thus wondering
++whether I'd be better off tracking the size "manually" or whether that'd be pointless.
+ </p>
+ <p>
+-That would be pointless. size() is O(1).
++That would be pointless. <tt>size()</tt> is O(1).
+ </p>
+ <p>
+ Nit: the standard says "should" have constant time. Implementations may take
+@@ -16083,31 +14437,31 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mandating O(1) size will not fly, too many implementations would be
+ invalidated. Alan to provide wording that toughens wording, but that
+ does not absolutely mandate O(1).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We observed that the wording "should" (in note a) has no effect.
+ Howard prefers that O(1) size be mandated.
+ It is not clear that this issue can be resolved to everyone's satisfaction,
+ but Alan will provide wording nonetheless.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Fixed by paper N2923.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -16121,12 +14475,12 @@ Fixed by paper N2923.
+
+ <hr>
+ <h3><a name="633"></a>633. Return clause mentions undefined "type()"</h3>
+-<p><b>Section:</b> 20.8.14.2.5 [func.wrap.func.targ] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.5 [func.wrap.func.targ] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.8.14.2.5 [func.wrap.func.targ], p4 says:
++20.9.12.2.5 [func.wrap.func.targ], p4 says:
+ </p>
+ <blockquote><p>
+ <i>Returns:</i> If <tt>type() == typeid(T)</tt>, a pointer to the stored
+@@ -16142,7 +14496,7 @@ function <tt>type()</tt> in class template function nor in the global or
+ <li>
+ Assuming that <tt>type</tt> should have been <tt>target_type()</tt>,
+ this description would lead to false results, if <tt>T = <i>cv</i>
+-void</tt> due to returns clause 20.8.14.2.5 [func.wrap.func.targ], p1.
++void</tt> due to returns clause 20.9.12.2.5 [func.wrap.func.targ], p1.
+ </li>
+ </ol>
+
+@@ -16150,7 +14504,7 @@ void</tt> due to returns clause 20.8.14.2.5 [func.wrap.func.targ], p1.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.14.2.5 [func.wrap.func.targ], p4:
++Change 20.9.12.2.5 [func.wrap.func.targ], p4:
+ </p>
+
+ <blockquote><p>
+@@ -16171,10 +14525,10 @@ Pete: Agreed. It's editorial, so I'll fix it.
+
+ <hr>
+ <h3><a name="636"></a>636. 26.5.2.3 valarray::operator[]</h3>
+-<p><b>Section:</b> 26.6.2.3 [valarray.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.6.2.4 [valarray.access] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The signature of the const operator[] has been changed to return a const
+@@ -16200,10 +14554,11 @@ Pete recommends editorial fix.
+
+ <hr>
+ <h3><a name="637"></a>637. [c.math]/10 inconsistent return values</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 26.8 [c.math], paragraph 10 has long lists of added signatures for float and long double
+@@ -16218,7 +14573,8 @@ overload.
+ Change 26.8 [c.math], paragraph 10,
+ </p>
+
+-<blockquote><pre><del>float</del> <ins>int</ins> ilogb(float);
++<blockquote><pre>
++<del>float</del> <ins>int</ins> ilogb(float);
+ <del>float</del> <ins>long</ins> lrint(float);
+ <del>float</del> <ins>long</ins> lround(float);
+ <del>float</del> <ins>long long</ins> llrint(float);
+@@ -16237,14 +14593,14 @@ Change 26.8 [c.math], paragraph 10,
+
+ <hr>
+ <h3><a name="639"></a>639. Still problems with exceptions during streambuf IO</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors], 27.7.2.6.3 [ostream.inserters] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors], 27.7.3.6.3 [ostream.inserters] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-There already exist two active DR's for the wording of 27.7.1.2.3 [istream::extractors]/13
+-from 14882:2003(E), namely <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#413">413</a>.
++There already exist two active DR's for the wording of 27.7.2.2.3 [istream::extractors]/13
++from 14882:2003(E), namely <a href="lwg-defects.html#64">64</a> and <a href="lwg-defects.html#413">413</a>.
+ </p>
+
+ <p>
+@@ -16293,7 +14649,7 @@ Is this behaviour by design?
+ </p>
+
+ <p>
+-I would like to add that its output counterpart in 27.7.2.6.3 [ostream.inserters]/7-9
++I would like to add that its output counterpart in 27.7.3.6.3 [ostream.inserters]/7-9
+ (also
+ N2134) does not demonstrate such an exception-loss-behaviour.
+ On the other side, I wonder concerning several subtle differences
+@@ -16309,7 +14665,7 @@ compared to input::
+
+ <p>
+ Note that there is nothing mentioned which would imply that such
+-an exception will be caught compared to 27.7.1.2.3 [istream::extractors]/14.
++an exception will be caught compared to 27.7.2.2.3 [istream::extractors]/14.
+ </p>
+
+ <p>
+@@ -16334,7 +14690,7 @@ imply that such an exception *should* be caught before.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-(a) In 27.7.1.2.3 [istream::extractors]/15 (N2134) change the sentence
++(a) In 27.7.2.2.3 [istream::extractors]/15 (N2134) change the sentence
+ </p>
+
+ <blockquote><p>
+@@ -16349,7 +14705,7 @@ caught exception is rethrown.
+ </p></blockquote>
+
+ <p>
+-(b) In 27.7.2.6.3 [ostream.inserters]/8 (N2134) change the sentence:
++(b) In 27.7.3.6.3 [ostream.inserters]/8 (N2134) change the sentence:
+ </p>
+
+ <blockquote>
+@@ -16368,39 +14724,41 @@ case the exception is caught)</ins>.</li>
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ This extractor is described as a formatted input function so the
+ exception behavior is already specified. There is additional behavior
+ described in this section that applies to the case in which failbit is
+ set. This doesn't contradict the usual exception behavior for formatted
+ input functions because that applies to the case in which badbit is set.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="641"></a>641. Editorial fix for 27.6.4 (N2134)</h3>
+-<p><b>Section:</b> 27.7.4 [ext.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 27.7.5 [ext.manip] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The function <tt>f</tt> in para 4 (27.7.4 [ext.manip]) references an unknown <tt>strm</tt>
++The function <tt>f</tt> in para 4 (27.7.5 [ext.manip]) references an unknown <tt>strm</tt>
+ in the following line:
+ </p>
+
+-<blockquote><pre>mg.get(Iter(str.rdbuf()), Iter(), intl, strm, err, mon);
++<blockquote><pre>
++mg.get(Iter(str.rdbuf()), Iter(), intl, strm, err, mon);
+ </pre></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 27.7.4 [ext.manip], p4:
++Change 27.7.5 [ext.manip], p4:
+ </p>
+
+-<blockquote><pre>mg.get(Iter(str.rdbuf()), Iter(), intl, str<del>m</del>, err, mon);
++<blockquote><pre>
++mg.get(Iter(str.rdbuf()), Iter(), intl, str<del>m</del>, err, mon);
+ </pre></blockquote>
+
+ <p><i>[
+@@ -16415,15 +14773,15 @@ Oxford: Editorial.
+
+ <hr>
+ <h3><a name="642"></a>642. Invalidated fstream footnotes in N2134</h3>
+-<p><b>Section:</b> 27.9.1.9 [ifstream.members], 27.9.1.13 [ofstream.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 27.9.1.9 [ifstream.members], 27.9.1.13 [ofstream.members] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard wording of N2134 has extended the 14882:2003(E)
+ wording for the ifstream/ofstream/fstream open function to fix
+-a long standing problem, see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#409">409</a>.
++a long standing problem, see <a href="lwg-defects.html#409">409</a>.
+ </p>
+
+ <p>
+@@ -16485,17 +14843,18 @@ In 27.9.1.13 [ofstream.members], remove footnote:
+
+ <hr>
+ <h3><a name="644"></a>644. Possible typos in 'function' description</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-02-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.8.14.2 [func.wrap.func]
++20.9.12.2 [func.wrap.func]
+ </p>
+ <p>
+ The note in paragraph 2 refers to 'undefined void operators', while the
+-section declares a pair of operators returning bool.
++section declares a pair of operators returning <tt>bool</tt>.
+ </p>
+
+ <p><i>[
+@@ -16503,11 +14862,11 @@ Post-Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Changed from Pending WP to Open. This issue was voted to WP at the same time the operators were
+ changed from private to deleted. The two issues stepped on each other. What do we want the return
+ type of these deleted functions to be?
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-02 Daniel adds:
+@@ -16517,9 +14876,10 @@ type of these deleted functions to be?
+ <blockquote>
+ <p>
+ I suggest harmonizing this issue with similar classes. E.g. in
+-20.9.10.3 [util.smartptr.weak] <tt>bool</tt> return values for
++20.8.2.3 [util.smartptr.weak] <tt>bool</tt> return values for
+ </p>
+-<blockquote><pre>template &lt;class Y&gt; bool operator&lt;(weak_ptr&lt;Y&gt; const&amp;) const = delete;
++<blockquote><pre>
++template &lt;class Y&gt; bool operator&lt;(weak_ptr&lt;Y&gt; const&amp;) const = delete;
+ template &lt;class Y&gt; bool operator&lt;=(weak_ptr&lt;Y&gt; const&amp;) const = delete;
+ template &lt;class Y&gt; bool operator&gt;(weak_ptr&lt;Y&gt; const&amp;) const = delete;
+ template &lt;class Y&gt; bool operator&gt;=(weak_ptr&lt;Y&gt; const&amp;) const = delete;
+@@ -16530,9 +14890,9 @@ are used and basically all <em>newer</em> provided deleted copy assignment opera
+ of type <tt>X</tt> use the canonical return type <tt>X&amp;</tt> instead of <tt>void</tt>. Since the note
+ mentioned in the issue description has now already been changed to
+ </p>
+-<blockquote>
++<blockquote><p>
+ deleted overloads close possible hole in the type system
+-</blockquote>
++</p></blockquote>
+ <p>
+ it seems to be of even lesser need to perform the change. Therefore
+ I recommend declaring the issue as NAD.
+@@ -16555,22 +14915,24 @@ Move to NAD.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.14.2 [func.wrap.func]
++Change 20.9.12.2 [func.wrap.func]
+ </p>
+
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ private:
+- // 20.8.14.2 [func.wrap.func], undefined operators:
++ // 20.9.12.2 [func.wrap.func], undefined operators:
+ template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator==(const function&lt;Function2&gt;&amp;);
+ template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator!=(const function&lt;Function2&gt;&amp;);
+ };
+ </pre></blockquote>
+
+ <p>
+-Change 20.8.14.2 [func.wrap.func]
++Change 20.9.12.2 [func.wrap.func]
+ </p>
+
+-<blockquote><pre>template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator==(const function&lt;Function2&gt;&amp;);
++<blockquote><pre>
++template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator==(const function&lt;Function2&gt;&amp;);
+ template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator!=(const function&lt;Function2&gt;&amp;);
+ </pre></blockquote>
+
+@@ -16580,10 +14942,10 @@ template&lt;class Function2&gt; <del>bool</del> <ins>void</ins> operator!=(const
+
+ <hr>
+ <h3><a name="645"></a>645. Missing members in match_results</h3>
+-<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.results">issues</a> in [re.results].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results">issues</a> in [re.results].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to the description given in 28.10 [re.results]/2 the class template
+@@ -16599,7 +14961,8 @@ missing operations:
+ 1) The members
+ </p>
+
+-<blockquote><pre>const_iterator rbegin() const;
++<blockquote><pre>
++const_iterator rbegin() const;
+ const_iterator rend() const;
+ </pre></blockquote>
+
+@@ -16624,7 +14987,8 @@ somewhat questionable.
+ <p>
+ 2) The new "convenience" members
+ </p>
+-<blockquote><pre>const_iterator cbegin() const;
++<blockquote><pre>
++const_iterator cbegin() const;
+ const_iterator cend() const;
+ const_iterator crbegin() const;
+ const_iterator crend() const;
+@@ -16640,7 +15004,8 @@ Add the following members to the <tt>match_results</tt> synopsis after <tt>end()
+ para 3:
+ </p>
+
+-<blockquote><pre>const_iterator cbegin() const;
++<blockquote><pre>
++const_iterator cbegin() const;
+ const_iterator cend() const;
+ </pre></blockquote>
+
+@@ -16649,7 +15014,8 @@ In section 28.10.4 [re.results.acc] change:
+ </p>
+
+ <blockquote>
+-<pre>const_iterator begin() const;
++<pre>
++const_iterator begin() const;
+ <ins>const_iterator cbegin() const;</ins>
+ </pre>
+ <blockquote>
+@@ -16658,7 +15024,8 @@ In section 28.10.4 [re.results.acc] change:
+ </p>
+ </blockquote>
+
+-<pre>const_iterator end() const;
++<pre>
++const_iterator end() const;
+ <ins>const_iterator cend() const;</ins>
+ </pre>
+ <blockquote>
+@@ -16686,16 +15053,17 @@ Bellevue: Proposed wording now in the WP.
+
+
+ <hr>
+-<h3><a name="647"></a>647. Inconsistent regex_search params</h3>
+-<p><b>Section:</b> 28.11.3 [re.alg.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="647"></a>647. Inconsistent <tt>regex_search</tt> params</h3>
++<p><b>Section:</b> 28.11.3 [re.alg.search] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 28.11.3 [re.alg.search]/5 declares
+ </p>
+
+-<blockquote><pre>template &lt;class iterator, class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class iterator, class charT, class traits&gt;
+ bool regex_search(iterator first, iterator last,
+ const basic_regex&lt;charT, traits&gt;&amp; e,
+ regex_constants::match_flag_type flags =
+@@ -16709,7 +15077,8 @@ to the preceding declaration in the synopsis section
+ 28.4 [re.syn], which says:
+ </p>
+
+-<blockquote><pre>template &lt;class BidirectionalIterator, class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class BidirectionalIterator, class charT, class traits&gt;
+ bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
+ const basic_regex&lt;charT, traits&gt;&amp; e,
+ regex_constants::match_flag_type flags =
+@@ -16723,7 +15092,8 @@ In 28.11.3 [re.alg.search]/5 replace all three occurences of param "iterator" wi
+ "BidirectionalIterator"
+ </p>
+
+-<blockquote><pre>template &lt;class <del>iterator</del> <ins>BidirectionalIterator</ins>, class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class <del>iterator</del> <ins>BidirectionalIterator</ins>, class charT, class traits&gt;
+ bool regex_search(<del>iterator</del> <ins>BidirectionalIterator</ins> first, <del>iterator</del> <ins>BidirectionalIterator</ins> last,
+ const basic_regex&lt;charT, traits&gt;&amp; e,
+ regex_constants::match_flag_type flags =
+@@ -16738,18 +15108,18 @@ of <tt>regex_search(first, last, what, e, flags)</tt>.
+ </blockquote>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Applied to working paper while issue was still in New status.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="648"></a>648. regex_iterator c'tor needs clarification/editorial fix</h3>
+-<p><b>Section:</b> 28.12.1.1 [re.regiter.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 28.12.1.1 [re.regiter.cnstr] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 28.12.1.1 [re.regiter.cnstr]/2 the effects paragraph starts with:
+@@ -16801,10 +15171,10 @@ constructor sets <tt>*this</tt> to the end-of-sequence iterator.
+
+ <hr>
+ <h3><a name="649"></a>649. Several typos in regex_token_iterator constructors</h3>
+-<p><b>Section:</b> 28.12.2.1 [re.tokiter.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.tokiter.cnstr">issues</a> in [re.tokiter.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 28.12.2.1 [re.tokiter.cnstr] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.tokiter.cnstr">issues</a> in [re.tokiter.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 28.12.2.1 [re.tokiter.cnstr]/1+2 both the constructor declaration
+@@ -16813,7 +15183,8 @@ and the following text shows some obvious typos:
+ <p>
+ 1) The third constructor form is written as
+ </p>
+-<blockquote><pre>template &lt;std::size_t N&gt;
++<blockquote><pre>
++template &lt;std::size_t N&gt;
+ regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type&amp; re,
+ const int (&amp;submatches)[R],
+@@ -16859,7 +15230,8 @@ by the parameter "m".
+ <p>
+ Change 28.12.2.1 [re.tokiter.cnstr]/1:
+ </p>
+-<blockquote><pre>template &lt;std::size_t N&gt;
++<blockquote><pre>
++template &lt;std::size_t N&gt;
+ regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type&amp; re,
+ const int (&amp;submatches)[<del>R</del> <ins>N</ins>],
+@@ -16903,10 +15275,10 @@ constructor sets <tt>*this</tt> to an end-of-sequence iterator.
+
+ <hr>
+ <h3><a name="653"></a>653. Library reserved names</h3>
+-<p><b>Section:</b> 1.2 [intro.refs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#intro.refs">issues</a> in [intro.refs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 1.2 [intro.refs] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#intro.refs">issues</a> in [intro.refs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ </p>
+@@ -16965,8 +15337,8 @@ Post-Kona: Alisdair request Open. A good example of the problem was a
+ discussion of the system error proposal, where it was pointed out an all-caps
+ identifier starting with a capital E conflicted with reserved macro names for
+ both Posix and C. I had absolutely no idea of this rule, and suspect I was
+-not the only one in the room.<br>
+-<br>
++not the only one in the room.<br/>
++<br/>
+ Resolution will require someone with access to all the listed documents to
+ research their respective name reservation rules, or people with access to
+ specific documents add their rules to this issue until the list is complete.
+@@ -16989,10 +15361,10 @@ Suggest a formal paper rather than a defect report is the correct way to proceed
+
+ <hr>
+ <h3><a name="656"></a>656. Typo in subtract_with_carry_engine declaration</h3>
+-<p><b>Section:</b> 26.5.2 [rand.synopsis] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.synopsis">issues</a> in [rand.synopsis].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.2 [rand.synopsis] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.synopsis">issues</a> in [rand.synopsis].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 26.5.2 [rand.synopsis] the header <tt>&lt;random&gt;</tt> synopsis
+@@ -17006,7 +15378,8 @@ contains an unreasonable closing curly brace inside the
+ Change the current declaration in 26.5.2 [rand.synopsis]
+ </p>
+
+-<blockquote><pre>template &lt;class UIntType, size_t w<del>}</del>, size_t s, size_t r&gt;
++<blockquote><pre>
++template &lt;class UIntType, size_t w<del>}</del>, size_t s, size_t r&gt;
+ class subtract_with_carry_engine;
+ </pre></blockquote>
+
+@@ -17021,9 +15394,10 @@ Pete: Recommends editorial.
+
+ <hr>
+ <h3><a name="657"></a>657. unclear requirement about header inclusion</h3>
+-<p><b>Section:</b> 17.6.2.2 [using.headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Gennaro Prota <b>Opened:</b> 2007-03-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.2.2 [using.headers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Gennaro Prota <b>Opened:</b> 2007-03-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#using.headers">issues</a> in [using.headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 17.6.2.2 [using.headers] states:
+@@ -17038,7 +15412,7 @@ external declaration or definition, [...]
+ I see three problems with this requirement:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li><p>The C++ standard doesn't define what an "external declaration" or
+ an "external definition" are (incidentally the C99 standard does, and
+ has a sentence very similar to the above regarding header inclusion).
+@@ -17050,7 +15424,8 @@ declaration" as "declaration of an identifier with external linkage".
+ If this were the correct interpretation, then the two inclusions below
+ would be legal:
+ </p>
+-<blockquote><pre> // at global scope
++<blockquote><pre>
++ // at global scope
+ static void f()
+ {
+ # include &lt;cstddef&gt;
+@@ -17092,7 +15467,8 @@ proposal (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1691
+ Those seeking to conveniently enable argument-dependent
+ lookups for all operators within an explicit namespace
+ could easily create a header file that does so:
+-</p><pre> namespace mymath::
++</p><pre>
++ namespace mymath::
+ {
+ #include "using_ops.hpp"
+ }
+@@ -17106,21 +15482,22 @@ proposal (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1691
+ </p>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ We believe that the existing language does not cause any real confusion
+ and any new formulation of the rules that we could come up with are
+ unlikely to be better than what's already in the standard.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="662"></a>662. Inconsistent handling of incorrectly-placed thousands separators</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Cosmin Truta <b>Opened:</b> 2007-04-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Cosmin Truta <b>Opened:</b> 2007-04-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ From Section 22.4.2.1.2 [facet.num.get.virtuals], paragraphs 11 and 12, it is implied
+@@ -17193,7 +15570,8 @@ successful but not-quite-correct extraction whose output happens to be the same
+ as the previous value, the programmer must resort to implementation tricks.
+ Consider the following example:
+ </p>
+-<pre> int i = old_i;
++<pre>
++ int i = old_i;
+ cin &gt;&gt; i;
+ if (cin.fail())
+ // can the value of i be trusted?
+@@ -17233,21 +15611,21 @@ Change 22.4.2.1.2 [facet.num.get.virtuals]:
+ </blockquote>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ post-Toronto: Changed from New to NAD at the request of the author. The preferred solution of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2327.pdf">N2327</a>
+ makes this resolution obsolete.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="663"></a>663. Complexity Requirements</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 17.5.1.4 [structure.specifications] para 5 says
+@@ -17284,20 +15662,20 @@ _23213Y31 etc]
+ </p>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Kona (2007): No specific instances of underspecification have been
+ identified, and big-O notation always involves constant factors.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="667"></a>667. <tt>money_get</tt>'s widened minus sign</h3>
+-<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.6.1.2 [locale.money.get.virtuals], para 1 says:
+@@ -17344,22 +15722,22 @@ post Bellevue: Bill adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The Standard is clear that the minus sign stored in <tt>digits</tt> is <tt>ct.widen('-')</tt>.
+ The subject string must contain characters <tt>c</tt> in the set <tt>[-0123456789]</tt>
+ which are translated by <tt>ct.widen(c)</tt> calls before being stored in <tt>digits</tt>;
+ the widened characters are not relevant to the parsing of the subject string.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with Bill's comment above,
+ in line with the first of the interpretations offered in the issue.
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -17372,10 +15750,10 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="668"></a>668. <tt>money_get</tt>'s empty minus sign</h3>
+-<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.6.1.2 [locale.money.get.virtuals], para 3 says:
+@@ -17407,7 +15785,7 @@ Kona (2007): Bill to provide proposed wording and interpretation of existing wor
+
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>.
++Related to <a href="lwg-closed.html#669">669</a>.
+ </p>
+
+ <p><i>[
+@@ -17422,7 +15800,7 @@ write a negative sign". The meaning requires the sentences of 22.4.6.1.2 [local
+ taken into account:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -3- ... If <tt>pos</tt> or <tt>neg</tt> is empty, the sign component is
+ optional, and if no sign is detected, the result is given the sign that
+ corresponds to the source of the empty string. Otherwise, the character
+@@ -17431,7 +15809,7 @@ or <tt>neg</tt>, and the result is given the corresponding sign. If the
+ first character of <tt>pos</tt> is equal to the first character of
+ <tt>neg</tt>, or if both strings are empty, the result is given a
+ positive sign.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ So a <tt>negative_sign</tt> of "" means "there is no way to write a
+@@ -17443,7 +15821,8 @@ when <tt>negative_sign</tt> is "" and <tt>postive_sign.size() &gt;
+ For example:
+ </p>
+
+-<blockquote><pre>pattern = {symbol, sign, value, none}
++<blockquote><pre>
++pattern = {symbol, sign, value, none}
+ positive_sign = "+"
+ negative_sign = ""
+ $123 // a negative value, using optional sign
+@@ -17455,7 +15834,8 @@ $-123 // a parse error
+ And:
+ </p>
+
+-<blockquote><pre>pattern = {symbol, sign, value, none}
++<blockquote><pre>
++pattern = {symbol, sign, value, none}
+ positive_sign = ""
+ negative_sign = ""
+ $123 // a positive value, no sign possible
+@@ -17465,10 +15845,11 @@ $-123 // a parse error
+
+
+ <p>
+-And (regarding <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>):
++And (regarding <a href="lwg-closed.html#669">669</a>):
+ </p>
+
+-<blockquote><pre>pattern = {symbol, sign, value, none}
++<blockquote><pre>
++pattern = {symbol, sign, value, none}
+ positive_sign = "-"
+ negative_sign = "-"
+ $123 // a parse error, sign is mandatory
+@@ -17479,7 +15860,7 @@ $-123 // a positive value
+
+ <p>
+ The text seems both unambiguous and clear to me. I recommend NAD for
+-both this issue and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>. However I would have no
++both this issue and <a href="lwg-closed.html#669">669</a>. However I would have no
+ objection to adding examples such as those above.
+ </p>
+ </blockquote>
+@@ -17490,7 +15871,7 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-This discussion applies equally to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a> (q.v.).
++This discussion applies equally to issue <a href="lwg-closed.html#669">669</a> (q.v.).
+ Howard has added examples above,
+ and recommends either NAD or a resolution that adds his (or similar) examples
+ to the Working Paper.
+@@ -17502,7 +15883,7 @@ Alan would like to rewrite paragraph 3.
+ We recommend moving to NAD.
+ Anyone who feels strongly about adding the examples
+ is invited to submit corresponding wording.
+-We further recommend issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a> be handled identically.
++We further recommend issue <a href="lwg-closed.html#669">669</a> be handled identically.
+ </p>
+ </blockquote>
+
+@@ -17516,18 +15897,18 @@ We further recommend issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ No consensus for closing as NAD. Leave in Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. Agreed that the original assessment as NAD was correct.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -17536,7 +15917,7 @@ NAD. Agreed that the original assessment as NAD was correct.
+ Change 22.4.6.1.2 [locale.money.get.virtuals] p3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -3- <del>If the first character (if any) in the string pos returned by
+ <tt>mp.positive_sign()</tt> or the string <tt>neg</tt> returned by
+ <tt>mp.negative_sign()</tt> is recognized in the position indicated by
+@@ -17569,9 +15950,9 @@ characters are matched, <tt>s</tt> is consumed up to and including those charact
+ value of "<tt>()</tt>" and a currency symbol of "<tt>L</tt>", in
+ "<tt>(100 L)</tt>" the entire string is consumed; but for a <tt>neg</tt>
+ value of "<tt>-</tt>", in "<tt>-100 L</tt>", the string is consumed
+-through the second "<tt>0</tt>" (the space and "<tt>L</tt>" are not consumed). — <i>end
++through the second "<tt>0</tt>" (the space and "<tt>L</tt>" are not consumed). &mdash; <i>end
+ example</i>] </ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -17579,10 +15960,10 @@ example</i>] </ins>
+
+ <hr>
+ <h3><a name="669"></a>669. Equivalent postive and negative signs in <tt>money_get</tt></h3>
+-<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.6.1.2 [locale.money.get.virtuals], para 3 sentence 4 says:
+@@ -17614,7 +15995,7 @@ Bill to provide proposed wording and interpretation of existing wording.
+
+
+ <p><i>[
+-2009-05-17 See Howard's comments in related issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>.
++2009-05-17 See Howard's comments in related issue <a href="lwg-closed.html#668">668</a>.
+ ]</i></p>
+
+
+@@ -17624,7 +16005,7 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-This discussion applies equally to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a> (q.v.).
++This discussion applies equally to issue <a href="lwg-closed.html#668">668</a> (q.v.).
+ Howard has added examples there,
+ and recommends either NAD or a resolution that adds his (or similar) examples
+ to the Working Paper.
+@@ -17633,7 +16014,7 @@ to the Working Paper.
+ We recommend moving to NAD.
+ Anyone who feels strongly about adding the examples
+ is invited to submit corresponding wording.
+-We further recommend issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a> be handled identically.
++We further recommend issue <a href="lwg-closed.html#668">668</a> be handled identically.
+ </p>
+ </blockquote>
+
+@@ -17648,10 +16029,10 @@ We further recommend issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/
+
+ <hr>
+ <h3><a name="670"></a>670. <tt>money_base::pattern</tt> and <tt>space</tt></h3>
+-<p><b>Section:</b> 22.4.6.3 [locale.moneypunct] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a></p>
++<p><b>Section:</b> 22.4.6.3 [locale.moneypunct] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#836">836</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.6.3 [locale.moneypunct], para 2 says:
+@@ -17691,10 +16072,10 @@ whitespace characters on input.
+
+ <hr>
+ <h3><a name="683"></a>683. regex_token_iterator summary error</h3>
+-<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2007-06-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2007-06-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 28.12.2 [re.tokiter], p3 says:
+@@ -17740,16 +16121,17 @@ Yep, looks like a typo/administrative fix to me.
+
+ <hr>
+ <h3><a name="684"></a>684. Unclear which members of match_results should be used in comparison</h3>
+-<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Nozomu Katoo <b>Opened:</b> 2007-05-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.results">issues</a> in [re.results].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Nozomu Katoo <b>Opened:</b> 2007-05-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results">issues</a> in [re.results].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 28.4 [re.syn] of N2284, two template functions
+ are declared here:
+ </p>
+-<blockquote><pre>// 28.10, class template match_results:
++<blockquote><pre>
++// 28.10, class template match_results:
+ &lt;<i>snip</i>&gt;
+ // match_results comparisons
+ template &lt;class BidirectionalIterator, class Allocator&gt;
+@@ -17795,7 +16177,8 @@ Add a new section after 28.10.7 [re.results.swap], which reads:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator, class Allocator&gt;
++<pre>
++template&lt;class BidirectionalIterator, class Allocator&gt;
+ bool operator==(const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
+ const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);
+ </pre>
+@@ -17807,7 +16190,8 @@ Add a new section after 28.10.7 [re.results.swap], which reads:
+ </blockquote>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator, class Allocator&gt;
++<pre>
++template&lt;class BidirectionalIterator, class Allocator&gt;
+ bool operator!=(const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
+ const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);
+ </pre>
+@@ -17819,7 +16203,8 @@ Add a new section after 28.10.7 [re.results.swap], which reads:
+ </blockquote>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator, class Allocator&gt;
++<pre>
++template&lt;class BidirectionalIterator, class Allocator&gt;
+ void swap(match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
+ match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);
+ </pre>
+@@ -17840,14 +16225,14 @@ Bellevue: Proposed wording now in WP.
+
+
+ <hr>
+-<h3><a name="686"></a>686. Unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type</h3>
+-<p><b>Section:</b> 20.9.9.2.4 [unique.ptr.single.observers], 20.9.10.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-06-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="686"></a>686. <tt>unique_ptr</tt> and <tt>shared_ptr</tt> fail to specify non-convertibility to int for unspecified-bool-type</h3>
++<p><b>Section:</b> 20.8.1.2.4 [unique.ptr.single.observers], 20.8.2.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard library uses the <tt>operator <i>unspecified-bool-type</i>() const</tt> idiom in
+-five places. In three of those places (20.8.14.2.3 [func.wrap.func.cap], function capacity
++five places. In three of those places (20.9.12.2.3 [func.wrap.func.cap], function capacity
+ for example) the returned value is constrained to disallow
+ unintended conversions to int. The standardese is
+ </p>
+@@ -17863,18 +16248,18 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Close as NAD. Accepting paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2435.htm">N2435</a>
+ makes it irrelevant.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ To the <i>Returns</i> paragraph for <tt>operator <i>unspecified-bool-type</i>()
+-const</tt> of 20.9.9.2.4 [unique.ptr.single.observers] paragraph 11 and 20.9.10.2.5 [util.smartptr.shared.obs] paragraph 16, add the sentence:
++const</tt> of 20.8.1.2.4 [unique.ptr.single.observers] paragraph 11 and 20.8.2.2.5 [util.smartptr.shared.obs] paragraph 16, add the sentence:
+ </p>
+ <blockquote><p>
+ The return type shall not be convertible to <tt>int</tt>.
+@@ -17891,10 +16276,11 @@ Kona (2007): Uncertain if <tt>nullptr</tt> will address this issue.
+
+ <hr>
+ <h3><a name="690"></a>690. abs(long long) should return long long</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2007-06-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2007-06-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Quoting the latest draft (n2135), 26.8 [c.math]:
+@@ -17904,7 +16290,8 @@ Quoting the latest draft (n2135), 26.8 [c.math]:
+ <p>
+ The added signatures are:
+ </p>
+-<blockquote><pre>long abs(long); // labs()
++<blockquote><pre>
++long abs(long); // labs()
+ long abs(long long); // llabs()
+ </pre></blockquote>
+ </blockquote>
+@@ -17917,22 +16304,23 @@ Shouldn't <tt>abs(long long)</tt> have <tt>long long</tt> as return type?
+ <p>
+ Change 26.8 [c.math]:
+ </p>
+-<blockquote><pre><ins>long </ins>long abs(long long); // llabs()
++<blockquote><pre>
++<ins>long </ins>long abs(long long); // llabs()
+ </pre></blockquote>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Had already been fixed in the WP by the time the LWG reviewed this.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="701"></a>701. assoc laguerre poly's</h3>
+-<p><b>Section:</b> TR1 5.2.1.1 [tr.num.sf.Lnm] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Christopher Crawford <b>Opened:</b> 2007-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TR1 5.2.1.1 [tr.num.sf.Lnm] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Christopher Crawford <b>Opened:</b> 2007-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I see that the definition the associated Laguerre
+@@ -17981,9 +16369,9 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="702"></a>702. Restriction in associated Legendre functions</h3>
+-<p><b>Section:</b> TR1 5.2.1.2 [tr.num.sf.Plm] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Christopher Crawford <b>Opened:</b> 2007-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TR1 5.2.1.2 [tr.num.sf.Plm] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Christopher Crawford <b>Opened:</b> 2007-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ One other small thing, in TR1 5.2.1.2 [tr.num.sf.Plm], the restriction should be
+@@ -18013,11 +16401,10 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="707"></a>707. null pointer constant for <tt>exception_ptr</tt></h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2007-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2007-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -18072,88 +16459,16 @@ implementation details.
+
+
+ <hr>
+-<h3><a name="708"></a>708. Locales need to be per thread and updated for POSIX changes</h3>
+-<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-07-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#localization">issues</a> in [localization].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The POSIX "Extended API Set Part 4,"
+-</p>
+-<blockquote><p>
+-<a href="http://www.opengroup.org/sib/details.tpl?id=C065">http://www.opengroup.org/sib/details.tpl?id=C065</a>
+-</p></blockquote>
+-<p>
+-introduces extensions to the C locale mechanism that
+-allow multiple concurrent locales to be used in the same application
+-by introducing a type <tt>locale_t</tt> that is very similar to
+-<tt>std::locale</tt>, and a number of <tt>_l</tt> functions that make use of it.
+-</p>
+-<p>
+-The global locale (set by setlocale) is now specified to be per-
+-process. If a thread does not call <tt>uselocale</tt>, the global locale is
+-in effect for that thread. It can install a per-thread locale by
+-using <tt>uselocale</tt>.
+-</p>
+-<p>
+-There is also a nice <tt>querylocale</tt> mechanism by which one can obtain
+-the name (such as "de_DE") for a specific <tt>facet</tt>, even for combined
+-locales, with no <tt>std::locale</tt> equivalent.
+-</p>
+-<p>
+-<tt>std::locale</tt> should be harmonized with the new POSIX <tt>locale_t</tt>
+-mechanism and provide equivalents for <tt>uselocale</tt> and <tt>querylocale</tt>.
+-</p>
+-
+-<p><i>[
+-Kona (2007): Bill and Nick to provide wording.
+-]</i></p>
+-
+-
+-<p><i>[
+-San Francisco: Bill and Nick still intend to provide wording, but this
+-is a part of the task to be addressed by the group that will look into
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-It's our intention to stay in sync with WG14. If WG14 makes a decision
+-that requires a change in WG21 the issue will be reopened.
+-</p>
+-<p>
+-Move to NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="717"></a>717. Incomplete <tt>valarray::operator[]</tt> specification in [valarray.access]</h3>
+-<p><b>Section:</b> 26.6.2.3 [valarray.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.6.2.4 [valarray.access] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Since the return type of <tt>valarray</tt>'s <tt>operator[] const</tt> overload has been
+-changed to <tt>const T&amp;</tt> as described in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a> several paragraphs of
+-the section 26.6.2.3 [valarray.access] are now
++changed to <tt>const T&amp;</tt> as described in <a href="lwg-defects.html#389">389</a> several paragraphs of
++the section 26.6.2.4 [valarray.access] are now
+ incompletely
+ specified, because many requirements and guarantees should now also
+ apply to the const overload. Most notably, the address and reference
+@@ -18163,7 +16478,7 @@ guarantees should be extended to the const overload case.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 26.6.2.3 [valarray.access]:
++Change 26.6.2.4 [valarray.access]:
+ </p>
+
+ <blockquote>
+@@ -18205,10 +16520,11 @@ of that array ends, whichever happens first.
+
+ <hr>
+ <h3><a name="718"></a>718. <tt>basic_string</tt> is not a sequence</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 21.4 [basic.string]/3 states:
+@@ -18251,7 +16567,7 @@ Bellevue:
+ </ul>
+ </li>
+ </ul>
+-General consensus is to suggest option 2.
++<p>General consensus is to suggest option 2.</p>
+ </blockquote>
+
+ <p><i>[
+@@ -18259,9 +16575,9 @@ General consensus is to suggest option 2.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD Editorial
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -18278,10 +16594,11 @@ different, a string abstraction in its own right.
+
+ <hr>
+ <h3><a name="721"></a>721. <tt>wstring_convert</tt> inconsistensies</h3>
+-<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 3 says that the <tt>Codecvt</tt> template parameter shall meet the
+@@ -18293,7 +16610,8 @@ be used (because of a protected destructor).
+ How are we going to explain this code to beginning programmers?
+ </p>
+
+-<blockquote><pre>template&lt;class I, class E, class S&gt;
++<blockquote><pre>
++template&lt;class I, class E, class S&gt;
+ struct codecvt : std::codecvt&lt;I, E, S&gt;
+ {
+ ~codecvt()
+@@ -18313,9 +16631,9 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Bill will propose a resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -18343,17 +16661,18 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="725"></a>725. Optional sequence container requirements column label</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2007-09-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2007-09-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 90: (Optional sequence container operations) states the
+ "assertion note pre/post-condition" of <tt>operator[]</tt> to be
+ </p>
+
+-<blockquote><pre>*(a.begin() + n)
++<blockquote><pre>
++*(a.begin() + n)
+ </pre></blockquote>
+
+ <p>
+@@ -18366,10 +16685,10 @@ Surely that's meant to be "operational semantics?"
+ <blockquote>
+ <table border="1">
+ <caption>Table 90: Optional sequence container operations</caption>
+-<tbody><tr>
+-<th>expression</th> <th>return type</th> <th><del>assertion/note<br>pre/post-condition</del><br> <ins>operational semantics</ins></th> <th>container</th>
++<tr>
++<th>expression</th> <th>return type</th> <th><del>assertion/note<br/>pre/post-condition</del><br/> <ins>operational semantics</ins></th> <th>container</th>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -18379,16 +16698,17 @@ Surely that's meant to be "operational semantics?"
+
+ <hr>
+ <h3><a name="726"></a>726. Missing <tt>regex_replace()</tt> overloads</h3>
+-<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-09-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Two overloads of <tt>regex_replace()</tt> are currently provided:
+ </p>
+
+-<blockquote><pre>template &lt;class OutputIterator, class BidirectionalIterator,
++<blockquote><pre>
++template &lt;class OutputIterator, class BidirectionalIterator,
+ class traits, class charT&gt;
+ OutputIterator
+ regex_replace(OutputIterator out,
+@@ -18413,7 +16733,8 @@ template &lt;class traits, class charT&gt;
+ <li>
+ <p>The absence of <tt>const charT *</tt> overloads prevents ordinary-looking code from compiling, such as:</p>
+
+-<blockquote><pre>const string s("kitten");
++<blockquote><pre>
++const string s("kitten");
+ const regex r("en");
+ cout &lt;&lt; regex_replace(s, r, "y") &lt;&lt; endl;
+ </pre></blockquote>
+@@ -18459,30 +16780,30 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We note that Boost already has these overloads. However, the proposed
+ wording is provided only for 28.11.4 [re.alg.replace]; wording is needed for the synopsis
+ as well. We also note that this has impact on <tt>match_results::format</tt>,
+ which may require further overloads.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Daniel to tweak for us.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-2009-07-25 Daniel tweaks both this issue and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>.
++2009-07-25 Daniel tweaks both this issue and <a href="lwg-defects.html#727">727</a>.
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-This is solved by the proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>.
++This is solved by the proposed resolution of <a href="lwg-defects.html#727">727</a>.
+ </p>
+ </blockquote>
+
+@@ -18491,10 +16812,10 @@ This is solved by the proposed resolution of <a href="http://www.open-std.org/jt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open. Though we believe this is solved by the proposed resolution
+-to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>.
+-</blockquote>
++to <a href="lwg-defects.html#727">727</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-01-27 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+@@ -18505,7 +16826,7 @@ Rationale added below.
+
+ <p><b>Rationale:</b></p>
+ <p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>.
++Solved by <a href="lwg-defects.html#727">727</a>.
+ </p>
+
+
+@@ -18520,7 +16841,8 @@ charT* str</tt> and <tt>const charT* fmt</tt>). 28.11.4 [re.alg.replace]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class OutputIterator, class BidirectionalIterator,
++<pre>
++template &lt;class OutputIterator, class BidirectionalIterator,
+ class traits, class charT&gt;
+ OutputIterator
+ regex_replace(OutputIterator out,
+@@ -18541,7 +16863,8 @@ charT* str</tt> and <tt>const charT* fmt</tt>). 28.11.4 [re.alg.replace]:
+ regex_constants::match_default);</ins>
+ </pre>
+ <p>...</p>
+-<pre>template &lt;class traits, class charT&gt;
++<pre>
++template &lt;class traits, class charT&gt;
+ basic_string&lt;charT&gt;
+ regex_replace(const basic_string&lt;charT&gt;&amp; s,
+ const basic_regex&lt;charT, traits&gt;&amp; e,
+@@ -18582,10 +16905,10 @@ charT* str</tt> and <tt>const charT* fmt</tt>). 28.11.4 [re.alg.replace]:
+
+ <hr>
+ <h3><a name="729"></a>729. Problem in [rand.req.eng]/3</h3>
+-<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The 3rd table row in 26.5.1.4 [rand.req.eng]/3 requires random number engines to accept any
+@@ -18601,7 +16924,7 @@ type of numbers returned.
+ </p>
+
+ <p>
+-<b>Posible resolution:</b> I propose to change the wording to a version similar to "Creates an
++<b>Possible resolution:</b> I propose to change the wording to a version similar to "Creates an
+ engine with initial state determined by <tt>static_cast&lt;UintType&gt;(s)</tt>, where <tt>UintType</tt> is an
+ implementation specific unsigned integer type."
+ </p>
+@@ -18649,9 +16972,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Propose close NAD for the reasons given in N2424.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -18672,19 +16995,19 @@ Stephan Tolksdorf adds pre-Bellevue:
+ Change row 3 of table 105 "Random number engine requirements" in 26.5.1.4 [rand.req.eng]/3
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Creates an engine with initial state determined by
+ <tt><del>static_cast&lt;X::result_type&gt;(</del>s<del>)</del></tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Similarly, change 26.5.1.5 [rand.req.adapt]/3 e)
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ When <tt>X::X</tt> is invoked with <del>an <tt>X::result_type</tt></del> value <tt>s</tt>
+ <ins>of arithmetic type (3.9.1)</ins>, ...
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -18695,9 +17018,9 @@ When <tt>X::X</tt> is invoked with <del>an <tt>X::result_type</tt></del> value <
+
+ <hr>
+ <h3><a name="730"></a>730. Comment on [rand.req.adapt]/3 e)</h3>
+-<p><b>Section:</b> 26.5.1.5 [rand.req.adapt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.1.5 [rand.req.adapt] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ If an engine adaptor is invoked with an argument of type <tt>seed_seq</tt>, then all base
+@@ -18724,9 +17047,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Close NAD for the reasons given in N2424.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -18742,10 +17065,10 @@ for the proposed resolution.
+
+ <hr>
+ <h3><a name="731"></a>731. proposal for a customizable <tt>seed_seq</tt></h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The proper way to seed random number engines seems to be the most frequently
+@@ -18764,7 +17087,7 @@ changes:
+ <b>Possible resolution:</b>
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ Turn the interface specification of 26.5.7.1 [rand.util.seedseq]/2 into a "SeedSeq" requirement, where the
+ exact behaviour of the constructors and the randomize method are left unspecified and where the
+@@ -18778,11 +17101,13 @@ Provide the class <tt>seed_seq</tt> as a default implementation of the SeedSeq i
+ <p>
+ Supplement the <tt>seed_seq</tt> with a traits class
+ </p>
+-<blockquote><pre>template &lt;typename T&gt;
++<blockquote><pre>
++template &lt;typename T&gt;
+ struct is_seed_seq { static const bool value = false; }
+ </pre></blockquote>
+ <p>and the specialization</p>
+-<blockquote><pre>template &lt;&gt;
++<blockquote><pre>
++template &lt;&gt;
+ struct is_seed_seq&lt;seed_seq&gt; { static const bool value = true; }
+ </pre></blockquote>
+ <p>which users can supplement with further specializations.</p>
+@@ -18799,10 +17124,10 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ See N2424. Close NAD but note that "conceptizing" the library may cause
+ this problem to be solved by that route.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -18816,84 +17141,10 @@ for the proposed resolution.
+
+
+ <hr>
+-<h3><a name="732"></a>732. Defect in [rand.dist.samp.genpdf]</h3>
+-<p><b>Section:</b> X [rand.dist.samp.genpdf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.genpdf">issues</a> in [rand.dist.samp.genpdf].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#795">795</a></p>
+-<p><b>Discussion:</b></p>
+-<p>
+-X [rand.dist.samp.genpdf] describes the interface for a distribution template that is
+-meant to simulate random numbers from any general distribution given only the density and the
+-support of the distribution. I'm not aware of any general purpose algorithm that would be capable
+-of correctly and efficiently implementing the described functionality. From what I know, this is
+-essentially an unsolved research problem. Existing algorithms either require more knowledge
+-about the distribution and the problem domain or work only under very limited circumstances.
+-Even the state of the art special purpose library UNU.RAN does not solve the problem in full
+-generality, and in any case, testing and customer support for such a library feature would be a
+-nightmare.
+-</p>
+-
+-<p>
+-<b>Possible resolution:</b> For these reasons, I propose to delete section X [rand.dist.samp.genpdf].
+-</p>
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Disagreement persists.
+-</p>
+-<p>
+-Objection to this issue is that this function takes a general functor.
+-The general approach would be to normalize this function, integrate it,
+-and take the inverse of the integral, which is not possible in general.
+-An example function is sin(1+n*x) -- for any spatial frequency that the
+-implementor chooses, there is a value of n that renders that choice
+-arbitrarily erroneous.
+-</p>
+-<p>
+-Correction: The formula above should instead read 1+sin(n*x).
+-</p>
+-<p>
+-Objector proposes the following possible compromise positions:
+-</p>
+-<ul>
+-<li>
+-rand.dist.samp.genpdf takes an number of points so that implementor need not guess.
+-</li>
+-<li>
+-replace rand.disk.samp.genpdf with an extension to either or both of the discrete functions to take arguments that take a functor and number of points in place of the list of probabilities. Reference issues 793 and 794.
+-</li>
+-</ul>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2813.pdf">N2813</a>
+-for the proposed resolution.
+-</p>
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="733"></a>733. Comment on [rand.req.dist]/9</h3>
+-<p><b>Section:</b> 26.5.1.6 [rand.req.dist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.1.6 [rand.req.dist] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The requirement "P shall have a declaration of the form <tt>typedef X distribution_-
+@@ -18914,9 +17165,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Close NAD for the reasons given in N2424. In practice it is not inconvenient to meet these requirements.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -18932,9 +17183,9 @@ for the proposed resolution.
+
+ <hr>
+ <h3><a name="735"></a>735. Unfortunate naming</h3>
+-<p><b>Section:</b> 26.5.8.2.2 [rand.dist.bern.bin], 26.5.8.2.4 [rand.dist.bern.negbin] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.3.2 [rand.dist.bern.bin], 26.5.8.3.4 [rand.dist.bern.negbin] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In my opinion the choice of name for the <tt>t</tt> parameter of the <tt>binomial_distribution</tt>
+@@ -18964,10 +17215,10 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ In N2424. NAD It has been around for a while. It is hardly universal,
+ there is prior art, and this would confuse people.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -18982,12 +17233,12 @@ for the proposed resolution.
+
+ <hr>
+ <h3><a name="736"></a>736. Comment on [rand.dist.samp.discrete]</h3>
+-<p><b>Section:</b> 26.5.8.5.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.6.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ The specification for <tt>discrete_distribution</tt> requires the member <tt>probabilities()</tt>
+ to return a vector of <i>standardized</i> probabilities, which forces the implementation every time to
+@@ -19079,7 +17330,7 @@ Stephan Tolksdorf adds pre-Bellevue:
+
+ <blockquote>
+ <p>
+-In 26.5.8.5.1 [rand.dist.samp.discrete]:
++In 26.5.8.6.1 [rand.dist.samp.discrete]:
+ </p>
+
+ <p>
+@@ -19088,24 +17339,24 @@ Proposed wording a):
+
+ <blockquote>
+ <p>
+-Changae in para. 2
++Change in para. 2
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Constructs a <tt>discrete_distribution</tt> object with <tt>n=1</tt> and <tt>p<sub>0</sub> <ins>= w<sub>0</sub></ins> = 1</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ and change in para. 5
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> A <tt>vector&lt;double&gt;</tt> whose <tt>size</tt> member returns <tt>n</tt> and whose
+ <tt>operator[]</tt> member returns <del><tt>p<sub>k</sub></tt></del>
+ <ins>the weight <tt>w<sub>k</sub></tt> as a double value</ins>
+ when invoked with argument <tt>k</tt> for <tt>k = 0,
+ ..., n-1</tt>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -19118,7 +17369,7 @@ Proposed wording b):
+ Change in para. 3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If <tt>firstW == lastW</tt>, let the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist
+ of the single value <tt>w<sub>0</sub> = 1</tt>. Otherwise, <tt>[firstW,lastW)</tt> shall form a
+ sequence <tt>w</tt> of length <tt>n <del>&gt; 0</del></tt>
+@@ -19126,7 +17377,7 @@ sequence <tt>w</tt> of length <tt>n <del>&gt; 0</del></tt>
+ and <tt>*firstW</tt> shall yield a value <tt>w<sub>0</sub></tt>
+ convertible to <tt>double</tt>. [<i>Note:</i> The values <tt>w<sub>k</sub></tt> are commonly known
+ as the weights . <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -19138,12 +17389,12 @@ as the weights . <i>-- end note</i>]
+
+ <hr>
+ <h3><a name="737"></a>737. Comment on [rand.dist.samp.pconst]</h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ The discussion in point T11 above regarding <tt>probabilities()</tt> similarly applies
+ to the method <tt>densities()</tt> of <tt>piecewise_constant_distribution</tt>.
+@@ -19152,7 +17403,8 @@ to the method <tt>densities()</tt> of <tt>piecewise_constant_distribution</tt>.
+ <p>
+ The design of the constructor
+ </p>
+-<blockquote><pre>template &lt;class InputIteratorB, class InputIteratorW&gt;
++<blockquote><pre>
++template &lt;class InputIteratorB, class InputIteratorW&gt;
+ piecewise_constant_distribution( InputIteratorB firstB, InputIteratorB lastB,
+ InputIteratorW firstW);
+ </pre></blockquote>
+@@ -19172,20 +17424,20 @@ interface, in particular the risk that input error might go unnoticed.
+ Stephan Tolksdorf adds pre-Bellevue:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ In reply to the discussion in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2424.pdf">N2424</a>
+-I'd like to make the same comments as for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>.
+-</blockquote>
++I'd like to make the same comments as for <a href="lwg-closed.html#736">736</a>.
++</p></blockquote>
+
+ <p><i>[
+ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ In N2424. There is already precedent elsewhere in the library. Follows existing convention. NAD.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -19201,7 +17453,7 @@ Stephan Tolksdorf adds pre-Bellevue:
+
+ <blockquote>
+ <p>
+-In 26.5.8.5.2 [rand.dist.samp.pconst]:
++In 26.5.8.6.2 [rand.dist.samp.pconst]:
+ </p>
+
+ <p>
+@@ -19212,21 +17464,21 @@ Proposed wording a)
+ <p>
+ Change in para. 2
+ </p>
+-<blockquote>
++<blockquote><p>
+ Constructs a <tt>piecewise_constant_distribution</tt> object with <tt>n = 1</tt>, <tt>p<sub>0</sub> <ins>= w<sub>0</sub></ins> = 1</tt>,
+ <tt>b<sub>0</sub> = 0</tt>, and <tt>b<sub>1</sub> = 1</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ and change in para. 5
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A <tt>vector&lt;result_type&gt;</tt> whose <tt>size</tt> member returns <tt>n</tt> and whose <tt>operator[]</tt>
+ member returns <del><tt>p<sub>k</sub></tt></del>
+ <ins>the weight <tt>w<sub>k</sub></tt> as a double value</ins>
+ when invoked with argument <tt>k</tt> for <tt>k = 0, ..., n-1</tt>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -19239,22 +17491,22 @@ Proposed wording b)
+ Change both occurrences of
+ </p>
+
+-<blockquote>
++<blockquote><pre>
+ "piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
+ InputIteratorW firstW<ins>, InputIteratorW lastW</ins>)
+-</blockquote>
++</pre></blockquote>
+
+ <p>
+ and change in para. 3
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del>the length of the sequence <tt>w</tt> starting from <tt>firstW</tt> shall be at least <tt>n</tt>,
+ <tt>*firstW</tt> shall return a value <tt>w<sub>0</sub></tt> that is convertible to <tt>double</tt>, and any
+ <tt>w<sub>k</sub></tt> for <tt>k &gt;= n</tt> shall be ignored by the distribution</del>
+ <ins><tt>[firstW, lastW)</tt> shall form a sequence <tt>w</tt> of length <tt>n</tt> whose leading element
+ <tt>w<sub>0</sub></tt> shall be convertible to <tt>double</tt></ins>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -19268,10 +17520,10 @@ and change in para. 3
+
+ <hr>
+ <h3><a name="738"></a>738. Editorial issue in [rand.adapt.disc]/3</h3>
+-<p><b>Section:</b> 26.5.4.1 [rand.adapt.disc] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.adapt.disc">issues</a> in [rand.adapt.disc].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.5.4.2 [rand.adapt.disc] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.adapt.disc">issues</a> in [rand.adapt.disc].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Since the template parameter <tt>p</tt> and <tt>r</tt> are of type <tt>size_t</tt>, the member <tt>n</tt> in the class
+@@ -19291,10 +17543,10 @@ for the proposed resolution.
+
+ <hr>
+ <h3><a name="739"></a>739. Defect in [rand.util.canonical]/3</h3>
+-<p><b>Section:</b> 26.5.7.2 [rand.util.canonical] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.canonical">issues</a> in [rand.util.canonical].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.7.2 [rand.util.canonical] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.canonical">issues</a> in [rand.util.canonical].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The complexity of <tt>generate_canonical</tt> is specified to be "exactly k=max(1, ceil(b/log2
+@@ -19313,9 +17565,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ In N2424. Close NAD as described there.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -19331,10 +17583,10 @@ for the proposed resolution.
+
+ <hr>
+ <h3><a name="741"></a>741. Const-incorrect <tt>get_deleter</tt> function for <tt>shared_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.11 [util.smartptr.getdeleter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-09-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.10 [util.smartptr.getdeleter] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-09-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The following issue was raised by Alf P. Steinbach in c.l.c++.mod:
+@@ -19342,10 +17594,11 @@ The following issue was raised by Alf P. Steinbach in c.l.c++.mod:
+
+ <p>
+ According to the recent draft N2369, both the header memory synopsis
+-of 20.9 [memory] and 20.9.10.2.11 [util.smartptr.getdeleter] declare:
++of 20.7 [memory] and 20.8.2.2.10 [util.smartptr.getdeleter] declare:
+ </p>
+
+-<blockquote><pre>template&lt;class D, class T&gt; D* get_deleter(shared_ptr&lt;T&gt; const&amp; p);
++<blockquote><pre>
++template&lt;class D, class T&gt; D* get_deleter(shared_ptr&lt;T&gt; const&amp; p);
+ </pre></blockquote>
+
+ <p>
+@@ -19357,25 +17610,26 @@ the mutability of the owner (as seen for the both overloads of
+ <tt>unique_ptr::get_deleter</tt>).
+ Even the next similar counter-part of <tt>get_deleter</tt> - the two
+ overloads of <tt>function::target</tt> in the class template function
+-synopsis 20.8.14.2 [func.wrap.func] or in 20.8.14.2.5 [func.wrap.func.targ] - do
++synopsis 20.9.12.2 [func.wrap.func] or in 20.9.12.2.5 [func.wrap.func.targ] - do
+ properly mirror the const-state of the owner.
+ </p>
+
+-<b>Possible proposed resolutions:</b>
++<p><b>Possible proposed resolutions:</b></p>
+
+ <p>
+ Replace the declarations of <tt>get_deleter</tt> in the header <tt>&lt;memory&gt;</tt>
+-synopsis of 20.9 [memory] and in 20.9.10.2.11 [util.smartptr.getdeleter] by one of the
++synopsis of 20.7 [memory] and in 20.8.2.2.10 [util.smartptr.getdeleter] by one of the
+ following alternatives (A) or (B):
+ </p>
+
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ Provide <b>only</b> the immutable variant. This would reflect the
+ current praxis of <tt>container::get_allocator()</tt>, <tt>map::key_comp()</tt>, or
+ <tt>map::value_comp</tt>.
+
+-<blockquote><pre>template&lt;class D, class T&gt; const D* get_deleter(shared_ptr&lt;T&gt; const&amp; p);
++<blockquote><pre>
++template&lt;class D, class T&gt; const D* get_deleter(shared_ptr&lt;T&gt; const&amp; p);
+ </pre></blockquote>
+ </li>
+ <li>
+@@ -19387,12 +17641,13 @@ Just remove the function.
+ Alberto Ganesh Barbati adds:
+ </p>
+
+-<ol type="A" start="3">
++<ol style="list-style-type:upper-alpha" start="3">
+ <li>
+ <p>
+ Replace it with two functions:
+ </p>
+-<blockquote><pre>template &lt;class D, class T&gt; D get_deleter(shared_ptr&lt;T&gt; const&amp;);
++<blockquote><pre>
++template &lt;class D, class T&gt; D get_deleter(shared_ptr&lt;T&gt; const&amp;);
+ template &lt;class D, class T&gt; bool has_deleter(shared_ptr&lt;T&gt; const&amp;);
+ </pre></blockquote>
+
+@@ -19420,9 +17675,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Concern this is similar to confusing "pointer to const" with "a constant pointer".
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -19435,11 +17690,10 @@ Concern this is similar to confusing "pointer to const" with "a constant pointer
+
+ <hr>
+ <h3><a name="745"></a>745. copy_exception API slices.</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It could be I did not understand the design rationale, but I thought
+@@ -19478,10 +17732,11 @@ slicing involved.
+
+ <hr>
+ <h3><a name="747"></a>747. We have 3 separate type traits to identify classes supporting no-throw operations</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ We have 3 separate type traits to identify classes supporting no-throw
+@@ -19501,7 +17756,8 @@ What level of magic do we expect to deduce if this is known?
+ E.g.
+ </p>
+
+-<blockquote><pre>struct test{
++<blockquote><pre>
++struct test{
+ int x;
+ test() : x() {}
+ };
+@@ -19535,11 +17791,11 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This looks like a QoI issue.
+ In the case of trivial and nothrow it is known. Static analysis of the program is definitely into QoI.
+ Move to OPEN. Need to talk to Core about this.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -19566,10 +17822,11 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="748"></a>748. The is_abstract type trait is defined by reference to 10.4.</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I am trying to decide is a pure virtual function is a <i>necessary</i> as well as
+@@ -19578,7 +17835,8 @@ sufficient requirement to be classified as abstract?
+ <p>
+ For instance, is the following (non-polymorphic) type considered abstract?
+ </p>
+-<blockquote><pre>struct abstract {
++<blockquote><pre>
++struct abstract {
+ protected:
+ abstract(){}
+ abstract( abstract const &amp; ) {}
+@@ -19603,11 +17861,11 @@ Core has clarified that the definition abstract is adequate. Issue withdrawn by
+ <hr>
+ <h3><a name="750"></a>750. The current definition for <tt>is_convertible</tt> requires that the type be
+ implicitly convertible, so explicit constructors are ignored.</h3>
+-<p><b>Section:</b> 20.7.6 [meta.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a></p>
++<p><b>Section:</b> 20.10.6 [meta.rel] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#719">719</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ With the pending arrival of explicit conversion functions though, I'm
+@@ -19619,21 +17877,21 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alisdair is considering preparing a paper listing a number of missing
+ type traits, and feels that it might be useful to handle them all
+ together rather than piecemeal. This would affect issue 719 and 750.
+ These two issues should move to OPEN pending AM paper on type traits.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
+-Duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a> (for our purposes).
+-</blockquote>
++<blockquote><p>
++Duplicate of <a href="lwg-defects.html#719">719</a> (for our purposes).
++</p></blockquote>
+
+ <p><i>[
+ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2947.html">N2947</a>.
+@@ -19651,13 +17909,13 @@ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2
+
+ <hr>
+ <h3><a name="751"></a>751. change pass-by-reference members of <tt>vector&lt;bool&gt;</tt> to pass-by-value?</h3>
+-<p><b>Section:</b> 23.4.2 [vector.bool] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-A number of vector&lt;bool&gt; members take const bool&amp; as arguments.
++A number of <tt>vector&lt;bool&gt;</tt> members take const bool&amp; as arguments.
+ Is there any chance we could change them to pass-by-value or would I
+ be wasting everyone's time if wrote up an issue?
+ </p>
+@@ -19683,7 +17941,7 @@ Many in the group feel that for vector&lt;bool&gt;, this is a "don't care",
+ and that at this point in the process it's not worth the bandwidth.
+ </p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a> -- which was in ready status pre-Bellevue and is
++Issue <a href="lwg-defects.html#679">679</a> -- which was in ready status pre-Bellevue and is
+ now in the working paper -- is related to this, though not a duplicate.
+ </p>
+ <p>
+@@ -19718,9 +17976,9 @@ Howard: Haven't yet opened new issue. Lacking wording for it.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. Insufficient motivation to make any changes.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -19733,17 +17991,18 @@ NAD. Insufficient motivation to make any changes.
+
+ <hr>
+ <h3><a name="754"></a>754. Ambiguous return clause for <tt>std::uninitialized_copy</tt></h3>
+-<p><b>Section:</b> 20.9.8.2 [uninitialized.copy] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#uninitialized.copy">issues</a> in [uninitialized.copy].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.7.12.2 [uninitialized.copy] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#uninitialized.copy">issues</a> in [uninitialized.copy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 14882-2003, [lib.uninitialized.copy] is currently written as follows:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class InputIterator, class ForwardIterator&gt;
++<pre>
++template &lt;class InputIterator, class ForwardIterator&gt;
+ ForwardIterator uninitialized_copy(InputIterator <i>first</i>, InputIterator <i>last</i>,
+ ForwardIterator <i>result</i>);
+ </pre>
+@@ -19751,7 +18010,8 @@ NAD. Insufficient motivation to make any changes.
+ <p>
+ -1- <i>Effects:</i>
+ </p>
+-<blockquote><pre>for (; first != last; ++result, ++first)
++<blockquote><pre>
++for (; first != last; ++result, ++first)
+ new (static_cast&lt;void*&gt;(&amp;*result))
+ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
+ </pre></blockquote>
+@@ -19763,7 +18023,7 @@ NAD. Insufficient motivation to make any changes.
+
+ <p>
+ similarily for N2369, and its corresponding section
+-20.9.8.2 [uninitialized.copy].
++20.7.12.2 [uninitialized.copy].
+ </p>
+
+ <p>
+@@ -19772,7 +18032,7 @@ two
+ possible interpretations:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ The notion of <tt><i>result</i></tt> is supposed to mean the value given by the
+ function parameter <tt><i>result</i></tt> [Note to the issue editor: Please use italics for
+@@ -19811,7 +18071,7 @@ for <tt>std::copy</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the wording of the return clause to say (20.9.8.2 [uninitialized.copy]):
++Change the wording of the return clause to say (20.7.12.2 [uninitialized.copy]):
+ </p>
+
+ <blockquote>
+@@ -19826,145 +18086,51 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Resolution: NAD editorial -- project editor to decide if change is
+ worthwhile. Concern is that there are many other places this might
+ occur.
+-</blockquote>
+-
+-
+-
+-
+-<hr>
+-<h3><a name="756"></a>756. Container adaptors push</h3>
+-<p><b>Section:</b> 23.5 [container.adaptors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-After n2369 we have a single <tt>push_back</tt> overload in the sequence containers,
+-of the "emplace" type. At variance with that, still in n2461, we have
+-two separate overloads, the C++03 one + one taking an rvalue reference
+-in the container adaptors. Therefore, simply from a consistency point of
+-view, I was wondering whether the container adaptors should be aligned
+-with the specifications of the sequence container themselves: thus have
+-a single <tt>push</tt> along the lines:
+-</p>
+-
+-<blockquote><pre>template&lt;typename... _Args&gt;
+-void
+-push(_Args&amp;&amp;... __args)
+- { c.push_back(std::forward&lt;_Args&gt;(__args)...); }
+-</pre></blockquote>
+-
+-<p><i>[
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>
+-]</i></p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 23.5.1.1 [queue.defn]:
+-</p>
+-
+-<blockquote><pre><del>void push(const value_type&amp; x) { c.push_back(x); }</del>
+-<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
+-<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
+-</pre></blockquote>
+-
+-<p>
+-Change 23.5.2 [priority.queue]:
+-</p>
+-
+-<blockquote><pre><del>void push(const value_type&amp; x) { c.push_back(x); }</del>
+-<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
+-<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
+-</pre></blockquote>
+-
+-<p>
+-Change 23.5.2.3 [priqueue.members]:
+-</p>
+-
+-<blockquote>
+-<pre><del>void push(const value_type&amp; x);</del>
+-</pre>
+-<blockquote>
+-<p>
+-<del><i>Effects:</i></del>
+-</p>
+-<blockquote><pre><del>c.push_back(x);</del>
+-<del>push_heap(c.begin(), c.end(), comp);</del>
+-</pre></blockquote>
+-</blockquote>
+-
+-<pre><ins>template&lt;class... Args&gt;</ins> void push(<del>value_type</del> <ins>Args</ins>&amp;&amp;<ins>...</ins> <del>x</del> <ins>args</ins>);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Effects:</i>
+-</p>
+-<blockquote><pre>c.push_back(std::<del>move</del><ins>forward&lt;Args&gt;</ins>(<del>x</del> <ins>args</ins>)<ins>...</ins>);
+-push_heap(c.begin(), c.end(), comp);
+-</pre></blockquote>
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-Change 23.5.3.1 [stack.defn]:
+-</p>
+-
+-<blockquote><pre><del>void push(const value_type&amp; x) { c.push_back(x); }</del>
+-<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
+-<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
+-</pre></blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680 Proposed Wording for Placement Insert (Revision 1)</a>.
+-</p>
+-
++</p></blockquote>
+
+
+
+
+ <hr>
+ <h3><a name="757"></a>757. Typo in the synopsis of vector</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-11-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-11-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In the synopsis 23.4.1 [vector], there is the signature:
++In the synopsis 23.3.6 [vector], there is the signature:
+ </p>
+
+-<blockquote><pre>void insert(const_iterator position, size_type n, T&amp;&amp; x);
++<blockquote><pre>
++void insert(const_iterator position, size_type n, T&amp;&amp; x);
+ </pre></blockquote>
+
+ <p>
+ instead of:
+ </p>
+
+-<blockquote><pre>iterator insert(const_iterator position, T&amp;&amp; x);
++<blockquote><pre>
++iterator insert(const_iterator position, T&amp;&amp; x);
+ </pre></blockquote>
+
+ <p>
+-23.4.1.4 [vector.modifiers] is fine.
++23.3.6.5 [vector.modifiers] is fine.
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in 23.4.1 [vector]:
++Change the synopsis in 23.3.6 [vector]:
+ </p>
+
+-<blockquote><pre>iterator insert(const_iterator position, const T&amp; x);
++<blockquote><pre>
++iterator insert(const_iterator position, const T&amp; x);
+ <ins>iterator insert(const_iterator position, T&amp;&amp; x);</ins>
+ void insert(const_iterator position, size_type n, const T&amp; x);
+ <del>void insert(const_iterator position, size_type n, T&amp;&amp; x);</del>
+@@ -19975,102 +18141,19 @@ void insert(const_iterator position, size_type n, const T&amp; x);
+
+
+ <hr>
+-<h3><a name="760"></a>760. The emplace issue</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-11-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-In an emplace member function the function parameter pack may be bound
+-to a priori unlimited number of objects: some or all of them can be
+-elements of the container itself. Apparently, in order to conform to the
+-blanket statement 23.2 [container.requirements]/11, the
+-implementation must check all of them for that possibility. A possible
+-solution can involve extending the exception in 23.2 [container.requirements]/12 also to the emplace member. As a
+-side note, the <tt>push_back</tt> and <tt>push_front</tt> member
+-functions are luckily not affected by this problem, can be efficiently
+-implemented anyway
+-</p>
+-
+-<p><i>[
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>
+-]</i></p>
+-
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-The proposed addition (13) is partially redundant with the existing
+-paragraph 12. Why was the qualifier "rvalues" added to paragraph 12? Why
+-does it not cover subelements and pointers?
+-</p>
+-<p>
+-Resolution: Alan Talbot to rework language, then set state to Review.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-The problem is broader than emplace. The LWG doesn't
+-feel that it knows how to write wording that prohibits all of the
+-problematic use cases at this time.
+-</p>
+-<p>
+-NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add after 23.2 [container.requirements]/12:
+-</p>
+-
+-<blockquote>
+-<p>
+--12- Objects passed to member functions of a container as rvalue
+-references shall not be elements of that container. No diagnostic
+-required.
+-</p>
+-<p>
+-<ins>
+--13- Objects bound to the function parameter pack of the
+-<tt>emplace</tt> member function shall not be elements or sub-objects of
+-elements of the container. No diagnostic required.
+-</ins>
+-</p>
+-
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="763"></a>763. Renaming <tt>emplace()</tt> overloads</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sylvain Pion <b>Opened:</b> 2007-12-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sylvain Pion <b>Opened:</b> 2007-12-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The associative containers provide 2 overloads of <tt>emplace()</tt>:
+ </p>
+
+-<blockquote><pre>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
++<blockquote><pre>
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
+ template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
+ </pre></blockquote>
+
+@@ -20080,7 +18163,7 @@ a <tt>const_iterator</tt> as first argument.
+ </p>
+
+ <p><i>[
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>
++Related to <a href="lwg-defects.html#767">767</a>
+ ]</i></p>
+
+
+@@ -20089,13 +18172,20 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
+-</blockquote>
+ <p>
+ This can be disambiguated by passing "begin" as the first argument in
+ the case when the non-default choice is desired. We believe that desire
+ will be rare.
+ </p>
++
++<p><i>[For related discussion see <a href="lwg-closed.html#1302">1302</a>]</i></p>
++
++
++<p>
++LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680</a>
++renamed one of the overloads to <tt>emplace_hint</tt>.
++</p>
++
+ <p>
+ Resolution: Change state to NAD.
+ </p>
+@@ -20113,11 +18203,11 @@ For example to <tt>emplace_here</tt>, <tt>hint_emplace</tt>...
+
+ <hr>
+ <h3><a name="764"></a>764. <tt>equal_range</tt> on unordered containers should return a <tt>pair</tt> of <tt>local_iterators</tt></h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-11-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-11-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A major attribute of the unordered containers is that iterating
+@@ -20133,7 +18223,8 @@ object of it's <tt>key_type</tt>, then <tt>b.equal_range(k)</tt> currently retur
+ <tt>pair&lt;B::iterator, B::iterator&gt;</tt>. Consider the following code:
+ </p>
+
+-<blockquote><pre>B::iterator lb, ub;
++<blockquote><pre>
++B::iterator lb, ub;
+ tie(lb, ub) = b.equal_range(k);
+ for (B::iterator it = lb; it != ub; ++it) {
+ // Do something with *it
+@@ -20163,10 +18254,10 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution breaks consistency with other container types
+ for dubious benefit, and iterators are already constant time.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -20175,7 +18266,7 @@ for dubious benefit, and iterators are already constant time.
+ Change the entry for <tt>equal_range</tt> in Table 93 (23.2.5 [unord.req]) as follows:
+ </p>
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>expression</th> <th>return type</th> <th>assertion/note pre/post-condition</th> <th>complexity</th>
+ </tr>
+
+@@ -20183,271 +18274,9 @@ Change the entry for <tt>equal_range</tt> in Table 93 (23.2.5 [unord.req]) as fo
+ <td><tt>b.equal_range(k)</tt></td>
+ <td><tt>pair&lt;<ins>local_</ins>iterator,<ins>local_</ins>iterator&gt;; pair&lt;const_<ins>local_</ins>iterator,const_<ins>local_</ins>iterator&gt;</tt> for <tt>const b</tt>.</td>
+ <td>Returns a range containing all elements with keys equivalent to <tt>k</tt>. Returns <tt>make_pair(b.end(<ins>b.bucket(key)</ins>),b.end(<ins>b.bucket(key)</ins>))</tt> if no such elements exist.</td>
+-<td>Average case &#920;<tt>(b.count(k))</tt>. Worst case &#920;<tt>(b.size())</tt>. </td>
+-</tr>
+-</tbody></table>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="767"></a>767. Forwarding and backward compatibility</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Sylvain Pion <b>Opened:</b> 2007-12-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Playing with g++'s C++0X mode, I noticed that the following
+-code, which used to compile:
+-</p>
+-
+-<blockquote><pre>#include &lt;vector&gt;
+-
+-int main()
+-{
+- std::vector&lt;char *&gt; v;
+- v.push_back(0);
+-}
+-</pre></blockquote>
+-
+-<p>
+-now fails with the following error message:
+-</p>
+-
+-<blockquote>
+-.../include/c++/4.3.0/ext/new_allocator.h: In member function 'void __gnu_cxx::new_allocator&lt;_Tp&gt;::construct(_Tp*, _Args&amp;&amp; ...) [with _Args = int, _Tp = char*]':
+-.../include/c++/4.3.0/bits/stl_vector.h:707: instantiated from 'void std::vector&lt;_Tp, _Alloc&gt;::push_back(_Args&amp;&amp; ...) [with _Args = int, _Tp = char*, _Alloc = std::allocator&lt;char*&gt;]'
+-test.cpp:6: instantiated from here
+-.../include/c++/4.3.0/ext/new_allocator.h:114: error: invalid conversion from 'int' to 'char*'
+-</blockquote>
+-
+-<p>
+-As far as I know, g++ follows the current draft here.
+-</p>
+-<p>
+-Does the committee really intend to break compatibility for such cases?
+-</p>
+-
+-<p><i>[
+-Sylvain adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I just noticed that <tt>std::pair</tt> has the same issue.
+-The following now fails with GCC's -std=c++0x mode:
+-</p>
+-
+-<blockquote><pre>#include &lt;utility&gt;
+-
+-int main()
+-{
+- std::pair&lt;char *, char *&gt; p (0,0);
+-}
+-</pre></blockquote>
+-
+-<p>
+-I have not made any general audit for such problems elsewhere.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>
+-]</i></p>
+-
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Motivation is to handle the old-style int-zero-valued NULL pointers.
+-Problem: this solution requires concepts in some cases, which some users
+-will be slow to adopt. Some discussion of alternatives involving
+-prohibiting variadic forms and additional library-implementation
+-complexity.
+-</p>
+-<p>
+-Discussion of "perfect world" solutions, the only such solution put
+-forward being to retroactively prohibit use of the integer zero for a
+-NULL pointer. This approach was deemed unacceptable given the large
+-bodies of pre-existing code that do use integer zero for a NULL pointer.
+-</p>
+-<p>
+-Another approach is to change the member names. Yet another approach is
+-to forbid the extension in absence of concepts.
+-</p>
+-<p>
+-Resolution: These issues (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>) will be subsumed into a
+-paper to be produced by Alan Talbot in time for review at the 2008
+-meeting in France. Once this paper is produced, these issues will be
+-moved to NAD.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add the following rows to Table 90 "Optional sequence container operations", 23.2.3 [sequence.reqmts]:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<tbody><tr>
+-<th>expression</th> <th>return type</th> <th>assertion/note<br>pre-/post-condition</th> <th>container</th>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>a.push_front(t)</tt>
+-</td>
+-<td>
+-<tt>void</tt>
+-</td>
+-<td>
+-<tt>a.insert(a.begin(), t)</tt><br>
+-<i>Requires:</i> <tt>T</tt> shall be <tt>CopyConstructible</tt>.
+-</td>
+-<td>
+-<tt>list, deque</tt>
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>a.push_front(rv)</tt>
+-</td>
+-<td>
+-<tt>void</tt>
+-</td>
+-<td>
+-<tt>a.insert(a.begin(), rv)</tt><br>
+-<i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt>.
+-</td>
+-<td>
+-<tt>list, deque</tt>
+-</td>
+-</tr>
+-
+-<tr>
+-<td>
+-<tt>a.push_back(t)</tt>
+-</td>
+-<td>
+-<tt>void</tt>
+-</td>
+-<td>
+-<tt>a.insert(a.end(), t)</tt><br>
+-<i>Requires:</i> <tt>T</tt> shall be <tt>CopyConstructible</tt>.
+-</td>
+-<td>
+-<tt>list, deque, vector, basic_string</tt>
+-</td>
++<td>Average case &Theta;<tt>(b.count(k))</tt>. Worst case &Theta;<tt>(b.size())</tt>. </td>
+ </tr>
+-
+-<tr>
+-<td>
+-<tt>a.push_back(rv)</tt>
+-</td>
+-<td>
+-<tt>void</tt>
+-</td>
+-<td>
+-<tt>a.insert(a.end(), rv)</tt><br>
+-<i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt>.
+-</td>
+-<td>
+-<tt>list, deque, vector, basic_string</tt>
+-</td>
+-</tr>
+-
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-Change the synopsis in 23.3.2 [deque]:
+-</p>
+-
+-<blockquote><pre><ins>void push_front(const T&amp; x);</ins>
+-<ins>void push_front(T&amp;&amp; x);</ins>
+-<ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-Change 23.3.2.3 [deque.modifiers]:
+-</p>
+-
+-<blockquote><pre><ins>void push_front(const T&amp; x);</ins>
+-<ins>void push_front(T&amp;&amp; x);</ins>
+-<ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-Change the synopsis in 23.3.4 [list]:
+-</p>
+-
+-<blockquote><pre><ins>void push_front(const T&amp; x);</ins>
+-<ins>void push_front(T&amp;&amp; x);</ins>
+-<ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-Change 23.3.4.3 [list.modifiers]:
+-</p>
+-
+-<blockquote><pre><ins>void push_front(const T&amp; x);</ins>
+-<ins>void push_front(T&amp;&amp; x);</ins>
+-<ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-Change the synopsis in 23.4.1 [vector]:
+-</p>
+-
+-<blockquote><pre><ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-Change 23.4.1.4 [vector.modifiers]:
+-</p>
+-
+-<blockquote><pre><ins>void push_back(const T&amp; x);</ins>
+-<ins>void push_back(T&amp;&amp; x);</ins>
+-template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680 Proposed Wording for Placement Insert (Revision 1)</a>.
+-</p>
+-
+-<p>
+-If there is still an issue with pair, Howard should submit another issue.
+-</p>
++</table>
+
+
+
+@@ -20455,27 +18284,27 @@ If there is still an issue with pair, Howard should submit another issue.
+
+ <hr>
+ <h3><a name="773"></a>773. issues with random</h3>
+-<p><b>Section:</b> 26.5.8.1 [rand.dist.uni] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-01-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.uni">issues</a> in [rand.dist.uni].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.2 [rand.dist.uni] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-01-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.uni">issues</a> in [rand.dist.uni].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <ol>
+ <li>
+-26.5.8.1.1 [rand.dist.uni.int] <tt>uniform_int</tt> constructor has changed the default
++26.5.8.2.1 [rand.dist.uni.int] <tt>uniform_int</tt> constructor has changed the default
+ max constructor parameter from 9 (in TR1) to <tt>max()</tt>. The value
+ is arbitrary at best and shouldn't be lightly changed because
+ it breaks backward compatibility.
+ </li>
+
+ <li>
+-26.5.8.1.1 [rand.dist.uni.int] <tt>uniform_int</tt> has a parameter <tt>param</tt> that you can
++26.5.8.2.1 [rand.dist.uni.int] <tt>uniform_int</tt> has a parameter <tt>param</tt> that you can
+ provide on construction or <tt>operator()</tt>, set, and get. But there
+ is not even a hint of what this might be for.
+ </li>
+
+ <li>
+-26.5.8.1.2 [rand.dist.uni.real] <tt>uniform_real</tt>. Same issue as #2.
++26.5.8.2.2 [rand.dist.uni.real] <tt>uniform_real</tt>. Same issue as #2.
+ </li>
+ </ol>
+
+@@ -20484,9 +18313,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. Withdrawn.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -20499,9 +18328,9 @@ NAD. Withdrawn.
+
+ <hr>
+ <h3><a name="784"></a>784. unique_lock::release</h3>
+-<p><b>Section:</b> 30.4.2.2.3 [thread.lock.unique.mod] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Constantine Sapuntzakis <b>Opened:</b> 2008-02-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 30.4.2.2.3 [thread.lock.unique.mod] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Constantine Sapuntzakis <b>Opened:</b> 2008-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>unique_lock::release</tt> will probably lead to many mistakes where people
+@@ -20536,12 +18365,12 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Change a name from release to disown. However prior art uses the release
+ name. Compatibility with prior art is more important that any possible
+ benefit such a change might make. We do not see the benefit for
+ changing. NAD
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -20549,7 +18378,8 @@ changing. NAD
+ Change the synopsis in 30.4.2.2 [thread.lock.unique]:
+ </p>
+
+-<blockquote><pre>template &lt;class Mutex&gt;
++<blockquote><pre>
++template &lt;class Mutex&gt;
+ class unique_lock
+ {
+ public:
+@@ -20563,7 +18393,8 @@ public:
+ Change 30.4.2.2.3 [thread.lock.unique.mod]:
+ </p>
+
+-<blockquote><pre>mutex_type *<del>release</del> <ins>disown</ins>();
++<blockquote><pre>
++mutex_type *<del>release</del> <ins>disown</ins>();
+ </pre></blockquote>
+
+
+@@ -20572,29 +18403,32 @@ Change 30.4.2.2.3 [thread.lock.unique.mod]:
+
+ <hr>
+ <h3><a name="785"></a>785. Random Number Requirements in TR1</h3>
+-<p><b>Section:</b> TR1 5.1.4.5 [tr.rand.eng.disc], TR1 5.1.4.6 [tr.rand.eng.xor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> John Maddock <b>Opened:</b> 2008-01-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> TR1 5.1.4.5 [tr.rand.eng.disc], TR1 5.1.4.6 [tr.rand.eng.xor] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> John Maddock <b>Opened:</b> 2008-01-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 16 of TR1 requires that all Pseudo Random Number generators have a
+ </p>
+
+-<blockquote><pre>seed(integer-type s)
++<blockquote><pre>
++seed(integer-type s)
+ </pre></blockquote>
+
+ <p>
+ member function that is equivalent to:
+ </p>
+
+-<blockquote><pre>mygen = Generator(s)
++<blockquote><pre>
++mygen = Generator(s)
+ </pre></blockquote>
+
+ <p>
+ But the generators <tt>xor_combine</tt> and <tt>discard_block</tt> have no such seed member, only the
+ </p>
+
+-<blockquote><pre>template &lt;class Gen&gt;
++<blockquote><pre>
++template &lt;class Gen&gt;
+ seed(Gen&amp;);
+ </pre></blockquote>
+
+@@ -20615,30 +18449,30 @@ Jens adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Both engines do have the necessary
+ constructor, therefore the omission of the <tt>seed()</tt> member
+ functions appears to be an oversight.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend NAD: <tt>xor_combine</tt> does no longer exist and <tt>discard_block[_engine]</tt>
+ has now the required seed overload accepting a <tt>result_type</tt>, which shall be an
+ unsigned integral type.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD as recommended.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -20652,10 +18486,10 @@ NAD Recommended.
+
+ <hr>
+ <h3><a name="790"></a>790. <tt>xor_combine::seed</tt> not specified</h3>
+-<p><b>Section:</b> X [rand.adapt.xor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.adapt.xor">issues</a> in [rand.adapt.xor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [rand.adapt.xor] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.adapt.xor">issues</a> in [rand.adapt.xor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>xor_combine::seed(result_type)</tt> and <tt>seed(seed_seq&amp;)</tt> don't say what
+@@ -20668,9 +18502,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
+-Overcome by the previous proposal. NAD mooted by resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>.
+-</blockquote>
++<blockquote><p>
++Overcome by the previous proposal. NAD mooted by resolution of <a href="lwg-defects.html#789">789</a>.
++</p></blockquote>
+
+
+
+@@ -20682,10 +18516,10 @@ Overcome by the previous proposal. NAD mooted by resolution of <a href="http://w
+
+ <hr>
+ <h3><a name="791"></a>791. <tt>piecewise_constant_distribution::densities</tt> has wrong name</h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>piecewise_constant_distribution::densities()</tt> should be <tt>probabilities()</tt>,
+@@ -20726,10 +18560,11 @@ variates.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change synopsis in 26.5.8.5.2 [rand.dist.samp.pconst]:
++Change synopsis in 26.5.8.6.2 [rand.dist.samp.pconst]:
+ </p>
+
+-<blockquote><pre>template &lt;class RealType = double&gt;
++<blockquote><pre>
++template &lt;class RealType = double&gt;
+ class piecewise_constant_distribution
+ {
+ public:
+@@ -20740,10 +18575,11 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Change 26.5.8.5.2 [rand.dist.samp.pconst]/6:
++Change 26.5.8.6.2 [rand.dist.samp.pconst]/6:
+ </p>
+
+-<blockquote><pre>vector&lt;double&gt; <del>densities</del> <ins>probabilities</ins>() const;
++<blockquote><pre>
++vector&lt;double&gt; <del>densities</del> <ins>probabilities</ins>() const;
+ </pre></blockquote>
+
+
+@@ -20752,533 +18588,12 @@ Change 26.5.8.5.2 [rand.dist.samp.pconst]/6:
+
+
+ <hr>
+-<h3><a name="793"></a>793. <tt>discrete_distribution</tt> missing constructor</h3>
+-<p><b>Section:</b> 26.5.8.5.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-<tt>discrete_distribution</tt> should have a constructor like:
+-</p>
+-
+-<blockquote><pre>template&lt;class _Fn&gt;
+- discrete_distribution(result_type _Count, double _Low, double _High,
+- _Fn&amp; _Func);
+-</pre></blockquote>
+-
+-<p>
+-(Makes it easier to fill a histogram with function values over a range.)
+-</p>
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-How do you specify the function so that it does not return negative
+-values? If you do it is a bad construction. This requirement is already
+-there. Where in each bin does one evaluate the function? In the middle.
+-Need to revisit tomorrow.
+-</blockquote>
+-
+-<p><i>[
+-Sophia Antipolis:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Bill is not requesting this.
+-</p>
+-<p>
+-Marc Paterno: <tt>_Fn</tt> cannot return negative values at the points where the
+-function is sampled. It is sampled in the middle of each bin. <tt>_Fn</tt> cannot
+-return 0 everywhere it is sampled.
+-</p>
+-<p>
+-Jens: lambda expressions are rvalues
+-</p>
+-<p>
+-Add a library issue to provide an
+-<tt>initializer_list&lt;double&gt;</tt> constructor for
+-<tt>discrete_distribution</tt>.
+-</p>
+-<p>
+-Marc Paterno: dislikes reference for <tt>_Fn</tt> parameter. Make it pass-by-value (to use lambda),
+-use <tt>std::ref</tt> to wrap giant-state function objects.
+-</p>
+-<p>
+-Daniel: See <tt>random_shuffle</tt>, pass-by-rvalue-reference.
+-</p>
+-<p>
+-Daniel to draft wording.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Pre San Francisco, Daniel provided wording:
+-]</i></p>
+-
+-
+-<blockquote>
+-The here proposed changes of the WP refer to the current state of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">N2691</a>.
+-During the Sophia Antipolis meeting two different proposals came up
+-regarding the functor argument type, either by value or by rvalue-reference.
+-For consistence with existing conventions (state-free algorithms and the
+-<tt>general_pdf_distribution</tt> c'tor signature) the author decided to propose a
+-function argument that is provided by value. If severe concerns exists that
+-stateful functions would be of dominant relevance, it should be possible to
+-replace the two occurrences of <tt>Func</tt> by <tt>Func&amp;&amp;</tt> in this proposal as part
+-of an editorial process.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p><b>Non-concept version of the proposed resolution</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class <tt>discrete_distribution</tt>, just
+-<em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit discrete_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-
+-<p>
+-insert:
+-</p>
+-
+-
+-<blockquote><pre>template&lt;typename Func&gt;
+-discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 insert a series of new paragraphs as part of the
+-new member description::
+-</p>
+-<blockquote><pre>template&lt;typename Func&gt;
+-discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+-</pre>
+-
+-<p>
+-<i>Complexity:</i> Exactly nf invocations of fw.
+-</p>
+-<p>
+-<i>Requires:</i>
+-</p>
+-<ol type="a">
+-<li>
+-fw shall be callable with one argument of type double, and shall
+-return values of a type convertible to double;</li>
+-
+-<li>If nf &gt; 0, the relation <tt><i>x</i><sub><i>min</i></sub></tt> &lt; <tt><i>x</i><sub><i>max</i></sub></tt> shall hold, and for all sample values
+-<tt><i>x</i><sub><i>k</i></sub></tt>, fw(<tt><i>x</i><sub><i>k</i></sub></tt>) shall return a weight value <tt><i>w</i><sub><i>k</i></sub></tt> that is non-negative, non-NaN,
+-and non-infinity;</li>
+-
+-<li>The following relations shall hold: nf &#8805; 0, and 0 &lt; S = <tt><i>w</i><sub><i>0</i></sub></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.</li>
+-
+-</ol>
+-
+-<p>
+-<i>Effects:</i>
+-</p>
+-<ol type="a">
+-<li>If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and
+- consist of the single value <tt><i>w</i><sub><i>0</i></sub></tt> = 1.</li>
+-
+-<li>
+-<p>Otherwise, sets n = nf, deltax = (<tt><i>x</i><sub><i>max</i></sub></tt> - <tt><i>x</i><sub><i>min</i></sub></tt>)/n and <tt><i>x</i><sub><i>cent</i></sub></tt> = <tt><i>x</i><sub><i>min</i></sub></tt> +
+-0.5 * deltax.</p>
+-<blockquote><pre>For each k = 0, . . . ,n-1, calculates:
+- <tt><i>x</i><sub><i>k</i></sub></tt> = <tt><i>x</i><sub><i>cent</i></sub></tt> + k * deltax
+- <tt><i>w</i><sub><i>k</i></sub></tt> = fw(<tt><i>x</i><sub><i>k</i></sub></tt>)
+-</pre></blockquote>
+-</li>
+-<li>
+-<p>Constructs a discrete_distribution object with probabilities:</p>
+-<blockquote><pre><tt><i>p</i><sub><i>k</i></sub></tt> = <tt><i>w</i><sub><i>k</i></sub></tt>/S for k = 0, . . . , n-1.
+-</pre></blockquote>
+-</li>
+-</ol>
+-</blockquote>
+-</li>
+-</ol>
+-
+-<p><b>Concept version of the proposed resolution</b></p>
+-
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class <tt>discrete_distribution</tt>, just
+-<em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit discrete_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-
+-<p>
+-insert:
+-</p>
+-
+-
+-<blockquote><pre>template&lt;Callable&lt;auto, double&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 insert a series of new paragraphs as part of the
+-new member description::
+-</p>
+-<blockquote><pre>template&lt;Callable&lt;auto, double&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
+-</pre>
+-
+-<p>
+-<i>Complexity:</i> Exactly nf invocations of fw.
+-</p>
+-<p>
+-<i>Requires:</i>
+-</p>
+-<ol type="a">
+-<li>If nf &gt; 0, the relation <tt><i>x</i><sub><i>min</i></sub></tt> &lt; <tt><i>x</i><sub><i>max</i></sub></tt> shall hold, and for all sample values
+-<tt><i>x</i><sub><i>k</i></sub></tt>, fw(<tt><i>x</i><sub><i>k</i></sub></tt>) shall return a weight value <tt><i>w</i><sub><i>k</i></sub></tt> that is non-negative, non-NaN,
+-and non-infinity;</li>
+-
+-<li>The following relations shall hold: nf &#8805; 0, and 0 &lt; S = <tt><i>w</i><sub><i>0</i></sub></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.</li>
+-
+-</ol>
+-
+-<p>
+-<i>Effects:</i>
+-</p>
+-<ol type="a">
+-<li>If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and
+- consist of the single value <tt><i>w</i><sub><i>0</i></sub></tt> = 1.</li>
+-
+-<li>
+-<p>Otherwise, sets n = nf, deltax = (<tt><i>x</i><sub><i>max</i></sub></tt> - <tt><i>x</i><sub><i>min</i></sub></tt>)/n and <tt><i>x</i><sub><i>cent</i></sub></tt> = <tt><i>x</i><sub><i>min</i></sub></tt> +
+-0.5 * deltax.</p>
+-<blockquote><pre>For each k = 0, . . . ,n-1, calculates:
+- <tt><i>x</i><sub><i>k</i></sub></tt> = <tt><i>x</i><sub><i>cent</i></sub></tt> + k * deltax
+- <tt><i>w</i><sub><i>k</i></sub></tt> = fw(<tt><i>x</i><sub><i>k</i></sub></tt>)
+-</pre></blockquote>
+-</li>
+-<li>
+-<p>Constructs a discrete_distribution object with probabilities:</p>
+-<blockquote><pre><tt><i>p</i><sub><i>k</i></sub></tt> = <tt><i>w</i><sub><i>k</i></sub></tt>/S for k = 0, . . . , n-1.
+-</pre></blockquote>
+-</li>
+-</ol>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="794"></a>794. <tt>piecewise_constant_distribution</tt> missing constructor</h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-<tt>piecewise_constant_distribution</tt> should have a constructor like:
+-</p>
+-
+-<blockquote><pre>template&lt;class _Fn&gt;
+- piecewise_constant_distribution(size_t _Count,
+- _Ty _Low, _Ty _High, _Fn&amp; _Func);
+-</pre></blockquote>
+-
+-<p>
+-(Makes it easier to fill a histogram with function values over a range.
+-The two (reference <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>) make a sensible replacement for
+-<tt>general_pdf_distribution</tt>.)
+-</p>
+-
+-<p><i>[
+-Sophia Antipolis:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Marc: uses variable width of bins and weight for each bin. This is not
+-giving enough flexibility to control both variables.
+-</p>
+-<p>
+-Add a library issue to provide an constructor taking an
+-<tt>initializer_list&lt;double&gt;</tt> and <tt>_Fn</tt> for <tt>piecewise_constant_distribution</tt>.
+-</p>
+-<p>
+-Daniel to draft wording.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Pre San Francisco, Daniel provided wording.
+-]</i></p>
+-
+-
+-<blockquote>
+-The here proposed changes of the WP refer to the current state of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">N2691</a>.
+-For reasons explained in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, the author decided to propose a function
+-argument that is provided by value. The issue proposes a c'tor signature,
+-that does not take advantage of the full flexibility of
+-<tt>piecewise_constant_distribution</tt>,
+-because it restricts on a constant bin width, but the use-case seems to
+-be popular enough to justify it's introduction.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p><b>Non-concept version of the proposed resolution</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
+-just <em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit piecewise_constant_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-<p>
+-insert:
+-</p>
+-<blockquote><pre>template&lt;typename Func&gt;
+-piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 insert a new sequence of paragraphs nominated
+-below as [p5_1], [p5_2],
+-[p5_3], and [p5_4] as part of the new member description:
+-</p>
+-
+-<blockquote><pre>template&lt;typename Func&gt;
+-piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+-</pre>
+-<blockquote>
+-<p>
+-[p5_1] <i>Complexity:</i> Exactly <tt>nf</tt> invocations of <tt>fw</tt>.
+-</p>
+-<p>
+-[p5_2] <i>Requires:</i>
+-</p>
+-<ol type="a">
+-<li><tt>fw</tt> shall be callable with one argument of type <tt>RealType</tt>, and shall
+-return values of a type convertible to double;
+-</li>
+-<li>
+-For all sample values <tt><i>x<sub>k</sub></i></tt> defined below, fw(<tt><i>x<sub>k</sub></i></tt>) shall return a weight
+-value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
+-</li>
+-<li>
+-The following relations shall hold: <tt><i>x<sub>min</sub></i></tt> &lt; <tt><i>x<sub>max</sub></i></tt>, and
+-0 &lt; S = <tt><i>w<sub>0</sub></i></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.
+-</li>
+-</ol>
+-<p>
+-[p5_3] <i>Effects:</i>
+-</p>
+-<ol type="a">
+-<li>
+-<p>If nf == 0,</p>
+- <ol type="a">
+- <li>
+-sets deltax = <tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>, and</li>
+-<li> lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
+- value <tt><i>w<sub>0</sub></i></tt> = 1, and</li>
+-<li> lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt><i>b<sub>0</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> and
+- <tt><i>b<sub>1</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt>
+-</li>
+-</ol>
+-</li>
+-<li>
+-<p>Otherwise,</p>
+-<ol type="a">
+-<li> sets <tt>n = nf</tt>, <tt>deltax = </tt>(<tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>)/n,
+- <tt><i>x<sub>cent</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + 0.5 * deltax, and
+-</li>
+-<li><p>lets the sequences <tt>w</tt> and <tt>b</tt> have length <tt>n</tt> and <tt>n+1</tt>, resp. and</p>
+-<blockquote><pre>for each k = 0, . . . ,n-1, calculates:
+- <tt><i>dx<sub>k</sub></i></tt> = k * deltax
+- <tt><i>b<sub>k</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
+- <tt><i>x<sub>k</sub></i></tt> = <tt><i>x<sub>cent</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
+- <tt><i>w<sub>k</sub></i></tt> = fw(<tt><i>x<sub>k</sub></i></tt>),
+-</pre></blockquote>
+-<p> and</p>
+-</li>
+-<li> sets <tt><i>b<sub>n</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt></li>
+-</ol>
+-</li>
+-<li>
+-<p>
+-Constructs a <tt>piecewise_constant_distribution</tt> object with
+-the above computed sequence <tt>b</tt> as the interval boundaries
+-and with the probability densities:
+-</p>
+-<blockquote><pre><tt><i>&#961;<sub>k</sub></i></tt> = <tt><i>w<sub>k</sub></i></tt>/(S * deltax) for k = 0, . . . , n-1.
+-</pre></blockquote>
+-</li>
+-</ol>
+-<p>
+-[p5_4] [<i>Note:</i> In this context, the subintervals [<tt><i>b<sub>k</sub></i></tt>, <tt><i>b<sub>k+1</sub></i></tt>) are commonly
+- known as the <i>bins</i> of a histogram. <i>-- end note</i>]
+- </p>
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-<p><b>Concept version of the proposed resolution</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
+-just <em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit piecewise_constant_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-<p>
+-insert:
+-</p>
+-<blockquote><pre>template&lt;Callable&lt;auto, RealType&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 insert a new sequence of paragraphs nominated
+-below as [p5_1], [p5_2],
+-[p5_3], and [p5_4] as part of the new member description:
+-</p>
+-
+-<blockquote><pre>template&lt;Callable&lt;auto, RealType&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
+-</pre>
+-<blockquote>
+-<p>
+-[p5_1] <i>Complexity:</i> Exactly <tt>nf</tt> invocations of <tt>fw</tt>.
+-</p>
+-<p>
+-[p5_2] <i>Requires:</i>
+-</p>
+-<ol type="a">
+-<li>
+-For all sample values <tt><i>x<sub>k</sub></i></tt> defined below, fw(<tt><i>x<sub>k</sub></i></tt>) shall return a weight
+-value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
+-</li>
+-<li>
+-The following relations shall hold: <tt><i>x<sub>min</sub></i></tt> &lt; <tt><i>x<sub>max</sub></i></tt>, and
+-0 &lt; S = <tt><i>w<sub>0</sub></i></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.
+-</li>
+-</ol>
+-<p>
+-[p5_3] <i>Effects:</i>
+-</p>
+-<ol type="a">
+-<li>
+-<p>If nf == 0,</p>
+- <ol type="a">
+- <li>
+-sets deltax = <tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>, and</li>
+-<li> lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
+- value <tt><i>w<sub>0</sub></i></tt> = 1, and</li>
+-<li> lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt><i>b<sub>0</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> and
+- <tt><i>b<sub>1</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt>
+-</li>
+-</ol>
+-</li>
+-<li>
+-<p>Otherwise,</p>
+-<ol type="a">
+-<li> sets <tt>n = nf</tt>, <tt>deltax = </tt>(<tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>)/n,
+- <tt><i>x<sub>cent</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + 0.5 * deltax, and
+-</li>
+-<li><p>lets the sequences <tt>w</tt> and <tt>b</tt> have length <tt>n</tt> and <tt>n+1</tt>, resp. and</p>
+-<blockquote><pre>for each k = 0, . . . ,n-1, calculates:
+- <tt><i>dx<sub>k</sub></i></tt> = k * deltax
+- <tt><i>b<sub>k</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
+- <tt><i>x<sub>k</sub></i></tt> = <tt><i>x<sub>cent</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
+- <tt><i>w<sub>k</sub></i></tt> = fw(<tt><i>x<sub>k</sub></i></tt>),
+-</pre></blockquote>
+-<p> and</p>
+-</li>
+-<li> sets <tt><i>b<sub>n</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt></li>
+-</ol>
+-</li>
+-<li>
+-<p>
+-Constructs a <tt>piecewise_constant_distribution</tt> object with
+-the above computed sequence <tt>b</tt> as the interval boundaries
+-and with the probability densities:
+-</p>
+-<blockquote><pre><tt><i>&#961;<sub>k</sub></i></tt> = <tt><i>w<sub>k</sub></i></tt>/(S * deltax) for k = 0, . . . , n-1.
+-</pre></blockquote>
+-</li>
+-</ol>
+-<p>
+-[p5_4] [<i>Note:</i> In this context, the subintervals [<tt><i>b<sub>k</sub></i></tt>, <tt><i>b<sub>k+1</sub></i></tt>) are commonly
+- known as the <i>bins</i> of a histogram. <i>-- end note</i>]
+- </p>
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="795"></a>795. <tt>general_pdf_distribution</tt> should be dropped</h3>
+-<p><b>Section:</b> X [rand.dist.samp.genpdf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.genpdf">issues</a> in [rand.dist.samp.genpdf].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a></p>
++<p><b>Section:</b> X [rand.dist.samp.genpdf] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.genpdf">issues</a> in [rand.dist.samp.genpdf].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#732">732</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>general_pdf_distribution</tt> should be dropped. (It's a research topic in
+@@ -21290,9 +18605,9 @@ Stephan Tolksdorf notes:
+ ]</i></p>
+
+
+-<blockquote>
+-This appears to be a duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>.
+-</blockquote>
++<blockquote><p>
++This appears to be a duplicate of <a href="lwg-defects.html#732">732</a>.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -21304,10 +18619,10 @@ This appears to be a duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg2
+
+ <hr>
+ <h3><a name="796"></a>796. <tt>ranlux48_base</tt> returns wrong value</h3>
+-<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The 10,000<sup>th</sup> value returned by <tt>ranlux48_base</tt> is supposed to be
+@@ -21320,9 +18635,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Submitter withdraws defect.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -21332,14 +18647,15 @@ Change 26.5.5 [rand.predef]/p5:
+ </p>
+
+ <blockquote>
+-<pre>typedef subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;
++<pre>
++typedef subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;
+ ranlux48_base;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Required behavior:</i> The 10000<sup>th</sup> consecutive invocation of a default-constructed
+ object of type <tt>ranlux48_base</tt> shall produce the value
+ <del>61839128582725</del> <ins>192113843633948</ins>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -21348,10 +18664,10 @@ object of type <tt>ranlux48_base</tt> shall produce the value
+
+ <hr>
+ <h3><a name="797"></a>797. <tt>ranlux48</tt> returns wrong value</h3>
+-<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The 10,000<sup>th</sup> value returned by <tt>ranlux48</tt> is supposed to be
+@@ -21363,9 +18679,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Submitter withdraws defect.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -21375,14 +18691,15 @@ Change 26.5.5 [rand.predef]/p6:
+ </p>
+
+ <blockquote>
+-<pre>typedef discard_block_engine&lt;ranlux48_base, 389, 11&gt;
++<pre>
++typedef discard_block_engine&lt;ranlux48_base, 389, 11&gt;
+ ranlux48
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Required behavior:</i> The 10000<sup>th</sup> consecutive invocation of a default-constructed
+ object of type <tt>ranlux48</tt> shall produce the value
+ <del>249142670248501</del> <ins>88229545517833</ins>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -21391,10 +18708,10 @@ object of type <tt>ranlux48</tt> shall produce the value
+
+ <hr>
+ <h3><a name="799"></a>799. [tr.rand.eng.mers] and [rand.eng.mers]</h3>
+-<p><b>Section:</b> 26.5.3.2 [rand.eng.mers], TR1 5.1.4.2 [tr.rand.eng.mers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 26.5.3.2 [rand.eng.mers], TR1 5.1.4.2 [tr.rand.eng.mers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ TR1 5.1.4.2 [tr.rand.eng.mers](10) requires that <tt>operator==</tt> for the <tt>mersenne_twister</tt>
+@@ -21469,21 +18786,21 @@ In 26.5.3.2 [rand.eng.mers]:
+ Insert at the end of para 2.:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> The lower <tt>r</tt> bits of <tt>X<sub>i-n</sub></tt> do not influence
+ the state transition and hence should not be compared when comparing two
+ <tt>mersenne_twister_engine</tt> objects. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ In para 5. change:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The textual representation of <tt>x<sub>i</sub></tt> consists of the values of
+ <tt>X<sub>i-n</sub> <ins>bitand ((2<sup>w</sup> - 1) - (2<sup>r</sup> - 1)), X<sub>i-(n-1)</sub></ins>,
+ ..., X<sub>i-1</sub></tt>, in that order.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -21491,647 +18808,240 @@ The textual representation of <tt>x<sub>i</sub></tt> consists of the values of
+
+
+ <hr>
+-<h3><a name="800"></a>800. Issues in 26.4.7.1 [rand.util.seedseq](6)</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="802"></a>802. <tt>knuth_b</tt> returns wrong value</h3>
++<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The for-loop in the algorithm specification has <tt>n</tt> iterations, where <tt>n</tt> is
+-defined to be <tt>end - begin</tt>, i.e. the number of supplied w-bit quantities.
+-Previous versions of this algorithm and the general logic behind it
+-suggest that this is an oversight and that in the context of the
+-for-loop <tt>n</tt> should be the number of full 32-bit quantities in <tt>b</tt> (rounded
+-upwards). If <tt>w</tt> is 64, the current algorithm throws away half of all bits
+-in <tt>b</tt>. If <tt>w</tt> is 16, the current algorithm sets half of all elements in <tt>v</tt>
+-to 0.
++The 10,000<sup>th</sup> value returned by <tt>knuth_b</tt> is supposed to be
++1112339016. We get 2126698284.
+ </p>
+
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-There are two more minor issues:
++Change 26.5.5 [rand.predef]/p8:
+ </p>
+
+-<ul>
+-<li>
+-Strictly speaking <tt>end - begin</tt> is not defined since
+-<tt>InputIterator</tt> is not required to be a random access iterator.
+-</li>
+-<li>
+-Currently all integral types are allowed as input to the <tt>seed_seq</tt>
+-constructor, including <tt>bool</tt>. IMHO allowing <tt>bool</tt>s unnecessarily
+-complicates the implementation without any real benefit to the user.
+-I'd suggest to exclude <tt>bool</tt>s as input.
+-</li>
+-</ul>
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+ <blockquote>
+-Move to OPEN Bill will try to propose a resolution by the next meeting.
++<pre>
++typedef shuffle_order_engine&lt;minstd_rand0, 256&gt;
++ knuth_b;
++</pre>
++<blockquote><p>
++<i>Required behavior:</i> The 10000<sup>th</sup> consecutive invocation of a default-constructed
++object of type <tt>knuth_b</tt> shall produce the value
++<del>1112339016</del> <ins>2126698284</ins>.
++</p></blockquote>
+ </blockquote>
+
++
+ <p><i>[
+-post Bellevue: Bill provided wording.
++Bellevue: Submitter withdraws defect. "We got the wrong value for entirely the right reasons". NAD.
+ ]</i></p>
+
+
+-<p>
+-This issue is made moot if <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a> is accepted.
+-</p>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<hr>
++<h3><a name="812"></a>812. unsolicited multithreading considered harmful?</h3>
++<p><b>Section:</b> 25.4.1 [alg.sort] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Paul McKenney <b>Opened:</b> 2008-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Replace 26.5.7.1 [rand.util.seedseq] paragraph 6 with:
++Multi-threading is a good thing, but unsolicited multi-threading can
++potentially be harmful. For example, <tt>sort()</tt> performance might be
++greatly increased via a multithreaded implementation. However, such
++a multithreaded implementation could result in concurrent invocations
++of the user-supplied comparator. This would in turn result in problems
++given a caching comparator that might be written for complex sort keys.
++Please note that this is not a theoretical issue, as multithreaded
++implementations of <tt>sort()</tt> already exist.
+ </p>
+-
+-<blockquote>
+ <p>
+-<i>Effects:</i> Constructs a <tt>seed_seq</tt> object by effectively concatenating the
+-low-order <tt>u</tt> bits of each of the elements of the supplied sequence <tt>[begin,
+-end)</tt>
+-in ascending order of significance to make a (possibly very large) unsigned
+-binary number <tt>b</tt> having a total of <tt>n</tt> bits, and then carrying out the
+-following
+-algorithm:
++Having a multithreaded <tt>sort()</tt> available is good, but it should not
++be the default for programs that are not explicitly multithreaded.
++Users should not be forced to deal with concurrency unless they have
++asked for it.
+ </p>
+
+-<blockquote><pre>for( v.clear(); n &gt; 0; n -= 32 )
+- v.push_back(b mod 2<sup>32</sup>), b /= 2<sup>32</sup>;
+-</pre></blockquote>
+-</blockquote>
++<p><i>[
++This may be covered by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2410.html">N2410</a>
++Thread-Safety in the Standard Library (Rev 1).
++]</i></p>
+
+
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
+
+
++<p><b>Rationale:</b></p><p>
++This is already covered by 17.6.5.6/20 in N2723.
++</p>
++
+
+
+
+ <hr>
+-<h3><a name="802"></a>802. <tt>knuth_b</tt> returns wrong value</h3>
+-<p><b>Section:</b> 26.5.5 [rand.predef] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="822"></a>822. Object with explicit copy constructor no longer <tt>CopyConstructible</tt></h3>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2008-04-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The 10,000<sup>th</sup> value returned by <tt>knuth_b</tt> is supposed to be
+-1112339016. We get 2126698284.
++I just noticed that the following program is legal in C++03, but
++is forbidden in the current draft:
+ </p>
+
++<blockquote><pre>
++#include &lt;vector&gt;
++#include &lt;iostream&gt;
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 26.5.5 [rand.predef]/p8:
+-</p>
++class Toto
++{
++public:
++ Toto() {}
++ explicit Toto( Toto const&amp; ) {}
++} ;
+
+-<blockquote>
+-<pre>typedef shuffle_order_engine&lt;minstd_rand0, 256&gt;
+- knuth_b;
+-</pre>
+-<blockquote>
+-<i>Required behavior:</i> The 10000<sup>th</sup> consecutive invocation of a default-constructed
+-object of type <tt>knuth_b</tt> shall produce the value
+-<del>1112339016</del> <ins>2126698284</ins>.
+-</blockquote>
+-</blockquote>
++int
++main()
++{
++ std::vector&lt; Toto &gt; v( 10 ) ;
++ return 0 ;
++}
++</pre></blockquote>
+
++<p>
++Is this change intentional? (And if so, what is the
++justification? I wouldn't call such code good, but I don't see
++any reason to break it unless we get something else in return.)
++</p>
+
+ <p><i>[
+-Bellevue: Submitter withdraws defect. "We got the wrong value for entirely the right reasons". NAD.
++San Francisco:
+ ]</i></p>
+
+
++<blockquote><p>
++The subgroup that looked at this felt this was a good change, but it may
++already be handled by incoming concepts (we're not sure).
++</p></blockquote>
+
++<p><i>[
++Post Summit:
++]</i></p>
+
+
+-<hr>
+-<h3><a name="803"></a>803. Simplification of <tt>seed_seq::seq_seq</tt></h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Charles Karney <b>Opened:</b> 2008-02-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
++<blockquote>
+ <p>
+-<tt>seed_seq(InputIterator begin, InputIterator end);</tt> constructs a <tt>seed_seq</tt>
+-object repacking the bits of supplied sequence <tt>[begin, end)</tt> into a
+-32-bit vector.
++Alisdair: Proposed resolution kinda funky as these tables no longer
++exist. Move from direct init to copy init. Clarify with Doug, recommends
++NAD.
+ </p>
+ <p>
+-This repacking triggers several problems:
++Walter: Suggest NAD via introduction of concepts.
+ </p>
+-<ol>
+-<li>
+-Distinctness of the output of <tt>seed_seq::generate</tt> required the
+-introduction of the initial "<tt>if (w &lt; 32) v.push_back(n);</tt>" (Otherwise
+-the unsigned short vectors [1, 0] and [1] generate the same sequence.)
+-</li>
+-<li>
+-Portability demanded the introduction of the template parameter <tt>u</tt>.
+-(Otherwise some sequences could not be obtained on computers where no
+-integer types are exactly 32-bits wide.)
+-</li>
+-<li>
+-The description and algorithm have become unduly complicated.
+-</li>
+-</ol>
+ <p>
+-I propose simplifying this <tt>seed_seq</tt> constructor to be "32-bit only".
+-Despite it's being simpler, there is NO loss of functionality (see
+-below).
++Recommend close as NAD.
+ </p>
++</blockquote>
++
++<p><i>[
++2009-07 Frankfurt:
++]</i></p>
++
++
++<blockquote><p>
++Need to look at again without concepts.
++</p></blockquote>
++
++<p><i>[
++2009-07 Frankfurt:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-Here's how the description would read
++Move to Ready with original proposed resolution.
+ </p>
+-<blockquote>
++<p><i>[Howard: Original proposed resolution restored.]</i></p>
++
++</blockquote>
++
++<p><i>[
++2010-11 Batavia:
++]</i></p>
++
+ <p>
+-26.5.7.1 [rand.util.seedseq] Class <tt>seed_seq</tt>
++This issue was re-reviewed in relation to [another issue, number to follow],
++and the verdict was reversed. Explicit copy and move constructors are rare
++beasts, and the ripple effect of this fix was far more difficult to contain
++than simply saying such types do not satisfy the <tt>MoveConstructible</tt>
++and <tt>CopyConstructible</tt> requirements.
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class InputIterator&gt;
+- seed_seq(InputIterator begin, InputIterator end);
+-</pre>
+-<blockquote>
+ <p>
+-5 <i>Requires:</i> NO CHANGE
++In 17.6.3.1 [utility.arg.requirements] change Table 33: <tt>MoveConstructible</tt> requirements [moveconstructible]:
+ </p>
++
++<blockquote>
++<table border="1">
++<tr>
++<th>expression</th><th>post-condition</th>
++</tr>
++<tr>
++<td><tt>T t<ins>(rv)</ins><del> = rv</del></tt></td><td><tt>t</tt> is equivalent to the value of <tt>rv</tt> before the construction</td>
++</tr>
++<tr>
++<td colspan="2" align="center">...</td>
++</tr>
++</table>
++</blockquote>
++
+ <p>
+-6 <i>Effects:</i> Constructs a <tt>seed_seq</tt> object by
++In 17.6.3.1 [utility.arg.requirements] change Table 34: <tt>CopyConstructible</tt> requirements [copyconstructible]:
+ </p>
++
+ <blockquote>
+-<pre>for (InputIterator s = begin; s != end; ++s)
+- v.push_back((*s) mod 2^32);
+-</pre>
+-</blockquote>
+-</blockquote>
++<table border="1">
++<tr>
++<th>expression</th><th>post-condition</th>
++</tr>
++<tr>
++<td><tt>T t<ins>(u)</ins><del> = u</del></tt></td><td>the value of <tt>u</tt> is unchanged and is equivalent to <tt>t</tt></td>
++</tr>
++<tr>
++<td colspan="2" align="center">...</td>
++</tr>
++</table>
+ </blockquote>
++
+ </blockquote>
+
+-<p>
+-Discussion:
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3215.htm">n3215</a>.
+ </p>
+-<p>
+-The chief virtues here are simplicity, portability, and generality.
+-</p>
+-<ul>
+-<li>
+-Simplicity -- compare the above specification with the
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a> proposal.
+-</li>
+-<li>
+-Portability -- with <tt>iterator_traits&lt;InputIterator&gt;::value_type =
+-uint_least32_t</tt> the user is guaranteed to get the same behavior across
+-platforms.
+-</li>
+-<li>
+-Generality -- any behavior that the
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
+-proposal can achieve can be
+-obtained with this simpler proposal (albeit with a shuffling of bits
+-in the input sequence).
+-</li>
+-</ul>
+-<p>
+-Arguments (and counter-arguments) against making this change (and
+-retaining the
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
+-behavior) are:
+-</p>
+-<ul>
+-<li>
+-<p>
+-The user can pass an array of <tt>unsigned char</tt> and <tt>seed_seq</tt> will nicely
+- repack it.
+-</p>
+-<p>
+- Response: So what? Consider the seed string "ABC". The
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
+- proposal results in
+-</p>
+-<blockquote><pre>v = { 0x3, 0x434241 };
+-</pre></blockquote>
+-<p>
+-while the simplified proposal yields
+-</p>
+-<blockquote><pre>v = { 0x41, 0x42, 0x43 };
+-</pre></blockquote>
+-<p>
+-The results produced by <tt>seed_seq::generate</tt> with the two inputs are
+-different but nevertheless equivalently "mixed up" and this remains
+-true even if the seed string is long.
+-</p>
+-</li>
+-<li>
+-<p>
+-With long strings (e.g., with bit-length comparable to the number of
+- bits in the state), <tt>v</tt> is longer (by a factor of 4) with the simplified
+- proposal and <tt>seed_seq::generate</tt> will be slower.
+-</p>
+-<p>
+-Response: It's unlikely that the efficiency of <tt>seed_seq::generate</tt> will
+- be a big issue. If it is, the user is free to repack the seed vector
+- before constructing <tt>seed_seq</tt>.
+-</p>
+-</li>
+-<li>
+-<p>
+-A user can pass an array of 64-bit integers and all the bits will be
+- used.
+-</p>
+-<p>
+- Response: Indeed. However, there are many instances in the
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
+- where integers are silently coerced to a narrower width and this
+- should just be a case of the user needing to read the documentation.
+- The user can of course get equivalent behavior by repacking his seed
+- into 32-bit pieces. Furthermore, the unportability of the
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
+- proposal with
+-</p>
+-<blockquote><pre>unsigned long s[] = {1, 2, 3, 4};
+-seed_seq q(s, s+4);
+-</pre></blockquote>
+-<p>
+- which typically results in <tt>v = {1, 2, 3, 4}</tt> on 32-bit machines and in
+-<tt>v = {1, 0, 2, 0, 3, 0, 4, 0}</tt> on 64-bit machines is a major pitfall for
+- unsuspecting users.
+-</p>
+-</li>
+-</ul>
+-
+-<p>
+-Note: this proposal renders moot issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>.
+-</p>
+-
+-<p><i>[
+-Bellevue:
+-]</i></p>
+-
+-
+-<blockquote>
+-Walter needs to ask Fermilab for guidance. Defer till tomorrow. Bill likes the proposed resolution.
+-</blockquote>
+-
+-<p><i>[
+-Sophia Antipolis:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Marc Paterno wants portable behavior between 32bit and 64bit machines;
+-we've gone to significant trouble to support portability of engines and
+-their values.
+-</p>
+-<p>
+-Jens: the new algorithm looks perfectly portable
+-</p>
+-<p>
+-Marc Paterno to review off-line.
+-</p>
+-<p>
+-Modify the proposed resolution to read "Constructs a seed_seq object by the following algorithm ..."
+-</p>
+-<p>
+-Disposition: move to review; unanimous consent.
+-</p>
+-<p>
+-(moots <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>)
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 26.5.7.1 [rand.util.seedseq]:
+-</p>
+-
+-<blockquote>
+-<pre>template&lt;class InputIterator<del>,
+- size_t u = numeric_limits&lt;iterator_traits&lt;InputIterator&gt;::value_type&gt;::digits</del>&gt;
+- seed_seq(InputIterator begin, InputIterator end);
+-</pre>
+-<blockquote>
+-<p>
+--5- <i>Requires:</i> <tt>InputIterator</tt> shall satisfy the requirements of an input iterator (24.1.1)
+-such that <tt>iterator_traits&lt;InputIterator&gt;::value_type</tt> shall denote an integral type.
+-</p>
+-<p>
+--6- Constructs a <tt>seed_seq</tt> object by <ins>the following algorithm</ins> <del>rearranging some or all of the bits of the supplied sequence
+-<tt>[begin,end)</tt> of w-bit quantities into 32-bit units, as if by the following: </del>
+-</p>
+-<p>
+-<del>First extract the rightmost <tt>u</tt> bits from each of the <tt>n = end
+-- begin</tt> elements of the supplied sequence and concatenate all the
+-extracted bits to initialize a single (possibly very large) unsigned
+-binary number, <tt>b = &#8721;<sup>n-1</sup><sub>i=0</sub> (begin[i]
+-mod 2<sup>u</sup>) · 2<sup>w·i</sup></tt> (in which the bits of each <tt>begin[i]</tt>
+-are treated as denoting an unsigned quantity). Then carry out
+-the following algorithm:</del>
+-</p>
+-<blockquote><pre><del>
+-v.clear();
+-if ($w$ &lt; 32)
+- v.push_back($n$);
+-for( ; $n$ &gt; 0; --$n$)
+- v.push_back(b mod 2<sup>32</sup>), b /= 2<sup>32</sup>;
+-</del></pre></blockquote>
+-<blockquote>
+-<pre><ins>
+-for (InputIterator s = begin; s != end; ++s)
+- v.push_back((*s) mod 2<sup>32</sup>);
+-</ins></pre>
+-</blockquote>
+-</blockquote>
+-</blockquote>
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="812"></a>812. unsolicited multithreading considered harmful?</h3>
+-<p><b>Section:</b> 25.4.1 [alg.sort] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Paul McKenney <b>Opened:</b> 2008-02-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Multi-threading is a good thing, but unsolicited multi-threading can
+-potentially be harmful. For example, <tt>sort()</tt> performance might be
+-greatly increased via a multithreaded implementation. However, such
+-a multithreaded implementation could result in concurrent invocations
+-of the user-supplied comparator. This would in turn result in problems
+-given a caching comparator that might be written for complex sort keys.
+-Please note that this is not a theoretical issue, as multithreaded
+-implementations of <tt>sort()</tt> already exist.
+-</p>
+-<p>
+-Having a multithreaded <tt>sort()</tt> available is good, but it should not
+-be the default for programs that are not explicitly multithreaded.
+-Users should not be forced to deal with concurrency unless they have
+-asked for it.
+-</p>
+-
+-<p><i>[
+-This may be covered by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2410.html">N2410</a>
+-Thread-Safety in the Standard Library (Rev 1).
+-]</i></p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-<p><b>Rationale:</b></p>
+-This is already covered by 17.6.5.6/20 in N2723.
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="822"></a>822. Object with explicit copy constructor no longer <tt>CopyConstructible</tt></h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2008-04-01 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I just noticed that the following program is legal in C++03, but
+-is forbidden in the current draft:
+-</p>
+-
+-<blockquote><pre>#include &lt;vector&gt;
+-#include &lt;iostream&gt;
+-
+-class Toto
+-{
+-public:
+- Toto() {}
+- explicit Toto( Toto const&amp; ) {}
+-} ;
+-
+-int
+-main()
+-{
+- std::vector&lt; Toto &gt; v( 10 ) ;
+- return 0 ;
+-}
+-</pre></blockquote>
+-
+-<p>
+-Is this change intentional? (And if so, what is the
+-justification? I wouldn't call such code good, but I don't see
+-any reason to break it unless we get something else in return.)
+-</p>
+-
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-The subgroup that looked at this felt this was a good change, but it may
+-already be handled by incoming concepts (we're not sure).
+-</blockquote>
+-
+-<p><i>[
+-Post Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Alisdair: Proposed resolution kinda funky as these tables no longer
+-exist. Move from direct init to copy init. Clarify with Doug, recommends
+-NAD.
+-</p>
+-<p>
+-Walter: Suggest NAD via introduction of concepts.
+-</p>
+-<p>
+-Recommend close as NAD.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-Need to look at again without concepts.
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Move to Ready with original proposed resolution.
+-</p>
+-<p><i>[Howard: Original proposed resolution restored.]</i></p>
+-
+-</blockquote>
+-
+-<p><i>[
+-2010-11 Batavia:
+-]</i></p>
+-
+-<p>
+-This issue was re-reviewed in relation to [another issue, number to follow],
+-and the verdict was reversed. Explicit copy and move constructors are rare
+-beasts, and the ripple effect of this fix was far more difficult to contain
+-than simply saying such types do not satisfy the <tt>MoveConstructible</tt>
+-and <tt>CopyConstructible</tt> requirements.
+-</p>
+-
+-<blockquote>
+-<p>
+-In 20.2.1 [utility.arg.requirements] change Table 33: <tt>MoveConstructible</tt> requirements [moveconstructible]:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<tbody><tr>
+-<th>expression</th><th>post-condition</th>
+-</tr>
+-<tr>
+-<td><tt>T t<ins>(rv)</ins><del> = rv</del></tt></td><td><tt>t</tt> is equivalent to the value of <tt>rv</tt> before the construction</td>
+-</tr>
+-<tr>
+-<td colspan="2" align="center">...</td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-In 20.2.1 [utility.arg.requirements] change Table 34: <tt>CopyConstructible</tt> requirements [copyconstructible]:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<tbody><tr>
+-<th>expression</th><th>post-condition</th>
+-</tr>
+-<tr>
+-<td><tt>T t<ins>(u)</ins><del> = u</del></tt></td><td>the value of <tt>u</tt> is unchanged and is equivalent to <tt>t</tt></td>
+-</tr>
+-<tr>
+-<td colspan="2" align="center">...</td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3215.html">n3215</a>.
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="825"></a>825. Missing rvalues reference stream insert/extract operators?</h3>
+-<p><b>Section:</b> 19.5.2.1 [syserr.errcode.overview], 20.9.10.2.8 [util.smartptr.shared.io], 22.4.8 [facets.examples], 20.5.4 [bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.9 [re.submatch] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-04-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses UK 220</b></p>
+-
+-<p>
+-Should the following use rvalues references to stream in insert/extract
+-operators?
+-</p>
+-
+-<ul>
+-<li>19.5.2.1 [syserr.errcode.overview]</li>
+-<li>20.9.10.2.8 [util.smartptr.shared.io]</li>
+-<li>22.4.8 [facets.examples]</li>
+-<li>20.5.4 [bitset.operators]</li>
+-<li>26.4.6 [complex.ops]</li>
+-<li>Doubled signatures in 27.6 [stream.buffers] for character inserters
+-(ref 27.7.2.6.4 [ostream.inserters.character])
+-+ definition 27.7.2.6.4 [ostream.inserters.character]</li>
+-<li>28.9 [re.submatch]</li>
+-</ul>
+-
+-<p><i>[
+-Sophia Antipolis
+-]</i></p>
+-
+-
+-<blockquote>
+-Agree with the idea in the issue, Alisdair to provide wording.
+-</blockquote>
+-
+-<p><i>[
+-Daniel adds 2009-02-14:
+-]</i></p>
+-
+-
+-<blockquote>
+-The proposal given in the paper
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2831.html">N2831</a>
+-apparently resolves this issue.
+-</blockquote>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-The cited paper is an earlier version of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html">N2844</a>,
+-which changed the rvalue reference binding rules.
+-That paper includes generic templates
+-<tt>operator&lt;&lt;</tt> and <tt>operator&gt;&gt;</tt>
+-that adapt rvalue streams.
+-</p>
+-<p>
+-We therefore agree with Daniel's observation.
+-Move to NAD Editorial.
+-</p>
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+
+
+
+
+ <hr>
+ <h3><a name="826"></a>826. Equivalent of <tt>%'d</tt>, or rather, lack thereof?</h3>
+-<p><b>Section:</b> 22.4.2.2 [locale.nm.put] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 22.4.2.2 [locale.nm.put] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the spirit of <tt>printf vs iostream</tt>...
+@@ -22150,155 +19060,49 @@ Pablo Halpern:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I'm not sure it constitutes a defect, but I would be in favor of adding
+ another flag (and corresponding manipulator).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Martin Sebor:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I don't know if it qualifies as a defect but I agree that there
+ should be an easy way to control whether the thousands separator
+ should or shouldn't be inserted. A new flag would be in line with
+ the current design of iostreams (like <tt>boolalpha</tt>, <tt>showpos</tt>, or
+ <tt>showbase</tt>).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This is not a part of C99. LWG suggests submitting a paper may be appropriate.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="828"></a>828. Static initialization for <tt>std::mutex</tt>?</h3>
+-<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.]
+-</p>
+-<p>
+-Currently <tt>std::mutex</tt> doesn't support static initialization. This is a
+-regression with respect to <tt>pthread_mutex_t</tt>, which does. I believe that
+-we should strive to eliminate such regressions in expressive power where
+-possible, both to ease migration and to not provide incentives to (or
+-force) people to forego the C++ primitives in favor of pthreads.
+-</p>
+-
+-<p><i>[
+-Sophia Antipolis:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-We believe this is implementable on POSIX, because the initializer-list
+-feature and the constexpr feature make this work. Double-check core
+-language about static initialization for this case. Ask core for a core
+-issue about order of destruction of statically-initialized objects wrt.
+-dynamically-initialized objects (should come afterwards). Check
+-non-POSIX systems for implementability.
+-</p>
+-<p>
+-If ubiquitous implementability cannot be assured, plan B is to introduce
+-another constructor, make this constexpr, which is
+-conditionally-supported. To avoid ambiguities, this new constructor needs
+-to have an additional parameter.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Post Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Jens: constant initialization seems to be ok core-language wise
+-</p>
+-<p>
+-Consensus: Defer to threading experts, in particular a Microsoft platform expert.
+-</p>
+-<p>
+-Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams,
+-Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker,
+-Peter Dimov to alert them of this issue.
+-</p>
+-<p>
+-Lawrence: What about header file shared with C? The initialization
+-syntax is different in C and C++.
+-</p>
+-<p>
+-Recommend Keep in Review
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-Keep in Review status pending feedback from members of the Concurrency subgroup.
+-</blockquote>
+-
+-<p><i>[
+-See related comments from Alisdiar and Daniel in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.html">N2994</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 30.4.1.2.1 [thread.mutex.class]:
+ </p>
+
+-<blockquote><pre>class mutex {
+-public:
+- <ins>constexpr</ins> mutex();
+- ...
+-</pre></blockquote>
+-
+
+
+
+
+ <hr>
+ <h3><a name="830"></a>830. Incomplete list of char_traits specializations</h3>
+-<p><b>Section:</b> 21.2 [char.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2008-04-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits">issues</a> in [char.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 21.2 [char.traits] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Dietmar K&#252;hl <b>Opened:</b> 2008-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits">issues</a> in [char.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 4 of 21.2 [char.traits] mentions that this
+@@ -22314,11 +19118,11 @@ public:
+ Alisdair adds:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>char_traits&lt; char16/32_t &gt;</tt>
+ should also be added to <tt>&lt;ios_fwd&gt;</tt> in 27.3 [iostream.forward], and all the specializations
+ taking a <tt>char_traits</tt> parameter in that header.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+@@ -22384,9 +19188,9 @@ Original proposed wording.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree. Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -22398,7 +19202,8 @@ Change Forward declarations 27.3 [iostream.forward]:
+ <p>
+ <b>Header <tt>&lt;iosfwd&gt;</tt> synopsis</b>
+ </p>
+-<pre>namespace std {
++<pre>
++namespace std {
+ template&lt;class charT&gt; class char_traits;
+ template&lt;&gt; class char_traits&lt;char&gt;;
+ <ins>template&lt;&gt; class char_traits&lt;char16_t&gt;;</ins>
+@@ -22415,10 +19220,10 @@ Change Forward declarations 27.3 [iostream.forward]:
+
+ <hr>
+ <h3><a name="831"></a>831. wrong type for not_eof()</h3>
+-<p><b>Section:</b> 21.2.3 [char.traits.specializations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2008-04-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits.specializations">issues</a> in [char.traits.specializations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 21.2.3 [char.traits.specializations] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Dietmar K&#252;hl <b>Opened:</b> 2008-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits.specializations">issues</a> in [char.traits.specializations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In Table 56 (Traits requirements) the <tt>not_eof()</tt> member function
+@@ -22447,19 +19252,19 @@ Change Forward declarations 27.3 [iostream.forward]:
+ </p>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Already fixed in WP.
+-
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="832"></a>832. Applying constexpr to System error support</h3>
+-<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#syserr">issues</a> in [syserr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr">issues</a> in [syserr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Initialization of objects of class <tt>error_code</tt>
+@@ -22489,10 +19294,10 @@ Thanks to Jens Maurer, Gabriel Dos Reis, and Bjarne Stroustrup for clarification
+ </p>
+
+ <p>
+-LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a> is related in that it raises the question of whether the
++LWG issue <a href="lwg-defects.html#804">804</a> is related in that it raises the question of whether the
+ exposition only member <tt>cat_</tt> of class <tt>error_code</tt> (19.5.2 [syserr.errcode]) and class
+ <tt>error_condition</tt> (19.5.3 [syserr.errcondition]) should be presented as a reference or pointer.
+-While in the context of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a> that is arguably an editorial question,
++While in the context of <a href="lwg-defects.html#804">804</a> that is arguably an editorial question,
+ presenting it as a pointer becomes more or less required with this
+ proposal, given <tt>constexpr</tt> does not play well with references. The
+ proposed resolution thus changes the private member to a pointer, which
+@@ -22504,9 +19309,9 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ On going question of extern pointer vs. inline functions for interface.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Pre-San Francisco:
+@@ -22531,9 +19336,9 @@ Gabriel and Jens Maurer.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-The proposed wording assumes the LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a> proposed wording has been
++The proposed wording assumes the LWG <a href="lwg-defects.html#805">805</a> proposed wording has been
+ applied to the WP, resulting in the former <tt>posix_category</tt> being renamed
+-<tt>generic_category</tt>. If <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a> has not been applied, the names in this
++<tt>generic_category</tt>. If <a href="lwg-defects.html#805">805</a> has not been applied, the names in this
+ proposal must be adjusted accordingly.
+ </p>
+
+@@ -22543,7 +19348,8 @@ Change 19.5.1.1 [syserr.errcat.overview] Class
+ indicated:
+ </p>
+
+-<blockquote><pre><del>const error_category&amp; get_generic_category();</del>
++<blockquote><pre>
++<del>const error_category&amp; get_generic_category();</del>
+ <del>const error_category&amp; get_system_category();</del>
+
+ <del>static</del> <ins>extern</ins> const error_category<del>&amp;</del><ins>* const</ins> generic_category<del> = get_generic_category()</del>;
+@@ -22555,7 +19361,8 @@ Change 19.5.1.5 [syserr.errcat.objects] Error category objects as indicated:
+ </p>
+
+ <blockquote>
+-<pre><ins>extern</ins> const error_category<del>&amp;</del><ins>* const</ins> <del>get_</del>generic_category<del>()</del>;
++<pre>
++<ins>extern</ins> const error_category<del>&amp;</del><ins>* const</ins> <del>get_</del>generic_category<del>()</del>;
+ </pre>
+ <p>
+ <del><i>Returns:</i> A reference</del> <ins><tt>generic_category</tt> shall point</ins>
+@@ -22570,7 +19377,8 @@ object's <tt>name</tt> virtual function shall return a pointer to the string
+ <tt>"GENERIC"</tt>.
+ </p>
+
+-<pre><ins>extern</ins> const error_category<del>&amp;</del><ins>* const</ins> <del>get_</del>system_category<del>()</del>;
++<pre>
++<ins>extern</ins> const error_category<del>&amp;</del><ins>* const</ins> <del>get_</del>system_category<del>()</del>;
+ </pre>
+
+ <p>
+@@ -22602,7 +19410,8 @@ Thus implementations are given latitude in determining correspondence.
+ Change 19.5.2.1 [syserr.errcode.overview] Class <tt>error_code</tt> overview as indicated:
+ </p>
+
+-<blockquote><pre>class error_code {
++<blockquote><pre>
++class error_code {
+ public:
+ ...;
+ <ins>constexpr</ins> error_code(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+@@ -22621,7 +19430,8 @@ Change 19.5.2.2 [syserr.errcode.constructors] Class <tt>error_code</tt> construc
+ </p>
+
+ <blockquote>
+-<pre><ins>constexpr</ins> error_code(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
++<pre>
++<ins>constexpr</ins> error_code(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+ </pre>
+ <p>
+ <i>Effects:</i> Constructs an object of type <tt>error_code</tt>.
+@@ -22639,7 +19449,8 @@ Change 19.5.2.3 [syserr.errcode.modifiers] Class <tt>error_code</tt> modifiers
+ </p>
+
+ <blockquote>
+-<pre>void assign(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
++<pre>
++void assign(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+ </pre>
+ <p>
+ <i>Postconditions:</i> <tt>val_ == val</tt> and <tt>cat_ == cat</tt>.
+@@ -22654,7 +19465,8 @@ Change 19.5.2.4 [syserr.errcode.observers] Class <tt>error_code</tt> observers
+ </p>
+
+ <blockquote>
+-<pre>const error_category<del>&amp;</del><ins>*</ins> category() const;
++<pre>
++const error_category<del>&amp;</del><ins>*</ins> category() const;
+ </pre>
+
+ <p>
+@@ -22670,7 +19482,8 @@ Change 19.5.3.1 [syserr.errcondition.overview] Class <tt>error_condition</tt> ov
+ </p>
+
+ <blockquote>
+-<pre>class error_condition {
++<pre>
++class error_condition {
+ public:
+ ...;
+ <ins>constexpr</ins> error_condition(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+@@ -22690,7 +19503,8 @@ Change 19.5.3.2 [syserr.errcondition.constructors] Class <tt>error_condition</tt
+ </p>
+
+ <blockquote>
+-<pre><ins>constexpr</ins> error_condition(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
++<pre>
++<ins>constexpr</ins> error_condition(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+ </pre>
+ <p>
+ <i>Effects:</i> Constructs an object of type <tt>error_condition</tt>.
+@@ -22708,7 +19522,8 @@ Change 19.5.3.3 [syserr.errcondition.modifiers] Class <tt>error_condition</tt> m
+ </p>
+
+ <blockquote>
+-<pre>void assign(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
++<pre>
++void assign(int val, const error_category<del>&amp;</del><ins>*</ins> cat);
+ </pre>
+ <p>
+ <i>Postconditions:</i> <tt>val_ == val</tt> and <tt>cat_ == cat</tt>.
+@@ -22723,7 +19538,8 @@ Change 19.5.3.4 [syserr.errcondition.observers] Class <tt>error_condition</tt> o
+ </p>
+
+ <blockquote>
+-<pre>const error_category<del>&amp;</del><ins>*</ins> category() const;
++<pre>
++const error_category<del>&amp;</del><ins>*</ins> category() const;
+ </pre>
+ <p>
+ <i>Returns:</i> <tt>cat_</tt>.
+@@ -22748,7 +19564,8 @@ paragraphs 2 and 4, change "<tt>category.equivalent(</tt>" to
+ Change 19.5.6.1 [syserr.syserr.overview] Class system_error overview as indicated:
+ </p>
+
+-<blockquote><pre>public:
++<blockquote><pre>
++public:
+ system_error(error_code ec, const string&amp; what_arg);
+ system_error(error_code ec);
+ system_error(int ev, const error_category<del>&amp;</del><ins>*</ins> ecat,
+@@ -22761,7 +19578,8 @@ Change 19.5.6.2 [syserr.syserr.members] Class system_error members as indicated:
+ </p>
+
+ <blockquote>
+-<pre>system_error(int ev, const error_category<del>&amp;</del><ins>*</ins> ecat, const string&amp; what_arg);
++<pre>
++system_error(int ev, const error_category<del>&amp;</del><ins>*</ins> ecat, const string&amp; what_arg);
+ </pre>
+ <blockquote>
+ <p>
+@@ -22773,7 +19591,8 @@ Change 19.5.6.2 [syserr.syserr.members] Class system_error members as indicated:
+ </p>
+ </blockquote>
+
+-<pre>system_error(int ev, const error_category<del>&amp;</del><ins>*</ins> ecat);
++<pre>
++system_error(int ev, const error_category<del>&amp;</del><ins>*</ins> ecat);
+ </pre>
+ <blockquote>
+ <p>
+@@ -22794,9 +19613,9 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD because Beman said so.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -22804,10 +19623,10 @@ NAD because Beman said so.
+
+ <hr>
+ <h3><a name="833"></a>833. Freestanding implementations header list needs review for C++0x</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Once the C++0x standard library is feature complete, the LWG needs to
+@@ -22828,7 +19647,8 @@ stopped adding headers to the library.
+ <p>
+ Three new headers that need to be added to the list:
+ </p>
+-<blockquote><pre>&lt;initializer_list&gt; &lt;concept&gt; &lt;iterator_concepts&gt;
++<blockquote><pre>
++&lt;initializer_list&gt; &lt;concept&gt; &lt;iterator_concepts&gt;
+ </pre></blockquote>
+ <p>
+ <tt>&lt;iterator_concepts&gt;</tt>, in particular, has lots of stuff
+@@ -22889,22 +19709,22 @@ Move to NAD.
+ <h3><a name="837"></a>837.
+ <code>basic_ios::copyfmt()</code> overly loosely specified
+ </h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+-The <code>basic_ios::copyfmt()</code> member function is specified in 27.5.4.2 [basic.ios.members] to have the following effects:
++The <code>basic_ios::copyfmt()</code> member function is specified in 27.5.5.3 [basic.ios.members] to have the following effects:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ <i>Effects</i>: If <code>(this == &amp;rhs)</code> does
+ nothing. Otherwise assigns to the member objects of <code>*this</code>
+ the corresponding member objects of <code>rhs</code>, except that
+-
++</p>
+ <ul>
+ <li>
+
+@@ -22936,10 +19756,10 @@ of <code>basic_ios</code> are this seems a little too loose.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -22949,9 +19769,9 @@ I propose to tighten things up by adding a <i>Postcondition</i> clause
+ to the function like so:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+ <i>Postconditions:</i>
+-
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -23021,349 +19841,57 @@ already there.
+
+
+ <hr>
+-<h3><a name="839"></a>839. Maps and sets missing splice operation</h3>
+-<p><b>Section:</b> 23.6 [associative], 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alan Talbot <b>Opened:</b> 2008-05-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative">issues</a> in [associative].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="840"></a>840. <tt>pair</tt> default template argument</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Splice is a very useful feature of <tt>list</tt>. This functionality is also very
+-useful for any other node based container, and I frequently wish it were
+-available for maps and sets. It seems like an omission that these
+-containers lack this capability. Although the complexity for a splice is
+-the same as for an insert, the actual time can be much less since the
+-objects need not be reallocated and copied. When the element objects are
+-heavy and the compare operations are fast (say a <tt>map&lt;int, huge_thingy&gt;</tt>)
+-this can be a big win.
++I have one issue with <tt>std::pair</tt>. Well, it might just be a very annoying
++historical accident, but why is there no default template argument for
++the second template argument? This is so annoying when the type in
++question is looong and hard to write (type deduction with <tt>auto</tt> won't
++help those cases where we use it as a return or argument type).
+ </p>
+
+-<p>
+-<b>Suggested resolution:</b>
+-</p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following signatures to map, set, multimap, multiset, and the unordered associative containers:
++Change the synopsis in 20.2 [utility] to read:
+ </p>
+-<blockquote><pre>
+-void splice(list&lt;T,Allocator&gt;&amp;&amp; x);
+-void splice(list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
+-void splice(list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator first, const_iterator last);
+-</pre></blockquote>
+
+-<p>
+-Hint versions of these are also useful to the extent hint is useful.
+-(I'm looking for guidance about whether hints are in fact useful.)
+-</p>
+-
+-<blockquote><pre>
+-void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
+-void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
+-void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator first, const_iterator last);
++<blockquote><pre>
++template &lt;class T1, class T2 <ins>= T1</ins>&gt; struct pair;
+ </pre></blockquote>
+
+-<p><i>[
+-Sophia Antipolis:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Don't try to <tt>splice "list"</tt> into the other containers, it should be container-type.
+-</p>
+-<p>
+-<tt>forward_list</tt> already has <tt>splice_after</tt>.
+-</p>
+-<p>
+-Would "<tt>splice</tt>" make sense for an <tt>unordered_map</tt>?
+-</p>
+-<p>
+-Jens, Robert: "<tt>splice</tt>" is not the right term, it implies maintaining ordering in <tt>list</tt>s.
+-</p>
+-<p>
+-Howard: <tt>adopt</tt>?
+-</p>
+-<p>
+-Jens: <tt>absorb</tt>?
+-</p>
+-<p>
+-Alan: <tt>subsume</tt>?
+-</p>
+-<p>
+-Robert: <tt>recycle</tt>?
+-</p>
+-<p>
+-Howard: <tt>transfer</tt>? (but no direction)
+-</p>
+-<p>
+-Jens: <tt>transfer_from</tt>. No.
+-</p>
+-<p>
+-Alisdair: Can we give a nothrow guarantee? If your <tt>compare()</tt> and <tt>hash()</tt> doesn't throw, yes.
+-</p>
+ <p>
+-Daniel: For <tt>unordered_map</tt>, we can't guarantee nothrow.
++Change 20.3 [pairs] to read:
+ </p>
+-</blockquote>
+
+-<p><i>[
+-San Francisco:
+-]</i></p>
++<blockquote><pre>
++namespace std {
++ template &lt;class T1, class T2 <ins>= T1</ins>&gt;
++ struct pair {
++ typedef T1 first_type;
++ typedef T2 second_type;
++ ...
++</pre></blockquote>
+
+
+-<blockquote>
+-<p>
+-Martin: this would possibly outlaw an implementation technique that is
+-currently in use; caching nodes in containers.
+-</p>
+-<p>
+-Alan: if you cache in the allocator, rather than the individual
+-container, this proposal doesn't interfere with that.
+-</p>
+-<p>
+-Martin: I'm not opposed to this, but I'd like to see an implementation
+-that demonstrates that it works.
++<p><b>Rationale:</b></p><p>
++<tt>std::pair</tt> is a heterogeneous container.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Future.
+-</blockquote>
+-
+-<p><i>[
+-2009-09-19 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I'm not disagreeing with the NAD Future resolution. But when the future gets
+-here, here is a possibility worth exploring:
+-</p>
+-
+-<blockquote>
+-<p>
+-Add to the "unique" associative containers:
+-</p>
+-
+-<blockquote><pre>typedef <i>details</i> node_ptr;
+-
+-node_ptr remove(const_iterator p);
+-pair&lt;iterator, bool&gt; insert(node_ptr&amp;&amp; nd);
+-iterator insert(const_iterator p, node_ptr&amp;&amp; nd);
+-</pre></blockquote>
+-
+-<p>
+-And add to the "multi" associative containers:
+-</p>
+-
+-<blockquote><pre>typedef <i>details</i> node_ptr;
+-
+-node_ptr remove(const_iterator p);
+-iterator insert(node_ptr&amp;&amp; nd);
+-iterator insert(const_iterator p, node_ptr&amp;&amp; nd);
+-</pre></blockquote>
+-
+-<p>
+-<tt>Container::node_ptr</tt> is a smart pointer much like <tt>unique_ptr</tt>.
+-It owns a node obtained from the container it was removed from. It maintains a
+-reference to the allocator in the container so that it can properly deallocate
+-the node if asked to, even if the allocator is stateful. This being said, the
+-<tt>node_ptr</tt> can not outlive the container for this reason.
+-</p>
+-
+-<p>
+-The <tt>node_ptr</tt> offers "<tt>const</tt>-free" access to the node's
+-<tt>value_type</tt>.
+-</p>
+-
+-<p>
+-With this interface, clients have a great deal of flexibility:
+-</p>
+-
+-<ul>
+-<li>
+-A client can remove a node from one container, and insert it into another
+-(without any heap allocation). This is the splice functionality this issue
+-asks for.
+-</li>
+-<li>
+-A client can remove a node from a container, change its key or value, and insert
+-it back into the same container, or another container, all without the cost of
+-allocating a node.
+-</li>
+-<li>
+-If the Compare function is nothrow (which is very common), then this functionality
+-is nothrow unless modifying the value throws. And if this does throw, it does
+-so outside of the containers involved.
+-</li>
+-<li>
+-If the Compare function does throw, the <tt>insert</tt> function will have the
+-argument <tt>nd</tt> retain ownership of the node.
+-</li>
+-<li>
+-The <tt>node_ptr</tt> should be independent of the <tt>Compare</tt> parameter
+-so that a node can be transferred from <tt>set&lt;T, C1, A&gt;</tt>
+-to <tt>set&lt;T, C2, A&gt;</tt> (for example).
+-</li>
+-</ul>
+-
+-<p>
+-Here is how the customer might use this functionality:
+-</p>
+-
+-<ul>
+-<li>
+-<p>
+-Splice a node from one container to another:
+-</p>
+-<blockquote><pre>m2.insert(m1.remove(i));
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change the "key" in a <tt>std::map</tt> without the cost of node reallocation:
+-</p>
+-<blockquote><pre>auto p = m.remove(i);
+-p-&gt;first = new_key;
+-m.insert(std::move(p));
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change the "value" in a <tt>std::set</tt> without the cost of node reallocation:
+-</p>
+-<blockquote><pre>auto p = s.remove(i);
+-*p = new_value;
+-s.insert(std::move(p));
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Move a move-only or heavy object out of an associative container (as opposed to
+-the proposal in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>):
+-</p>
+-<blockquote><pre>MoveOnly x = std::move(*s.remove(i));
+-</pre></blockquote>
+-<ol>
+-<li>
+-<tt>remove(i)</tt> transfers ownership of the node from the set to a temporary
+-<tt>node_ptr</tt>.
+-</li>
+-<li>
+-The <tt>node_ptr</tt> is dereferenced, and that non-const reference is sent to
+-<tt>move</tt> to cast it to an rvalue.
+-</li>
+-<li>
+-The rvalue <tt>MoveOnly</tt> is move constructed into <tt>x</tt> from
+-the <tt>node_ptr</tt>.
+-</li>
+-<li>
+-<tt>~node_ptr()</tt> destructs the moved-from <tt>MoveOnly</tt> and deallocates
+-the node.
+-</li>
+-</ol>
+-
+-<p>
+-Contrast this with the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a> solution:
+-</p>
+-<blockquote><pre>MoveOnly x = std::move(s.extract(i).first);
+-</pre></blockquote>
+-
+-<p>
+-The former requires one move construction for <tt>x</tt> while the latter
+-requires two (one into the <tt>pair</tt> and then one into <tt>x</tt>). Either
+-of these constructions can throw (say if there is only a copy constructor for
+-<tt>x</tt>). With the former, the point of throw is outside of the container
+-<tt>s</tt>, after the element has been removed from the container. With the latter,
+-one throwing construction takes place prior to the removal of the element, and
+-the second takes place after the element is removed.
+-</p>
+-
+-</li>
+-</ul>
+-
+-<p>
+-The "node insertion" API maintains the API associated with inserting <tt>value_type</tt>s
+-so the customer can use familiar techniques for getting an iterator to the
+-inserted node, or finding out whether it was inserted or not for the "unique"
+-containers.
+-</p>
+-
+-<p>
+-Lightly prototyped. No implementation problems. Appears to work great
+-for the client.
+-</p>
+-
+-</blockquote>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="840"></a>840. <tt>pair</tt> default template argument</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-05-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I have one issue with <tt>std::pair</tt>. Well, it might just be a very annoying
+-historical accident, but why is there no default template argument for
+-the second template argument? This is so annoying when the type in
+-question is looong and hard to write (type deduction with <tt>auto</tt> won't
+-help those cases where we use it as a return or argument type).
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change the synopsis in 20.3 [utility] to read:
+-</p>
+-
+-<blockquote><pre>template &lt;class T1, class T2 <ins>= T1</ins>&gt; struct pair;
+-</pre></blockquote>
+-
+-<p>
+-Change 20.3.5 [pairs] to read:
+-</p>
+-
+-<blockquote><pre>namespace std {
+- template &lt;class T1, class T2 <ins>= T1</ins>&gt;
+- struct pair {
+- typedef T1 first_type;
+- typedef T2 second_type;
+- ...
+-</pre></blockquote>
+-
+-
+-<p><b>Rationale:</b></p>
+-<tt>std::pair</tt> is a heterogeneous container.
+-
+
+
+
+
+ <hr>
+ <h3><a name="841"></a>841. cstdint.syn inconsistent with C99</h3>
+-<p><b>Section:</b> 18.4.1 [cstdint.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cstdint.syn">issues</a> in [cstdint.syn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 18.4.1 [cstdint.syn] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cstdint.syn">issues</a> in [cstdint.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -23384,13 +19912,13 @@ types with these exact widths.
+
+ </p>
+ <p>
+- </p>
+
+ In addition, paragraph 1 of the same section makes use of a rather
+ informal shorthand notation to specify sets of macros. When
+ interpreted strictly, the notation specifies macros such
+ as <code>INT_8_MIN</code> that are not intended to be specified.
+
++ </p>
+ <p>
+
+ Finally, the section is missing the usual table of symbols defined
+@@ -23424,7 +19952,8 @@ synopsis and paragraph 1 with the following text:
+ </p>
+ <blockquote>
+ <p>
+- </p><ol>
++ </p>
++ <ol>
+ <li>
+
+ In the names defined in the <code>&lt;cstdint&gt;</code> header, the
+@@ -23440,8 +19969,8 @@ and macros are required.
+
+ </li>
+ </ol>
+- <p></p>
+- <pre>namespace std {
++ <pre>
++namespace std {
+
+ // required types
+
+@@ -23498,8 +20027,9 @@ and macros are required.
+ [Note to editor: Remove all of the existing paragraph 1 from cstdint.syn.]
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table ??: Header <code>&lt;cstdint&gt;</code> synopsis
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -23600,10 +20130,11 @@ and macros are required.
+
+ <hr>
+ <h3><a name="849"></a>849. missing type traits to compute root class and derived class of types in a class hierachy</h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The type traits library contains various traits to dealt with
+@@ -23635,21 +20166,22 @@ identity transformation. I expect this gives the best overall usability.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following to the synopsis in 20.7.2 [meta.type.synop] under "other transformations":
++Add the following to the synopsis in 20.10.2 [meta.type.synop] under "other transformations":
+ </p>
+
+-<blockquote><pre>template&lt; class T &gt; struct direct_base_class;
++<blockquote><pre>
++template&lt; class T &gt; struct direct_base_class;
+ template&lt; class T &gt; struct direct_derived_class;
+ template&lt; class T &gt; struct root_base_class;
+ </pre></blockquote>
+
+ <p>
+-Add three new entries to table 51 (20.7.7.6 [meta.trans.other]) with the following content
++Add three new entries to table 51 (20.10.7.6 [meta.trans.other]) with the following content
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Template</th><th>Condition</th><th>Comments</th>
+ </tr>
+ <tr>
+@@ -23671,356 +20203,24 @@ as an accessible unambiguous direct base class. If no such type exists, the memb
+ <td>The member typedef <tt>type</tt> shall equal the accessible unambiguous most indirect base class of
+ <tt>T</tt>. If no such type exists, the member typedef type shall equal <tt>T</tt>.</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ 2008-9-16 San Francisco: Issue pulled by author prior to being reviewed by the LWG.
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="851"></a>851. simplified array construction</h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Benjamin Kosnik <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-This is an issue that came up on the libstdc++ list, where a
+-discrepancy between "C" arrays and C++0x's <tt>std::array</tt> was pointed
+-out.
+-</p>
+-
+-<p>
+-In "C," this array usage is possible:
+ </p>
+
+-<blockquote><pre>int ar[] = {1, 4, 6};
+-</pre></blockquote>
+-
+-<p>
+-But for C++,
+-</p>
+-
+-<blockquote><pre>std::array&lt;int&gt; a = { 1, 4, 6 }; // error
+-</pre></blockquote>
+-
+-<p>
+-Instead, the second parameter of the <tt>array</tt> template must be
+-explicit, like so:
+-</p>
+-
+-<blockquote><pre>std::array&lt;int, 3&gt; a = { 1, 4, 6 };
+-</pre></blockquote>
+-
+-<p>
+-Doug Gregor proposes the following solution, that assumes
+-generalized initializer lists.
+-</p>
+-
+-<blockquote><pre>template&lt;typename T, typename... Args&gt;
+-inline array&lt;T, sizeof...(Args)&gt;
+-make_array(Args&amp;&amp;... args)
+-{ return { std::forward&lt;Args&gt;(args)... }; }
+-</pre></blockquote>
+-
+-<p>
+-Then, the way to build an <tt>array</tt> from a list of unknown size is:
+-</p>
+-
+-<blockquote><pre>auto a = make_array&lt;T&gt;(1, 4, 6);
+-</pre></blockquote>
+-
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Benjamin: Move to Ready?
+-</p>
+-<p>
+-Bjarne: I'm not convinced this is useful enough to add, so I'd like us
+-to have time to reflect on it.
+-</p>
+-<p>
+-Alisdair: the constraints are wrong, they should be
+-</p>
+-<blockquote><pre>template&lt;ValueType T, ValueType... Args&gt;
+-requires Convertible&lt;Args, T&gt;...
+-array&lt;T, sizeof...(Args)&gt; make_array(Args&amp;&amp;... args);
+-</pre></blockquote>
+-<p>
+-Alidair: this would be useful if we had a constexpr version.
+-</p>
+-<p>
+-Bjarne: this is probably useful for arrays with a small number of
+-elements, but it's not clearly useful otherwise.
+-</p>
+-<p>
+-Consensus is to move to Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-06-07 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I suggest a fix and a simplification of the current proposal: Recent
+-prototyping by
+-Howard showed, that a fix is required because narrowing conversion
+-8.5.4 [dcl.init.list]/6 b.3
+-would severely limit the possible distribution of argument types, e.g.
+-the expression
+-<tt>make_array&lt;double&gt;(1, 2.0)</tt> is ill-formed, because the narrowing
+-happens <em>inside</em> the
+-function body where no constant expressions exist anymore. Furthermore
+-given e.g.
+-</p>
+-<blockquote><pre>int f();
+-double g();
+-</pre></blockquote>
+-<p>
+-we probably want to support
+-</p>
+-<blockquote><pre>make_array&lt;double&gt;(f(), g());
+-</pre></blockquote>
+-
+-<p>
+-as well. To make this feasible, the currently suggested expansion
+-</p>
+-
+-<blockquote><pre>{ std::forward&lt;Args&gt;(args)... }
+-</pre></blockquote>
+-
+-<p>
+-needs to be replaced by
+-</p>
+-
+-<blockquote><pre>{ static_cast&lt;T&gt;(std::forward&lt;Args&gt;(args))... }
+-</pre></blockquote>
+-
+-<p>
+-which is safe, because we already ensure convertibility via the
+-element-wise <tt>Convertible&lt;Args, T&gt;</tt> requirement. Some other fixes are
+-necessary: The <tt>ValueType</tt> requirement for the function <em>parameters</em>
+-is invalid, because all lvalue arguments will deduce to an lvalue-reference,
+-thereby no longer satisfying this requirement.
+-</p>
+-
+-<p>
+-The suggested simplification is to provide a default-computed effective
+-type for the result array based on common_type and decay, in
+-unconstrained form:
+-</p>
+-
+-<blockquote><pre>template&lt;typename... Args&gt;
+-array&lt;typename decay&lt;typename common_type&lt;Args...&gt;::type&gt;::type,
+-sizeof...(Args)&gt;
+-make_array(Args&amp;&amp;... args);
+-</pre></blockquote>
+-
+-<p>
+-The approach used below is similar to that of <tt>make_pair</tt> and <tt>make_tuple</tt>
+-using a symbol <tt>C</tt> to represent the decayed common type [Note: Special
+-handling of <tt>reference_wrapper</tt> types is intentionally <em>not</em> provided, because
+-our target has so satisfy <tt>ValueType</tt>, thus under the revised proposal only
+-an all-<tt>reference_wrapper</tt>-arguments would be well-formed and an array of
+-<tt>reference_wrapper</tt> will be constructed]. I do currently not suggest to
+-add new concepts reflecting <tt>decay</tt> and <tt>common_type</tt>, but an implementor will
+-need something like this to succeed. Note that we use a similar fuzziness for
+-<tt>make_pair</tt> and <tt>make_tuple</tt> currently. This fuzziness is not related to
+-the currently
+-missing <tt>Constructible&lt;Vi, Ti&amp;&amp;&gt;</tt> requirement for those functions. The following
+-proposal fixes that miss for <tt>make_array</tt>. If the corresponding <tt>C</tt> type
+-deduction is
+-explicitly wanted for standardization, here the implementation
+-</p>
+-
+-<blockquote><pre>auto concept DC&lt;typename... T&gt; {
+- typename type = typename decay&lt;typename common_type&lt;T...&gt;::type&gt;::type;
+-}
+-</pre></blockquote>
+-
+-<p>
+-where <tt>C</tt> is identical to <tt>DC&lt;Args...&gt;::type</tt> in the proposed resolution below.
+-</p>
+-<p>
+-I intentionally added no further type relation between type and the concept
+-template parameters, but instead added this requirement below to make
+-the specification as transparent as possible. As written this concept is
+-satisfied, if the corresponding associated type exists.
+-</p>
+-
+-<p><b>Suggested Resolution:</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-Add to the array synopsis in 23.3 [sequences]:
+-</p>
+-<blockquote><pre><ins>
+-template&lt;ReferentType... Args&gt;
+-requires ValueType&lt;C&gt; &amp;&amp; IdentityOf&lt;Args&gt; &amp;&amp; Constructible&lt;C, Args&amp;&amp;&gt;...
+-array&lt;C, sizeof...(Args)&gt;
+-make_array(Args&amp;&amp;... args);
+-</ins>
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Append after 23.3.1.8 [array.tuple] Tuple interface to class template array
+-the following new section:
+-</p>
+-<blockquote>
+-<p>
+-23.4.1.7 Array creation functions [array.creation]
+-</p>
+-
+-<pre><ins>
+-template&lt;ReferentType... Args&gt;
+-requires ValueType&lt;C&gt; &amp;&amp; IdentityOf&lt;Args&gt; &amp;&amp; Constructible&lt;C, Args&amp;&amp;&gt;...
+-array&lt;C, sizeof...(Args)&gt;
+-make_array(Args&amp;&amp;... args);</ins>
+-</pre>
+-
+-<blockquote>
+-<p><ins>
+-Let <tt>C</tt> be <tt>decay&lt;common_type&lt;Args...&gt;::type&gt;::type</tt>.
+-</ins></p>
+-<p>
+-<ins><i>Returns:</i> an <tt>array&lt;C, sizeof...(Args)&gt;</tt> initialized with
+-<tt>{ static_cast&lt;C&gt;(std::forward&lt;Args&gt;(args))... }</tt>.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-
+-</li>
+-
+-</ol>
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-The proposed resolution uses concepts.
+-</p>
+-<p>
+-Daniel to rewrite the proposed resolution.
+-</p>
+-<p>
+-Leave Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07-25 Daniel provides rewritten proposed resolution.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Argument for NAD future: everything about this could be added on. This
+-does not require changes to the existing text.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-Add to the array synopsis in 23.3 [sequences]:
+-</p>
+-
+-<blockquote><pre><ins>template&lt;class... Args&gt;
+- array&lt;<i>CT</i>, sizeof...(Args)&gt;
+- make_array(Args&amp;&amp;... args);</ins>
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Append after 23.3.1.8 [array.tuple] "Tuple interface to class template array" the
+-following new section:
+-</p>
+-
+-<blockquote>
+-<p>
+-<ins>XX.X.X.X Array creation functions [array.creation]</ins>
+-</p>
+-
+-<pre><ins>
+-template&lt;class... Args&gt;
+-array&lt;<i>CT</i>, sizeof...(Args)&gt;
+-make_array(Args&amp;&amp;... args)
+-</ins></pre>
+-
+-<blockquote>
+-<p>
+-<ins>Let <i>CT</i> be <tt>decay&lt;common_type&lt;Args...&gt;::type&gt;::type</tt>.</ins>
+-</p>
+-<p>
+-<ins><i>Returns:</i> An <tt>array&lt;<i>CT</i>, sizeof...(Args)&gt;</tt> initialized with <tt>{
+-static_cast&lt;<i>CT</i>&gt;(std::forward&lt;Args&gt;(args))... }</tt>.</ins>
+-</p>
+-
+-<p><ins>
+-[<i>Example:</i>
+-</ins></p>
+-<blockquote><pre><ins>
+-int i = 0; int&amp; ri = i;
+-make_array(42u, i, 2.78, ri);
+-</ins></pre></blockquote>
+-<p><ins>
+-returns an array of type
+-</ins></p>
+-<blockquote><pre><ins>
+-array&lt;double, 4&gt;
+-</ins></pre></blockquote>
+-
+-<p><ins>
+-—<i>end example</i>]</ins>
+-</p>
+-</blockquote>
+-</blockquote>
+-</li>
+-
+-</ol>
+-
+-
+-
+-
+-
+
+
+
+ <hr>
+ <h3><a name="855"></a>855. capacity() and reserve() for deque?</h3>
+-<p><b>Section:</b> 23.3.2.2 [deque.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Hervé Brönnimann <b>Opened:</b> 2008-06-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.3.3 [deque.capacity] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Herv&eacute; Br&ouml;nnimann <b>Opened:</b> 2008-06-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The main point is that <tt>capacity</tt> can be viewed as a mechanism to
+@@ -24047,7 +20247,8 @@ this definition, even though the guarantee could be made stronger.
+ <p>
+ A simple picture of a deque:
+ </p>
+-<blockquote><pre>A-----|----|-----|---F+|++++|++B--|-----|-----Z
++<blockquote><pre>
++A-----|----|-----|---F+|++++|++B--|-----|-----Z
+ </pre></blockquote>
+ <p>
+ (A,Z mark the beginning/end, | the block boundaries, F=front, B=back,
+@@ -24095,19 +20296,21 @@ implementation details.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Add new signatures to synopsis in 23.3.2 [deque]:
++Add new signatures to synopsis in 23.3.3 [deque]:
+ </p>
+
+-<blockquote><pre>size_type capacity() const;
++<blockquote><pre>
++size_type capacity() const;
+ bool reserve(size_type n);
+ </pre></blockquote>
+
+ <p>
+-Add new signatures to 23.3.2.2 [deque.capacity]:
++Add new signatures to 23.3.3.3 [deque.capacity]:
+ </p>
+
+ <blockquote>
+-<pre>size_type capacity() const;
++<pre>
++size_type capacity() const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -24127,7 +20330,8 @@ except to the erased elements.
+ </blockquote>
+
+ <blockquote>
+-<pre>bool reserve(size_type n);
++<pre>
++bool reserve(size_type n);
+ </pre>
+ <blockquote>
+ <p>
+@@ -24167,19 +20371,19 @@ during such a sequence other than by the element constructors.
+ </blockquote>
+
+ <p>
+-And 23.3.2.3 [deque.modifiers] para 1, can be enhanced:
++And 23.3.3.4 [deque.modifiers] para 1, can be enhanced:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 <i>Effects:</i> An insertion in the middle of the deque invalidates all the iterators and references to elements of the
+ deque. An insertion at either end of the deque invalidates all the iterators to the deque,
+ <ins>unless provisions have been made with reserve,</ins>
+ but has no effect on the validity of references to elements of the deque.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Rationale:</b></p>
+-Complication outweighs the benefit.
++<p>Complication outweighs the benefit.</p>
+
+
+
+@@ -24187,10 +20391,10 @@ Complication outweighs the benefit.
+
+ <hr>
+ <h3><a name="862"></a>862. Impossible complexity for 'includes'</h3>
+-<p><b>Section:</b> 25.4.5.1 [includes] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-07-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#includes">issues</a> in [includes].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 25.4.5.1 [includes] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#includes">issues</a> in [includes].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 25.4.5.1 [includes] the complexity is "at most -1 comparisons" if passed
+@@ -24215,14 +20419,14 @@ This same issue also applies to:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Suggest NAD. The complexity of empty ranges is -1 in other places in the
+ standard. See 25.4.4 [alg.merge] <tt>merge</tt> and
+ <tt>inplace_merge</tt>, and <tt>forward_list</tt> merge, for example.
+ The time and effort to find and fix all places in the standard where
+ empty range[s] result in negative complexity isn't worth the very
+ limited benefit.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair adds:
+@@ -24245,10 +20449,10 @@ further cases.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Pete to provide "straightforward" wording.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -24262,10 +20466,10 @@ Recommend NAD.
+
+ <hr>
+ <h3><a name="863"></a>863. What is the state of a stream after close() succeeds</h3>
+-<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2008-07-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fstreams">issues</a> in [fstreams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2008-07-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fstreams">issues</a> in [fstreams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Suppose writing to an <tt>[o]fstream</tt> fails and you later close the <tt>stream</tt>.
+@@ -24314,18 +20518,18 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="864"></a>864. Defect in atomic wording</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-07-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-07-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There's an error in 29.6 [atomics.types.operations]/p9:
+ </p>
+
+ <blockquote>
+-<pre>C atomic_load(const volatile A * object);
++<pre>
++C atomic_load(const volatile A * object);
+ C atomic_load_explicit(const volatile A * object, memory_order);
+ C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+ </pre>
+@@ -24340,27 +20544,27 @@ C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+ <p>
+ I believe that this should state
+ </p>
+-<blockquote>
++<blockquote><p>
+ shall not be <tt>memory_order_release</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ There's also an error in 29.6 [atomics.types.operations]/p17:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... When only one <tt>memory_order</tt> argument is supplied, the value of success
+ is <tt>order</tt>, and
+ the value of failure is <tt>order</tt> except that a value of
+ <tt>memory_order_acq_rel</tt> shall be replaced by the value
+ <tt>memory_order_require</tt> ...
+-</blockquote>
++</p></blockquote>
+ <p>
+ I believe this should state
+ </p>
+-<blockquote>
++<blockquote><p>
+ shall be replaced by the value <tt>memory_order_acquire</tt> ...
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -24369,7 +20573,8 @@ Change 29.6 [atomics.types.operations]/p9:
+ </p>
+
+ <blockquote>
+-<pre>C atomic_load(const volatile A * object);
++<pre>
++C atomic_load(const volatile A * object);
+ C atomic_load_explicit(const volatile A * object, memory_order);
+ C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+ </pre>
+@@ -24385,18 +20590,18 @@ C A ::load(memory_order order = memory_order_seq_cst) const volatile;
+ Change 29.6 [atomics.types.operations]/p17:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... When only one <tt>memory_order</tt> argument is supplied, the value of success
+ is <tt>order</tt>, and
+ the value of failure is <tt>order</tt> except that a value of
+ <tt>memory_order_acq_rel</tt> shall be replaced by the value
+ <del><tt>memory_order_require</tt></del> <ins><tt>memory_order_acquire</tt></ins> ...
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+-Already fixed by the time the LWG processed it.
++<p>Already fixed by the time the LWG processed it.</p>
+
+
+
+@@ -24404,21 +20609,22 @@ Already fixed by the time the LWG processed it.
+
+ <hr>
+ <h3><a name="867"></a>867. Valarray and value-initialization</h3>
+-<p><b>Section:</b> 26.6.2.1 [valarray.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 26.6.2.2 [valarray.cons] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-From 26.6.2.1 [valarray.cons], paragraph 2:
++From 26.6.2.2 [valarray.cons], paragraph 2:
+ </p>
+
+-<blockquote><pre>explicit valarray(size_t);
++<blockquote><pre>
++explicit valarray(size_t);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ The array created by this constructor has a length equal to the value of the argument. The elements
+ of the array are constructed using the default constructor for the instantiating type <tt>T</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -24427,15 +20633,15 @@ and <tt>double</tt>, they don't have a default constructor. I guess the intent i
+ the elements, so I suggest replacing:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The elements of the array are constructed using the default constructor for the instantiating type <tt>T</tt>.
+-</blockquote>
++</p></blockquote>
+ <p>
+ with
+ </p>
+-<blockquote>
++<blockquote><p>
+ The elements of the array are value-initialized.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ There is another reference to the default constructor of <tt>T</tt> in the non-normative note in paragraph 9.
+@@ -24447,37 +20653,38 @@ and so it doesn't need changes).
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 26.6.2.1 [valarray.cons], paragraph 2:
++Change 26.6.2.2 [valarray.cons], paragraph 2:
+ </p>
+
+ <blockquote>
+-<pre>explicit valarray(size_t);
++<pre>
++explicit valarray(size_t);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ The array created by this constructor has a length equal to the value of the argument. The elements
+ of the array are <del>constructed using the default constructor for the instantiating type <tt>T</tt></del>
+ <ins>value-initialized (8.5 [dcl.init])</ins>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 26.6.2.7 [valarray.members], paragraph 9:
++Change 26.6.2.8 [valarray.members], paragraph 9:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Example:</i> If the argument has the value -2, the first two elements of the result will be <del>constructed using the
+ default constructor</del>
+ <ins>value-initialized (8.5 [dcl.init])</ins>;
+ the third element of the result will be assigned the value of the first element of the argument; etc. <i>-- end example</i>]
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -24486,9 +20693,9 @@ the third element of the result will be assigned the value of the first element
+
+ <hr>
+ <h3><a name="873"></a>873. signed integral type and unsigned integral type are not clearly defined</h3>
+-<p><b>Section:</b> 3.9.1 [basic.fundamental] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Travis Vitek <b>Opened:</b> 2008-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 3.9.1 [basic.fundamental] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Travis Vitek <b>Opened:</b> 2008-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Neither the term "signed integral type" nor the term "unsigned
+@@ -24525,16 +20732,16 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Plum, Sebor to review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution needs to be "conceptualized". Currently we have
+ in [concept.support] only concept <tt>IntegralType</tt>
+ for all "integral types", thus indeed the current <tt>Container</tt>
+@@ -24542,7 +20749,7 @@ concept and Iterator concepts are sufficiently satisfied with "integral
+ types". If the changes are applied, we might ask core for concept
+ <tt>BilateralIntegerType</tt> and add proper restrictions to the library
+ concepts.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -24561,7 +20768,8 @@ concepts.
+ </p>
+ <blockquote>
+ <p>
+- </p><ol>
++ </p>
++ <ol>
+ <li>
+ When two pointers to elements of the same array object are
+ subtracted, the result is the difference of the subscripts of
+@@ -24572,7 +20780,6 @@ concepts.
+ <code>&lt;cstdint&gt;</code> header (18.1)...
+ </li>
+ </ol>
+- <p></p>
+ </blockquote>
+
+ <p>
+@@ -24580,10 +20787,11 @@ concepts.
+ <tt>X::difference_type</tt> cannot be <tt>char</tt> or
+ <tt>wchar_t</tt>, but could be one of the signed or unsigned integer
+ types as appropriate.
+- 20.2.5 [allocator.requirements] table 40...
++ 17.6.3.5 [allocator.requirements] table 40...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table 40: Allocator requirements
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -24619,10 +20827,11 @@ concepts.
+ The proposed change makes it clear that <tt>make_signed&lt;T&gt;::type</tt>
+ must be one of the signed integer types as defined in 3.9.1. Ditto for
+ <tt>make_unsigned&lt;T&gt;type</tt> and unsigned integer types.
+- 20.7.7.3 [meta.trans.sign] table 48...
++ 20.10.7.3 [meta.trans.sign] table 48...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table 48: Sign modifications
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -24693,8 +20902,9 @@ concepts.
+
+ 22.4.2.1.2 [facet.num.get.virtuals] table 78...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table 78: Integer Conversions
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -24735,8 +20945,9 @@ concepts.
+ Rationale is same as above.
+ 22.4.2.2.2 [facet.num.put.virtuals] table 80...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table 80: Integer Conversions
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -24780,8 +20991,9 @@ concepts.
+ <p>
+ 23.2 [container.requirements] table 80...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Table 89: Container requirements
++ </p>
+ <table border="1">
+ <thead>
+ <tr>
+@@ -24816,7 +21028,7 @@ concepts.
+ <p>
+ X [iterator.concepts] paragraph 1...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Iterators are a generalization of pointers that allow a C++ program to
+ work with different data structures (containers) in a uniform manner.
+ To be able to construct template algorithms that work correctly and
+@@ -24830,12 +21042,12 @@ concepts.
+ value of some type that is in the set of types that are
+ <i>writable</i> to the particular iterator type of <code>i</code>. All
+ iterators <code>i</code> for which the expression <code>(*i).m</code>
+- is well-defined, support the expression <code>i-&gt;m</code> with the
++ is well-defined, support the expression <code>i->m</code> with the
+ same semantics as <code>(*i).m</code>. For every iterator type
+ <code>X</code> for which equality is defined, there is a corresponding
+ <del>signed integral type</del> <ins>signed integer type</ins> called
+ the <i>difference type</i> of the iterator.
+- </blockquote>
++ </p></blockquote>
+
+ <p>
+ I'm a little unsure of this change. Previously this paragraph would
+@@ -24844,7 +21056,7 @@ concepts.
+ new wording prohibits this.
+ 26.5.3.1 [rand.eng.lcong] paragraph 2...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ The template parameter <code>UIntType</code> shall denote an
+ <del>unsigned integral type</del><ins>unsigned integer type</ins>
+ large enough to store values as large as <code>m - 1</code>. If the
+@@ -24855,31 +21067,31 @@ concepts.
+ <code>result_type</code>. --end note] Otherwise, the following
+ relations shall hold: <code>a &lt; m</code> and <code>c &lt;
+ m</code>.
+- </blockquote>
++ </p></blockquote>
+
+ <p>
+ Same rationale as the previous change.
+ X [rand.adapt.xor] paragraph 6...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ Both <code>Engine1::result_type</code> and
+ <code>Engine2::result_type</code> shall denote (possibly different)
+ <del>unsigned integral types</del><ins>unsigned integer types</ins>.
+ The member <i>result_type</i> shall denote either the type
+ <i>Engine1::result_type</i> or the type <i>Engine2::result_type</i>,
+ whichever provides the most storage according to clause 3.9.1.
+- </blockquote>
++ </p></blockquote>
+
+ <p>
+ 26.5.7.1 [rand.util.seedseq] paragraph 7...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ <i>Requires:</i><code>RandomAccessIterator</code> shall meet the
+ requirements of a random access iterator (24.1.5) such that
+ <code>iterator_traits&lt;RandomAccessIterator&gt;::value_type</code>
+ shall denote an <del>unsigned integral type</del><ins>unsigned integer
+ type</ins> capable of accomodating 32-bit quantities.
+- </blockquote>
++ </p></blockquote>
+
+ <p>
+ By making this change, integral types that happen to have a signed
+@@ -24888,13 +21100,13 @@ concepts.
+ the original intent, and should be reviewed.
+ 29.6 [atomics.types.operations] paragraph 24...
+ </p>
+- <blockquote>
++ <blockquote><p>
+ <i>Remark:</i> For <del>signed integral types</del><ins>signed integer
+ types</ins>, arithmetic is defined using two's complement
+ representation. There are no undefined results. For address types, the
+ result may be an undefined address, but the operations otherwise have
+ no undefined behavior.
+- </blockquote>
++ </p></blockquote>
+
+
+
+@@ -24902,657 +21114,11 @@ concepts.
+
+
+ <hr>
+-<h3><a name="874"></a>874. Missing <tt>initializer_list</tt> constructor for <tt>discrete_distribution</tt></h3>
+-<p><b>Section:</b> 26.5.8.5.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-During the Sophia Antipolis meeting it was decided to separate from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a> a
+-subrequest that adds initializer list support to
+-<tt>discrete_distribution</tt>, specifically,
+-the issue proposed to add a c'tor taking a <tt>initializer_list&lt;double&gt;</tt>.
+-</p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.1 [rand.dist.samp.discrete]/1, class <tt>discrete_distribution</tt>,
+-just <em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit discrete_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-
+-<p>
+-insert
+-</p>
+-
+-<blockquote><pre>discrete_distribution(initializer_list&lt;double&gt; wl);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 of the same section insert a new
+-paragraph as part of the new member description:
+-</p>
+-
+-<blockquote><pre>discrete_distribution(initializer_list&lt;double&gt; wl);
+-</pre>
+-
+-<blockquote>
+-<i>Effects:</i> Same as <tt>discrete_distribution(wl.begin(), wl.end())</tt>.
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="875"></a>875. Missing <tt>initializer_list</tt> constructor for <tt>piecewise_constant_distribution</tt></h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-During the Sophia Antipolis meeting it was decided to separate from
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a> a subrequest that adds initializer list support to
+-<tt>piecewise_constant_distribution</tt>, specifically, the issue proposed
+-to add a c'tor taking a <tt>initializer_list&lt;double&gt;</tt> and a <tt>Callable</tt> to evaluate
+-weight values. For consistency with the remainder of this class and
+-the remainder of the <tt>initializer_list</tt>-aware library the author decided to
+-change the list argument type to the template parameter <tt>RealType</tt>
+-instead. For the reasoning to use <tt>Func</tt> instead of <tt>Func&amp;&amp;</tt> as c'tor
+-function argument see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p><b>Non-concept version of the proposed resolution</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
+-just <em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit piecewise_constant_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-
+-<p>
+-insert
+-</p>
+-
+-<blockquote><pre>template&lt;typename Func&gt;
+-piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 of the same section insert a series of
+-new paragraphs nominated below as [p5_1], [p5_2], and [p5_3]
+-as part of the new member description:
+-</p>
+-
+-<blockquote><pre>template&lt;typename Func&gt;
+-piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
+-</pre>
+-
+-<blockquote>
+-
+-<p>
+-[p5_1] <i>Complexity:</i> Exactly <tt>nf = max(bl.size(), 1) - 1</tt> invocations of <tt>fw</tt>.
+-</p>
+-
+-<p>
+-[p5_2] <i>Requires:</i>
+-</p>
+-
+-<ol type="a">
+-<li>
+-<tt>fw</tt> shall be callable with one argument of type <tt>RealType</tt>, and shall
+- return values of a type convertible to <tt>double</tt>;
+-</li>
+-<li>
+-The relation <tt>0 &lt; S = w<sub>0</sub>+. . .+w<sub>n-1</sub></tt> shall hold.
+-For all sampled values <tt><i>x<sub>k</sub></i></tt> defined below, <tt>fw(<i>x<sub>k</sub></i>)</tt> shall return a weight
+- value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
+-</li>
+-<li>
+-If <tt>nf &gt; 0</tt> let <tt>b<sub><i>k</i></sub> = *(bl.begin() + k), k = 0, . . . , bl.size()-1</tt> and the
+-following relations shall hold for <tt>k = 0, . . . , nf-1: b<sub><i>k</i></sub> &lt; b<sub><i>k+1</i></sub></tt>.
+-</li>
+-</ol>
+-
+-<p>
+-[p5_3] <i>Effects:</i>
+-</p>
+-
+-<ol type="a">
+-<li>
+-<p>If <tt>nf == 0</tt>,</p>
+-<ol type="a">
+-<li>
+-lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
+- value <tt>w<sub>0</sub> = 1</tt>, and
+-</li>
+-<li>
+-lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt>b<sub>0</sub> = 0</tt> and <tt>b<sub>1</sub> = 1</tt>.
+-</li>
+-</ol>
+-</li>
+-
+-<li>
+-<p>Otherwise,</p>
+-<ol type="a">
+-<li>
+-sets <tt>n = nf</tt>, and <tt>[bl.begin(), bl.end())</tt> shall form the sequence <tt>b</tt> of
+-length <tt>n+1</tt>, and
+-</li>
+-<li>
+-<p>lets the sequences <tt>w</tt> have length <tt>n</tt> and for each <tt>k = 0, . . . ,n-1</tt>,
+- calculates:</p>
+-<blockquote><pre>x<sub><i>k</i></sub> = 0.5*(b<sub><i>k+1</i></sub> + b<sub><i>k</i></sub>)
+-w<sub><i>k</i></sub> = fw(x<sub><i>k</i></sub>)
+-</pre></blockquote>
+-</li>
+-</ol>
+-</li>
+-
+-<li>
+-<p>
+-Constructs a <tt>piecewise_constant_distribution</tt> object with
+-the above computed sequence <tt>b</tt> as the interval boundaries
+-and with the probability densities:
+-</p>
+-<blockquote><pre>&#961;<sub><i>k</i></sub> = w<sub><i>k</i></sub>/(S * (b<sub><i>k+1</i></sub> - b<sub><i>k</i></sub>)) for k = 0, . . . , n-1.
+-</pre></blockquote>
+-
+-</li>
+-</ol>
+-
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-<p><b>Concept version of the proposed resolution</b></p>
+-
+-<ol>
+-<li>
+-<p>
+-In 26.5.8.5.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
+-just <em>before</em> the member declaration
+-</p>
+-
+-<blockquote><pre>explicit piecewise_constant_distribution(const param_type&amp; parm);
+-</pre></blockquote>
+-
+-<p>
+-insert
+-</p>
+-
+-<blockquote><pre>template&lt;Callable&lt;auto, RealType&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Between p.4 and p.5 of the same section insert a series of
+-new paragraphs nominated below as [p5_1], [p5_2], and [p5_3]
+-as part of the new member description:
+-</p>
+-
+-<blockquote><pre>template&lt;Callable&lt;auto, RealType&gt; Func&gt;
+- requires Convertible&lt;Func::result_type, double&gt;
+-piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
+-</pre>
+-
+-<blockquote>
+-
+-<p>
+-[p5_1] <i>Complexity:</i> Exactly <tt>nf = max(bl.size(), 1) - 1</tt> invocations of <tt>fw</tt>.
+-</p>
+-
+-<p>
+-[p5_2] <i>Requires:</i>
+-</p>
+-
+-<ol type="a">
+-<li>
+-The relation <tt>0 &lt; S = w<sub>0</sub>+. . .+w<sub>n-1</sub></tt> shall hold.
+-For all sampled values <tt><i>x<sub>k</sub></i></tt> defined below, <tt>fw(<i>x<sub>k</sub></i>)</tt> shall return a weight
+- value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
+-</li>
+-<li>
+-If <tt>nf &gt; 0</tt> let <tt>b<sub><i>k</i></sub> = *(bl.begin() + k), k = 0, . . . , bl.size()-1</tt> and the
+-following relations shall hold for <tt>k = 0, . . . , nf-1: b<sub><i>k</i></sub> &lt; b<sub><i>k+1</i></sub></tt>.
+-</li>
+-</ol>
+-
+-<p>
+-[p5_3] <i>Effects:</i>
+-</p>
+-
+-<ol type="a">
+-<li>
+-<p>If <tt>nf == 0</tt>,</p>
+-<ol type="a">
+-<li>
+-lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
+- value <tt>w<sub>0</sub> = 1</tt>, and
+-</li>
+-<li>
+-lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt>b<sub>0</sub> = 0</tt> and <tt>b<sub>1</sub> = 1</tt>.
+-</li>
+-</ol>
+-</li>
+-
+-<li>
+-<p>Otherwise,</p>
+-<ol type="a">
+-<li>
+-sets <tt>n = nf</tt>, and <tt>[bl.begin(), bl.end())</tt> shall form the sequence <tt>b</tt> of
+-length <tt>n+1</tt>, and
+-</li>
+-<li>
+-<p>lets the sequences <tt>w</tt> have length <tt>n</tt> and for each <tt>k = 0, . . . ,n-1</tt>,
+- calculates:</p>
+-<blockquote><pre>x<sub><i>k</i></sub> = 0.5*(b<sub><i>k+1</i></sub> + b<sub><i>k</i></sub>)
+-w<sub><i>k</i></sub> = fw(x<sub><i>k</i></sub>)
+-</pre></blockquote>
+-</li>
+-</ol>
+-</li>
+-
+-<li>
+-<p>
+-Constructs a <tt>piecewise_constant_distribution</tt> object with
+-the above computed sequence <tt>b</tt> as the interval boundaries
+-and with the probability densities:
+-</p>
+-<blockquote><pre>&#961;<sub><i>k</i></sub> = w<sub><i>k</i></sub>/(S * (b<sub><i>k+1</i></sub> - b<sub><i>k</i></sub>)) for k = 0, . . . , n-1.
+-</pre></blockquote>
+-
+-</li>
+-</ol>
+-
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="877"></a>877. to <tt>throw()</tt> or to <i>Throw:</i> Nothing.</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-08-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+- <p>
+-
+-Recent changes to
+-the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">working
+-draft</a> have introduced a gratuitous inconsistency with the C++ 2003
+-version of the specification with respect to exception guarantees
+-provided by standard functions. While the C++ 2003 standard
+-consistenly uses the empty exception specification, <tt>throw()</tt>,
+-to declare functions that are guaranteed not to throw exceptions, the
+-current working draft contains a number of "<i>Throws:</i> Nothing."
+-clause to specify essentially the same requirement. The difference
+-between the two approaches is that the former specifies the behavior
+-of programs that violate the requirement (<tt>std::unexpected()</tt>
+-is called) while the latter leaves the behavior undefined.
+-
+- </p>
+- <p>
+-
+-A survey of the working draft reveals that there are a total of 209
+-occurrences of <tt>throw()</tt> in the library portion of the spec,
+-the majority in clause 18, a couple (literally) in 19, a handful in
+-20, a bunch in 22, four in 24, one in 27, and about a dozen in D.9.
+-
+- </p>
+- <p>
+-
+-There are also 203 occurrences of "<i>Throws:</i> Nothing." scattered
+-throughout the spec.
+-
+- </p>
+- <p>
+-
+-While sometimes there are good reasons to use the "<i>Throws:</i>
+-Nothing." approach rather than making use of <tt>throw()</tt>, these
+-reasons do not apply in most of the cases where this new clause has
+-been introduced and the empty exception specification would be a
+-better approach.
+-
+- </p>
+- <p>
+-
+-First, functions declared with the empty exception specification
+-permit compilers to generate better code for calls to such
+-functions. In some cases, the compiler might even be able to eliminate
+-whole chunks of user-written code when instantiating a generic
+-template on a type whose operations invoked from the template
+-specialization are known not to throw. The prototypical example are
+-the <tt>std::uninitialized_copy()</tt>
+-and <tt>std::uninitialized_fill()</tt> algorithms where the
+-entire <tt>catch(...)</tt> block can be optimized away.
+-
+- </p>
+- <p>
+-
+-For example, given the following definition of
+-the <tt>std::uninitialized_copy</tt> function template and a
+-user-defined type <tt>SomeType</tt>:
+-
+- </p>
+- <blockquote>
+- <pre>template &lt;class InputIterator, class ForwardIterator&gt;
+-ForwardIterator
+-uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator res)
+-{
+- typedef iterator_traits&lt;ForwardIterator&gt;::value_type ValueType;
+-
+- ForwardIterator start = res;
+-
+- try {
+- for (; first != last; ++first, ++res)
+- ::new (&amp;*res) ValueType (*first);
+- }
+- catch (...) {
+- for (; start != res; --start)
+- (&amp;*start)-&gt;~ValueType ();
+- throw;
+- }
+- return res;
+-}
+-
+-struct SomeType {
+- SomeType (const SomeType&amp;) <ins>throw ()</ins>;
+-}</pre>
+- </blockquote>
+- <p>
+-
+-compilers are able to emit the following efficient specialization
+-of <tt>std::uninitialized_copy&lt;const SomeType*, SomeType*&gt;</tt>
+-(note that the <tt>catch</tt> block has been optimized away):
+-
+- </p>
+- <blockquote>
+- <pre>template &lt;&gt; SomeType*
+-uninitialized_copy (const SomeType *first, const SomeType *last, SomeType *res)
+-{
+- for (; first != last; ++first, ++res)
+- ::new (res) SomeType (*first);
+-
+- return res;
+-}</pre>
+- </blockquote>
+- <p>
+-
+-Another general example is default constructors which, when decorated
+-with <tt>throw()</tt>, allow the compiler to eliminate the
+-implicit <tt>try</tt> and <tt>catch</tt> blocks that it otherwise must
+-emit around each the invocation of the constructor
+-in <i>new-expressions</i>.
+-
+- </p>
+- <p>
+-
+-For example, given the following definitions of
+-class <tt>MayThrow</tt> and <tt>WontThrow</tt> and the two
+-statements below:
+-
+- </p>
+- <blockquote>
+- <pre>struct MayThrow {
+- MayThrow ();
+-};
+-
+-struct WontThrow {
+- WontThrow () <ins>throw ()</ins>;
+-};
+-
+-MayThrow *a = new MayThrow [N];
+-WontThrow *b = new WontThrow [N];</pre>
+-
+- </blockquote>
+- <p>
+-
+-the compiler generates the following code for the first statement:
+-
+- </p>
+- <blockquote>
+- <pre>MayThrow *a;
+-{
+- MayThrow *first = operator new[] (N * sizeof (*a));
+- MayThrow *last = first + N;
+- MayThrow *next = first;
+- try {
+- for ( ; next != last; ++next)
+- new (next) MayThrow;
+- }
+- catch (...) {
+- for ( ; first != first; --next)
+- next-&gt;~MayThrow ();
+- operator delete[] (first);
+- throw;
+- }
+- a = first;
+-}</pre>
+- </blockquote>
+- <p>
+-
+-but it is can generate much more compact code for the second statement:
+-
+- </p>
+- <blockquote>
+- <pre>WontThrow *b = operator new[] (N * sizeof (*b));
+-WontThrow *last = b + N;
+-for (WontThrow *next = b; next != last; ++next)
+- new (next) WontThrow;
+-</pre>
+- </blockquote>
+- <p>
+-
+-Second, in order for users to get the maximum benefit out of the new
+-<tt>std::has_nothrow_xxx</tt> traits when using standard library types
+-it will be important for implementations to decorate all non throwing
+-copy constructors and assignment operators with <tt>throw()</tt>. Note
+-that while an optimizer may be able to tell whether a function without
+-an explicit exception specification can throw or not based on its
+-definition, it can only do so when it can see the source code of the
+-definition. When it can't it must assume that the function may
+-throw. To prevent violating the One Definition Rule,
+-the <tt>std::has_nothrow_xxx</tt> trait must return the most
+-pessimistic guess across all translation units in the program, meaning
+-that <tt>std::has_nothrow_xxx&lt;T&gt;::value</tt> must evaluate to
+-<tt>false</tt> for any <tt>T</tt> whose <tt>xxx</tt>
+-(where <tt>xxx</tt> is default or copy ctor, or assignment operator)
+-is defined out-of-line.
+-
+- </p>
+- <p>
+-
+-<b>Counterarguments:</b>
+-
+- </p>
+- <p>
+-
+-During the discussion of this issue
+-on <a href="mailto:c++std-lib@accu.org">c++std-lib@accu.org</a>
+-(starting with post <tt>c++std-lib-21950</tt>) the following arguments
+-in favor of the "<i>Throws:</i> Nothing." style have been made.
+-
+- </p>
+- <p>
+- </p><ol>
+- <li>
+-
+-Decorating functions that cannot throw with the empty exception
+-specification can cause the compiler to generate suboptimal code for
+-the implementation of the function when it calls other functions that
+-aren't known to the compiler not to throw (i.e., that aren't decorated
+-with <tt>throw()</tt> even if they don't actually throw). This is a
+-common situation when the called function is a C or POSIX function.
+-
+- </li>
+- <li>
+-
+-Alternate, proprietary mechanisms exist (such as
+-GCC <a href="http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Function-Attributes.html#index-g_t_0040code_007bnothrow_007d-function-attribute-2160"><tt>__attribute__((nothrow))</tt></a>
+-or Visual
+-C++ <a href="http://msdn.microsoft.com/en-us/library/49147z04(VS.80).aspx"><tt>__declspec(nothrow)</tt></a>)
+-that let implementers mark up non-throwing functions, often without
+-the penalty mentioned in (1) above. The C++ standard shouldn't
+-preclude the use of these potentially more efficient mechanisms.
+-
+- </li>
+- <li>
+-
+-There are functions, especially function templates, that invoke
+-user-defined functions that may or may not be
+-declared <tt>throw()</tt>. Declaring such functions with the empty
+-exception specification will cause compilers to generate suboptimal
+-code when the user-defined function isn't also declared not to throw.
+-
+- </li>
+- </ol>
+- <p></p>
+- <p>
+-
+-The answer to point (1) above is that implementers can (and some have)
+-declare functions with <tt>throw()</tt> to indicate to the compiler
+-that calls to the function can safely be assumed not to throw in order
+-to allow it to generate efficient code at the call site without also
+-having to define the functions the same way and causing the compiler
+-to generate suboptimal code for the function definition. That is, the
+-function is declared with <tt>throw()</tt> in a header but it's
+-defined without it in the source file. The <tt>throw()</tt>
+-declaration is suppressed when compiling the definition to avoid
+-compiler errors. This technique, while strictly speaking no permitted
+-by the language, is safe and has been employed in practice. For
+-example, the GNU C library takes this approach. Microsoft Visual C++
+-takes a similar approach by simply assuming that no function with C
+-language linkage can throw an exception unless it's explicitly
+-declared to do so using the language extension <tt>throw(...)</tt>.
+-
+- </p>
+- <p>
+-
+-Our answer to point (2) above is that there is no existing practice
+-where C++ Standard Library implementers have opted to make use of the
+-proprietary mechanisms to declare functions that don't throw. The
+-language provides a mechanism specifically designed for this
+-purpose. Avoiding its use in the specification itself in favor of
+-proprietary mechanisms defeats the purpose of the feature. In
+-addition, making use of the empty exception specification
+-inconsistently, in some areas of the standard, while conspicuously
+-avoiding it and making use of the "<i>Throws:</i> Nothing." form in
+-others is confusing to users.
+-
+- </p>
+- <p>
+-
+-The answer to point (3) is simply to exercise caution when declaring
+-functions and especially function templates with the empty exception
+-specification. Functions that required not to throw but that may call
+-back into user code are poor candidates for the empty exception
+-specification and should instead be specified using "<i>Throws:</i>
+-Nothing." clause.
+-
+- </p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-We need someone to do an extensive review.
+-</p>
+-<p>
+-NAD Future.
+-</p>
+-</blockquote>
+-
+-
+- <p><b>Proposed resolution:</b></p>
+- <p>
+-
+-We propose two possible solutions. Our recommendation is to adopt
+-Option 1 below.
+-
+- </p>
+- <p>
+-
+-<b>Option 1:</b>
+-
+- </p>
+- <p>
+-
+-Except for functions or function templates that make calls back to
+-user-defined functions that may not be declared <tt>throw()</tt>
+-replace all occurrences of the "<i>Throws:</i> Nothing." clause with
+-the empty exception specification. Functions that are required not to
+-throw but that make calls back to user code should be specified to
+-"<i>Throw:</i> Nothing."
+-
+- </p>
+- <p>
+-
+-<b>Option 2:</b>
+-
+- </p>
+- <p>
+-
+-For consistency, replace all occurrences of the empty exception
+-specification with a "<i>Throws:</i> Nothing." clause.
+-
+- </p>
+-
+-
+-
+-
+-<hr>
+ <h3><a name="879"></a>879. Atomic load const qualification</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alexander Chemeris <b>Opened:</b> 2008-08-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alexander Chemeris <b>Opened:</b> 2008-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>atomic_address</tt> type and <tt>atomic&lt;T*&gt;</tt> specialization provide atomic
+@@ -25565,11 +21131,11 @@ is unnecessary and unintended.
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to review. Lawrence will first check with Peter whether the
+ current examples are sufficient, or whether they need to be expanded to
+ include all cases.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -25599,10 +21165,10 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
+
+
+
+@@ -25612,7 +21178,8 @@ Add const qualification to the pointer values of the <tt>atomic_address</tt>
+ and <tt>atomic&lt;T*&gt;</tt> specializations. E.g.
+ </p>
+
+-<blockquote><pre>typedef struct atomic_address {
++<blockquote><pre>
++typedef struct atomic_address {
+ void store(<ins>const</ins> void*, memory_order = memory_order_seq_cst) volatile;
+ void* exchange( <ins>const</ins> void*, memory_order = memory_order_seq_cst) volatile;
+ bool compare_exchange( <ins>const</ins> void*&amp;, <ins>const</ins> void*,
+@@ -25640,90 +21207,11 @@ bool atomic_compare_exchange_explicit(volatile atomic_address*,
+
+
+ <hr>
+-<h3><a name="880"></a>880. Missing atomic exchange parameter</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-08-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a></p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The <tt>atomic_exchange</tt> and <tt>atomic_exchange_explicit</tt> functions seem to
+-be inconsistently missing parameters.
+-</p>
+-
+-<p><i>[
+-Post Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Lawrence: Need to write up a list for Pete with details.
+-</p>
+-<p>
+-Detlef: Should not be New, we already talked about in Concurrency group.
+-</p>
+-<p>
+-Recommend Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Lawrence will handle all issues relating to atomics in a single paper.
+-</p>
+-<p>
+-LWG will defer discussion on atomics until that paper appears.
+-</p>
+-<p>
+-Move to Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-08-17 Handled by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add the appropriate parameters. For example,
+-</p>
+-
+-<blockquote><pre>bool atomic_exchange(volatile atomic_bool*<ins>, bool</ins>);
+-bool atomic_exchange_explicit(volatile atomic_bool*, bool<ins>, memory_order</ins>);
+-</pre></blockquote>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="887"></a>887. issue with condition::wait_...</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The Posix/C++ working group has identified an inconsistency between
+@@ -25750,7 +21238,8 @@ overload for unknown clocks which synchs to a known clock before waiting.
+ For example:
+ </p>
+
+-<blockquote><pre>template &lt;class Duration&gt;
++<blockquote><pre>
++template &lt;class Duration&gt;
+ bool
+ condition_variable::wait_until(unique_lock&lt;mutex&gt;&amp; lock,
+ const chrono::time_point&lt;chrono::system_clock, Duration&gt;&amp; abs_time)
+@@ -25822,9 +21311,9 @@ See the minutes at: <a href="http://wiki.dinkumware.com/twiki/bin/view/Posix/POS
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-18 Detlef reopens the issue:
+@@ -25886,14 +21375,14 @@ text concerning <tt>pthread_cond_timedwait</tt> found
+ <a href="http://www.unix.org/single_unix_specification/">here</a>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>pthread_cond_timedwait()</tt> function shall be equivalent to
+ <tt>pthread_cond_wait()</tt>, except that an error is returned if the absolute
+ time specified by <tt>abstime</tt> passes (that is, system time equals or exceeds
+ <tt>abstime</tt>) before the condition <tt>cond</tt> is signaled or broadcasted, or if the
+ absolute time specified by <tt>abstime</tt> has already been passed at the time
+ of the call.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I.e. the POSIX specification speaks of the error code returned in case of a time
+@@ -25909,11 +21398,11 @@ I do not believe so. This same section goes on to say in <em>non-normative</em>
+ text:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For cases when the system clock is advanced discontinuously by an
+ operator, it is expected that implementations process any timed wait
+ expiring at an intervening time as if that time had actually occurred.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Here is non-normative wording encouraging the implementation to ignore an advancing
+@@ -25934,7 +21423,8 @@ advanced during the wait. In contrast <tt>condition_variable::wait_until</tt>
+ always returns:
+ </p>
+
+-<blockquote><pre><tt>Clock::now() &lt; abs_time</tt>
++<blockquote><pre>
++<tt>Clock::now() &lt; abs_time</tt>
+ </pre></blockquote>
+
+ <p>
+@@ -25980,11 +21470,11 @@ not have good wording for such a note, but welcome suggestions.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The LWG is in favor of Detlef to supply revision which adopts Option 2 from
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2969.html">N2969</a>
+ but is modified by saying that <tt>system_clock</tt> must be available for <tt>wait_until</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-11 Anthony provided wording.
+@@ -26104,7 +21594,7 @@ If a function in this clause takes a timeout argument, and the time point or
+ elapsed time specified passes before the function returns, the latency between
+ the timeout occurring and the function returning is unspecified [<i>Note:</i>
+ Implementations should strive to keep such latency as small as possible, but
+-portable code should not rely on any specific upper limits — <i>end
++portable code should not rely on any specific upper limits &mdash; <i>end
+ note</i>]
+ </ins></p>
+ </blockquote>
+@@ -26114,334 +21604,86 @@ note</i>]
+
+
+ <hr>
+-<h3><a name="889"></a>889. thread::id comparisons</h3>
+-<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="892"></a>892. Forward_list issues...</h3>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Ed Smith-Rowland <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 324</b></p>
+-
+ <p>
+-The <tt>thread::id</tt> type supports the full set of comparison operators. This
+-is substantially more than is required for the associative containers that
+-justified them. Please place an issue against the threads library.
++I was looking at the latest draft on <tt>forward_list</tt>. Especially the splice methods.
+ </p>
++<p>
++The first one splices a whole list after a given iterator in <tt>this</tt>. The name is <tt>splice_after</tt>.
++I think in 23.3.4.6 [forwardlist.ops] paragraph 40
++change:
++</p>
++<blockquote><p>
++<i>Effect:</i> Insert the contents of <tt>x</tt> <del>before</del> <ins>after</ins> <tt>position</tt>, ...
++</p></blockquote>
+
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-Would depend on proposed extension to POSIX, or non-standard extension.
+-What about hash? POSIX discussing op. POSIX not known to be considering
+-support needed for hash, op.
++A deeper issue involves the complexity. <tt>forward_list</tt> has no <tt>size</tt> and we
++don't know when we've reached the end except to walk up to it. To
++splice we would need to hook the end of the source list to the item
++after <tt>position</tt> in this list. This would involve walking length of the
++source list until we got to the last dereference-able element in source.
++There's no way we could do this in O(1) unless we stored a bogus end in
++<tt>forward_list</tt>.
+ </p>
+ <p>
+-Group expresses support for putting ids in both unordered and ordered containers.
++OTOH, the last version of <tt>splice_after</tt> with iterator ranges we could do
++in O(1) because we know how to hook the end of the source range to ...
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-post San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-Howard: It turns out the current working paper
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+-<i>already has</i> <tt>hash&lt;thread::id&gt;</tt>
+-(20.8 [function.objects], 20.8.15 [unord.hash]). We simply
+-overlooked it in the meeting. It is a good thing we voted in favor of it
+-(again). :-)
++Unless I'm misconceiving the whole thing. Which is possible. I'll look at it again.
+ </p>
+ <p>
+-Recommend NAD.
++I'm pretty sure about the first part though.
+ </p>
+
+-</blockquote>
+-
+-<p><i>[
+-Post Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-Recommend to close as NAD. For POSIX, see if we need to add a function to
+-convert <tt>pthread_t</tt> to integer.
+-</blockquote>
+-
+ <p><i>[
+-Post Summit, Alisdair adds:
++San Francisco:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-The recommendation for LWG-889/UK-324 is NAD, already specified.
++This issue is more complicated than it looks.
+ </p>
+ <p>
+-It is not clear to me that the specification is complete.
++paragraph 47: replace each <tt>(first, last) with (first, last]</tt>
+ </p>
+ <p>
+-In particular, the synopsis of <tt>&lt;functional&gt;</tt> in 20.8 [function.objects] does not mention <tt>hash&lt; thread::id
+-&gt;</tt> nor <tt>hash&lt; error_code &gt;</tt>, although their
+-existence is implied by 20.8.15 [unord.hash], p1.
++add a statement after paragraph 48 that complexity is O(1)
+ </p>
+ <p>
+-I am fairly uncomfortable putting the declaration for the
+-<tt>thread_id</tt> specialization into <tt>&lt;functional&gt;</tt> as
+-<tt>id</tt> is a nested class inside <tt>std::thread</tt>, so it implies
+-that <tt>&lt;functional&gt;</tt> would require the definition of the
+-<tt>thread</tt> class template in order to forward declared
+-<tt>thread::id</tt> and form this specialization.
++remove the complexity statement from the first overload of splice_after
+ </p>
+ <p>
+-It seems better to me that the dependency goes the other way around
+-(<tt>&lt;thread&gt;</tt> will more typically make use of
+-<tt>&lt;functional&gt;</tt> than vice-versa) and the
+-<tt>hash&lt;thread::id&gt;</tt> specialization be declared in the
+-<tt>&lt;thread&gt;</tt> header.
++We may have the same problems with other modifiers, like erase_after.
++Should it require that all iterators in the range (position, last] be
++dereferenceable?
+ </p>
+ <p>
+-I think <tt>hash&lt;error_code&gt;</tt> could go into either
+-<tt>&lt;system_error&gt;</tt> or <tt>&lt;functional&gt;</tt> and have no
+-immediate preference either way. However, it should clearly appear in
+-the synopsis of one of these two.
++We do, however, like the proposed changes and consider them Editorial.
++Move to NAD Editorial, Pending. Howard to open a new issue to handle the
++problems with the complexity requirements.
+ </p>
+ <p>
+-Recommend moving 889 back to open, and tying in a reference to UK-324.
++Opened <a href="lwg-defects.html#897">897</a>.
+ </p>
+ </blockquote>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+
+-<blockquote>
+-Howard observes that <tt>thread::id</tt> need not be a nested class;
+-it could be a <tt>typedef</tt> for a more visible type.
+-</blockquote>
+-
+-<p><i>[
+-2009-05-24 Alisdair adds:
+-]</i></p>
+-
+-<blockquote>
+-I do not believe this is correct. <tt>thread::id</tt> is explicitly documents as a
+-nested class, rather than as an unspecified typedef analogous to an
+-iterator. If the intent is that this is not implemented as a nested class
+-(under the as-if freedoms) then this is a novel form of standardese.
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Decided we want to move hash specialization for thread_id to the thread
+-header. Alisdair to provide wording.
+-</blockquote>
+-
+-<p><i>[
+-2009-07-28 Alisdair provided wording, moved to Review.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Add a strike for <tt>hash&lt;thread::id&gt;</tt>. Move to Ready
+-</blockquote>
+-
+-<p><i>[
+-2009-11-13 The proposed wording of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a> is a superset of the
+-wording in this issue.
+-]</i></p>
+-
+-
+-<p><i>[
+-2010-02-09 Moved from Ready to Open:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a> is not quite a superset of this issue and it is controversial
+-whether or not the note:
+-</p>
+-
+-<blockquote>
+-hash template specialization allows <tt>thread::id</tt> objects to be used as keys in
+-unordered containers.
+-</blockquote>
+-
+-<p>
+-should be added to the WP.
+-</p>
+-
+-
+-</blockquote>
+-
+-<p><i>[
+-2010-02-09 Objections to moving this to NAD Editorial, solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a> have been removed. Set to Tentatively NAD Editorial.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p>
+-Remove the following prototype from the synopsis in
+-20.8 [function.objects]:
+-</p>
+-
+-<blockquote><pre><del>
+-template &lt;&gt; struct hash&lt;std::thread::id&gt;;
+-</del></pre></blockquote>
+-
+-<p>
+-Add to 30.3 [thread.threads], p1 Header <tt>&lt;thread&gt;</tt> synopsis:
+-</p>
+-
+-<blockquote><pre><ins>template &lt;class T&gt; struct hash;
+-template &lt;&gt; struct hash&lt;thread::id&gt;;</ins>
+-</pre></blockquote>
+-
+-<p>
+-Add template specialization below class definition in 30.3.1.1 [thread.thread.id]
+-</p>
+-
+-<blockquote><pre><ins>template &lt;&gt;
+-struct hash&lt;thread::id&gt; : public unary_function&lt;thread::id, size_t&gt; {
+- size_t operator()(thread::id val) const;
+-};</ins>
+-</pre></blockquote>
+-
+-<p>
+-Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence:
+-</p>
+-
+-<blockquote>
+-[<i>Note:</i> Relational operators allow <tt>thread::id</tt> objects to be used
+-as keys in associative containers.
+-<ins><tt>hash</tt> template specialization allows <tt>thread::id</tt> objects to be used as keys
+-in unordered containers.</ins>
+-— <i>end note</i>]
+-</blockquote>
+-
+-<p>
+-Add new paragraph to end of 30.3.1.1 [thread.thread.id]
+-</p>
+-
+-<blockquote><pre><ins>template &lt;&gt; struct hash&lt;thread::id&gt;;</ins>
+-</pre>
+-<blockquote><ins>
+-An explicit specialization of the class template hash (20.8.15 [unord.hash])
+-shall be provided for the type <tt>thread::id</tt>.
+-</ins></blockquote>
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="892"></a>892. Forward_list issues...</h3>
+-<p><b>Section:</b> 23.3.3.5 [forwardlist.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Ed Smith-Rowland <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I was looking at the latest draft on <tt>forward_list</tt>. Especially the splice methods.
+-</p>
+-<p>
+-The first one splices a whole list after a given iterator in <tt>this</tt>. The name is <tt>splice_after</tt>.
+-I think in 23.3.3.5 [forwardlist.ops] paragraph 40
+-change:
+-</p>
+-<blockquote>
+-<i>Effect:</i> Insert the contents of <tt>x</tt> <del>before</del> <ins>after</ins> <tt>position</tt>, ...
+-</blockquote>
+-
+-<p>
+-A deeper issue involves the complexity. <tt>forward_list</tt> has no <tt>size</tt> and we
+-don't know when we've reached the end except to walk up to it. To
+-splice we would need to hook the end of the source list to the item
+-after <tt>position</tt> in this list. This would involve walking length of the
+-source list until we got to the last dereference-able element in source.
+-There's no way we could do this in O(1) unless we stored a bogus end in
+-<tt>forward_list</tt>.
+-</p>
+-<p>
+-OTOH, the last version of <tt>splice_after</tt> with iterator ranges we could do
+-in O(1) because we know how to hook the end of the source range to ...
+-</p>
+-<p>
+-Unless I'm misconceiving the whole thing. Which is possible. I'll look at it again.
+-</p>
+-<p>
+-I'm pretty sure about the first part though.
+-</p>
+-
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-This issue is more complicated than it looks.
+-</p>
+-<p>
+-paragraph 47: replace each <tt>(first, last) with (first, last]</tt>
+-</p>
+-<p>
+-add a statement after paragraph 48 that complexity is O(1)
+-</p>
+-<p>
+-remove the complexity statement from the first overload of splice_after
+-</p>
+-<p>
+-We may have the same problems with other modifiers, like erase_after.
+-Should it require that all iterators in the range (position, last] be
+-dereferenceable?
+-</p>
+-<p>
+-We do, however, like the proposed changes and consider them Editorial.
+-Move to NAD Editorial, Pending. Howard to open a new issue to handle the
+-problems with the complexity requirements.
+-</p>
+-<p>
+-Opened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>.
+-</p>
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In 23.3.3.5 [forwardlist.ops] paragraph 40
+-change:
+-</p>
+-<blockquote>
+-<i>Effect:</i> Insert the contents of <tt>x</tt> <del>before</del> <ins>after</ins> <tt>position</tt>, ...
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
++<p>
++In 23.3.4.6 [forwardlist.ops] paragraph 40
++change:
++</p>
++<blockquote><p>
++<i>Effect:</i> Insert the contents of <tt>x</tt> <del>before</del> <ins>after</ins> <tt>position</tt>, ...
++</p></blockquote>
+
+
+
+@@ -26449,11 +21691,11 @@ change:
+
+ <hr>
+ <h3><a name="895"></a>895. "Requires:" on std::string::at et al</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> James Dennett <b>Opened:</b> 2008-09-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a></p>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> James Dennett <b>Opened:</b> 2008-09-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#625">625</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Per discussion, we need an issue open to cover looking at "Requires"
+@@ -26466,346 +21708,15 @@ clauses which are not constraints on user code, such as that on
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alan to address in paper.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="897"></a>897. Forward_list issues... Part 2</h3>
+-<p><b>Section:</b> 23.3.3.4 [forwardlist.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-09-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-This issue was split off from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a> at the request of the LWG.
+-</p>
+-
+-<p><i>[
+-San Francisco:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-This issue is more complicated than it looks.
+-</p>
+-<p>
+-paragraph 47: replace each <tt>(first, last) with (first, last]</tt>
+-</p>
+-<p>
+-add a statement after paragraph 48 that complexity is O(1)
+-</p>
+-<p>
+-remove the complexity statement from the first overload of splice_after
+-</p>
+-<p>
+-We may have the same problems with other modifiers, like erase_after.
+-Should it require that all iterators in the range (position, last] be
+-dereferenceable?
+-</p>
+-</blockquote>
+-
+-<p>
+-There are actually 3 issues here:
+-</p>
+-
+-<ol>
+-<li>
+-<p>
+-What value should <tt>erase_after</tt> return? With <tt>list</tt>, code often
+-looks like:
+-</p>
+-<blockquote><pre>for (auto i = l.begin(); i != l.end();)
+-{
+- // inspect *i and decide if you want to erase it
+- // ...
+- if (I want to erase *i)
+- i = l.erase(i);
+- else
+- ++i;
+-}
+-</pre></blockquote>
+-<p>
+-I.e. the iterator returned from <tt>erase</tt> is useful for setting up the
+-logic for operating on the next element. For <tt>forward_list</tt> this might
+-look something like:
+-</p>
+-<blockquote><pre>auto i = fl.before_begin();
+-auto ip1 = i;
+-for (++ip1; ip1 != fl.end(); ++ip1)
+-{
+- // inspect *(i+1) and decide if you want to erase it
+- // ...
+- if (I want to erase *(i+1))
+- i = fl.erase_after(i);
+- else
+- ++i;
+- ip1 = i;
+-}
+-</pre></blockquote>
+-<p>
+-In the above example code, it is convenient if <tt>erase_after</tt> returns
+-the element <i>prior</i> to the erased element (range) instead of the element
+-<i>after</i> the erase element (range).
+-</p>
+-<p>
+-Existing practice:
+-</p>
+-<ul>
+-<li>SGI slist returns an iterator referencing the element <i>after</i> the erased range.</li>
+-<li>CodeWarrior slist returns an iterator referencing the element <i>before</i> the erased range.</li>
+-</ul>
+-<p>
+-There is not a strong technical argument for either solution over the other.
+-</p>
+-</li>
+-
+-<li>
+-<p>
+-With all other containers, operations always work on the range
+-<tt>[first, last)</tt> and/or <i>prior to</i> the given <tt>position</tt>.
+-</p>
+-<p>
+-With <tt>forward_list</tt>, operations sometimes work on the range
+-<tt>(first, last]</tt> and/or <i>after</i> the given <tt>position</tt>.
+-</p>
+-<p>
+-This is simply due to the fact that in order to operate on
+-<tt>*first</tt> (with <tt>forward_list</tt>) one needs access to
+-<tt>*(first-1)</tt>. And that's not practical with
+-<tt>forward_list</tt>. So the operating range needs to start with <tt>(first</tt>,
+-not <tt>[first</tt> (as the current working paper says).
+-</p>
+-<p>
+-Additionally, if one is interested in splicing the range <tt>(first, last)</tt>,
+-then (with <tt>forward_list</tt>), one needs practical (constant time) access to
+-<tt>*(last-1)</tt> so that one can set the <i>next</i> field in this node to
+-the proper value. As this is not possible with <tt>forward_list</tt>, one must
+-specify the last element of interest instead of one past the last element of
+-interest. The syntax for doing this is to pass <tt>(first, last]</tt> instead
+-of <tt>(first, last)</tt>.
+-</p>
+-<p>
+-With <tt>erase_after</tt> we have a choice of either erasing the range
+-<tt>(first, last]</tt> <em>or</em> <tt>(first, last)</tt>. Choosing the latter
+-enables:
+-</p>
+-<blockquote><pre>x.erase_after(pos, x.end());
+-</pre></blockquote>
+-
+-<p>
+-With the former, the above statement is inconvenient or expensive due to the lack
+-of constant time access to <tt>x.end()-1</tt>. However we could introduce:
+-</p>
+-
+-<blockquote><pre>iterator erase_to_end(const_iterator position);
+-</pre></blockquote>
+-
+-<p>
+-to compensate.
+-</p>
+-
+-<p>
+-The advantage of the former (<tt>(first, last]</tt>) for <tt>erase_after</tt>
+-is a consistency with <tt>splice_after</tt> which uses <tt>(first, last]</tt>
+-as the specified range. But this either requires the addition of <tt>erase_to_end</tt>
+-or giving up such functionality.
+-</p>
+-
+-</li>
+-
+-<li>
+-As stated in the discussion of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>, and reienforced by point 2 above,
+-a <tt>splice_after</tt> should work on the source range <tt>(first, last]</tt>
+-if the operation is to be <i>&#927;</i>(1). When splicing an entire list <tt>x</tt> the
+-algorithm needs <tt>(x.before_begin(), x.end()-1]</tt>. Unfortunately <tt>x.end()-1</tt>
+-is not available in constant time unless we specify that it must be. In order to
+-make <tt>x.end()-1</tt> available in constant time, the implementation would have
+-to dedicate a pointer to it. I believe the design of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2543.htm">N2543</a>
+-intended a nominal overhead of <tt>foward_list</tt> of 1 pointer. Thus splicing
+-one <i>entire</i> <tt>forward_list</tt> into another can not be <i>&#927;</i>(1).
+-</li>
+-</ol>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-We agree with the proposed resolution.
+-</p>
+-<p>
+-Move to Review.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-We may need a new issue to correct splice_after, because it may no
+-longer be correct to accept an rvalues as an argument. Merge may be
+-affected, too. This might be issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>. (Howard: confirmed)
+-</p>
+-<p>
+-Move this to Ready, but the Requires clause of the second form of
+-splice_after should say "(first, last)," not "(first, last]" (there are
+-three occurrences). There was considerable discussion on this. (Howard: fixed)
+-</p>
+-<p>
+-Alan suggested removing the "foward_last&lt;T. Alloc&gt;&amp;&amp; x"
+-parameter from the second form of splice_after, because it is redundant.
+-PJP wanted to keep it, because it allows him to check for bad ranges
+-(i.e. "Granny knots").
+-</p>
+-<p>
+-We prefer to keep <tt>x</tt>.
+-</p>
+-<p>
+-Beman. Whenever we deviate from the customary half-open range in the
+-specification, we should add a non-normative comment to the standard
+-explaining the deviation. This clarifies the intention and spares the
+-committee much confusion in the future.
+-</p>
+-<p>
+-Alan to write a non-normative comment to explain the use of fully-closed ranges.
+-</p>
+-<p>
+-Move to Ready, with the changes described above. (Howard: awaiting note from Alan)
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial, addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2988.pdf">N2988</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Wording below assumes issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a> is accepted, but this issue is
+-independent of that issue.
+-</p>
+-
+-<p>
+-Change 23.3.3.4 [forwardlist.modifiers]:
+-</p>
+-
+-<blockquote>
+-<pre>iterator erase_after(const_iterator position);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Requires:</i> The iterator following <tt>position</tt> is dereferenceable.
+-</p>
+-<p>
+-<i>Effects:</i> Erases the element pointed to by the iterator following <tt>position</tt>.
+-</p>
+-<p>
+-<i>Returns:</i> <del>An iterator pointing to the element following the one that was erased, or <tt>end()</tt> if no such
+-element exists</del>
+-<ins>An iterator equal to <tt>position</tt></ins>.
+-</p>
+-</blockquote>
+-
+-
+-<pre>iterator erase_after(const_iterator position, <ins>const_</ins>iterator last);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Requires:</i> All iterators in the range
+-<tt><del>[</del><ins>(</ins>position,last)</tt>
+-are dereferenceable.
+-</p>
+-<p>
+-<i>Effects:</i> Erases the elements in the range
+-<tt><del>[</del><ins>(</ins>position,last)</tt>.
+-</p>
+-<p>
+-<i>Returns:</i> <ins>An iterator equal to <tt>position</tt></ins> <del><tt>last</tt></del>
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-Change 23.3.3.5 [forwardlist.ops]:
+-</p>
+-
+-<blockquote>
+-<pre>void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Requires:</i> <tt>position</tt> is <tt>before_begin()</tt> or a
+-dereferenceable iterator in the range <tt>[begin(), end))</tt>. <tt>&amp;x != this</tt>.
+-</p>
+-<p>
+-<i>Effects:</i> Inserts the contents of <tt>x</tt> after <tt>position</tt>, and
+-<tt>x</tt> becomes empty. Pointers and references to
+-the moved elements of <tt>x</tt> now refer to those same elements but as members of <tt>*this</tt>.
+-Iterators referring to the moved elements will continue to refer to their elements,
+-but they now behave as iterators into <tt>*this</tt>, not into <tt>x</tt>.
+-</p>
+-<p>
+-<i>Throws:</i> Nothing.
+-</p>
+-<p>
+-<i>Complexity:</i> <del><i>&#927;</i>(1)</del> <ins><i>&#927;</i>(<tt>distance(x.begin(), x.end())</tt>)</ins>
+-</p>
+-</blockquote>
+-
+-<p>...</p>
+-
+-<pre>void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x,
+- const_iterator first, const_iterator last);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Requires:</i> <tt>position</tt> is <tt>before_begin()</tt> or a
+-dereferenceable iterator in the range <tt>[begin(), end))</tt>.
+-<tt>(first,last)</tt> is a valid range in
+-<tt>x</tt>, and all iterators in the range
+-<tt>(first,last)</tt> are dereferenceable.
+-<tt>position</tt> is not an iterator in the range <tt>(first,last)</tt>.
+-</p>
+-<p>
+-<i>Effects:</i> Inserts elements in the range <tt>(first,last)</tt>
+-after <tt>position</tt> and removes the elements from <tt>x</tt>.
+-Pointers and references to the moved elements of <tt>x</tt> now refer to
+-those same elements but as members of <tt>*this</tt>. Iterators
+-referring to the moved elements will continue to refer to their
+-elements, but they now behave as iterators into <tt>*this</tt>, not into
+-<tt>x</tt>.
+-</p>
+-<p>
+-<ins><i>Complexity:</i> <i>&#927;</i>(1).</ins>
+ </p>
+-</blockquote>
+-
+-</blockquote>
+-
+
+
+
+@@ -26813,9 +21724,9 @@ elements, but they now behave as iterators into <tt>*this</tt>, not into
+
+ <hr>
+ <h3><a name="901"></a>901. insert iterators can move from lvalues</h3>
+-<p><b>Section:</b> 24.5.2.5 [insert.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.5.2.5 [insert.iterator] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 282</b></p>
+
+@@ -26827,7 +21738,7 @@ assignment operator will implicitly move from lvalues of a move-only type.
+ <p>
+ Suggested resolutions are:
+ </p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ Add another overload with a negative constraint on copy-constructible
+ and flag it "= delete".
+@@ -26864,10 +21775,10 @@ Suggest resolve as NAD Editorial with a reference to the paper.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree that this has been resolved in the latest Working Draft.
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -26881,10 +21792,10 @@ Recommend NAD, addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs
+
+ <hr>
+ <h3><a name="902"></a>902. Regular is the wrong concept to constrain numeric_limits</h3>
+-<p><b>Section:</b> 18.3.1 [limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#limits">issues</a> in [limits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 18.3.2 [limits] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#limits">issues</a> in [limits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses FR 32 and DE 16</b></p>
+@@ -26898,7 +21809,7 @@ appopriate for this specific API and we need a less refined constraint.
+
+ <p>FR 32:</p>
+
+-<blockquote>
++<blockquote><p>
+ The definition of <tt>numeric_limits&lt;&gt;</tt> as requiring a regular
+ type is both conceptually wrong and operationally illogical. As we
+ pointed before, this mistake needs to be corrected. For example, the
+@@ -26906,26 +21817,26 @@ template can be left unconstrained. In fact this reflects a much more
+ general problem with concept_maps/axioms and their interpretations. It
+ appears that the current text heavily leans toward experimental academic
+ type theory.
+-</blockquote>
++</p></blockquote>
+
+ <p>DE 16:</p>
+
+-<blockquote>
++<blockquote><p>
+ The class template <tt>numeric_limits</tt> should not specify the Regular concept
+ requirement for its template parameter, because it contains functions
+ returning NaN values for floating-point types; these values violate the
+ semantics of EqualityComparable.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open. Alisdair and Gaby will work on a solution, along with the new
+ treatment of axioms in clause 14.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -26939,9 +21850,9 @@ treatment of axioms in clause 14.
+
+ <hr>
+ <h3><a name="903"></a>903. <tt>back_insert_iterator</tt> issue</h3>
+-<p><b>Section:</b> 24.5.2.1 [back.insert.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2008-09-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.5.2.1 [back.insert.iterator] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2008-09-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I just noticed this; don't know how far the problem(?) extends or
+@@ -26983,7 +21894,7 @@ Move to NAD.
+
+ <ol>
+ <li>
+-If <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a> is accepted, <tt>OutputIterator</tt> does no longer support post increment.
++If <a href="lwg-closed.html#1009">1009</a> is accepted, <tt>OutputIterator</tt> does no longer support post increment.
+ </li>
+ <li>
+ To support backward compatibility a second overload of <tt>operator*</tt>
+@@ -27005,11 +21916,11 @@ to properly reflect the dual nature of built-in <tt>operator*</tt> as of
+
+ <hr>
+ <h3><a name="905"></a>905. Mutex specification questions</h3>
+-<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a></p>
++<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#893">893</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A few questions on the current WP,
+@@ -27017,7 +21928,7 @@ A few questions on the current WP,
+ </p>
+ <p>
+ 30.4.1 [thread.mutex.requirements]/24 says an expression
+-<tt>mut.unlock()</tt> "Throws: Nothing." I'm assuming that, per 17.6.3.11 [res.on.required], errors that violate the precondition "The
++<tt>mut.unlock()</tt> "Throws: Nothing." I'm assuming that, per 17.6.4.11 [res.on.required], errors that violate the precondition "The
+ calling thread shall own the mutex" opens the door for throwing an
+ exception anyway, such as to report unbalanced unlock operations and
+ unlocking from a thread that does not have ownership. Right?
+@@ -27070,7 +21981,7 @@ fails the program has undefined behaviour and therefore an
+ implementation may throw an exception already.
+ </li>
+ <li>
+-30.4.1.2.1 [thread.mutex.class]/3 bullet 2: Already addressed by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>.
++30.4.1.2.1 [thread.mutex.class]/3 bullet 2: Already addressed by issue <a href="lwg-defects.html#893">893</a>.
+ </li>
+ <li>
+ 30.4.1.2.1 [thread.mutex.class]/3 proposed addition: NAD. This is
+@@ -27090,9 +22001,11 @@ Precondition.
+
+ <hr>
+ <h3><a name="906"></a>906. <tt>ObjectType</tt> is the wrong concept to constrain <tt>initializer_list</tt></h3>
+-<p><b>Section:</b> 18.9 [support.initlist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 18.9 [support.initlist] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.initlist">active issues</a> in [support.initlist].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.initlist">issues</a> in [support.initlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The currently proposed constraint on <tt>initializer_list</tt>'s element type
+@@ -27103,21 +22016,21 @@ make clear, that it references an implicitly allocated array:
+ <p>
+ 8.5.4 [dcl.init.list]/4:
+ </p>
+-<blockquote>
++<blockquote><p>
+ When an initializer list is implicitly converted to a
+ <tt>std::initializer_list&lt;E&gt;</tt>, the object passed is constructed as if the
+ implementation allocated an array of N elements of type <tt>E</tt>, where
+ N is the number of elements in the initializer list.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ 18.9 [support.initlist]/2.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ An object of type <tt>initializer_list&lt;E&gt;</tt> provides access to an array of
+ objects of type <tt>const E</tt>.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Therefore, <tt>E</tt> needs to fulfill concept <tt>ValueType</tt> (thus excluding
+@@ -27126,7 +22039,8 @@ to prevent deep instantiation errors known from the bad old times,
+ as shown in the following example:
+ </p>
+
+-<blockquote><pre>// Header A: (Should concept-check even in stand-alone modus)
++<blockquote><pre>
++// Header A: (Should concept-check even in stand-alone modus)
+
+ template &lt;DefaultConstructible T&gt;
+ requires MoveConstructible&lt;T&gt;
+@@ -27180,7 +22094,8 @@ class template) provides a constructor that accepts an <tt>initializer_list</tt>
+ only <em>this</em> constructor would need to be restricted on <tt>ValueType</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;ObjectType T&gt;
++<blockquote><pre>
++template&lt;ObjectType T&gt;
+ class ExtContainer {
+ public:
+ requires ValueType&lt;T&gt;
+@@ -27193,18 +22108,18 @@ public:
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Need to look at again without concepts.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -27223,99 +22138,11 @@ constraint "<tt>ValueType</tt>".
+
+
+ <hr>
+-<h3><a name="908"></a>908. Deleted assignment operators for atomic types must be volatile</h3>
+-<p><b>Section:</b> X [atomics.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types">issues</a> in [atomics.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 90</b></p>
+-
+-<p>
+-The deleted copy-assignment operators for the atomic types are not
+-marked as volatile in N2723, whereas the assignment operators from the
+-associated non-atomic types are. e.g.
+-</p>
+-<blockquote><pre>atomic_bool&amp; operator=(atomic_bool const&amp;) = delete;
+-atomic_bool&amp; operator=(bool) volatile;
+-</pre></blockquote>
+-
+-<p>
+-This leads to ambiguity when assigning a non-atomic value to a
+-non-volatile instance of an atomic type:
+-</p>
+-<blockquote><pre>atomic_bool b;
+-b=false;
+-</pre></blockquote>
+-
+-<p>
+-Both assignment operators require a standard conversions: the
+-copy-assignment operator can use the implicit <tt>atomic_bool(bool)</tt>
+-conversion constructor to convert <tt>false</tt> to an instance of
+-<tt>atomic_bool</tt>, or <tt>b</tt> can undergo a qualification conversion in order to
+-use the assignment from a plain <tt>bool</tt>.
+-</p>
+-
+-<p>
+-This is only a problem once issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a> is applied.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-<blockquote>
+-Move to open. Assign to Lawrence. Related to US 90 comment.
+-</blockquote>
+-
+-<p><i>[
+-2009-08-17 Handled by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add volatile qualification to the deleted copy-assignment operator of
+-all the atomic types:
+-</p>
+-
+-<blockquote><pre>atomic_bool&amp; operator=(atomic_bool const&amp;) <ins>volatile</ins> = delete;
+-atomic_itype&amp; operator=(atomic_itype const&amp;) <ins>volatile</ins> = delete;
+-</pre></blockquote>
+-
+-<p>
+-etc.
+-</p>
+-<p>
+-This will mean that the deleted copy-assignment operator will require
+-<i>two</i> conversions in the above example, and thus be a worse match than
+-the assignment from plain <tt>bool</tt>.
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="910"></a>910. Effects of MoveAssignable</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 150</b></p>
+
+@@ -27324,25 +22151,26 @@ The description of the effect of <tt>operator=</tt> in the <tt>MoveAssignable</t
+ concept, given in paragraph 7 is:
+ </p>
+
+-<blockquote><pre>result_type T::operator=(T&amp;&amp; rv); // inherited from HasAssign&lt;T, T&amp;&amp;&gt;
++<blockquote><pre>
++result_type T::operator=(T&amp;&amp; rv); // inherited from HasAssign&lt;T, T&amp;&amp;&gt;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Postconditions:</i> the constructed <tt>T</tt> object is equivalent to the value of
+ <tt>rv</tt> before the assignment. [<i>Note:</i> there is no
+ requirement on the value of <tt>rv</tt> after the assignment. <i>--end note</i>]
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ The sentence contains a typo (what is the "constructed <tt>T</tt> object"?)
+ probably due to a cut&amp;paste from <tt>MoveConstructible</tt>. Moreover, the
+-discussion of LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a> shows that the postcondition is too generic
++discussion of LWG issue <a href="lwg-defects.html#675">675</a> shows that the postcondition is too generic
+ and might not reflect the user expectations. An implementation of the
+ move assignment that just calls <tt>swap()</tt> would always fulfill the
+ postcondition as stated, but might have surprising side-effects in case
+ the source rvalue refers to an object that is not going to be
+-immediately destroyed. See LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a> for another example. Due to
++immediately destroyed. See LWG issue <a href="lwg-defects.html#900">900</a> for another example. Due to
+ the sometimes intangible nature of the "user expectation", it seems
+ difficult to have precise normative wording that could cover all cases
+ without introducing unnecessary restrictions. However a non-normative
+@@ -27394,7 +22222,8 @@ the values have been moved from.
+ <p>
+ Here is user-written code which must be allowed to be legal:
+ </p>
+-<blockquote><pre>#include &lt;vector&gt;
++<blockquote><pre>
++#include &lt;vector&gt;
+ #include &lt;cstdio&gt;
+
+ template &lt;class Allocator&gt;
+@@ -27429,38 +22258,38 @@ I believe the current proposed wording is consistent with my view on this.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree that the proposed resolution
+ is an improvement over the current wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Need to look at again without concepts.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Walter will consult with Dave and Doug.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-We believe this is handled by the resolution to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>,
++<blockquote><p>
++We believe this is handled by the resolution to issue <a href="lwg-defects.html#1204">1204</a>,
+ but there is to much going on in this area to be sure. Defer for now.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-01-23 Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib.
+@@ -27482,14 +22311,14 @@ assignment.
+ In [concept.copymove], replace the postcondition in paragraph 7 with:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Postconditions:</i> <tt>*this</tt> is equivalent to the value of <tt>rv</tt> before the
+ assignment. [<i>Note:</i> there is no requirement on the value of <tt>rv</tt> after the
+ assignment, but the
+ effect should be unsurprising to the user even in case <tt>rv</tt> is not
+ immediately destroyed. This may require that resources previously owned
+ by <tt>*this</tt> are released instead of transferred to <tt>rv</tt>. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -27497,13 +22326,13 @@ by <tt>*this</tt> are released instead of transferred to <tt>rv</tt>. <i>-- end
+
+ <hr>
+ <h3><a name="912"></a>912. Array swap needs to be conceptualized</h3>
+-<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-With the adaption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>
++With the adaption of <a href="lwg-defects.html#809">809</a>
+ we have a new algorithm <tt>swap</tt> for C-arrays, which needs to be conceptualized.
+ </p>
+
+@@ -27512,18 +22341,18 @@ Post Summit Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend as NAD Editorial: The changes have already been applied to the WP
+-<a href="" ref="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2800.pdf">N2800</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2800.pdf">N2800</a>.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD; the changes have already been made.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -27531,7 +22360,8 @@ Move to NAD; the changes have already been made.
+ Replace in 25.3.3 [alg.swap] before p. 3 until p. 4 by
+ </p>
+
+-<blockquote><pre>template &lt;<del>class</del> <ins>ValueType</ins> T, size_t N&gt;
++<blockquote><pre>
++template &lt;<del>class</del> <ins>ValueType</ins> T, size_t N&gt;
+ <ins>requires Swappable&lt;T&gt;</ins>
+ void swap(T (&amp;a)[N], T (&amp;b)[N]);
+ </pre>
+@@ -27552,27 +22382,27 @@ void swap(T (&amp;a)[N], T (&amp;b)[N]);
+
+ <hr>
+ <h3><a name="913"></a>913. Superfluous requirements for replace algorithms</h3>
+-<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ (A) 25.3.5 [alg.replace]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The expression <tt>*first = new_value</tt> shall be valid.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ (B) 25.3.5 [alg.replace]/4:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The results of the expressions <tt>*first</tt> and <tt>new_value</tt> shall
+ be writable to the result output iterator.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Since conceptualization, the quoted content of these clauses is covered
+@@ -27610,12 +22440,13 @@ Move to Tentatively Ready.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+ Remove 25.3.5 [alg.replace]/1.
+ </p>
+-<blockquote><pre>template&lt;ForwardIterator Iter, class T&gt;
++<blockquote><pre>
++template&lt;ForwardIterator Iter, class T&gt;
+ requires OutputIterator&lt;Iter, Iter::reference&gt;
+ &amp;&amp; OutputIterator&lt;Iter, const T&amp;&gt;
+ &amp;&amp; HasEqualTo&lt;Iter::value_type, T&gt;
+@@ -27629,9 +22460,9 @@ template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred,
+ void replace_if(Iter first, Iter last,
+ Pred pred, const T&amp; new_value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del>1 <i>Requires:</i> The expression <tt>*first = new_value</tt> shall be valid.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ <li>
+@@ -27640,7 +22471,8 @@ template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred,
+ expressions <tt>*first</tt> and
+ <tt>new_value</tt> shall be writable to the result output iterator.".
+ </p>
+-<blockquote><pre>template&lt;InputIterator InIter, typename OutIter, class T&gt;
++<blockquote><pre>
++template&lt;InputIterator InIter, typename OutIter, class T&gt;
+ requires OutputIterator&lt;OutIter, InIter::reference&gt;
+ &amp;&amp; OutputIterator&lt;OutIter, const T&amp;&gt;
+ &amp;&amp; HasEqualTo&lt;InIter::value_type, T&gt;
+@@ -27657,12 +22489,12 @@ template&lt;InputIterator InIter, typename OutIter,
+ OutIter result,
+ Pred pred, const T&amp; new_value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 4 <i>Requires:</i> <del>The results of the expressions <tt>*first</tt> and
+ <tt>new_value</tt> shall be writable to the <tt>result</tt> output
+ iterator.</del> The ranges <tt>[first,last)</tt> and <tt>[result,result +
+ (last - first))</tt> shall not overlap.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ </ol>
+@@ -27673,10 +22505,10 @@ iterator.</del> The ranges <tt>[first,last)</tt> and <tt>[result,result +
+
+ <hr>
+ <h3><a name="914"></a>914. Superfluous requirement for unique</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 25.3.9 [alg.unique]/2: "Requires: The comparison function shall be an
+@@ -27687,7 +22519,8 @@ equivalence relation."
+ The essence of this is already covered by the given requirement
+ </p>
+
+-<blockquote><pre>EquivalenceRelation&lt;auto, Iter::value_type&gt; Pred
++<blockquote><pre>
++EquivalenceRelation&lt;auto, Iter::value_type&gt; Pred
+ </pre></blockquote>
+
+ <p>
+@@ -27698,10 +22531,10 @@ and should thus be removed.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -27709,7 +22542,8 @@ Move to Tentatively Ready.
+ Remove 25.3.9 [alg.unique]/2
+ </p>
+
+-<blockquote><pre>template&lt;ForwardIterator Iter&gt;
++<blockquote><pre>
++template&lt;ForwardIterator Iter&gt;
+ requires OutputIterator&lt;Iter, Iter::reference&gt;
+ &amp;&amp; EqualityComparable&lt;Iter::value_type&gt;
+ Iter unique(Iter first, Iter last);
+@@ -27737,10 +22571,10 @@ template&lt;ForwardIterator Iter, EquivalenceRelation&lt;auto, Iter::value_type&
+ <hr>
+ <h3><a name="915"></a>915. <tt>minmax</tt> with <tt>initializer_list</tt> should return
+ <tt>pair</tt> of <tt>T</tt>, not <tt>pair</tt> of <tt>const T&amp;</tt></h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It seems that the proposed changes for
+@@ -27749,7 +22583,7 @@ were not clear enough in
+ this point:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 25.4.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return
+ type of the <tt>minmax</tt> overloads with an <tt>initializer_list</tt> is
+ <tt>pair&lt;const T&amp;, const T&amp;&gt;</tt>,
+@@ -27757,49 +22591,48 @@ which is inconsistent with the decision for the other <tt>min/max</tt> overloads
+ a <tt>initializer_list</tt> as argument and return a <tt>T</tt>, not a <tt>const T&amp;</tt>.
+ Doing otherwise for <tt>minmax</tt> would easily lead to unexpected life-time
+ problems by using <tt>minmax</tt> instead of <tt>min</tt> and <tt>max</tt> separately.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+ tweaked for concepts removal.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-18 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend NAD since the proposed changes have already been performed
+ as part of editorial work of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Can't find initializer_list form of minmax anymore, only variadic
++<blockquote><p>
++Can't find <tt>initializer_list</tt> form of <tt>minmax</tt> anymore, only variadic
+ version. Seems like we had an editing clash with concepts. Leave Open,
+-at least until editorial issues resolved. Bring this to Editor's
+-attention.
+-</blockquote>
++at least until editorial issues resolved. Bring this to Editor's attention.
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Pete to reapply
+@@ -27809,10 +22642,10 @@ attention.
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Solved by reapplying
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2772.pdf">N2772</a>.
+-
++</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+@@ -27821,7 +22654,8 @@ Solved by reapplying
+ In 25 [algorithms]/2, header <tt>&lt;algorithm&gt;</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;<del>class</del><ins>LessThanComparable</ins> T&gt;
++<blockquote><pre>
++template&lt;<del>class</del><ins>LessThanComparable</ins> T&gt;
+ <ins>requires CopyConstructible&lt;T&gt;</ins>
+ pair&lt;<del>const </del>T<del>&amp;</del>, <del>const </del>T<del>&amp;</del>&gt;
+ minmax(initializer_list&lt;T&gt; t);
+@@ -27836,7 +22670,8 @@ minmax(initializer_list&lt;T&gt; t, Compare comp);
+ <p>
+ In 25.4.7 [alg.min.max] change as indicated (Begin: Just before p.20):
+ </p>
+-<blockquote><pre>template&lt;<del>class</del><ins>LessThanComparable</ins> T&gt;
++<blockquote><pre>
++template&lt;<del>class</del><ins>LessThanComparable</ins> T&gt;
+ <ins>requires CopyConstructible&lt;T&gt;</ins>
+ pair&lt;<del>const </del>T<del>&amp;</del>, <del>const </del>T<del>&amp;</del>&gt;
+ minmax(initializer_list&lt;T&gt; t);
+@@ -27854,7 +22689,8 @@ smallest value and <tt>y</tt> the largest value in the <tt>initializer_list</tt>
+ </blockquote>
+
+ <p>[..]</p>
+-<pre>template&lt;class T, <del>class</del><ins>StrictWeakOrder&lt;auto, T&gt;</ins> Compare&gt;
++<pre>
++template&lt;class T, <del>class</del><ins>StrictWeakOrder&lt;auto, T&gt;</ins> Compare&gt;
+ <ins>requires CopyConstructible&lt;T&gt;</ins>
+ pair&lt;<del>const </del>T<del>&amp;</del>, <del>const </del>T<del>&amp;</del>&gt;
+ minmax(initializer_list&lt;T&gt; t, Compare comp);
+@@ -27881,31 +22717,34 @@ smallest value and <tt>y</tt> largest value in the <tt>initializer_list</tt>.
+
+ <hr>
+ <h3><a name="916"></a>916. Redundant move-assignment operator of <tt>pair</tt> should be removed</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>see also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>.</b></p>
++<p><b>see also <a href="lwg-closed.html#917">917</a>.</b></p>
+
+ <p>
+ The current WP provides the following assignment operators for <tt>pair</tt>
+-in 20.3.5 [pairs]/1:
++in 20.3 [pairs]/1:
+ </p>
+
+ <ol>
+ <li>
+-<pre>template&lt;class U , class V&gt;
++<pre>
++template&lt;class U , class V&gt;
+ requires HasAssign&lt;T1, const U&amp;&gt; &amp;&amp; HasAssign&lt;T2, const V&amp;&gt;
+ pair&amp; operator=(const pair&lt;U , V&gt;&amp; p);
+ </pre>
+ </li>
+ <li>
+-<pre>requires MoveAssignable&lt;T1&gt; &amp;&amp; MoveAssignable&lt;T2&gt; pair&amp; operator=(pair&amp;&amp; p );
++<pre>
++requires MoveAssignable&lt;T1&gt; &amp;&amp; MoveAssignable&lt;T2&gt; pair&amp; operator=(pair&amp;&amp; p );
+ </pre>
+ </li>
+ <li>
+-<pre>template&lt;class U , class V&gt;
++<pre>
++template&lt;class U , class V&gt;
+ requires HasAssign&lt;T1, RvalueOf&lt;U&gt;::type&gt; &amp;&amp; HasAssign&lt;T2, RvalueOf&lt;V&gt;::type&gt;
+ pair&amp; operator=(pair&lt;U , V&gt;&amp;&amp; p);
+ </pre>
+@@ -27938,29 +22777,30 @@ related to the pair templates.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave this open pending the removal of concepts from the WD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as NAD, see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>.
+-</blockquote>
++<blockquote><p>
++Mark as NAD, see issue <a href="lwg-defects.html#801">801</a>.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+-In 20.3.5 [pairs] p. 1, class <tt>pair</tt> and just before p. 13 remove the declaration:
++In 20.3 [pairs] p. 1, class <tt>pair</tt> and just before p. 13 remove the declaration:
+ </p>
+
+-<blockquote><pre>requires MoveAssignable&lt;T1&gt; &amp;&amp; MoveAssignable&lt;T2&gt; pair&amp; operator=(pair&amp;&amp; p );
++<blockquote><pre>
++requires MoveAssignable&lt;T1&gt; &amp;&amp; MoveAssignable&lt;T2&gt; pair&amp; operator=(pair&amp;&amp; p );
+ </pre></blockquote>
+ </li>
+
+@@ -27976,12 +22816,13 @@ Remove p.13+p.14
+
+ <hr>
+ <h3><a name="917"></a>917. Redundant move-assignment operator of <tt>tuple</tt> should be removed</h3>
+-<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>see also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>.</b></p>
++<p><b>see also <a href="lwg-closed.html#916">916</a>.</b></p>
+ <p>
+ N2770 (and thus now the WP) removed the
+ non-template move-assignment operator from tuple's class definition,
+@@ -28023,18 +22864,18 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave this open pending the removal of concepts from the WD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as NAD, see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>.
+-</blockquote>
++<blockquote><p>
++Mark as NAD, see issue <a href="lwg-defects.html#801">801</a>.
++</p></blockquote>
+
+
+
+@@ -28049,7 +22890,8 @@ change as indicated:
+ This fixes an editorial loss between N2798 to N2800
+ ]</i></p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... UTypes&gt;
+ requires HasAssign&lt;Types, const UTypes&amp;&gt;...
+ <ins>tuple&amp; operator=(const pair&lt;UTypes...&gt;&amp;);</ins>
+
+@@ -28064,7 +22906,8 @@ In 20.4.2.1 [tuple.cnstr], starting just before p. 11 please remove
+ as indicated:
+ </p>
+
+-<blockquote><pre><del>requires MoveAssignable&lt;Types&gt;... tuple&amp; operator=(tuple&amp;&amp; u);</del>
++<blockquote><pre>
++<del>requires MoveAssignable&lt;Types&gt;... tuple&amp; operator=(tuple&amp;&amp; u);</del>
+ </pre>
+ <blockquote>
+ <p>
+@@ -28085,12 +22928,12 @@ element of <tt>*this</tt>.</del>
+
+ <hr>
+ <h3><a name="918"></a>918. Swap for tuple needs to be conceptualized</h3>
+-<p><b>Section:</b> 20.4.2.3 [tuple.swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 20.4.2.3 [tuple.swap] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a> was accepted after <tt>tuple</tt> had been conceptualized,
++Issue <a href="lwg-defects.html#522">522</a> was accepted after <tt>tuple</tt> had been conceptualized,
+ therefore this step needs to be completed.
+ </p>
+
+@@ -28099,24 +22942,23 @@ Post Summit Daniel adds
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This is now NAD Editorial (addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html">N2844</a>)
+ except for item 3 in the proposed wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-01 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ As of the recent WP
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>),
+-this issue is now completely covered by editorial
+-changes (including the third bullet), therefore I unconditionally recommend
+-NAD.
+-</blockquote>
++this issue is now completely covered by editorial changes (including the third bullet),
++therefore I unconditionally recommend NAD.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -28141,7 +22983,8 @@ Move to NAD.
+ In both 20.4.1 [tuple.general]/2 and 20.4.2.9 [tuple.special] change
+ </p>
+
+-<blockquote><pre>template &lt;<del>class</del> <ins>Swappable</ins>... Types&gt;
++<blockquote><pre>
++template &lt;<del>class</del> <ins>Swappable</ins>... Types&gt;
+ void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y);
+ </pre></blockquote>
+
+@@ -28153,7 +22996,8 @@ In 20.4.2 [tuple.tuple], class <tt>tuple</tt> definition and in
+ 20.4.2.3 [tuple.swap], change
+ </p>
+
+-<blockquote><pre><ins>requires Swappable&lt;Types&gt;...</ins>void swap(tuple&amp;);
++<blockquote><pre>
++<ins>requires Swappable&lt;Types&gt;...</ins>void swap(tuple&amp;);
+ </pre></blockquote>
+
+ </li>
+@@ -28163,9 +23007,9 @@ In 20.4.2 [tuple.tuple], class <tt>tuple</tt> definition and in
+ In 20.4.2.3 [tuple.swap] remove the current requires-clause, which says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del><i>Requires:</i> Each type in <tt>Types</tt> shall be <tt>Swappable</tt></del>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ </ol>
+@@ -28177,17 +23021,18 @@ In 20.4.2.3 [tuple.swap] remove the current requires-clause, which says:
+
+ <hr>
+ <h3><a name="919"></a>919. (forward_)list specialized remove algorithms are over constrained</h3>
+-<p><b>Section:</b> 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-10-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops], 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-10-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The signatures of <tt>forwardlist::remove</tt> and <tt>list::remove</tt>
+-defined in 23.3.3.5 [forwardlist.ops] before 11 + 23.3.4.4 [list.ops] before 15:
++defined in 23.3.4.6 [forwardlist.ops] before 11 + 23.3.5.5 [list.ops] before 15:
+ </p>
+
+-<blockquote><pre>requires EqualityComparable&lt;T&gt; void remove(const T&amp; value);
++<blockquote><pre>
++requires EqualityComparable&lt;T&gt; void remove(const T&amp; value);
+ </pre></blockquote>
+
+ <p>
+@@ -28219,19 +23064,19 @@ Move to Review.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Current rationale and wording for this issue is built around concepts. I
+ suggest the issue reverts to Open status. I believe there is enough of
+ an issue to review after concepts are removed from the WP to re-examine
+ the issue in Santa Cruz, rather than resolve as NAD Concepts.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-10 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend NAD: The concept-free wording as of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
+ has no longer the
+@@ -28240,27 +23085,28 @@ over-specified requirement
+ the same test conditions exists
+ as for the free algorithm <tt>remove</tt> (25.3.8 [alg.remove]). The error was
+ introduced in the process of conceptifying.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD, solved by the removal of concepts.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+-Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15
++Replace in 23.3.4.6 [forwardlist.ops] before 11 and in 23.3.5.5 [list.ops] before 15
+ </p>
+
+-<blockquote><pre>requires <del>EqualityComparable&lt;T&gt;</del> <ins>HasEqualTo&lt;T, T&gt;</ins> void remove(const T&amp; value);
++<blockquote><pre>
++requires <del>EqualityComparable&lt;T&gt;</del> <ins>HasEqualTo&lt;T, T&gt;</ins> void remove(const T&amp; value);
+ </pre></blockquote>
+ </li>
+ </ol>
+@@ -28271,213 +23117,12 @@ Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] befor
+
+
+ <hr>
+-<h3><a name="923"></a>923. atomics with floating-point </h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-10-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Right now, C++0x doesn't have <tt>atomic&lt;float&gt;</tt>. We're thinking of adding
+-the words to support it for TR2 (note: that would be slightly
+-post-C++0x). If we need it, we could probably add the words.
+-</p>
+-<p>
+-<b>Proposed resolutions:</b> Using <tt>atomic&lt;FP&gt;::compare_exchange</tt> (weak or
+-strong) should be either:
+-</p>
+-
+-<ol>
+-<li>
+-ill-formed, or
+-</li>
+-<li>
+-well-defined.
+-</li>
+-</ol>
+-
+-<p>
+-I propose Option 1 for C++0x for expediency. If someone wants to argue
+-for Option 2, they need to say what exactly they want <tt>compare_exchange</tt>
+-to mean in this case (IIRC, C++0x doesn't even assume IEEE 754).
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to open. Blocked until concepts for atomics are addressed.
+-</blockquote>
+-
+-<p><i>[
+-Post Summit Anthony adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Recommend NAD. C++0x does have <tt>std::atomic&lt;float&gt;</tt>, and both
+-<tt>compare_exchange_weak</tt> and <tt>compare_exchange_strong</tt> are well-defined in
+-this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to:
+-</p>
+-
+-<blockquote>
+-<p>
+-[<i>Note:</i> The effect of the compare-and-exchange operations is
+-</p>
+-<blockquote><pre>if (!memcmp(object,expected,sizeof(*object)))
+- *object = desired;
+-else
+- *expected = *object;
+-</pre></blockquote>
+-
+-<p>
+-This may result in failed comparisons for values that compare equal if
+-the underlying type has padding bits or alternate representations of
+-the same value. <i>-- end note</i>]
+-</p>
+-</blockquote>
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change the note in 29.6 [atomics.types.operations] paragraph 20 to:
+-</p>
+-
+-<blockquote>
+-<p>
+-[<i>Note:</i> The effect of the compare-and-exchange operations is
+-</p>
+-<blockquote><pre>if (<del>*object == *expected</del> <ins>!memcmp(object,expected,sizeof(*object))</ins>)
+- *object = desired;
+-else
+- *expected = *object;
+-</pre></blockquote>
+-
+-<p><ins>
+-This may result in failed comparisons for values that compare equal if
+-the underlying type has padding bits or alternate representations of
+-the same value.</ins> <i>-- end note</i>]
+-</p>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="924"></a>924. structs with internal padding</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-10-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Right now, the <tt>compare_exchange_weak</tt> loop should rapidly converge on the
+-padding contents. But <tt>compare_exchange_strong</tt> will require a bit more
+-compiler work to ignore padding for comparison purposes.
+-</p>
+-<p>
+-Note that this isn't a problem for structs with no padding, and we do
+-already have one portable way to ensure that there is no padding that
+-covers the key use cases: Have elements be the same type. I suspect that
+-the greatest need is for a structure of two pointers, which has no
+-padding problem. I suspect the second need is a structure of a pointer
+-and some form of an integer. If that integer is <tt>intptr_t</tt>, there will be
+-no padding.
+-</p>
+-<p>
+-Related but separable issue: For unused bitfields, or other unused
+-fields for that matter, we should probably say it's the programmer's
+-responsibility to set them to zero or otherwise ensure they'll be
+-ignored by <tt>memcmp</tt>.
+-</p>
+-
+-<p>
+-<b>Proposed resolutions:</b> Using
+-<tt>atomic&lt;struct-with-padding&gt;::compare_exchange_strong</tt> should be either:
+-</p>
+-
+-<ol>
+-<li>
+-ill-formed, or
+-</li>
+-<li>
+-well-defined.
+-</li>
+-</ol>
+-
+-<p>
+-I propose Option 1 for C++0x for expediency, though I'm not sure how to
+-say it. I would be happy with Option 2, which I believe would mean that
+-<tt>compare_exchange_strong</tt> would be implemented to avoid comparing padding
+-bytes, or something equivalent such as always zeroing out padding when
+-loading/storing/comparing. (Either implementation might require compiler
+-support.)
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to open. Blocked until concepts for atomics are addressed.
+-</blockquote>
+-
+-<p><i>[
+-Post Summit Anthony adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-The resoultion of LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a> should resolve this issue as well.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="926"></a>926. Sequentially consistent fences, relaxed operations and modification order</h3>
+-<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-10-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-10-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 313</b></p>
+
+@@ -28486,7 +23131,8 @@ There was an interesting issue raised over on comp.programming.threads
+ today regarding the following example
+ </p>
+
+-<blockquote><pre>// Thread 1:
++<blockquote><pre>
++// Thread 1:
+ x.store(1, memory_order_relaxed); // SX
+ atomic_thread_fence(memory_order_seq_cst); // F1
+ y.store(1, memory_order_relaxed); // SY1
+@@ -28517,7 +23163,7 @@ If <tt>F3</tt> is <em>after</em> <tt>F2</tt>, then we can apply 29.3 [atomics.or
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For atomic operations <tt>A</tt> and <tt>B</tt> on an atomic object
+ <tt>M</tt>, where <tt>A</tt> modifies <tt>M</tt> and <tt>B</tt> takes
+ its value, if there are <tt>memory_order_seq_cst</tt> fences <tt>X</tt>
+@@ -28526,7 +23172,7 @@ and <tt>Y</tt> such that <tt>A</tt> is sequenced before <tt>X</tt>,
+ <tt>Y</tt> in <tt>S</tt>, then <tt>B</tt> observes either the effects of
+ <tt>A</tt> or a later modification of <tt>M</tt> in its modification
+ order.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ In this case, <tt>A</tt> is <tt>SX</tt>, <tt>B</tt> is <tt>RX</tt>, the
+@@ -28593,7 +23239,7 @@ disaster either.
+ In any case, we should probably add text along the lines of the
+ following between p5 and p6 in 29.3 [atomics.order]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ [Note: <tt>Memory_order_seq_cst</tt> only ensures sequential consistency for a
+ data-race-free program that uses exclusively <tt>memory_order_seq_cst</tt>
+ operations. Any use of weaker ordering will invalidate this guarantee
+@@ -28601,7 +23247,7 @@ unless extreme care is used. In particular, <tt>memory_order_seq_cst</tt> fence
+ only ensure a total order for the fences themselves. They cannot, in
+ general, be used to restore sequential consistency for atomic operations
+ with weaker ordering specifications.]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Also see thread beginning at c++std-lib-23271.
+@@ -28621,11 +23267,11 @@ has ingrained an automatic introspection on the use of "only". I
+ think you meant:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [Note: <tt>Memory_order_seq_cst</tt> ensures sequential consistency only
+ for . . . . In particular, <tt>memory_order_seq_cst</tt> fences ensure a
+ total order only for . . .
+-</blockquote>
++</p></blockquote>
+ <p>
+ Unless, of course, <tt>Memory_order_seq_cst</tt> really do nothing but ensure
+ sequential consistency for a data-race-free program that uses
+@@ -28638,10 +23284,10 @@ exclusively <tt>memory_order_seq_cst</tt> operations.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD Editorial. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -28650,7 +23296,7 @@ NAD Editorial. Solved by
+ Add a new paragraph after 29.3 [atomics.order]p5 that says
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For atomic operations <tt>A</tt> and <tt>B</tt> on an atomic object
+ <tt>M</tt>, where <tt>A</tt> and <tt>B</tt> modify <tt>M</tt>, if there
+ are <tt>memory_order_seq_cst</tt> fences <tt>X</tt> and <tt>Y</tt> such
+@@ -28658,7 +23304,7 @@ that <tt>A</tt> is sequenced before <tt>X</tt>, <tt>Y</tt> is sequenced
+ before <tt>B</tt>, and <tt>X</tt> precedes <tt>Y</tt> in <tt>S</tt>,
+ then <tt>B</tt> occurs later than <tt>A</tt> in the modifiction order of
+ <tt>M</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -28666,9 +23312,9 @@ then <tt>B</tt> occurs later than <tt>A</tt> in the modifiction order of
+
+ <hr>
+ <h3><a name="927"></a>927. <tt>Dereferenceable</tt> should be <tt>HasDereference</tt></h3>
+-<p><b>Section:</b> X [allocator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2008-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> X [allocator.concepts] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2008-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ X [allocator.concepts] contains a reference to a concept named
+@@ -28680,11 +23326,11 @@ Daniel adds 2009-02-14:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposal given in the paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2829.pdf">N2829</a>
+ would automatically resolve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><i>[
+@@ -28715,17 +23361,19 @@ Change all uses of the concept <tt>Dereferenceable</tt> to
+
+ <hr>
+ <h3><a name="928"></a>928. Wrong concepts used for <tt>tuple</tt>'s comparison operators</h3>
+-<p><b>Section:</b> 20.4.2.7 [tuple.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2008-10-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 20.4.2.7 [tuple.rel] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2008-10-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.rel">active issues</a> in [tuple.rel].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the latest working draft for C++0x, <tt>tuple</tt>'s <tt>operator==</tt> and <tt>operator&lt;</tt>
+ are declared as
+ </p>
+
+-<blockquote><pre>template&lt;class... TTypes, class... UTypes&gt;
++<blockquote><pre>
++template&lt;class... TTypes, class... UTypes&gt;
+ requires EqualityComparable&lt;TTypes, UTypes&gt;...
+ bool operator==(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
+ </pre></blockquote>
+@@ -28734,7 +23382,8 @@ are declared as
+ and
+ </p>
+
+-<blockquote><pre>template&lt;class... TTypes, class... UTypes&gt;
++<blockquote><pre>
++template&lt;class... TTypes, class... UTypes&gt;
+ requires LessThanComparable&lt;TTypes, UTypes&gt;...
+ bool operator&lt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
+ </pre></blockquote>
+@@ -28745,14 +23394,16 @@ parameter, not two. Also, even if <tt>LessThanComparable</tt> could take two
+ parameters, the definition of <tt>tuple::operator&lt;()</tt> should also require
+ </p>
+
+-<blockquote><pre>LessThanComparable&lt;UTypes, TTypes&gt;... // (note the order)
++<blockquote><pre>
++LessThanComparable&lt;UTypes, TTypes&gt;... // (note the order)
+ </pre></blockquote>
+
+ <p>
+ since the algorithm for <tt>tuple::operator&lt;</tt> is the following (pseudo-code)
+ </p>
+
+-<blockquote><pre>for (size_t N = 0; N &lt; sizeof...(TTypes); ++N) {
++<blockquote><pre>
++for (size_t N = 0; N &lt; sizeof...(TTypes); ++N) {
+ if (get&lt;N&gt;(t) &lt; get&lt;N&gt;(u) return true;
+ else if ((get&lt;N&gt;(u) &lt; get&lt;N&gt;(t)) return false;
+ }
+@@ -28769,9 +23420,9 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -28780,7 +23431,8 @@ Recommend Tentatively Ready.
+ In 20.4.1 [tuple.general] and 20.4.2.7 [tuple.rel] change:
+ </p>
+
+-<blockquote><pre>template&lt;class... TTypes, class... UTypes&gt;
++<blockquote><pre>
++template&lt;class... TTypes, class... UTypes&gt;
+ requires <del>EqualityComparable</del><ins>HasEqualTo</ins>&lt;TTypes, UTypes&gt;...
+ bool operator==(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
+
+@@ -28811,10 +23463,11 @@ template&lt;class... TTypes, class... UTypes&gt;
+
+ <hr>
+ <h3><a name="930"></a>930. Access to std::array data as built-in array type</h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-11-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -28825,7 +23478,8 @@ The Working Draft (N2798) allows access to the elements of
+ <blockquote>
+
+ <h5>23.2.1.4 array::data [array.data]</h5>
+-<pre> T *data();
++<pre>
++ T *data();
+ const T *data() const;
+ </pre>
+ <ol><li>
+@@ -28842,7 +23496,8 @@ This hampers the use of <tt>std::array</tt>, for example when trying to
+ pass its data to a C style API function:
+ </p>
+
+-<pre> // Some C style API function.
++<pre>
++ // Some C style API function.
+ void set_path( char (*)[MAX_PATH] );
+
+ std::array&lt;char,MAX_PATH&gt; path;
+@@ -28855,7 +23510,8 @@ Another example, trying to pass the array data to an instance of another
+ C++ class:
+ </p>
+
+-<pre> // Represents a 3-D point in space.
++<pre>
++ // Represents a 3-D point in space.
+ class three_d_point {
+ public:
+ explicit three_d_point(const double (&amp;)[3]);
+@@ -28907,7 +23563,8 @@ type <tt>T</tt> that has a <tt>data()</tt> member function. When
+ <tt>std::swap</tt> call may swap the container elements instead.
+ </p>
+
+-<pre> template &lt;typename T&gt;
++<pre>
++ template &lt;typename T&gt;
+ void func(T&amp; container1, T&amp; container2)
+ {
+ // Are data1 and data2 pointers or references?
+@@ -28926,7 +23583,8 @@ containers, but it no longer is for <tt>std::array</tt>, when
+ is changed to return a reference (tested on ConceptGCC Alpha 7):
+ </p>
+
+-<pre> auto concept ContiguousContainerConcept&lt;typename T&gt;
++<pre>
++ auto concept ContiguousContainerConcept&lt;typename T&gt;
+ {
+ typename value_type = typename T::value_type;
+ const value_type * T::data() const;
+@@ -28979,7 +23637,8 @@ the new member function?
+ <p>
+ Alisdair: Noodling about:
+ </p>
+-<blockquote><pre>template&lt;size_t N, ValueType T&gt;
++<blockquote><pre>
++template&lt;size_t N, ValueType T&gt;
+ struct array
+ {
+ T elems[N];
+@@ -29023,7 +23682,8 @@ Walter: Would this address the issue? Are we inclined to go this route?
+ <p>
+ Alan: What would usage look like?
+ </p>
+-<blockquote><pre>// 3-d point in space
++<blockquote><pre>
++// 3-d point in space
+ struct three_d_point
+ {
+ explicit three_d_point(const double (&amp;)[3]);
+@@ -29064,10 +23724,10 @@ The idea to resolve the issue by adding explicit conversion operators
+ was abandoned, because it would be inconvenient to use, especially when
+ passing the array to a template function, as mentioned by Daniel. So we
+ reconsidered the original proposed resolution, which appeared
+-acceptable, except for its proposed changes to 23.3.1.7 [array.zero], which
++acceptable, except for its proposed changes to 23.3.2.8 [array.zero], which
+ allowed <tt>c_array_type</tt> and <tt>c_array()</tt> to be absent for a zero-sized array.
+ Alisdair argued that such wording would disallow certain generic use
+-cases. New wording for 23.3.1.7 [array.zero] was agreed upon (Howard: and
++cases. New wording for 23.3.2.8 [array.zero] was agreed upon (Howard: and
+ is reflected in the proposed resolution).
+ </p>
+ <p>
+@@ -29106,17 +23766,17 @@ prepared to proceed without it.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark as NAD. There was not enough consensus that this was sufficiently
+ useful. There are known other ways to do this, such as small inline
+ conversion functions.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to the template definition of array, 23.3.1 [array]/3:
++Add to the template definition of array, 23.3.2 [array]/3:
+ </p>
+
+ <blockquote>
+@@ -29130,7 +23790,7 @@ const c_array_type &amp; c_array() const &amp;;
+ </blockquote>
+
+ <p>
+-Add the following subsection to 23.3.1 [array], after 23.3.1.4 [array.data]:
++Add the following subsection to 23.3.2 [array], after 23.3.2.5 [array.data]:
+ </p>
+
+ <blockquote>
+@@ -29151,7 +23811,7 @@ const c_array_type &amp; c_array() const &amp;;
+
+
+ <p>
+-Change Zero sized arrays 23.3.1.7 [array.zero]:
++Change Zero sized arrays 23.3.2.8 [array.zero]:
+ </p>
+
+ <blockquote>
+@@ -29174,323 +23834,11 @@ The type <tt>c_array_type</tt> is unspecified for a zero-sized array.
+
+
+ <hr>
+-<h3><a name="933"></a>933. Unique_ptr defect</h3>
+-<p><b>Section:</b> 20.9.9.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-11-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-If we are supporting stateful deleters, we need an overload for
+-<tt>reset</tt> that
+-takes a deleter as well.
+-</p>
+-
+-<blockquote><pre>void reset( pointer p, deleter_type d);
+-</pre></blockquote>
+-
+-<p>
+-We probably need two overloads to support move-only deleters, and
+-this
+-sounds uncomfortably like the two constructors I have been ignoring
+-for
+-now...
+-</p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-Howard comments that we have the functionality via move-assigment.
+-</p>
+-<p>
+-Move to Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD Future.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="935"></a>935. clock error handling needs to be specified</h3>
+-<p><b>Section:</b> 20.11.5 [time.clock] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-11-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Each of the three clocks specified in Clocks 20.11.5 [time.clock]
+-provides the member function:
+-</p>
+-
+-<blockquote><pre>static time_point now();
+-</pre></blockquote>
+-
+-<p>
+-The semantics specified by Clock requirements 20.11.1 [time.clock.req]
+-make no mention of error handling. Thus the function may throw <tt>bad_alloc</tt>
+-or an implementation-defined exception (17.6.4.12 [res.on.exception.handling]
+-paragraph 4).
+-</p>
+-
+-<p>
+-Some implementations of these functions on POSIX, Windows, and
+-presumably on other operating systems, may fail in ways only detectable
+-at runtime. Some failures on Windows are due to supporting chipset
+-errata and can even occur after successful calls to a clock's <tt>now()</tt>
+-function.
+-</p>
+-
+-<p>
+-These functions are used in cases where exceptions are not appropriate
+-or where the specifics of the exception or cause of error need to be
+-available to the user. See
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2828.html">N2828</a>,
+-<i>Library Support for hybrid error
+-handling (Rev 1)</i>, for more specific discussion of use cases. Thus some change in
+-the interface of now is required.
+-</p>
+-
+-<p>
+-The proposed resolution has been implemented in the Boost version of the
+-chrono library. No problems were encountered.
+-</p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-We recommend this issue be deferred until the next Committee Draft
+-has been issued and the prerequisite paper has been accepted.
+-</p>
+-<p>
+-Move to Open.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD future. Too late to make this change without having already
+-accepted the hybrid error handling proposal.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Accept the proposed wording of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2828.html">N2828</a>,
+-<i>Library Support for hybrid error handling (Rev 1)</i>.
+-</p>
+-
+-<p>
+-Change Clock requirements 20.11.1 [time.clock.req] as indicated:
+-</p>
+-
+-<blockquote>
+-<p>
+--2- In Table 55 <tt>C1</tt> and <tt>C2</tt> denote clock types. <tt>t1</tt> and
+-<tt>t2</tt> are values returned by <tt>C1::now()</tt> where the call
+-returning <tt>t1</tt> happens before (1.10) the call returning <tt>t2</tt> and
+-both of these calls happen before <tt>C1::time_point::max()</tt>.
+-<ins><tt>ec</tt> denotes an object of type <tt>error_code</tt>
+-(19.5.2.1 [syserr.errcode.overview]).</ins>
+-</p>
+-
+-<table border="1">
+-<caption>Table 55 -- Clock requirements</caption>
+-<tbody><tr>
+-<th>Expression</th><th>Return type</th><th>Operational semantics</th>
+-</tr>
+-
+-<tr>
+-<td>...</td>
+-<td>...</td>
+-<td>...</td>
+-</tr>
+-
+-<tr>
+-<td><tt>C1::now()</tt></td>
+-<td><tt>C1::time_point</tt></td>
+-<td>Returns a <tt>time_point</tt> object representing the current point in time.
+-</td>
+-</tr>
+-
+-<tr>
+-<td><tt><ins>C1::now(ec)</ins></tt></td>
+-<td><tt><ins>C1::time_point</ins></tt></td>
+-<td><ins>Returns a <tt>time_point</tt> object representing the current point in time.</ins>
+-</td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-Change Class system_clock 20.11.5.1 [time.clock.system] as indicated:
+-</p>
+-
+-<blockquote><pre>static time_point now(<ins>error_code&amp; ec=throws()</ins>);
+-</pre></blockquote>
+-
+-<p>
+-Change Class monotonic_clock X [time.clock.monotonic] as indicated:
+-</p>
+-
+-<blockquote><pre>static time_point now(<ins>error_code&amp; ec=throws()</ins>);
+-</pre></blockquote>
+-
+-<p>
+-Change Class high_resolution_clock 20.11.5.3 [time.clock.hires] as indicated:
+-</p>
+-
+-<blockquote><pre>static time_point now(<ins>error_code&amp; ec=throws()</ins>);
+-</pre></blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="936"></a>936. Mutex type overspecified</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a></p>
+-<p><b>Discussion:</b></p>
+-
+-
+-
+-<p>
+-30.4.1 [thread.mutex.requirements] describes the requirements for a type to be
+-a "Mutex type". A Mutex type can be used as the template argument for
+-the <tt>Lock</tt> type that's passed to <tt>condition_variable_any::wait</tt> (although
+-<tt>Lock</tt> seems like the wrong name here, since <tt>Lock</tt> is given a different
+-formal meaning in 30.4.2 [thread.lock]) and, although the WD doesn't quite say
+-so, as the template argument for <tt>lock_guard</tt> and <tt>unique_lock</tt>.
+-</p>
+-
+-<p>
+-The requirements for a Mutex type include:
+-</p>
+-
+-<ul>
+-<li>
+-<tt>m.lock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>void</tt>.
+-</li>
+-<li>
+-<tt>m.try_lock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>bool</tt>.
+-</li>
+-<li>
+-<tt>m.unlock()</tt> shall be well-formed and have [described] semantics, including a return type of <tt>void</tt>.
+-</li>
+-</ul>
+-
+-<p>
+-Also, a Mutex type "shall not be copyable nor movable".
+-</p>
+-
+-<p>
+-The latter requirement seems completely irrelevant, and the three
+-requirements on return types are tighter than they need to be. For
+-example, there's no reason that <tt>lock_guard</tt> can't be instantiated with a
+-type that's copyable. The rule is, in fact, that <tt>lock_guard</tt>, etc. won't
+-try to copy objects of that type. That's a constraint on locks, not on
+-mutexes. Similarly, the requirements for <tt>void</tt> return types are
+-unnecessary; the rule is, in fact, that <tt>lock_guard</tt>, etc. won't use any
+-returned value. And with the return type of <tt>bool</tt>, the requirement should
+-be that the return type is convertible to <tt>bool</tt>.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Move to open. Related to conceptualization and should probably be tackled as part of that.
+-</p>
+-<ul>
+-<li>
+-The intention is not only to place a constraint on what types such as
+-<tt>lock_guard</tt> may do with mutex types, but on what any code, including user
+-code, may do with mutex types. Thus the constraints as they are apply to
+-the mutex types themselves, not the current users of mutex types in the
+-standard.
+-</li>
+-<li>
+-This is a low priority issue; the wording as it is may be overly
+-restrictive but this may not be a real issue.
+-</li>
+-</ul>
+-</blockquote>
+-
+-<p><i>[
+-Post Summit Anthony adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Section 30.4.1 [thread.mutex.requirements] conflates the
+-requirements on a generic Mutex type (including user-supplied mutexes)
+-with the requirements placed on the standard-supplied mutex types in an
+-attempt to group everything together and save space.
+-</p>
+-<p>
+-When applying concepts to chapter 30, I suggest that the concepts
+-<tt>Lockable</tt> and <tt>TimedLockable</tt> embody the requirements for
+-*use* of a mutex type as required by
+-<tt>unique_lock/lock_guard/condition_variable_any</tt>. These should be
+-relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of
+-<tt>std::mutex</tt>, <tt>std::timed_mutex</tt>,
+-<tt>std::recursive_mutex</tt> and <tt>std::recursive_timed_mutex</tt>,
+-and should be rephrased as such.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="937"></a>937. Atomics for standard typedef types</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Clark Nelson <b>Opened:</b> 2008-12-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Clark Nelson <b>Opened:</b> 2008-12-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses US 89</b></p>
+@@ -29562,251 +23910,12 @@ with C.
+
+
+ <hr>
+-<h3><a name="940"></a>940. <tt>std::distance</tt></h3>
+-<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Thomas <b>Opened:</b> 2008-12-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 270</b></p>
+-
+-<p>
+-Regarding the <tt>std::distance</tt> - function, 24.4.4 [iterator.operations]
+-/ 4 says:
+-</p>
+-<blockquote>
+-Returns the
+-number of increments or decrements needed to get from first to last.
+-</blockquote>
+-<p>
+-This sentence is completely silent about the sign of the return value.
+-24.4.4 [iterator.operations] / 1 gives more information about the
+-underlying operations, but
+-again no inferences about the sign can be made.
+-Strictly speaking, that is taking that sentence literally, I think this
+-sentence even implies a positive return value in all cases, as the
+-number of increments or decrements is clearly a ratio scale variable,
+-with a natural zero bound.
+-</p>
+-<p>
+-Practically speaking, my implementations did what common sense and
+-knowledge based on pointer arithmetic forecasts, namely a positive sign
+-for increments (that is, going from <tt>first</tt> to <tt>last</tt> by <tt>operator++</tt>), and a
+-negative sign for decrements (going from <tt>first</tt> to <tt>last</tt> by <tt>operator--</tt>).
+-</p>
+-<p>
+-Here are my two questions:
+-</p>
+-<p>
+-First, is that paragraph supposed to be interpreted in the way what I
+-called 'common sense', that is negative sign for decrements ? I am
+-fairly sure that's the supposed behavior, but a double-check here in
+-this group can't hurt.
+-</p>
+-<p>
+-Second, is the present wording (2003 standard version - no idea about
+-the draft for the upcoming standard) worth an edit to make it a bit more
+-sensible, to mention the sign of the return value explicitly ?
+-</p>
+-
+-<p><i>[
+-Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-My first thought was that resolution <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#204">204</a> would already cover the
+-issue report, but it seems that current normative wording is in
+-contradiction to that resolution:
+-</p>
+-
+-<p>
+-Referring to
+-<a href="" ref="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>,
+-24.4.4 [iterator.operations]/ p.4 says:
+-</p>
+-
+-<blockquote>
+-<i>Effects:</i> Returns the number of increments or decrements needed to get
+-from <tt>first</tt> to <tt>last</tt>.
+-</blockquote>
+-
+-<p>
+-IMO the part " or decrements" is in contradiction to p. 5 which says
+-</p>
+-
+-<blockquote>
+-<i>Requires:</i> <tt>last</tt> shall be reachable from <tt>first</tt>.
+-</blockquote>
+-
+-<p>
+-because "reachable" is defined in X [iterator.concepts]/7 as
+-</p>
+-
+-<blockquote>
+-An iterator <tt>j</tt> is called reachable from an iterator <tt>i</tt> if and only if
+-there is a finite
+-sequence of applications of the expression <tt>++i</tt> that makes <tt>i == j</tt>.[..]
+-</blockquote>
+-
+-<p>
+-Here is wording that would be consistent with this definition of "reachable":
+-</p>
+-
+-<p>
+-Change 24.4.4 [iterator.operations] p4 as follows:
+-</p>
+-
+-<blockquote>
+-<i>Effects:</i> Returns the number of increments <del>or decrements</del>
+-needed to get from <tt>first</tt> to <tt>last</tt>.
+-</blockquote>
+-
+-</blockquote>
+-
+-<p>
+-Thomas adds more discussion and an alternative view point
+-<a href="http://groups.google.com/group/comp.std.c++/browse_thread/thread/e8e46dcda0a5d797#">here</a>.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-The proposed wording below was verbally agreed to. Howard provided.
+-</blockquote>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-Pete reports that a recent similar change has been made
+-for the <tt>advance()</tt> function.
+-</p>
+-<p>
+-We agree with the proposed resolution.
+-Move to Tentatively Ready.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved from Tentatively Ready to Open only because the wording needs to be
+-tweaked for concepts removal.
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-Leave Open pending arrival of a post-Concepts WD.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-14 Daniel provided de-conceptified wording.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to Ready, replacing the Effects clause in the proposed wording with
+-"If InputIterator meets the requirements of random access iterator then
+-returns (last - first), otherwise returns the number of increments
+-needed to get from first to list.".
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by N3066.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Change 24.2.7 [random.access.iterators], Table 105 as indicated [This change is not
+-essential but it simplifies the specification] for the row with
+-expression "<tt>b - a</tt>"
+-and the column Operational semantics:
+-</p>
+-
+-<blockquote><pre><del>(a &lt; b) ? </del>distance(a,b)
+-<del>: -distance(b,a)</del>
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 24.4.4 [iterator.operations]/4+5 as indicated:
+-</p>
+-
+-<blockquote><pre>template&lt;class InputIterator&gt;
+- typename iterator_traits&lt;InputIterator&gt;::difference_type
+- distance(InputIterator first, InputIterator last);
+-</pre>
+-<blockquote>
+-<p>
+-4 <i>Effects:</i> <ins>If <tt>InputIterator</tt> meets the requirements
+-of random access iterator then returns <tt>(last - first)</tt>,
+-otherwise</ins> <del>R</del><ins>r</ins>eturns the number of increments
+-<del>or decrements</del> needed to get from <tt>first</tt> to
+-<tt>last</tt>.
+-</p>
+-
+-<p>
+-5 <i>Requires:</i> <ins>If <tt>InputIterator</tt> meets the requirements
+-of random access iterator then <tt>last</tt> shall be reachable from
+-<tt>first</tt> or <tt>first</tt> shall be reachable from <tt>last</tt>,
+-otherwise</ins> <tt>last</tt> shall be reachable from <tt>first</tt>.
+-</p>
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="941"></a>941. Ref-qualifiers for assignment operators</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-12-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-12-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The assignment and equality operators <tt>=</tt> and <tt>==</tt> are easily confused, just
+@@ -29814,7 +23923,8 @@ because of their visual similarity, and in this case a simple typo can cause
+ a serious bug. When the left side of an <tt>operator=</tt> is an rvalue, it's
+ highly unlikely that the assignment was intended by the programmer:
+ </p>
+-<blockquote><pre>if ( func() = value ) // Typical typo: == intended!
++<blockquote><pre>
++if ( func() = value ) // Typical typo: == intended!
+ </pre></blockquote>
+ <p>
+ Built-in types don't support assignment to an rvalue, but unfortunately,
+@@ -29838,10 +23948,10 @@ assignment operators in the library.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open.
+ We recommend this be deferred until after the next Committee Draft.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Frankfurt 2009-07:
+@@ -29872,12 +23982,11 @@ A proposed resolution is provided by the paper on this subject,
+
+ <hr>
+ <h3><a name="942"></a>942. Atomics synopsis typo</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a></p>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#880">880</a></p>
+ <p><b>Discussion:</b></p>
+
+
+@@ -29895,18 +24004,20 @@ The <tt>atomic_exchange</tt> overload taking an <tt>atomic_address</tt>
+ is missing the second parameter:
+ </p>
+
+-<blockquote><pre>void* atomic_exchange(volatile atomic_address*);
++<blockquote><pre>
++void* atomic_exchange(volatile atomic_address*);
+ </pre></blockquote>
+
+ <p>
+ should be
+ </p>
+
+-<blockquote><pre>void* atomic_exchange(volatile atomic_address*<ins>, void*</ins>);
++<blockquote><pre>
++void* atomic_exchange(volatile atomic_address*<ins>, void*</ins>);
+ </pre></blockquote>
+
+ <p>
+-Note, that this is <em>not</em> covered by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a> "Missing atomic exchange parameter",
++Note, that this is <em>not</em> covered by <a href="lwg-defects.html#880">880</a> "Missing atomic exchange parameter",
+ which only talks about the <tt>atomic_bool</tt>.
+ </p>
+ </blockquote>
+@@ -29918,7 +24029,8 @@ which only talks about the <tt>atomic_bool</tt>.
+ Change the synopsis in 29 [atomics]/2:
+ </p>
+
+-<blockquote><pre>void* atomic_exchange(volatile atomic_address*<ins>, void*</ins>);
++<blockquote><pre>
++void* atomic_exchange(volatile atomic_address*<ins>, void*</ins>);
+ </pre></blockquote>
+
+
+@@ -29927,97 +24039,14 @@ Change the synopsis in 29 [atomics]/2:
+
+
+ <hr>
+-<h3><a name="944"></a>944. <tt>atomic&lt;bool&gt;</tt> derive from <tt>atomic_bool</tt>?</h3>
+-<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I think it's fairly obvious that <tt>atomic&lt;bool&gt;</tt> is supposed to be derived
+-from <tt>atomic_bool</tt> (and otherwise follow the <tt>atomic&lt;integral&gt;</tt> interface),
+-though I think the current wording doesn't support this. I raised this
+-point along with <tt>atomic&lt;floating-point&gt;</tt> privately with Herb and I seem
+-to recall it came up in the resulting discussion on this list. However,
+-I don't see anything on the current libs issue list mentioning this
+-problem.
+-</p>
+-
+-<p>
+-29.5 [atomics.types.generic]/3 reads
+-</p>
+-
+-<blockquote>
+-There are full specializations over the integral types on the atomic
+-class template. For each integral type integral in the second column of
+-table 121 or table 122, the specialization <tt>atomic&lt;integral&gt;</tt> shall be
+-publicly derived from the corresponding atomic integral type in the
+-first column of the table. These specializations shall have trivial
+-default constructors and trivial destructors.
+-</blockquote>
+-
+-<p>
+-Table 121 does not include (<tt>atomic_bool</tt>, <tt>bool</tt>),
+-so that this should probably be mentioned explicitly in the quoted paragraph.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to open. Lawrence will draft a proposed resolution. Also, ask
+-Howard to fix the title.
+-</blockquote>
+-
+-<p><i>[
+-Post Summit Anthony provided proposed wording.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Replace paragraph 3 in 29.5 [atomics.types.generic] with
+-</p>
+-
+-<blockquote>
+--3- There are full specializations over the integral types on the <tt>atomic</tt>
+-class template. For each integral type <tt>integral</tt> in the second column of
+-table 121 or table 122, the specialization <tt>atomic&lt;integral&gt;</tt> shall be
+-publicly derived from the corresponding atomic integral type in the first
+-column of the table.
+-<ins>In addition, the specialization <tt>atomic&lt;bool&gt;</tt>
+-shall be publicly derived from <tt>atomic_bool</tt>.</ins>
+-These specializations shall have trivial default
+-constructors and trivial destructors.
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="945"></a>945. <tt>system_clock::rep</tt> not specified</h3>
+-<p><b>Section:</b> 20.11.5.1 [time.clock.system] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.system">issues</a> in [time.clock.system].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.12.7.1 [time.clock.system] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.system">issues</a> in [time.clock.system].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.11.5.1 [time.clock.system], the declaration of <tt>system_clock::rep</tt> says "see
++In 20.12.7.1 [time.clock.system], the declaration of <tt>system_clock::rep</tt> says "see
+ below", but there is nothing below that describes it.
+ </p>
+
+@@ -30031,19 +24060,19 @@ Howard adds:
+ This note refers to:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <tt>system_clock::duration::min() &lt; system_clock::duration::zero()</tt> shall be <tt>true</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I.e. this is standardeze for "<tt>system_clock::rep</tt> is signed".
+ Perhaps an editorial note along the lines of:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <tt>system_clock::duration::min() &lt; system_clock::duration::zero()</tt>
+ shall be <tt>true</tt>. <ins>[<i>Note:</i> <tt>system_clock::rep</tt> shall be signed. <i>-- end note</i>].</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ ?
+@@ -30055,21 +24084,21 @@ shall be <tt>true</tt>. <ins>[<i>Note:</i> <tt>system_clock::rep</tt> shall be s
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the direction of the proposed resolution.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a note to 20.11.5.1 [time.clock.system], p2:
++Add a note to 20.12.7.1 [time.clock.system], p2:
+ </p>
+-<blockquote>
++<blockquote><p>
+ -2- <tt>system_clock::duration::min() &lt; system_clock::duration::zero()</tt>
+ shall be <tt>true</tt>. <ins>[<i>Note:</i> <tt>system_clock::rep</tt> shall be signed. <i>-- end note</i>].</ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -30077,28 +24106,28 @@ shall be <tt>true</tt>. <ins>[<i>Note:</i> <tt>system_clock::rep</tt> shall be s
+
+ <hr>
+ <h3><a name="946"></a>946. <tt>duration_cast</tt> improperly specified</h3>
+-<p><b>Section:</b> 20.11.3.7 [time.duration.cast] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.cast">issues</a> in [time.duration.cast].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.12.5.7 [time.duration.cast] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.cast">issues</a> in [time.duration.cast].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-20.11.3.7 [time.duration.cast]/3:
+-
+-<blockquote>
++<p>
++20.12.5.7 [time.duration.cast]/3:
++</p>
++<blockquote><p>
+ .... All intermediate computations shall be
+ carried out in the widest possible representation... .
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-So ignoring
+-floating-point types for the moment, all this arithmetic has to be done
++So ignoring floating-point types for the moment, all this arithmetic has to be done
+ using the implementation's largest integral type, even if both arguments
+-use int for their representation. This seems excessive. And it's not at
++use <tt>int</tt> for their representation. This seems excessive. And it's not at
+ all clear what this means if we don't ignore floating-point types.
+ </p>
+
+ <p>
+-This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>.
++This issue is related to <a href="lwg-closed.html#952">952</a>.
+ </p>
+
+ <p><i>[
+@@ -30112,7 +24141,8 @@ The intent of this remark is that intermediate computations are carried out
+ using:
+ </p>
+
+-<blockquote><pre>common_type&lt;typename ToDuration::rep, Rep, intmax_t&gt;::type
++<blockquote><pre>
++common_type&lt;typename ToDuration::rep, Rep, intmax_t&gt;::type
+ </pre></blockquote>
+
+ <p>
+@@ -30128,7 +24158,7 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-We view this as a specific case of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>,
++We view this as a specific case of issue <a href="lwg-closed.html#952">952</a>,
+ and should be resolved when that issue is resolved.
+ </p>
+ <p>
+@@ -30148,19 +24178,19 @@ Move to NAD.
+
+ <hr>
+ <h3><a name="952"></a>952. Various threading bugs #2</h3>
+-<p><b>Section:</b> 20.11.3.7 [time.duration.cast] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.cast">issues</a> in [time.duration.cast].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 20.12.5.7 [time.duration.cast] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.cast">issues</a> in [time.duration.cast].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.11.3.7 [time.duration.cast] specifies an implementation and imposes
++20.12.5.7 [time.duration.cast] specifies an implementation and imposes
+ requirements in text (and the implementation doesn't satisfy all of the
+ text requirements). Pick one.
+ </p>
+
+ <p>
+-This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>.
++This issue is related to <a href="lwg-closed.html#946">946</a>.
+ </p>
+
+ <p><i>[
+@@ -30202,13 +24232,13 @@ Move to NAD Editorial.
+
+ <hr>
+ <h3><a name="955"></a>955. Various threading bugs #5</h3>
+-<p><b>Section:</b> 20.11.1 [time.clock.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 20.12.3 [time.clock.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.11.1 [time.clock.req] requires that a clock type have a member
++20.12.3 [time.clock.req] requires that a clock type have a member
+ typedef named <tt>time_point</tt> that names an instantiation of the
+ template <tt>time_point</tt>, and a member named <tt>duration</tt> that
+ names an instantiation of the template <tt>duration</tt>. This mixing of
+@@ -30245,7 +24275,8 @@ For example, here is code that I once wrote in testing out the usability of
+ this facility:
+ </p>
+
+-<blockquote><pre>template &lt;class Clock, class Duration&gt;
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
+ void do_until(const std::chrono::<b>time_point</b>&lt;Clock, Duration&gt;&amp; t)
+ {
+ typename Clock::<b>time_point now</b> = Clock::now();
+@@ -30272,16 +24303,17 @@ I see no rationale to require the client to append <tt>_type</tt> to <em>some</e
+ of those declarations. It seems overly burdensome on the author of <tt>do_until</tt>:
+ </p>
+
+-<blockquote><pre>template &lt;class Clock, class Duration&gt;
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
+ void do_until(const std::chrono::<b>time_point</b>&lt;Clock, Duration&gt;&amp; t)
+ {
+- typename Clock::<b>time_point<font color="#C80000">_type</font></b> now = Clock::now();
++ typename Clock::<b>time_point<span style="color:#C80000">_type</span></b> now = Clock::now();
+ if (t &gt; now)
+ {
+ typedef typename std::common_type
+ &lt;
+ Duration,
+- typename std::chrono::system_clock::<b>duration<font color="#C80000">_type</font></b>
++ typename std::chrono::system_clock::<b>duration<span style="color:#C80000">_type</span></b>
+ &gt;::type CD;
+ typedef std::chrono::<b>duration</b>&lt;double, std::nano&gt; ID;
+
+@@ -30299,9 +24331,9 @@ Additionally I'm fairly certain that this suggestion hasn't been implemented.
+ If it had, it would have been discovered that it is incomplete. <tt>time_point</tt>
+ also has a nested type (purposefully) named <tt>duration</tt>.
+ </p>
+-<blockquote>
++<blockquote><p>
+ That is, the current proposed wording would put the WP into an inconsistent state.
+-</blockquote>
++</p></blockquote>
+ <p>
+ In contrast,
+ the current WP has been implemented and I've received very favorable feedback
+@@ -30343,7 +24375,8 @@ with the precedent of using the same name for the nested type as an external
+ class representing an identical concept.
+ </p>
+
+-<blockquote><pre>template&lt;class Category, class T, class Distance = ptrdiff_t,
++<blockquote><pre>
++template&lt;class Category, class T, class Distance = ptrdiff_t,
+ class Pointer = T*, class Reference = T&amp;&gt;
+ struct <b>iterator</b>
+ {
+@@ -30378,7 +24411,8 @@ names also having related meaning at namespace std scope.
+ Would we really be doing programmers a favor by renaming these nested types?
+ </p>
+
+-<blockquote><pre>template &lt;ValueType T, Allocator Alloc = allocator&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;ValueType T, Allocator Alloc = allocator&lt;T&gt; &gt;
+ requires NothrowDestructible&lt;T&gt;
+ class list
+ {
+@@ -30401,30 +24435,31 @@ reducing readability.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark as NAD. No concensus for changing the WP.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.11 [time]:
++Change 20.12 [time]:
+ </p>
+
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ template &lt;class Clock, class Duration = typename Clock::duration<ins>_type</ins>&gt; class time_point;
+ ...
+ </pre></blockquote>
+
+ <p>
+-Change 20.11.1 [time.clock.req]:
++Change 20.12.3 [time.clock.req]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+ <caption>Table 45 -- Clock requirements</caption>
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+@@ -30462,11 +24497,11 @@ representing the current point
+ in time.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Change 20.11.5.1 [time.clock.system]:
++Change 20.12.7.1 [time.clock.system]:
+ </p>
+
+ <blockquote>
+@@ -30474,7 +24509,8 @@ Change 20.11.5.1 [time.clock.system]:
+ -1- Objects of class <tt>system_clock</tt> represent wall clock time from the system-wide realtime clock.
+ </p>
+
+-<blockquote><pre>class system_clock {
++<blockquote><pre>
++class system_clock {
+ public:
+ typedef <i>see below</i> rep;
+ typedef ratio&lt;<i>unspecified</i>, <i>unspecified</i>&gt; period;
+@@ -30494,30 +24530,33 @@ public:
+ -2- <tt>system_clock::duration<ins>_type</ins>::min() &lt; system_clock::duration<ins>_type</ins>::zero()</tt> shall be <tt>true</tt>.
+ </p>
+
+-<pre>time_t to_time_t(const time_point<ins>_type</ins>&amp; t);
++<pre>
++time_t to_time_t(const time_point<ins>_type</ins>&amp; t);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ -3- <i>Returns:</i> A <tt>time_t</tt> object that represents the same
+ point in time as <tt>t</tt> when both values are truncated to the
+ coarser of the precisions of <tt>time_t</tt> and <tt>time_point<ins>_type</ins></tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre><tt>time_point<ins>_type</ins></tt> from_time_t(time_t t);
++<pre>
++<tt>time_point<ins>_type</ins></tt> from_time_t(time_t t);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ -4- <i>Returns:</i> A <tt>time_point<ins>_type</ins></tt> object that represents the same point
+ in time as <tt>t</tt> when both values are truncated to the coarser of the
+ precisions of <tt>time_t</tt> and <tt>time_point<ins>_type</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change X [time.clock.monotonic]:
+ </p>
+
+-<blockquote><pre>class monotonic_clock {
++<blockquote><pre>
++class monotonic_clock {
+ public:
+ typedef <i>unspecified</i> rep;
+ typedef ratio&lt;<i>unspecified</i> , <i>unspecified</i>&gt; period;
+@@ -30530,10 +24569,11 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Change 20.11.5.3 [time.clock.hires]:
++Change 20.12.7.3 [time.clock.hires]:
+ </p>
+
+-<blockquote><pre>class high_resolution_clock {
++<blockquote><pre>
++class high_resolution_clock {
+ public:
+ typedef <i>unspecified</i> rep;
+ typedef ratio&lt;<i>unspecified</i> , <i>unspecified</i>&gt; period;
+@@ -30551,67 +24591,11 @@ public:
+
+
+ <hr>
+-<h3><a name="958"></a>958. Various threading bugs #8</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-30.5.1 [thread.condition.condvar]: the specification for <tt>wait_for</tt>
+-with no predicate has an effects clause that says it calls <tt>wait_until</tt>,
+-and a returns clause that sets out in words how to determine the return
+-value. Is this description of the return value subtly different from the
+-description of the value returned by <tt>wait_until</tt>? Or should the effects
+-clause and the returns clause be merged?
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to open. Associate with LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> and any other monotonic-clock
+-related issues.
+-</blockquote>
+-
+-<p><i>[
+-2009-08-01 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-I believe that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> (currently Ready) addresses this issue, and
+-that this issue should be marked NAD, solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> (assuming
+-it moves to WP).
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD Editorial, solved by resolution of Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="959"></a>959. Various threading bugs #9</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.5.1 [thread.condition.condvar]: <tt>condition_variable::wait_for</tt>
+@@ -30625,30 +24609,30 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to open. Associate with LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> and any other monotonic-clock
++<blockquote><p>
++Move to open. Associate with LWG <a href="lwg-defects.html#859">859</a> and any other monotonic-clock
+ related issues.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-01 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-I believe that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> (currently Ready) addresses this issue, and
+-that this issue should be marked NAD, solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> (assuming
++<blockquote><p>
++I believe that <a href="lwg-defects.html#859">859</a> (currently Ready) addresses this issue, and
++that this issue should be marked NAD, solved by <a href="lwg-defects.html#859">859</a> (assuming
+ it moves to WP).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave open, but expect to be fixed by N2969 revision that Detlef is writing.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-18 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+@@ -30674,64 +24658,14 @@ Rationale added below.
+
+
+ <hr>
+-<h3><a name="961"></a>961. Various threading bugs #11</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a></p>
+-<p><b>Discussion:</b></p>
+-<p>
+-30.4.1 [thread.mutex.requirements] describes required member
+-functions of mutex types, and requires that they throw exceptions under
+-certain circumstances. This is overspecified. User-defined types can
+-abort on such errors without affecting the operation of templates
+-supplied by standard-library.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-<blockquote>
+-Move to open. Related to conceptualization and should probably be
+-tackled as part of that.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Would be OK to leave it as is for time constraints, could loosen later.
+-</p>
+-
+-<p>
+-Mark as NAD Future.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+ <h3><a name="969"></a>969. What happened to Library Issue 475?</h3>
+-<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-01-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-01-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Library Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a> has CD1 status, but the non-normative note in
++Library Issue <a href="lwg-defects.html#475">475</a> has CD1 status, but the non-normative note in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+ was removed in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>
+@@ -30742,9 +24676,9 @@ was removed in
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -30758,9 +24692,9 @@ Restore the non-normative note. It might need to be expressed in terms of concep
+
+ <hr>
+ <h3><a name="971"></a>971. Spurious diagnostic conversion function</h3>
+-<p><b>Section:</b> 19.5.2.5 [syserr.errcode.nonmembers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-01-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 19.5.2.5 [syserr.errcode.nonmembers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-01-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Anthony Williams raised the question in c++std-lib-22987 "why is there
+@@ -30779,31 +24713,31 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The designer of the facility (Christopher Kohlhoff)
+ strongly disagrees that there is an issue here,
+ and especially disagrees with the proposed resolution.
+ Bill would prefer to be conservative and not apply this proposed resolution.
+ Move to Open, and recommend strong consideration for NAD status.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-21 Beman adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ My mistake. Christopher and Bill are correct and the issue should be
+ NAD. The function is needed by users.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-21 Christopher Kohlhoff adds rationale for <tt>make_error_code</tt>:
+@@ -30816,7 +24750,8 @@ Users (and indeed library implementers) may need to use the
+ <tt>errc</tt> codes in portable code. For example:
+ </p>
+
+-<blockquote><pre>void do_foo(error_code&amp; ec)
++<blockquote><pre>
++void do_foo(error_code&amp; ec)
+ {
+ #if defined(_WIN32)
+ // Windows implementation ...
+@@ -30835,9 +24770,9 @@ Users (and indeed library implementers) may need to use the
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -30847,7 +24782,8 @@ Change System error support 19.5 [syserr], Header <tt>&lt;system_error&gt;</tt>
+ synopsis, as indicated:
+ </p>
+
+-<blockquote><pre><del>error_code make_error_code(errc e);</del>
++<blockquote><pre>
++<del>error_code make_error_code(errc e);</del>
+ error_condition make_error_condition(errc e);
+ </pre></blockquote>
+
+@@ -30856,12 +24792,13 @@ Delete from Class error_code non-member functions
+ 19.5.2.5 [syserr.errcode.nonmembers]:
+ </p>
+
+-<blockquote><pre><del>error_code make_error_code(errc e);</del>
++<blockquote><pre>
++<del>error_code make_error_code(errc e);</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Returns:</i> <tt>error_code(static_cast&lt;int&gt;(e),
+ generic_category)</tt>.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -30871,11 +24808,11 @@ generic_category)</tt>.</del>
+
+ <hr>
+ <h3><a name="972"></a>972. The term "Assignable" undefined but still in use</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Previous versions of the Draft had a table, defining the Assignable
+@@ -30898,9 +24835,9 @@ Are all of those instances of "<tt>Assignable</tt>" to be replaced by "<tt>CopyA
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -30908,53 +24845,56 @@ Move to NAD Editorial.
+ <p>
+ Change Exception Propagation 18.8.5 [propagation]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>exception_ptr</tt> shall be <tt>DefaultConstructible</tt>, <tt>CopyConstructible</tt>,
+ <tt><ins>Copy</ins>Assignable</tt> and <tt>EqualityComparable</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change Class template reference_wrapper 20.8.4 [refwrap]:
++Change Class template reference_wrapper 20.9.4 [refwrap]:
+ </p>
+-<blockquote>
+-<tt>reference_wrapper&lt;T&gt;</tt> is a <tt>CopyConstructible</tt> and <tt><ins>Copy</ins>Assignable</tt> wrapper around a reference to an object of type <tt>T</tt>.
+-</blockquote>
++<blockquote><p>
++<tt>reference_wrapper&lt;T&gt;</tt> is a <tt>CopyConstructible</tt> and <tt><ins>Copy</ins>Assignable</tt>
++wrapper around a reference to an object of type <tt>T</tt>.
++</p></blockquote>
+ <p>
+-Change Placeholders 20.8.10.1.3 [func.bind.place]:
++Change Placeholders 20.9.10.4 [func.bind.place]:
+ </p>
+-<blockquote>
+-It is implementation defined whether placeholder types are <tt><ins>Copy</ins>Assignable</tt>. <tt><ins>Copy</ins>Assignable</tt> placeholders' copy assignment operators shall not throw exceptions.
+-</blockquote>
++<blockquote><p>
++It is implementation defined whether placeholder types are <tt><ins>Copy</ins>Assignable</tt>.
++<tt><ins>Copy</ins>Assignable</tt> placeholders' copy assignment operators shall not throw exceptions.
++</p></blockquote>
+ <p>
+-Change Class template shared_ptr 20.9.10.2 [util.smartptr.shared]:
++Change Class template shared_ptr 20.8.2.2 [util.smartptr.shared]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Specializations of <tt>shared_ptr</tt> shall be <tt>CopyConstructible</tt>, <tt><ins>Copy</ins>Assignable</tt>, and <tt>LessThanComparable</tt>...
+-</blockquote>
++</p></blockquote>
+ <p>
+-Change Class template weak_ptr 20.9.10.3 [util.smartptr.weak]:
++Change Class template weak_ptr 20.8.2.3 [util.smartptr.weak]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Specializations of <tt>weak_ptr</tt> shall be <tt>CopyConstructible</tt>, <tt><ins>Copy</ins>Assignable</tt>, and <tt>LessThanComparable</tt>...
+-</blockquote>
++</p></blockquote>
+ <p>
+ Change traits typedefs 21.2.2 [char.traits.typedefs] (note: including deletion of reference to 23.1!):
+ </p>
+-<blockquote>
+-<i>Requires:</i> <tt>state_type</tt> shall meet the requirements of <tt><ins>Copy</ins>Assignable</tt><del> (23.1)</del>, <tt>CopyConstructible</tt> (20.1.8), and <tt>DefaultConstructible</tt> types.
+-</blockquote>
++<blockquote><p>
++<i>Requires:</i> <tt>state_type</tt> shall meet the requirements of <tt><ins>Copy</ins>Assignable</tt><del>
++(23.1)</del>, <tt>CopyConstructible</tt> (20.1.8), and <tt>DefaultConstructible</tt> types.
++</p></blockquote>
+ <p>
+ Change Class seed_seq 26.5.7.1 [rand.util.seedseq] (note again: including deletion of reference to 23.1!):
+ </p>
+-<blockquote>
++<blockquote><p>
+ In addition to the requirements set forth below, instances of
+ <tt>seed_seq</tt> shall meet the requirements of <tt>CopyConstructible</tt> (20.1.8) and of <tt><ins>Copy</ins>Assignable</tt><del> (23.1)</del>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Note: The proposed resolution of this issue does not deal with the
+-instance of the term "Assignable" in D.12.1 [auto.ptr], as this is dealt
+-with more specifically by LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, "<tt>auto_ptr</tt> characteristics", submitted
++instance of the term "Assignable" in X [auto.ptr], as this is dealt
++with more specifically by LWG <a href="lwg-closed.html#973">973</a>, "<tt>auto_ptr</tt> characteristics", submitted
+ by Maarten Hilferink.
+ </p>
+
+@@ -30965,13 +24905,13 @@ by Maarten Hilferink.
+
+ <hr>
+ <h3><a name="973"></a>973. auto_ptr characteristics</h3>
+-<p><b>Section:</b> D.12.1 [auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Maarten Hilferink <b>Opened:</b> 2009-01-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> X [auto.ptr] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Maarten Hilferink <b>Opened:</b> 2009-01-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-I think that the Note of D.12.1 [auto.ptr], paragraph 3 needs a rewrite
++I think that the Note of X [auto.ptr], paragraph 3 needs a rewrite
+ since "Assignable" is no longer defined as a concept.
+ The relationship of <tt>auto_ptr</tt> with the new <tt>CopyAssignable</tt>, <tt>MoveAssignable</tt>,
+ and <tt>MoveConstructible</tt> concepts should be clarified.
+@@ -30983,18 +24923,18 @@ Furthermore, since the use of <tt>auto_ptr</tt> is depreciated anyway,
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the intent of the proposed resolution.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change D.12.1 [auto.ptr], paragraph 3:
++Change X [auto.ptr], paragraph 3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>auto_ptr</tt> provides a semantics of strict ownership. An
+ <tt>auto_ptr</tt> owns the ob ject it holds a pointer to. Copying an
+ <tt>auto_ptr</tt> copies the pointer and transfers ownership to the
+@@ -31009,104 +24949,13 @@ allocated memory from a function.
+ standard library container elements and thus instantiating a standard
+ library container with an <tt>auto_ptr</tt> results in undefined
+ behavior.</del>
+-
++<p/>
+ <ins>Instances of <tt>auto_ptr</tt> shall
+ meet the <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>
+ requirements, but do not meet the <tt>CopyConstructible</tt> and
+ <tt>CopyAssignable</tt> requirements.</ins>
+ -- <i>end note</i>]
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="976"></a>976. Class template std::stack should be movable</h3>
+-<p><b>Section:</b> 23.5.3.1 [stack.defn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-02-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The synopsis given in 23.5.3.1 [stack.defn] does not show up
+-</p>
+-
+-<blockquote><pre>requires MoveConstructible&lt;Cont&gt; stack(stack&amp;&amp;);
+-requires MoveAssignable&lt;Cont&gt; stack&amp; operator=(stack&amp;&amp;);
+-</pre></blockquote>
+-
+-<p>
+-although the other container adaptors do provide corresponding
+-members.
+-</p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-We agree with the proposed resolution.
+-</p>
+-<p>
+-Move to Tentatively Ready.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved from Tentatively Ready to Open only because the wording needs to be
+-tweaked for concepts removal.
+-</blockquote>
+-
+-<p><i>[
+-2009-08-18 Daniel updates the wording and Howard sets to Review.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-08-23 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a> also adds these move members using an editorially different
+-style.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark NAD Editorial, solved by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In the class stack synopsis of 23.5.3.1 [stack.defn] insert:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
+-class stack {
+- [..]
+- explicit stack(const Container&amp;);
+- explicit stack(Container&amp;&amp; = Container());
+- <ins>stack(stack&amp;&amp; s) : c(std::move(s.c)) {}</ins>
+- <ins>stack&amp; operator=(stack&amp;&amp; s) { c = std::move(s.c); return *this; }</ins>
+- [..]
+-};
+-</pre></blockquote>
+-
+-
+-
++</p></blockquote>
+
+
+
+@@ -31114,23 +24963,24 @@ class stack {
+
+ <hr>
+ <h3><a name="977"></a>977. insert iterators inefficient for expensive to move types</h3>
+-<p><b>Section:</b> 24.5.2 [insert.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.5.2 [insert.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The new concepts for the insert iterators mandate an extra copy when
+ inserting an lvalue:
+ </p>
+
+-<blockquote><pre>requires CopyConstructible&lt;Cont::value_type&gt;
++<blockquote><pre>
++requires CopyConstructible&lt;Cont::value_type&gt;
+ back_insert_iterator&lt;Cont&gt;&amp;
+ operator=(const Cont::value_type&amp; value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <tt>push_back(*container, <b>Cont::value_type(</b>value<b>)</b>);</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -31139,7 +24989,8 @@ The reason is to convert <tt>value</tt> into an rvalue because the current
+ rvalues:
+ </p>
+
+-<blockquote><pre>concept BackInsertionContainer&lt;typename C&gt; : Container&lt;C&gt; {
++<blockquote><pre>
++concept BackInsertionContainer&lt;typename C&gt; : Container&lt;C&gt; {
+ void push_back(C&amp;, value_type&amp;&amp;);
+ }
+ </pre></blockquote>
+@@ -31155,7 +25006,8 @@ the client can pass in the parameter type for <tt>push_back</tt> similar to
+ what is already done for the <tt>OutputIterator</tt> concept:
+ </p>
+
+-<blockquote><pre>concept BackInsertionContainer&lt;typename C, typename Value = C::value_type&amp;&amp;&gt;
++<blockquote><pre>
++concept BackInsertionContainer&lt;typename C, typename Value = C::value_type&amp;&amp;&gt;
+ : Container&lt;C&gt; {
+ void push_back(C&amp;, Value);
+ }
+@@ -31165,14 +25017,15 @@ what is already done for the <tt>OutputIterator</tt> concept:
+ This allows the assignment operator to be adjusted appropriately:
+ </p>
+
+-<blockquote><pre>requires BackInsertionContainer&lt;Cont, Cont::value_type const&amp;&gt; &amp;&amp;
++<blockquote><pre>
++requires BackInsertionContainer&lt;Cont, Cont::value_type const&amp;&gt; &amp;&amp;
+ CopyConstructible&lt;Cont::value_type&gt;
+ back_insert_iterator&lt;Cont&gt;&amp;
+ operator=(const Cont::value_type&amp; value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <tt>push_back(*container, value);</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -31207,9 +25060,9 @@ Committee Draft is issued.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD, solved by the removal of concepts.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31219,7 +25072,8 @@ Change [container.concepts.free]:
+ </p>
+
+ <blockquote>
+-<pre>concept FrontInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++concept FrontInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : Container&lt;C&gt; {
+ void push_front(C&amp;, <del>value_type&amp;&amp;</del> <ins>Value</ins>);
+
+@@ -31231,7 +25085,8 @@ Change [container.concepts.free]:
+
+ <p>...</p>
+
+-<pre>concept BackInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++concept BackInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : Container&lt;C&gt; {
+ void push_back(C&amp;, <del>value_type&amp;&amp;</del> <ins>Value</ins>);
+ }
+@@ -31239,7 +25094,8 @@ Change [container.concepts.free]:
+
+ <p>...</p>
+
+-<pre>concept InsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++concept InsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : Container&lt;C&gt; {
+ iterator insert(C&amp;, const_iterator, <del>value_type&amp;&amp;</del> <ins>Value</ins>);
+
+@@ -31256,7 +25112,8 @@ Change [container.concepts.member]:
+ </p>
+
+ <blockquote>
+-<pre>auto concept MemberFrontInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++auto concept MemberFrontInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : MemberContainer&lt;C&gt; {
+ void C::push_front(<del>value_type&amp;&amp;</del> <ins>Value</ins>);
+
+@@ -31268,7 +25125,8 @@ Change [container.concepts.member]:
+
+ <p>...</p>
+
+-<pre>auto concept MemberBackInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++auto concept MemberBackInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : MemberContainer&lt;C&gt; {
+ void C::push_back(<del>value_type&amp;&amp;</del> <ins>Value</ins>);
+ }
+@@ -31276,7 +25134,8 @@ Change [container.concepts.member]:
+
+ <p>...</p>
+
+-<pre>auto concept MemberInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++auto concept MemberInsertionContainer&lt;typename C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ : MemberContainer&lt;C&gt; {
+ iterator C::insert(const_iterator, <del>value_type&amp;&amp;</del> <ins>Value</ins>);
+
+@@ -31292,7 +25151,8 @@ Change [container.concepts.maps]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;MemberFrontInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++template &lt;MemberFrontInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ concept_map FrontInsertionContainer&lt;C<ins>, Value</ins>&gt; {
+ typedef Container&lt;C&gt;::value_type value_type;
+
+@@ -31302,7 +25162,8 @@ concept_map FrontInsertionContainer&lt;C<ins>, Value</ins>&gt; {
+
+ <p>...</p>
+
+-<pre>template &lt;MemberBackInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++template &lt;MemberBackInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ concept_map BackInsertionContainer&lt;C<ins>, Value</ins>&gt; {
+ typedef Container&lt;C&gt;::value_type value_type;
+
+@@ -31312,7 +25173,8 @@ concept_map BackInsertionContainer&lt;C<ins>, Value</ins>&gt; {
+
+ <p>...</p>
+
+-<pre>template &lt;MemberInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
++<pre>
++template &lt;MemberInsertionContainer C<ins>, typename Value = C::value_type&amp;&amp;</ins>&gt;
+ concept_map InsertionContainer&lt;C<ins>, Value</ins>&gt; {
+ typedef Container&lt;C&gt;::value_type value_type;
+ Container&lt;C&gt;::iterator insert(C&amp; c, Container&lt;C&gt;::const_iterator i, <del>value_type&amp;&amp;</del> <ins>Value</ins> v)
+@@ -31326,7 +25188,8 @@ concept_map InsertionContainer&lt;C<ins>, Value</ins>&gt; {
+ Change 24.5.2.1 [back.insert.iterator]:
+ </p>
+
+-<blockquote><pre>template &lt;BackInsertionContainer Cont&gt;
++<blockquote><pre>
++template &lt;BackInsertionContainer Cont&gt;
+ class back_insert_iterator {
+ ...
+ requires <ins>BackInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+@@ -31341,21 +25204,23 @@ Change 24.5.2.2.2 [back.insert.iter.op=]:
+ </p>
+
+ <blockquote>
+-<pre>requires <ins>BackInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
++<pre>
++requires <ins>BackInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+ <del>CopyConstructible&lt;Cont::value_type&gt;</del>
+ back_insert_iterator&lt;Cont&gt;&amp;
+ operator=(const Cont::value_type&amp; value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <tt>push_back(*container, <del>Cont::value_type(</del>value<del>)</del>);</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 24.5.2.3 [front.insert.iterator]:
+ </p>
+
+-<blockquote><pre>template &lt;FrontInsertionContainer Cont&gt;
++<blockquote><pre>
++template &lt;FrontInsertionContainer Cont&gt;
+ class front_insert_iterator {
+ ...
+ requires <ins>FrontInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+@@ -31370,21 +25235,23 @@ Change 24.5.2.4.2 [front.insert.iter.op=]:
+ </p>
+
+ <blockquote>
+-<pre>requires <ins>FrontInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
++<pre>
++requires <ins>FrontInsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+ <del>CopyConstructible&lt;Cont::value_type&gt;</del>
+ front_insert_iterator&lt;Cont&gt;&amp;
+ operator=(const Cont::value_type&amp; value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <tt>push_front(*container, <del>Cont::value_type(</del>value<del>)</del>);</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 24.5.2.5 [insert.iterator]:
+ </p>
+
+-<blockquote><pre>template &lt;InsertionContainer Cont&gt;
++<blockquote><pre>
++template &lt;InsertionContainer Cont&gt;
+ class insert_iterator {
+ ...
+ requires <ins>InsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+@@ -31399,7 +25266,8 @@ Change 24.5.2.6.2 [insert.iter.op=]:
+ </p>
+
+ <blockquote>
+-<pre>requires <ins>InsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
++<pre>
++requires <ins>InsertionContainer&lt;Cont, const Cont::value_type&amp;&gt;</ins>
+ <del>CopyConstructible&lt;Cont::value_type&gt;</del>
+ insert_iterator&lt;Cont&gt;&amp;
+ operator=(const Cont::value_type&amp; value);
+@@ -31408,7 +25276,8 @@ Change 24.5.2.6.2 [insert.iter.op=]:
+ <p>
+ -1- <i>Effects:</i>
+ </p>
+-<blockquote><pre>iter = insert(*container, iter, <del>Cont::value_type(</del>value<del>)</del>);
++<blockquote><pre>
++iter = insert(*container, iter, <del>Cont::value_type(</del>value<del>)</del>);
+ ++iter;
+ </pre></blockquote>
+ </blockquote>
+@@ -31421,9 +25290,10 @@ Change 24.5.2.6.2 [insert.iter.op=]:
+
+ <hr>
+ <h3><a name="979"></a>979. Bad example</h3>
+-<p><b>Section:</b> 24.5.3 [move.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Section:</b> 24.5.3 [move.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#move.iterators">issues</a> in [move.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 24.5.3 [move.iterators] has an incorrect example:
+@@ -31434,7 +25304,8 @@ Change 24.5.2.6.2 [insert.iter.op=]:
+ -2- [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>set&lt;string&gt; s;
++<blockquote><pre>
++set&lt;string&gt; s;
+ // populate the set s
+ vector&lt;string&gt; v1(s.begin(), s.end()); // copies strings into v1
+ vector&lt;string&gt; v2(make_move_iterator(s.begin()),
+@@ -31455,9 +25326,9 @@ references.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution. Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31471,7 +25342,8 @@ Change 24.5.3 [move.iterators]/2:
+ -2- [<i>Example:</i>
+ </p>
+
+-<blockquote><pre><del>set</del><ins>list</ins>&lt;string&gt; s;
++<blockquote><pre>
++<del>set</del><ins>list</ins>&lt;string&gt; s;
+ // populate the <del>set</del><ins>list</ins> s
+ vector&lt;string&gt; v1(s.begin(), s.end()); // copies strings into v1
+ vector&lt;string&gt; v2(make_move_iterator(s.begin()),
+@@ -31489,10 +25361,11 @@ vector&lt;string&gt; v2(make_move_iterator(s.begin()),
+
+ <hr>
+ <h3><a name="980"></a>980. <tt>mutex lock()</tt> missing error conditions</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Ion Gaztañaga <b>Opened:</b> 2009-02-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Ion Gazta&ntilde;aga <b>Opened:</b> 2009-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ POSIX 2008 adds two return values for <tt>pthread_mutex_xxxlock()</tt>:
+@@ -31511,7 +25384,8 @@ being destroyed.
+ Consider:
+ </p>
+
+-<blockquote><pre>//Suppose mutex.lock() throws "owner_dead"
++<blockquote><pre>
++//Suppose mutex.lock() throws "owner_dead"
+ unique_lock ul(&amp;mutex);
+ //mutex left locked if "owner_dead" is thrown
+ </pre></blockquote>
+@@ -31537,10 +25411,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Not a defect. Handling these error conditions is an implementation
+ detail and must be handled below the C++ interface.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31579,10 +25453,10 @@ to detect it.
+
+ <hr>
+ <h3><a name="988"></a>988. <tt>Reflexivity</tt> meaningless?</h3>
+-<p><b>Section:</b> X [concept.comparison] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#concept.comparison">issues</a> in [concept.comparison].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> X [concept.comparison] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#concept.comparison">issues</a> in [concept.comparison].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ X [concept.comparison] p2:
+@@ -31593,15 +25467,16 @@ not do anything as written. It merely states that a value is substitutable
+ with itself, rather than asserting a property of the <tt>==</tt> operator.
+ </p>
+
+-<b>
++<p><b>
+ Original proposed resolution:
+-</b>
++</b></p>
+
+ <p>
+ Change the definition of <tt>Reflexivity</tt> in X [concept.comparison]:
+ </p>
+
+-<blockquote><pre>axiom Reflexivity(T a) { <ins>(</ins>a == a<ins>) == true</ins>; }
++<blockquote><pre>
++axiom Reflexivity(T a) { <ins>(</ins>a == a<ins>) == true</ins>; }
+ </pre></blockquote>
+
+ <p><i>[
+@@ -31631,11 +25506,11 @@ NAD.
+
+ <hr>
+ <h3><a name="989"></a>989. late_check and library</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The example in 6.9p2 shows how late_check blocks inhibit concept_map lookup
+@@ -31652,22 +25527,23 @@ Doug adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We need something like this, but it should be a more general statement
+ about implementations respecting the concept maps provided by the
+ user. Use of late_check is one way in which implementations can
+ subvert the concept maps provided by the user, but there are other
+ ways as well ("pattern-based" overloading, tricks with "auto" concept
+ maps and defaulted associated type arguments).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++
++<blockquote><p>
+ Move to Open, pending proposed wording from Alisdair and/or Doug for further review.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -31677,13 +25553,13 @@ Move to Open, pending proposed wording from Alisdair and/or Doug for further rev
+
+
+ <hr>
+-<h3><a name="992"></a>992. Response to UK 169</h3>
+-<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#contents">issues</a> in [contents].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="992"></a>992. Allow implementations to implement C library in the global namespace</h3>
++<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#contents">issues</a> in [contents].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 169</b></p>
++<p><b>Addresses UK-169 [CD1]</b></p>
+ <p>
+ This phrasing contradicts later freedom to implement the C standard
+ library portions in the global namespace as well as std. (17.6.2.3p4)
+@@ -31693,10 +25569,10 @@ library portions in the global namespace as well as std. (17.6.2.3p4)
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The proposed wording seems to go too far.
+ Move back to Open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -31740,7 +25616,7 @@ nested within namespace <tt>std</tt><ins><sup>*</sup></ins>.
+ </p>
+
+ <p><ins>
+-<sup>*</sup>The C standard library headers D.7 [depr.c.headers] also define
++<sup>*</sup>The C standard library headers D.5 [depr.c.headers] also define
+ names within the global namespace, while the C++ headers for
+ C library facilities 17.6.1.2 [headers] may also define names within
+ the global namespace.
+@@ -31754,9 +25630,9 @@ the global namespace.
+
+ <hr>
+ <h3><a name="995"></a>995. Operational Semantics Unclear</h3>
+-<p><b>Section:</b> 17.5.1.3 [structure.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17.5.1.3 [structure.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ As a practical matter there's disagreement on the meaning of <i>operational
+@@ -31769,9 +25645,9 @@ disagreement is merely due to people not being aware of the text.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Agree with the recommended NAD resolution.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -31786,11 +25662,11 @@ perfectly clear.
+
+ <hr>
+ <h3><a name="996"></a>996. Move operation not well specified</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There are lots of places in the standard where we talk about "the move
+@@ -31805,10 +25681,10 @@ we need to.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open, pending proposed wording from Dave for further
+ review.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31817,9 +25693,9 @@ review.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to NAD. We define what we expect from a moved-from object in Table 34 [movesconstructible].
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31833,10 +25709,10 @@ Move to NAD. We define what we expect from a moved-from object in Table 34 [mov
+
+ <hr>
+ <h3><a name="1000"></a>1000. adjacent_find is over-constrained</h3>
+-<p><b>Section:</b> 25.2.8 [alg.adjacent.find] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.adjacent.find">issues</a> in [alg.adjacent.find].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 25.2.8 [alg.adjacent.find] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.adjacent.find">issues</a> in [alg.adjacent.find].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <b>Addresses UK 296</b>
+@@ -31849,7 +25725,7 @@ number of use cases, including:
+ </p>
+ <blockquote>
+ <table>
+-<tbody><tr>
++<tr>
+ <td valign="top">
+ <tt>adjacent_find(begin,&nbsp;end,&nbsp;less&lt;double&gt;)</tt>
+ </td>
+@@ -31870,7 +25746,7 @@ to check an algorithm which produces points in space does not generate
+ points too far apart.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -31891,7 +25767,8 @@ Change the definition of adjacent_find in the synopsis of 25 [algorithms]
+ and 25.2.8 [alg.adjacent.find] to:
+ </p>
+
+-<blockquote><pre>template&lt;ForwardIterator Iter&gt;
++<blockquote><pre>
++template&lt;ForwardIterator Iter&gt;
+ requires <del>EqualityComparable</del><ins>HasEqualTo</ins>&lt;Iter::value_type<ins>, Iter::value_type</ins>&gt;
+ Iter adjacent_find(Iter first, Iter last);
+
+@@ -31906,21 +25783,21 @@ template&lt;ForwardIterator Iter, <del>EquivalenceRelation</del><ins>Predicate</
+
+ <hr>
+ <h3><a name="1001"></a>1001. Pointers, concepts and headers</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 78</b></p>
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>.
++Related to <a href="lwg-closed.html#1063">1063</a>.
+ </p>
+
+ <p>
+-This is effectively an extension of LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#343">343</a>.
++This is effectively an extension of LWG issue <a href="lwg-defects.html#343">343</a>.
+ </p>
+ <p>
+ We know there is an increasing trend (encouraged by conformance testers and
+@@ -31946,7 +25823,8 @@ iterator concepts are specifically required to <tt>#include &lt;iterator_concept
+ At a minimum, the list of headers would be: (assuming all are constrained by
+ concepts)
+ </p>
+-<blockquote><pre>algorithm
++<blockquote><pre>
++algorithm
+ array
+ deque
+ forward_list
+@@ -31955,7 +25833,7 @@ iterator
+ locale
+ list
+ map
+-memory // if <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a> is adopted
++memory // if <a href="lwg-closed.html#1029">1029</a> is adopted
+ memory_concepts
+ numeric
+ random
+@@ -32024,10 +25902,10 @@ he prefers a solution that spells out what needs to be declared,
+ rather than how those declarations are to be provided,
+ e.g.,
+ </p>
+-<blockquote>
++<blockquote><p>
+ A C++ header shall provide the names
+ that are required to be defined in that header.
+-</blockquote>
++</p></blockquote>
+ <p>
+ Bill suggests approaching the wording from a programmer's perspective.
+ We may want to consider promising that certain widely-used headers
+@@ -32069,7 +25947,7 @@ Move to Open status.
+ <blockquote>
+ <ul>
+ <li>Strike two pieces of text considered unnecessary.</li>
+-<li>Change "definitions" to "declarations and definitions" in two places.</li>
++<li>Change &quot;definitions&quot; to &quot;declarations and definitions&quot; in two places.</li>
+ <li>Wording tightened slightly.</li>
+ </ul>
+ </blockquote>
+@@ -32092,17 +25970,14 @@ in the synopses of those other headers.
+ </p>
+ <p>
+ Alisdair: Does this address the BSI comment?
+-</p>
+-<p>
++<p/>
+ Beman: There were several overlapping comments. I tried to handle them
+ all with one resolution.
+-</p>
+-<p>
++<p/>
+ Alisdair: I'd prefer to see this closed as NAD and have this resolution
+ be the subject of some other, new issue.
+-</p>
+-<p>
+-Move to NAD Concepts. Howard to open a new issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>) in Ready state with the
++<p/>
++Move to NAD Concepts. Howard to open a new issue (<a href="lwg-defects.html#1178">1178</a>) in Ready state with the
+ Proposed Resolution above. Beman will write up a discussion for the new
+ issue.
+ </p>
+@@ -32111,7 +25986,7 @@ issue.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:</i></p>
++<p><i>Change 17.6.5.2 [res.on.headers], Headers, paragraph 1, as indicated:</i></p>
+
+ <blockquote>
+
+@@ -32134,14 +26009,14 @@ if those other headers were included.</ins>
+
+
+ <hr>
+-<h3><a name="1002"></a>1002. Response to UK 170</h3>
+-<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#headers">issues</a> in [headers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1002"></a>1002. Provide bulk include headers</h3>
++<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#headers">issues</a> in [headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 170</b></p>
++<p><b>Addresses UK-170 [CD1]</b></p>
+
+ <p>
+ One of goals of C++0x is to make language easier to teach and for
+@@ -32156,11 +26031,11 @@ single include statement.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We do not all agree that this is an issue,
+ but we agree that if it needs solving this is the right way to do it.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-06 Beman notes:
+@@ -32197,9 +26072,9 @@ a chance to look at <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ No consensus for change.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32207,26 +26082,26 @@ No consensus for change.
+ <p>
+ Insert a new paragraph in 17.6.1.2 [headers] between p4 and p5
+ </p>
+-<blockquote>
++<blockquote><p>
+ An additional header <tt>&lt;std&gt;</tt> shall have the effect of
+ supplying the entire standard library. [<i>Note:</i> for example, it
+ might be implemented as a file with an <tt>#include</tt> statement for each of the
+ headers listed in tables 13 and 14. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1003"></a>1003. Response to JP 23</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1003"></a>1003. Require more useful headers for freestanding implementations</h3>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses JP 23</b></p>
++<p><b>Addresses JP 23 [CD1]</b></p>
+
+ <p>
+ There is a freestanding implementation including
+@@ -32267,7 +26142,7 @@ library interface, so should be supported.
+ <p>
+ (it is anticipated the resolution will come via an update to paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2814.pdf">N2814</a>)
+-(see also LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>)
++(see also LWG <a href="lwg-closed.html#833">833</a>)
+ </p>
+ </blockquote>
+
+@@ -32275,10 +26150,10 @@ library interface, so should be supported.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Leave in Review status pending a paper on freestanding implementations
+ by Martin Tasker.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -32313,12 +26188,11 @@ Add <tt>&lt;type_traits&gt;</tt> to Table 15.
+
+
+
+-
+ <hr>
+ <h3><a name="1005"></a>1005. <tt>numeric_limits</tt> partial specializations not concept enabled</h3>
+-<p><b>Section:</b> 18.3.1.1 [numeric.limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 18.3.2.3 [numeric.limits] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses JP 26</b></p>
+@@ -32332,50 +26206,51 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
+-Alisdair will provide a soltion as part of treatment of axioms and LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>.
+-</blockquote>
++<blockquote><p>
++Alisdair will provide a solution as part of treatment of axioms and LWG <a href="lwg-closed.html#902">902</a>.
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alisdair recommends NAD as the partial specializations are already
+ constrained by requirements on the primary template.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The Working Draft does not in general repeat a primary template's constraints
+ in any specializations.
+ Move to NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-25 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ A c++std-lib thread starting at c++std-lib-23880 has cast doubt that NAD is the
+ correct resolution of this issue. Indeed the discussion also casts doubt that
+ the current proposed wording is the correct resolution as well. Personally I'm
+ inclined to reset the status to Open. However I'm reverting the status to
+ that which it had prior to the Batavia recommendation. I'm setting back to Review.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 18.3.1.1 [numeric.limits]:
++Change 18.3.2.3 [numeric.limits]:
+ </p>
+
+-<blockquote><pre>template&lt;<del>class</del> <ins>Regular</ins> T&gt; class numeric_limits&lt;const T&gt;;
++<blockquote><pre>
++template&lt;<del>class</del> <ins>Regular</ins> T&gt; class numeric_limits&lt;const T&gt;;
+ template&lt;<del>class</del> <ins>Regular</ins> T&gt; class numeric_limits&lt;volatile T&gt;;
+ template&lt;<del>class</del> <ins>Regular</ins> T&gt; class numeric_limits&lt;const volatile T&gt;;
+ </pre></blockquote>
+@@ -32387,10 +26262,11 @@ template&lt;<del>class</del> <ins>Regular</ins> T&gt; class numeric_limits&lt;co
+
+ <hr>
+ <h3><a name="1007"></a>1007. <tt>throw_with_nested</tt> not concept enabled</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses JP 29</b></p>
+@@ -32404,9 +26280,9 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agreed.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32427,10 +26303,11 @@ review.
+
+ <hr>
+ <h3><a name="1008"></a>1008. <tt>nested_exception</tt> wording unclear</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses JP 31</b></p>
+@@ -32444,28 +26321,28 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alisdair will add an example in an update to
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2619.pdf">N2619</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ It doesn't appear that N2619 really addresses this. Alisdair to propose wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark issue 1008 as NAD, the type is adequately described.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32487,9 +26364,10 @@ scenario.
+
+ <hr>
+ <h3><a name="1009"></a>1009. <tt>InputIterator</tt> post-increment dangerous</h3>
+-<p><b>Section:</b> 24.2.2 [iterator.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Section:</b> 24.2.2 [iterator.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.iterators">issues</a> in [iterator.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 251</b></p>
+@@ -32509,22 +26387,22 @@ percieved need for the post-increment operator in this case either.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We still think the issue is relevant, but needs totally rewording in
+ non-concept language. We would like to see the issue retained as Open,
+ rather than deferred as NAD Concepts. Review status is no longer
+ appropriate.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD. Without concepts we do not feel that input iterator post increment
+ is broken.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32533,7 +26411,8 @@ is broken.
+ Change 24.2.2 [iterator.iterators]:
+ </p>
+
+-<blockquote><pre>concept Iterator&lt;typename X&gt; : Semiregular&lt;X&gt; {
++<blockquote><pre>
++concept Iterator&lt;typename X&gt; : Semiregular&lt;X&gt; {
+ MoveConstructible reference = typename X::reference;
+ <del>MoveConstructible postincrement_result;</del>
+
+@@ -32546,12 +26425,13 @@ Change 24.2.2 [iterator.iterators]:
+ </pre>
+
+ <p>...</p>
+-<pre><del>postincrement_result operator++(X&amp; r, int);</del>
++<pre>
++<del>postincrement_result operator++(X&amp; r, int);</del>
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <del>-3- <i>Effects:</i> equivalent to <tt>{ X tmp = r; ++r; return tmp; }</tt>.</del>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -32560,7 +26440,8 @@ Change 24.2.3 [input.iterators]:
+ </p>
+
+ <blockquote>
+-<pre>concept InputIterator&lt;typename X&gt; : Iterator&lt;X&gt;, EqualityComparable&lt;X&gt; {
++<pre>
++concept InputIterator&lt;typename X&gt; : Iterator&lt;X&gt;, EqualityComparable&lt;X&gt; {
+ ObjectType value_type = typename X::value_type;
+ MoveConstructible pointer = typename X::pointer;
+
+@@ -32582,7 +26463,8 @@ Change 24.2.4 [output.iterators]:
+ </p>
+
+ <blockquote>
+-<pre>auto concept OutputIterator&lt;typename X, typename Value&gt; {
++<pre>
++auto concept OutputIterator&lt;typename X, typename Value&gt; {
+ requires Iterator&lt;X&gt;;
+
+ typename reference = Iterator&lt;X&gt;::reference;
+@@ -32601,13 +26483,14 @@ Change 24.2.5 [forward.iterators]:
+ </p>
+
+ <p><i>[
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a> which is attempting to change this same area in a compatible
++See <a href="lwg-closed.html#1084">1084</a> which is attempting to change this same area in a compatible
+ way.
+ ]</i></p>
+
+
+ <blockquote>
+-<pre>concept ForwardIterator&lt;typename X&gt; : InputIterator&lt;X&gt;, Regular&lt;X&gt; {
++<pre>
++concept ForwardIterator&lt;typename X&gt; : InputIterator&lt;X&gt;, Regular&lt;X&gt; {
+ <del>requires Convertible&lt;postincrement_result, const X&amp;&gt;;</del>
+
+ <ins>MoveConstructible postincrement_result;</ins>
+@@ -32627,7 +26510,8 @@ way.
+ <p>-4- ...</p>
+ </blockquote>
+
+-<pre><ins>postincrement_result operator++(X&amp; r, int);</ins>
++<pre>
++<ins>postincrement_result operator++(X&amp; r, int);</ins>
+ </pre>
+
+ <blockquote>
+@@ -32645,10 +26529,10 @@ way.
+
+ <hr>
+ <h3><a name="1010"></a>1010. <tt>operator-=</tt> should use default in concept</h3>
+-<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 263</b></p>
+@@ -32662,14 +26546,14 @@ implementation in the concept, with a matching axiom.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution should also remove
+ paragraph 5 and the declaration that precedes it.
+ Further, we should provide an axiom
+ that captures the desired semantics.
+ This may be a broader policy to be applied.
+ Move to Open.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -32677,7 +26561,8 @@ Move to Open.
+ Change 24.2.7 [random.access.iterators]:
+ </p>
+
+-<blockquote><pre>concept RandomAccessIterator&lt;typename X&gt; : BidirectionalIterator&lt;X&gt;, LessThanComparable&lt;X&gt; {
++<blockquote><pre>
++concept RandomAccessIterator&lt;typename X&gt; : BidirectionalIterator&lt;X&gt;, LessThanComparable&lt;X&gt; {
+ ...
+ X&amp; operator-=(X&amp; <ins>x</ins>, difference_type <ins>n</ins>)<ins> { return x += -n</ins>;<ins> }</ins>
+ ...
+@@ -32690,11 +26575,11 @@ Change 24.2.7 [random.access.iterators]:
+
+
+ <hr>
+-<h3><a name="1013"></a>1013. Response to UK 305</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1013"></a>1013. Remove <tt>IsSameType</tt> hold-over constraints</h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 305</b></p>
+@@ -32709,20 +26594,20 @@ longer necessary.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We believe this is NAD, but this needs to be reviewed against the
+ post-remove-concepts draft.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32731,7 +26616,8 @@ post-remove-concepts draft.
+ Change 25 [algorithms]:
+ </p>
+
+-<blockquote><pre>template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
++<blockquote><pre>
++template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
+ <del>requires !SameType&lt;T, Compare&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;</del>
+ const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
+ ...
+@@ -32748,7 +26634,8 @@ template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
+ Change 25.4.7 [alg.min.max], p1, p9 and p17:
+ </p>
+
+-<blockquote><pre>template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
++<blockquote><pre>
++template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
+ <del>requires !SameType&lt;T, Compare&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;</del>
+ const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
+ ...
+@@ -32767,11 +26654,11 @@ template&lt;class T, StrictWeakOrder&lt;auto, T&gt; Compare&gt;
+
+
+ <hr>
+-<h3><a name="1015"></a>1015. Response to UK 199</h3>
+-<p><b>Section:</b> X [concept.transform] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#concept.transform">issues</a> in [concept.transform].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1015"></a>1015. C++ programs - but not users - need to provide support <tt>concept_map</tt>s</h3>
++<p><b>Section:</b> X [concept.transform] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#concept.transform">issues</a> in [concept.transform].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 199</b></p>
+@@ -32811,13 +26698,13 @@ mandated there.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the issue,
+ but believe the wording needs further improvement.
+ We want to investigate current definitions for nomenclature such as
+ "user" and "program."
+ Move to Open pending the recommended investigation.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -32825,28 +26712,28 @@ Move to Open pending the recommended investigation.
+ Change X [concept.transform] p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- A <del>program</del> <ins>user</ins> shall not provide concept maps for
+ any concept in 20.1.1.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change [concept.true] p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <i>Requires:</i> a <del>program</del> <ins>user</ins> shall not
+ provide a concept map for the <tt>True</tt> concept.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change [concept.classify] p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <i>Requires:</i> a <del>program</del><ins>user</ins> shall not provide concept
+ maps for any concept in this section.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32854,11 +26741,11 @@ maps for any concept in this section.
+
+
+ <hr>
+-<h3><a name="1016"></a>1016. Response to JP 33</h3>
+-<p><b>Section:</b> X [concept.comparison] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#concept.comparison">issues</a> in [concept.comparison].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1016"></a>1016. Provide <tt>LessThanComparable</tt> and <tt>EqualityComparable</tt> for <tt>FloatingPointType</tt></h3>
++<p><b>Section:</b> X [concept.comparison] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#concept.comparison">issues</a> in [concept.comparison].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses JP 33</b></p>
+@@ -32886,7 +26773,7 @@ float/double etc. Also not clear how we are supposed to match values to
+ concepts.
+ </p>
+ <p>
+-Recommend NAD and treat as a subset of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>.
++Recommend NAD and treat as a subset of issue <a href="lwg-closed.html#902">902</a>.
+ </p>
+ </blockquote>
+
+@@ -32902,10 +26789,10 @@ Recommend NAD.
+
+
+ <hr>
+-<h3><a name="1017"></a>1017. Response to US 66</h3>
+-<p><b>Section:</b> X [concept.regular] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1017"></a>1017. Floating-point types should not satisfy <tt>Regular</tt></h3>
++<p><b>Section:</b> X [concept.regular] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses US 66</b></p>
+@@ -32928,7 +26815,7 @@ Summit:
+
+ <blockquote>
+ <p>
+-Recommend that we handle the same as JP 33 / <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>.
++Recommend that we handle the same as JP 33 / <a href="lwg-closed.html#1016">1016</a>.
+ </p>
+ </blockquote>
+
+@@ -32939,7 +26826,7 @@ Post Summit, Alisdair adds:
+
+ <blockquote>
+ <p>
+-Recommend Open, and review after resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a> and revised axiom
++Recommend Open, and review after resolution of <a href="lwg-closed.html#902">902</a> and revised axiom
+ feature.
+ </p>
+ </blockquote>
+@@ -32953,14 +26840,15 @@ feature.
+
+
+ <hr>
+-<h3><a name="1018"></a>1018. Response to US 70</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1018"></a>1018. Trait specifications should be expressed in terms of concepts</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses US 70</b></p>
++<p><b>Addresses US 70 [CD1]</b></p>
+
+ <p>
+ Specifications now expressed via narrative text are more accurately and
+@@ -32996,14 +26884,15 @@ at the next meeting.
+
+
+ <hr>
+-<h3><a name="1020"></a>1020. Response to UK 204</h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1020"></a>1020. Restore <tt>aligned_union</tt></h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 204</b></p>
++<p><b>Addresses UK 204 [CD1]</b></p>
+
+ <p>
+ It is not possible to create a variant union based on a parameter pack
+@@ -33013,7 +26902,7 @@ expansion, e.g. to implement a classic discriminated union template.
+ <p><b>Original proposed resolutuion:</b></p>
+
+ <p>
+-Restore <tt>aligned_union</tt> template that was removed by LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>.
++Restore <tt>aligned_union</tt> template that was removed by LWG issue <a href="lwg-defects.html#856">856</a>.
+ </p>
+
+ <p><i>[
+@@ -33021,30 +26910,30 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree. The need for <tt>aligned_union</tt> is compelling enough to reinstate.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit, Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-paper
++<blockquote><p>
++Paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2843.html">N2843</a>
+ proposes an extension to the <tt>[[align]]</tt> attribute
+ that further diminishes the need for this template. Recommend NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark NAD as suggested.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33055,20 +26944,21 @@ Mark NAD as suggested.
+
+
+ <hr>
+-<h3><a name="1022"></a>1022. Response to UK 212</h3>
+-<p><b>Section:</b> 20.9.11 [util.dynamic.safety] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1022"></a>1022. Pointer-safety API has nothing to do with smart pointers</h3>
++<p><b>Section:</b> 20.7.4 [util.dynamic.safety] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 212</b></p>
++<p><b>Addresses UK 212 [CD1]</b></p>
+
+ <p>
+ The pointer-safety API is nothing to do with smart pointers, so does not
+-belong in 20.9.10 [util.smartptr]. In fact it is a set of language
+-support features are really belongs in clause 18 [language.support], with the contents declared in a header that
+-deals with language-support of memory management.
++belong in 20.8.2 [util.smartptr]. In fact it is a set of language
++support features are really belongs in clause 18 [language.support],
++with the contents declared in a header that deals with language-support
++of memory management.
+ </p>
+
+ <p><i>[
+@@ -33076,11 +26966,12 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree in principle, but not with the proposed resolution. We believe it
+-belongs either a subsection of either 20 [utilities] or 20.9 [memory] as part of the general reorganization of 20 [utilities]. The declaration should stay in
+-<tt>&lt;memory&gt;</tt>.
+-</blockquote>
++belongs either a subsection of either 20 [utilities] or
++20.7 [memory] as part of the general reorganization of
++20 [utilities]. The declaration should stay in <tt>&lt;memory&gt;</tt>.
++</p></blockquote>
+
+
+
+@@ -33091,16 +26982,17 @@ belongs either a subsection of either 20 [utilities] or 20.9 [memory] as part of
+
+
+ <hr>
+-<h3><a name="1023"></a>1023. Response to DE 22</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1023"></a>1023. Unclear inheritance relation for <tt>std::function</tt></h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses DE 22</b></p>
++<p><b>Addresses DE 22 [CD1]</b></p>
+
+-<p>Related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</p>
++<p>Related to issue <a href="lwg-defects.html#1114">1114</a>.</p>
+
+ <p>
+ The conditions for deriving from <tt>std::unary_function</tt> and
+@@ -33114,31 +27006,30 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree. <tt>std::reference_wrapper</tt> has the same structure, and we
+ suggest that <tt>std::function</tt> be presented in the same way as
+ <tt>std::reference_wrapper</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Phrasing should be "publicly and
+-unambiguously derived from" and probably back in reference_wrapper too. Updated
+-wording supplied.
+-</blockquote>
++<blockquote><p>
++Phrasing should be "publicly and unambiguously derived from" and probably back in
++<tt>reference_wrapper</tt> too. Updated wording supplied.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed wording.
+ Move to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -33147,10 +27038,11 @@ Move to NAD Editorial.
+ </p>
+
+ <p>
+-Change synopsis in Class template function 20.8.14.2 [func.wrap.func]:
++Change synopsis in Class template function 20.9.12.2 [func.wrap.func]:
+ </p>
+
+-<blockquote><pre>template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
++<blockquote><pre>
++template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
+ class function&lt;R(ArgTypes...)&gt;
+ : public unary_function&lt;T1, R&gt; // <del><i>iff</i> sizeof...(ArgTypes) == 1 <i>and</i></del> <ins><i>see below</i></ins>
+ <del>// ArgTypes <i>contains</i> T1</del>
+@@ -33161,7 +27053,7 @@ class function&lt;R(ArgTypes...)&gt;
+ </pre></blockquote>
+
+ <p>
+-Add new p1/p2 before 20.8.14.2.1 [func.wrap.func.con]:
++Add new p1/p2 before 20.9.12.2.1 [func.wrap.func.con]:
+ </p>
+
+ <blockquote>
+@@ -33180,7 +27072,8 @@ parameter is a function type taking two arguments of type <tt>T1</tt> and <tt>T2
+ returning <tt>R</tt>.
+ </ins></p>
+
+-<pre>explicit function();
++<pre>
++explicit function();
+ </pre>
+ </blockquote>
+
+@@ -33190,14 +27083,15 @@ returning <tt>R</tt>.
+
+
+ <hr>
+-<h3><a name="1024"></a>1024. Response to JP 39</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1024"></a>1024. <tt>std::function</tt> constructors overly generous</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses JP 39</b></p>
++<p><b>Addresses JP 39 [CD1]</b></p>
+
+ <p>
+ There are no requires corresponding to <tt>F</tt> of <tt>std::function</tt>.
+@@ -33208,39 +27102,40 @@ There are no requires corresponding to <tt>F</tt> of <tt>std::function</tt>.
+ ]</i></p>
+
+
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a> removes the second constructor.
+-</blockquote>
++<blockquote><p>
++<a href="lwg-defects.html#1070">1070</a> removes the second constructor.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-If issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a> is accepted,
++If issue <a href="lwg-defects.html#1070">1070</a> is accepted,
+ the changes to the second constructor
+ in this issue are moot.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Constructors have no definition.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Correct as follows in 20.8.14.2 [func.wrap.func] (class definition)
++Correct as follows in 20.9.12.2 [func.wrap.func] (class definition)
+ </p>
+
+-<blockquote><pre> template&lt;class F, Allocator Alloc&gt;
++<blockquote><pre>
++ template&lt;class F, Allocator Alloc&gt;
+ <ins>requires ConstructibleWithAllocator&lt;F, Alloc&gt;
+ &amp;&amp; call=Callable&lt;F, ArgTypes...&gt;
+ &amp;&amp; Convertible&lt;call::result_type, R&gt;</ins>
+@@ -33258,38 +27153,14 @@ Correct as follows in 20.8.14.2 [func.wrap.func] (class definition)
+
+
+ <hr>
+-<h3><a name="1025"></a>1025. Response to UK 208</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 208</b></p>
+-
+-<p>
+-<tt>std::hash</tt> should be implemented for much more of the standard
+-library. In particular for <tt>pair</tt>, <tt>tuple</tt> and all the
+-standard containers.
+-</p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1026"></a>1026. Response to UK 209</h3>
+-<p><b>Section:</b> 20.9 [memory] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#memory">issues</a> in [memory].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1026"></a>1026. Smart pointers need to be concept-constrained templates</h3>
++<p><b>Section:</b> 20.7 [memory] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#memory">issues</a> in [memory].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 209</b></p>
++<p><b>Addresses UK 209 [CD1]</b></p>
+
+ <p>
+ Smart pointers cannot be used in constrained templates.
+@@ -33300,23 +27171,23 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We look forward to a paper on this topic. We recommend no action until a
+ paper is available. We understand that a paper is forthcoming.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Peter Dimov adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <tt>shared_ptr&lt;T&gt;</tt> and <tt>weak_ptr&lt;T&gt;</tt> support all
+ types <tt>T</tt> for which <tt>T*</tt> is valid. In other words, a
+ possible (partial) resolution is to change class <tt>T</tt> to
+ <tt>PointeeType T</tt> for <tt>shared_ptr</tt>, <tt>weak_ptr</tt> and
+ possibly <tt>enable_shared_from_this</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33327,13 +27198,14 @@ possibly <tt>enable_shared_from_this</tt>.
+
+
+ <hr>
+-<h3><a name="1027"></a>1027. Response to UK 213</h3>
+-<p><b>Section:</b> 20.9.5 [default.allocator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1027"></a>1027. <tt>std::allocator</tt> needs to be a concept-constrained template</h3>
++<p><b>Section:</b> 20.7.9 [default.allocator] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#default.allocator">issues</a> in [default.allocator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 213</b></p>
++<p><b>Addresses UK 213 [CD1]</b></p>
+
+ <p>
+ <tt>std::allocator</tt> should be constrained to simplify its use on constrained
+@@ -33359,9 +27231,9 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree as stated. A future paper will address additional related issues.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33372,13 +27244,14 @@ Agree as stated. A future paper will address additional related issues.
+
+
+ <hr>
+-<h3><a name="1028"></a>1028. Response to UK 214</h3>
+-<p><b>Section:</b> 20.9.6 [storage.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1028"></a>1028. <tt>raw_storage_iterator</tt> needs to be a concept-constrained template</h3>
++<p><b>Section:</b> 20.7.10 [storage.iterator] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#storage.iterator">issues</a> in [storage.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 214</b></p>
++<p><b>Addresses UK 214 [CD1]</b></p>
+
+ <p>
+ <tt>raw_storage_iterator</tt> needs constraining as an iterator adaptor to be safely
+@@ -33390,10 +27263,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We look forward to a paper on this topic. We recommend no action until a
+ paper is available.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair provided wording and rationale.
+@@ -33404,12 +27277,13 @@ Post Summit Alisdair provided wording and rationale.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-20.9 [memory] p2
++20.7 [memory] p2
+ </p>
+ <p>
+ Update the synopsis for <tt>&lt;memory&gt;</tt>
+ </p>
+-<blockquote><pre>// 20.7.8, raw storage iterator:
++<blockquote><pre>
++// 20.7.8, raw storage iterator:
+ template &lt;<del>class</del> <ins>ForwardIterator</ins> Out<del>put</del>Iter<del>ator</del>, <del>class</del> <ins>ObjectType</ins> T&gt;
+ <ins>requires OutputIterator&lt; OutIter, T &gt;</ins>
+ class raw_storage_iterator;
+@@ -33421,12 +27295,13 @@ template &lt;<del>class</del> <ins>ForwardIterator</ins> Out<del>put</del>Iter<d
+
+
+ <p>
+-20.9.6 [storage.iterator] p1
++20.7.10 [storage.iterator] p1
+ </p>
+ <p>
+ Replace class template definition with:
+ </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;<del>class</del> <ins>ForwardIterator</ins> Out<del>put</del>Iter<del>ator</del>, <del>class</del> <ins>ObjectType</ins> T&gt;
+ <ins>requires OutputIterator&lt; OutIter, T &gt;</ins>
+ class raw_storage_iterator
+@@ -33453,7 +27328,7 @@ Replace class template definition with:
+ rather than just an <tt>InputIterator</tt> for two reasons:
+ </p>
+
+-<ol type="i">
++<ol style="list-style-type:lower-roman">
+ <li>
+ The initial iterator passed by value is expected to remain valid,
+ pointing to the initialized region of memory.
+@@ -33470,19 +27345,19 @@ require some kind of proxy formulation to support generalised InputIterators.
+
+
+ <hr>
+-<h3><a name="1029"></a>1029. Response to UK 210</h3>
+-<p><b>Section:</b> 20.9.8 [specialized.algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1029"></a>1029. Specialized algorithms for memory management need to be concept-constrained templates</h3>
++<p><b>Section:</b> 20.7.12 [specialized.algorithms] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 210</b></p>
++<p><b>Addresses UK 210 [CD1]</b></p>
+
+-<p>Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a></p>
++<p>Related to <a href="lwg-closed.html#582">582</a></p>
+
+ <p>
+-Specialized algorithms for memory managenment need requirements to be
++Specialized algorithms for memory management need requirements to be
+ easily usable in constrained templates.
+ </p>
+
+@@ -33491,10 +27366,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We look forward to a paper on this topic. We recommend no action until a
+ paper is available.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair provided wording.
+@@ -33524,7 +27399,7 @@ The current for-loop-test relies on evaluation in boolean context which is
+ not provided by <tt>ArithmeticLike</tt> and it's refinements. I propose to change the
+ corresponding for-loop-headers to:
+ </p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ for <tt>uninitialized_copy_n</tt>: <tt>for ( ; n &gt; Size(0); ++result, ++first, --n) {</tt>
+ </li>
+@@ -33539,9 +27414,9 @@ for <tt>uninitialized_fill_n</tt>: <tt>for (; n &gt; Size(0); ++first, --n) {</t
+ <p>
+ Alisdair adds:
+ </p>
+-<blockquote>
++<blockquote><p>
+ For the record I agree with Daniel's suggestion.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -33549,12 +27424,13 @@ For the record I agree with Daniel's suggestion.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-20.9 [memory] p2
++20.7 [memory] p2
+ </p>
+ <p>
+ Update the synopsis for <tt>&lt;memory&gt;</tt>
+ </p>
+-<blockquote><pre>template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
++<blockquote><pre>
++template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
+ <del>class ForwardIterator</del> <ins>OutputIterator&lt;auto, InIter::reference&gt; OutIter</ins>&gt;
+ <ins>requires ForwardIterator&lt;OutIter&gt;</ins>
+ <del>ForwardIterator</del> <ins>OutIter</ins>
+@@ -33585,10 +27461,11 @@ Update as follows:
+ </p>
+
+ <p>
+-uninitialized_copy 20.9.8.2 [uninitialized.copy]
++uninitialized_copy 20.7.12.2 [uninitialized.copy]
+ </p>
+
+-<blockquote><pre>template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
++<blockquote><pre>
++template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
+ <del>class ForwardIterator</del> <ins>OutputIterator&lt;auto, InIter::reference&gt; OutIter</ins>&gt;
+ <ins>requires ForwardIterator&lt;OutIter&gt;</ins>
+ <del>ForwardIterator</del> <ins>OutIter</ins>
+@@ -33600,7 +27477,8 @@ uninitialized_copy 20.9.8.2 [uninitialized.copy]
+ <p>
+ -1- <i>Effects:</i>
+ </p>
+-<blockquote><pre>for (; first != last; ++result, ++first) {
++<blockquote><pre>
++for (; first != last; ++result, ++first) {
+ new (static_cast&lt;void*&gt;(&amp;*result))
+ <del>typename iterator_traits&lt;ForwardIterator&gt;</del> <ins>OutIter</ins>::value_type(*first);
+ }
+@@ -33612,7 +27490,8 @@ uninitialized_copy 20.9.8.2 [uninitialized.copy]
+
+ </blockquote>
+
+-<pre>template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
++<pre>
++template &lt;<del>class</del> InputIterator <ins>InIter</ins>,
+ <del>class</del> <ins>IntegralLike</ins> Size,
+ <del>class ForwardIterator</del> <ins>OutputIterator&lt;auto, InIter::reference&gt; OutIter</ins>&gt;
+ <ins>requires ForwardIterator&lt;OutIter&gt;</ins>
+@@ -33625,7 +27504,8 @@ uninitialized_copy 20.9.8.2 [uninitialized.copy]
+ <p>
+ -3- Effects:
+ </p>
+-<blockquote><pre>for ( ; n &gt; <ins>Size(</ins>0<ins>)</ins>; ++result, ++first, --n) {
++<blockquote><pre>
++for ( ; n &gt; <ins>Size(</ins>0<ins>)</ins>; ++result, ++first, --n) {
+ new (static_cast&lt;void*&gt;(&amp;*result))
+ <del>typename iterator_traits&lt;ForwardIterator&gt;</del> <ins>OutIter</ins>::value_type(*first);
+ }
+@@ -33639,10 +27519,11 @@ uninitialized_copy 20.9.8.2 [uninitialized.copy]
+
+
+ <p>
+-uninitialized_fill 20.9.8.3 [uninitialized.fill]
++uninitialized_fill 20.7.12.3 [uninitialized.fill]
+ </p>
+
+-<blockquote><pre>template &lt;<del>class</del> ForwardIterator <ins>Iter</ins>, <del>class</del> <ins>ObjectType</ins> T&gt;
++<blockquote><pre>
++template &lt;<del>class</del> ForwardIterator <ins>Iter</ins>, <del>class</del> <ins>ObjectType</ins> T&gt;
+ <ins>requires Constructible&lt; Iter::value_type, const T&amp; &gt;</ins>
+ void uninitialized_fill(<del>ForwardIterator</del> <ins>Iter</ins> first, <del>ForwardIterator</del> <ins>Iter</ins> last,
+ const T&amp; x);
+@@ -33652,7 +27533,8 @@ uninitialized_fill 20.9.8.3 [uninitialized.fill]
+ <p>
+ -1- <i>Effects:</i>
+ </p>
+-<blockquote><pre>for (; first != last; ++first) {
++<blockquote><pre>
++for (; first != last; ++first) {
+ new ( static_cast&lt;void*&gt;( &amp;*first) )
+ <del>typename iterator_traits&lt;ForwardIterator&gt;</del> <ins>Iter</ins>::value_type(x);
+ }
+@@ -33662,10 +27544,11 @@ uninitialized_fill 20.9.8.3 [uninitialized.fill]
+
+
+ <p>
+-uninitialized_fill_n 20.9.8.4 [uninitialized.fill.n]
++uninitialized_fill_n 20.7.12.4 [uninitialized.fill.n]
+ </p>
+
+-<blockquote><pre>template &lt;<del>class</del> ForwardIterator <ins>Iter</ins>, <del>class</del> <ins>IntegralLike</ins> Size, <del>class</del> <ins>ObjectType</ins> T&gt;
++<blockquote><pre>
++template &lt;<del>class</del> ForwardIterator <ins>Iter</ins>, <del>class</del> <ins>IntegralLike</ins> Size, <del>class</del> <ins>ObjectType</ins> T&gt;
+ <ins>requires Constructible&lt; Iter::value_type, const T&amp; &gt;</ins>
+ void
+ uninitialized_fill_n(<del>ForwardIterator</del> <ins>Iter</ins> first, Size n, const T&amp; x);
+@@ -33675,7 +27558,8 @@ uninitialized_fill_n 20.9.8.4 [uninitialized.fill.n]
+ <p>
+ -1- <i>Effects:</i>
+ </p>
+-<blockquote><pre>for (; n<del>--</del> <ins>&gt; Size(0)</ins>; ++first<ins>, --n</ins>) {
++<blockquote><pre>
++for (; n<del>--</del> <ins>&gt; Size(0)</ins>; ++first<ins>, --n</ins>) {
+ new ( static_cast&lt;void*&gt;( &amp;*first) )
+ <del>typename iterator_traits&lt;ForwardIterator&gt;</del> <ins>Iter</ins>::value_type(x);
+ }
+@@ -33689,145 +27573,26 @@ uninitialized_fill_n 20.9.8.4 [uninitialized.fill.n]
+
+
+ <hr>
+-<h3><a name="1031"></a>1031. Response to US 78</h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 78</b></p>
+-
+-<p>
+-There is presently no way to convert directly from a <tt>shared_ptr</tt> to a
+-<tt>unique_ptr</tt>. Add an interface that performs the conversion.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-We look forward to a paper on this topic. We recommend no action until a
+-paper is available. We believe that the shared pointer must use the default
+-deleter for the conversion to succeed.
+-</blockquote>
+-
+-<p><i>[
+-Peter Dimov adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-This is basically a request for <tt>shared_ptr&lt;&gt;::release</tt> in
+-disguise, with all the associated problems. Not a good idea.
+-</blockquote>
+-
+-<p><i>[
+-2009-07 post-Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-The rationale for the omission of a release() member function from shared_ptr is given in:
+-<a href="http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm">http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm</a>
+-</p>
+-<p>
+-The implementation of such a member is non-trivial (and maybe
+-impossible), because it would need to account for the deleter.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009-07-26 Howard sets to Tentatively NAD Future.
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I took an online poll and got 3 votes for NAD and 3 for NAD Future. Personally
+-I prefer NAD Future as this does refer to an extension that could conceivably be
+-considered beyond C++0X.
+-</p>
+-
+-<p>
+-However such an extension would need to solve a couple of problems:
+-</p>
+-
+-<ol>
+-<li>What is the interface for such a conversion when the <tt>shared_ptr</tt> does
+-not have unique ownership? Throw an exception? Create a null <tt>unique_ptr</tt>?
+-Undefined behavior?
+-</li>
+-
+-<li>
+-<p>
+-How does one handle custom deleters given to the <tt>shared_ptr</tt> constructor?
+-</p>
+-<p>
+-I do not believe it is possible to implement a general answer to this question.
+-The <tt>shared_ptr</tt> deleter is a run time (or construction time) characteristic.
+-The <tt>unique_ptr</tt> deleter is a compile time characteristic. In general one
+-can not know to what type of <tt>unqiue_ptr</tt> you are converting to.
+-</p>
+-<p>
+-One answer is for the user of the conversion to specify the deleter type and perhaps
+-throw an exception if the specification turns out to be incorrect.
+-</p>
+-<p>
+-Another answer is for the conversion to only be valid when the underlying deleter
+-is <tt>default_delete</tt>. We would probalby need to specify that this is indeed the
+-underlying deleter of a <tt>shared_ptr</tt> when a custom deleter is not given in
+-the constructor.
+-</p>
+-</li>
+-</ol>
+-
+-<p>
+-At any rate, there are non-trivial design issues which would need to be implemented
+-and tested in the field for usability prior to standardization.
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to NAD Future.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1032"></a>1032. Response to JP 45</h3>
+-<p><b>Section:</b> 20.11 [time] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time">issues</a> in [time].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1032"></a>1032. Tome utility templates need to be concept-constrained</h3>
++<p><b>Section:</b> 20.12 [time] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time">issues</a> in [time].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses JP 45</b></p>
++<p><b>Addresses JP 45 [CD1]</b></p>
+
+ <p>
+ <tt>Rep</tt>, <tt>Period</tt>, <tt>Clock</tt> and <tt>Duration</tt>
+ don't correspond to concept.
+ </p>
+-<blockquote><pre>template &lt;class Rep, class Period = ratio&lt;1&gt;&gt; class duration;
++<blockquote><pre>
++template &lt;class Rep, class Period = ratio&lt;1&gt;&gt; class duration;
+ template &lt;class Clock, class Duration = typename Clock::duration&gt; class time_point;
+ </pre></blockquote>
+ <p>
+ Make concept for <tt>Rep</tt>, <tt>Period</tt>, <tt>Clock</tt> and <tt>Duration</tt>.
+-Fix 20.11 [time] and <tt>wait_until</tt>
++Fix 20.12 [time] and <tt>wait_until</tt>
+ and <tt>wait_for</tt>'s template parameter at 30 [thread].
+ </p>
+
+@@ -33836,10 +27601,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We agree that this section needs concepts. We look forward to a paper on
+ this topic. We recommend no action until a paper is available.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33850,15 +27615,15 @@ this topic. We recommend no action until a paper is available.
+
+
+ <hr>
+-<h3><a name="1035"></a>1035. Response to UK 226</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1035"></a>1035. <tt>&lt;array&gt;::swap</tt> can invalidate references, pointers, and iterators</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 226</b></p>
++<p><b>Addresses UK 226 [CD1]</b></p>
+
+ <p>
+ <tt>&lt;array&gt;</tt> must be added to this list. In particular it
+@@ -33878,37 +27643,36 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree. The proposed resolution is incomplete. Further work required.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-01 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a> also suggests
+-adding move constructor to this.
+-</blockquote>
++<blockquote><p>
++Issue <a href="lwg-closed.html#1099">1099</a> also suggests adding move constructor to this.
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 post-Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Howard is to draft a note that explains what happens to references.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark as NAD. No consensus for change.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33919,22 +27683,24 @@ Mark as NAD. No consensus for change.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a paragraph to 23.3.1.2 [array.special]:
++Add a paragraph to 23.3.2.3 [array.special]:
+ </p>
+
+-<blockquote><pre>template &lt;Swappable T, size_t N&gt; void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y);
++<blockquote><pre>
++template &lt;Swappable T, size_t N&gt; void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y);
+ </pre>
+ <blockquote>
+ <p>
+ <i>Effects:</i>
+ </p>
+-<blockquote><pre>swap_ranges(x.begin(), x.end(), y.begin());
++<blockquote><pre>
++swap_ranges(x.begin(), x.end(), y.begin());
+ </pre></blockquote>
+
+ <p><ins>
+ [<i>Note:</i>
+ Outstanding iterators, references and pointers may be invalidated.
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </ins></p>
+ </blockquote>
+ </blockquote>
+@@ -33944,14 +27710,14 @@ Outstanding iterators, references and pointers may be invalidated.
+
+
+ <hr>
+-<h3><a name="1036"></a>1036. Response to UK 231</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1036"></a>1036. Remove iterator specification that is redundant due to concept constraints</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 231</b></p>
++<p><b>Addresses UK 231 [CD1]</b></p>
+
+ <p>
+ p9-p11 are redundant now that Concepts define what it means to be an
+@@ -33963,11 +27729,11 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree with issue and change to 23.2.3 [sequence.reqmts]. The
+ changes required to 21 [strings] will be part of the general
+ concept support for that clause.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33983,158 +27749,14 @@ has constraints similar to
+
+
+ <hr>
+-<h3><a name="1041"></a>1041. Response to UK 239</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 239</b></p>
+-
+-<p>
+-It is not possible to take a move-only key out of an unordered
+-container, such as (<tt>multi</tt>)<tt>set</tt> or
+-(<tt>multi</tt>)<tt>map</tt>, or the new unordered containers.
+-</p>
+-
+-<p>
+-Add below <tt>a.erase(q)</tt>, <tt>a.extract(q)</tt>, with the following notation:
+-</p>
+-<p>
+-<tt>a.extract(q)&gt;</tt>, Return type <tt>pair&lt;key, iterator&gt;</tt>
+-Extracts the element pointed to by <tt>q</tt> and erases it from the
+-<tt>set</tt>. Returns a <tt>pair</tt> containing the value pointed to by
+-<tt>q</tt> and an <tt>iterator</tt> pointing to the element immediately
+-following <tt>q</tt> prior to the element being erased. If no such
+-element exists,returns <tt>a.end()</tt>.
+-</p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+-We look forward to a paper on this topic. We recommend no action until a
+-paper is available. The paper would need to address exception safety.
+-</blockquote>
+-
+-<p><i>[
+-Post Summit Alisdair adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-Would <tt>value_type</tt> be a better return type than <tt>key_type</tt>?
+-</blockquote>
+-
+-<p><i>[
+-2009-07 post-Frankfurt:
+-]</i></p>
+-
+-
+-<blockquote>
+-Leave Open. Alisdair to contact Chris Jefferson about this.
+-</blockquote>
+-
+-<p><i>[
+-2009-09-20 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-See the 2009-09-19 comment of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a> for an API which
+-accomplishes this functionality and also addresses several other use
+-cases which this proposal does not.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD Future. No consensus to make the change at this time.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In 23.2.4 [associative.reqmts] Table 85, add:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<caption>Table 85 -- Associative container requirements (in addition to container)</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
+-<th>Complexity</th>
+-</tr>
+-<tr><td><tt>a.erase(q)</tt></td>
+-<td>...</td>
+-<td>...</td>
+-<td>...</td>
+-</tr><tr>
+-<td><ins><tt>a.extract(q)</tt></ins></td>
+-<td><ins><tt>pair&lt;key_type, iterator&gt;</tt></ins></td>
+-<td><ins>Extracts the element pointed to by <tt>q</tt> and erases it from the <tt>set</tt>.
+-Returns a <tt>pair</tt> containing the value pointed to by <tt>q</tt> and an <tt>iterator</tt>
+-pointing to the element immediately following <tt>q</tt> prior to the element being
+-erased. If no such element
+-exists, returns <tt>a.end()</tt>.</ins></td>
+-<td><ins>amortized constant</ins></td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-In 23.2.5 [unord.req] Table 87, add:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<caption>Table 87 -- Unordered associative container requirements (in addition to container)</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
+-<th>Complexity</th>
+-</tr>
+-<tr><td><tt>a.erase(q)</tt></td>
+-<td>...</td>
+-<td>...</td>
+-<td>...</td>
+-</tr><tr>
+-<td><ins><tt>a.extract(q)</tt></ins></td>
+-<td><ins><tt>pair&lt;key_type, iterator&gt;</tt></ins></td>
+-<td><ins>Extracts the element pointed to by <tt>q</tt> and erases it from the <tt>set</tt>.
+-Returns a <tt>pair</tt> containing the value pointed to by <tt>q</tt> and an <tt>iterator</tt>
+-pointing to the element immediately following <tt>q</tt> prior to the element being
+-erased. If no such element
+-exists, returns <tt>a.end()</tt>.</ins></td>
+-<td><ins>amortized constant</ins></td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1042"></a>1042. Response to UK 244</h3>
+-<p><b>Section:</b> 23.3 [sequences] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequences">issues</a> in [sequences].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1042"></a>1042. Provide <tt>ContiguousStorage</tt> concept and apply it to corresponding containers</h3>
++<p><b>Section:</b> 23.3 [sequences] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequences">issues</a> in [sequences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 244</b></p>
++<p><b>Addresses UK 244 [CD1]</b></p>
+
+ <p>
+ The validity of the expression <tt>&amp;a[n] == &amp;a[0] + n</tt> is contingent on
+@@ -34150,7 +27772,7 @@ Suggested solution:
+ </p>
+
+ <p>
+-Define a <tt>ContiguousStrorage</tt> and apply it to
++Define a <tt>ContiguousStorage</tt> and apply it to
+ <tt>vector</tt>, <tt>array</tt> and <tt>string</tt>.
+ </p>
+
+@@ -34159,39 +27781,38 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree with the issue but not the details of the proposed solution. Walter to
+ provide wording for the new concept.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Another LWG subgroup wondered if this concept
+-should extend to <tt>complex&lt;T&gt;</tt>, and so not be built on the container concept at
+-all?
+-</blockquote>
++<blockquote><p>
++Another LWG subgroup wondered if this concept should extend to <tt>complex&lt;T&gt;</tt>,
++and so not be built on the container concept at all?
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 post-Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open, pending a post-Concepts Working Draft.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark issue 1042 as NAD, in rationale state that this was solved by removal of concepts.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -34200,7 +27821,8 @@ Mark issue 1042 as NAD, in rationale state that this was solved by removal of co
+ Add to <tt>&lt;container_concepts&gt;</tt> synopsis in [container.concepts]
+ </p>
+
+-<blockquote><pre><ins>concept&lt; typename C &gt; ContiguousStorageContainer <i>see below</i>;</ins>
++<blockquote><pre>
++<ins>concept&lt; typename C &gt; ContiguousStorageContainer <i>see below</i>;</ins>
+ </pre></blockquote>
+
+ <p>
+@@ -34212,7 +27834,8 @@ Add a new section to the end of [container.concepts]
+ 23.1.6.x ContiguousStorageContainer concept [container.concepts.contiguous]
+ </p>
+
+-<pre>concept ContiguousStorageContainer&lt; typename C &gt;
++<pre>
++concept ContiguousStorageContainer&lt; typename C &gt;
+ : Container&lt;C&gt;
+ {
+ value_type* data(C&amp;);
+@@ -34234,21 +27857,22 @@ For example, the elements may be stored in a
+ single array of suitable length.
+ </p>
+
+-<pre>value_type * data( C&amp; );
++<pre>
++value_type * data( C&amp; );
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> a pointer to the first element in the region of storage.
+ Result is unspecified for an empty container.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+ <p>
+-Change 23.3.1 [array] p1:
++Change 23.3.2 [array] p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -1- The header <tt>&lt;array&gt;</tt> defines a class template for
+ storing fixed-size sequences of objects. An <tt>array</tt> supports
+ random access iterators. An instance of <tt>array&lt;T, N&gt;</tt>
+@@ -34259,13 +27883,14 @@ contiguously, meaning that <del>if <tt>a</tt> is</del> an
+ == &amp;a[0] + n</tt> for all <tt>0 &lt;= n &lt; N</tt></del>
+ <ins>satisfies the concept <tt>ContiguousStorageContainer&lt; array&lt;T,
+ N&gt;&gt;</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Add to the synopsis in 23.3.1 [array]:
++Add to the synopsis in 23.3.2 [array]:
+ </p>
+
+-<blockquote><pre> ...
++<blockquote><pre>
++ ...
+ T * data();
+ const T * data() const;
+ };
+@@ -34276,10 +27901,10 @@ Add to the synopsis in 23.3.1 [array]:
+ </pre></blockquote>
+
+ <p>
+-Change 23.4.1 [vector] p1:
++Change 23.3.6 [vector] p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A <tt>vector</tt> is a sequence container that supports random access
+ iterators. In addition, it supports (amortized) constant time insert and
+ erase operations at the end; insert and erase in the middle take linear
+@@ -34291,13 +27916,14 @@ type other than <tt>bool</tt><ins>)</ins><del>, then it obeys the
+ identity <tt>&amp;v[n] == &amp;v[0] + n</tt> for all <tt>0 &lt;= n &lt;
+ v.size()</tt></del> <ins>satisfies the concept <tt>ContiguousStorageContainer&lt;
+ vector&lt; T, Alloc&gt;&gt;</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Add at the end of the synopsis in 23.4.1 [vector] p2:
++Add at the end of the synopsis in 23.3.6 [vector] p2:
+ </p>
+
+-<blockquote><pre><ins>template&lt; typename T, typename A &gt;
++<blockquote><pre>
++<ins>template&lt; typename T, typename A &gt;
+ requires !SameType&lt; T, bool &gt;
+ concept_map ContiguousStorageContainer&lt; vector&lt;T, A&gt;&gt; {};</ins>
+ </pre></blockquote>
+@@ -34305,219 +27931,168 @@ Add at the end of the synopsis in 23.4.1 [vector] p2:
+
+
+ <p><b>Rationale:</b></p>
+-Solved by removal of concepts.
++<p>Solved by removal of concepts.</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1043"></a>1043. Response to US 91</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1051"></a>1051. Specify subscript operation return types of <tt>reverse_iterator</tt> and <tt>move_iterator</tt></h3>
++<p><b>Section:</b> 24.5.1.3.12 [reverse.iter.opindex], 24.5.3.3.12 [move.iter.op.index] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iter.opindex">issues</a> in [reverse.iter.opindex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses US 91</b></p>
++<p><b>Addresses UK 279 [CD1]</b></p>
+
+ <p>
+-It is unclear whether or not a failed <tt>compare_exchange</tt> is a RMW operation
+-(as used in 1.10 [intro.multithread]).
+-</p>
+-
+-<p>
+-Suggested solution:
++The reason the return type became unspecified is LWG issue <a href="lwg-defects.html#386">386</a>. This
++reasoning no longer applies as there are at least two ways to get the right
++return type with the new language facilities added since the previous
++standard.
+ </p>
+
+ <p>
+-Make failing <tt>compare_exchange</tt> operations <b>not</b> be RMW.
++Proposal: Specify the return type using either decltype or the Iter concept_map.
+ </p>
+
+ <p><i>[
+-Anthony Williams adds:
++Summit:
+ ]</i></p>
+
+
+ <blockquote>
+-In 29.6 [atomics.types.operations] p18 it says that "These
+-operations are atomic read-modify-write operations" (final sentence).
+-This is overly restrictive on the implementations of
+-<tt>compare_exchange_weak</tt> and <tt>compare_exchange_strong</tt> on platforms without a
+-native CAS instruction.
++<p>
++Under discussion. This is a general question about all iterator
++adapters.
++</p>
+ </blockquote>
+
+-
+ <p><i>[
+-Summit:
++Howard adds post Summit:
+ ]</i></p>
+
+
+-<blockquote>
+-Group agrees with the resolution as proposed by Anthony Williams in the attached note.
+-</blockquote>
++<blockquote><p>
++I am requesting test cases to demonstrate a position.
++</p></blockquote>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-07-24 Daniel adds:
+ ]</i></p>
+
+-<blockquote>
+-We recommend the proposed resolution be reviewed
+-by members of the Concurrency Subgroup.
+-</blockquote>
+
+-<p><i>[
+-2009-07 post-Frankfurt:
+-]</i></p>
++<blockquote>
++<p>
++I recommend NAD. Without concepts we can no longer
++restrict this member in a trivial way. Using <tt>decltype</tt> the
++declaration would be along the lines of
++</p>
++<blockquote><pre>
++static const Iter&amp; __base(); // not defined
++auto operator[](difference_type n) const -&gt; decltype(__base()[-n-1]);
++</pre></blockquote>
+
++<p>
++but once <tt>reverse_iterator</tt> is instantiated for some given type
++<tt>Iter</tt> which cannot form a well-formed expression <tt>__base()[-n-1]</tt>
++this would cause an ill-formed function declaration, diagnostic
++required, and no silent SFINAE elimination.
++</p>
+
+-<blockquote>
+-This is likely to be addressed by Lawrence's upcoming paper. He will
+-adopt the proposed resolution.
+ </blockquote>
+
+ <p><i>[
+-2009-08-17 Handled by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
++<blockquote><p>
++Moved to NAD.
++</p></blockquote>
++
+ <p><i>[
+-2009-10 Santa Cruz:
++2009-10-22 Daniel adds:
+ ]</i></p>
+
+
+ <blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Change 29.6 [atomics.types.operations] p18:
++IMO, my original comment regarding ill-formedness of the described
++construction is still correct, but I must add that I should weaken my
++assertion "Without concepts we can no longer restrict this member in
++a trivial way".
+ </p>
+
+-<blockquote>
+--18- <i>Effects:</i> Atomically, compares the value pointed to by
+-<tt>object</tt> or by <tt>this</tt> for equality with that in
+-<tt>expected</tt>, and if true, replaces the value pointed to by
+-<tt>object</tt> or by <tt>this</tt> with desired, and if false, updates
+-the value in <tt>expected</tt> with the value pointed to by
+-<tt>object</tt> or by <tt>this</tt>. Further, if the comparison is true,
+-memory is affected according to the value of <tt>success</tt>, and if the
+-comparison is false, memory is affected according to the value of
+-<tt>failure</tt>. When only one <tt>memory_order</tt> argument is
+-supplied, the value of <tt>success</tt> is <tt>order</tt>, and the value
+-of <tt>failure</tt> is <tt>order</tt> except that a value of
+-<tt>memory_order_acq_rel</tt> shall be replaced by the value
+-<tt>memory_order_acquire</tt> and a value of
+-<tt>memory_order_release</tt> shall be replaced by the value
+-<tt>memory_order_relaxed</tt>. <ins>If the comparison is <tt>true</tt>, </ins>
+-<del>T</del><ins>t</ins>hese operations are atomic
+-read-modify-write operations (1.10).
+-<ins>If the comparison is <tt>false</tt>, these
+-operations are atomic load operations.</ins>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1046"></a>1046. Response to UK 329</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 329</b></p>
+-
+ <p>
+-<tt>future</tt>, <tt>promise</tt> and <tt>packaged_task</tt> provide a
+-framework for creating future values, but a simple function to tie all
+-three components together is missing. Note that we only need a *simple*
+-facility for C++0x. Advanced thread pools are to be left for TR2.
++In fact with the existence of default template arguments for function
++templates it is not too hard to implement this like as follows, which
++shows that we can indeed simulate to some sense constrained
++member functions in C++0x.
+ </p>
+
+ <p>
+-Simple Proposal:
++My example does not really proof that the specification is easy, but
++it should be possible. I assume that the implementation would not
++be ABI compatible, though.
+ </p>
+
+ <p>
+-Provide a simple function along the lines of:
++It is now your own decision how to proceed ;-)
+ </p>
+-<blockquote><pre>template&lt; typename F, typename ... Args &gt;
+- requires Callable&lt; F, Args... &gt;
+- future&lt; Callable::result_type &gt; async( F&amp;&amp; f, Args &amp;&amp; ... );
+-</pre></blockquote>
+
+-<p>
+-Semantics are similar to creating a <tt>thread</tt> object with a <tt>packaged_task</tt>
+-invoking <tt>f</tt> with <tt>forward&lt;Args&gt;(args...)</tt>
+-but details are left unspecified to allow different scheduling and thread
+-spawning implementations.
+-</p>
+-<p>
+-It is unspecified whether a task submitted to async is run on its own thread
+-or a thread previously used for another async task. If a call to <tt>async</tt>
+-succeeds, it shall be safe to wait for it from any thread.
+-</p>
+-<p>
+-The state of <tt>thread_local</tt> variables shall be preserved during <tt>async</tt> calls.
+-</p>
+-<p>
+-No two incomplete async tasks shall see the same value of
+-<tt>this_thread::get_id()</tt>.
+-</p>
+-<p>
+-[<i>Note:</i> this effectively forces new tasks to be run on a new thread, or a
+-fixed-size pool with no queue. If the
+-library is unable to spawn a new thread or there are no free worker threads
+-then the <tt>async</tt> call should fail. <i>--end note</i>]
+-</p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++#include &lt;cstddef&gt;
+
+-<p><i>[
+-Summit:
+-]</i></p>
++template&lt;class T&gt;
++typename std::add_rvalue_reference&lt;T&gt;::type declval();
+
++template&lt;class It&gt;
++struct reverse_iterator {
++ It base;
++
++ typedef std::ptrdiff_t difference_type;
++
++ template&lt;class U = It, class Res =
++ decltype(declval&lt;const U&amp;&gt;()[declval&lt;difference_type&gt;()])
++ &gt;
++ Res operator[](difference_type n) const {
++ return base[-n-1];
++ }
++};
++
++struct MyIter {
++};
++
++int main() {
++ reverse_iterator&lt;int*&gt; ri;
++ ri[0] = 2;
++ reverse_iterator&lt;MyIter&gt; ri2;
++}
++</pre></blockquote>
+
+-<blockquote>
+-<p>
+-The concurrency subgroup has revisited this issue and decided that it
+-could be considered a defect according to the Kona compromise. A task
+-group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a
+-paper for Frankfort proposing a simple asynchronous launch facility
+-returning a <tt>future</tt>. It was agreed that the callable must be run on a
+-separate thread from the caller, but not necessarily a brand-new thread.
+-The proposal might or might not allow for an implementation that uses
+-fixed-size or unlimited thread pools.
+-</p>
+ <p>
+-Bjarne in c++std-lib-23121: I think that what we agreed was that to
+-avoid deadlock <tt>async()</tt> would almost certainly be specified to launch in
+-a different thread from the thread that executed <tt>async()</tt>, but I don't
+-think it was a specific design constraint.
++The above declaration could be simplified, but the ideal solution
+ </p>
+-</blockquote>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
++<blockquote><pre>
++template&lt;class U = It&gt;
++ decltype(declval&lt;const U&amp;&gt;()[declval&lt;difference_type&gt;()])
++ operator[](difference_type n) const;
++</pre></blockquote>
+
++<p>
++does not work yet on gcc 4.4.1.
++</p>
+
+-<blockquote>
+-Proposed resolution: see
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2996.html">N2996</a>
+-(Herb's and Lawrence's paper on Async). Move state to NAD editorial.
+ </blockquote>
+
+
+
++
+ <p><b>Proposed resolution:</b></p>
+
+
+@@ -34525,220 +28100,178 @@ Proposed resolution: see
+
+
+ <hr>
+-<h3><a name="1047"></a>1047. Response to UK 334</h3>
+-<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1056"></a>1056. Must all Engines and Distributions be Streamable?</h3>
++<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 334</b></p>
+-
+ <p>
+-Behaviour of <tt>get()</tt> is undefined if calling <tt>get()</tt> while
+-not <tt>is_ready()</tt>. The intent is that <tt>get()</tt> is a blocking
+-call, and will wait for the future to become ready.
++Both the concepts <tt>RandomNumberEngine</tt> and <tt>RandomNumberDistribution</tt> have
++requirements to be <tt>InputStreamable</tt> and <tt>OutputStreamable</tt>.
++</p>
++<p>
++I have no problems leaving the WP in an inconsistent state on the best-faith
++assumption these concepts will be provided later, however disagree with the
++proposers that these constraints are not separable, orthogonal to the basic
++concepts of generating random number distributions.
++</p>
++<p>
++These constraints should be dropped, and applied to specific algorithms as
++needed.
++</p>
++<p>
++If a more refined concept (certainly deemed useful by the proposers) is
++proposed there is no objection, but the basic concept should not require
++persistence via streaming.
+ </p>
+
+ <p><i>[
+-Summit:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+-<blockquote>
+-<p>
+-Agree, move to Review.
+-</p>
+-</blockquote>
++<blockquote><p>
++Move to Open.
++</p></blockquote>
+
+ <p><i>[
+-2009-04-03 Thomas J. Gritzan adds:
++2009-05-31 Alisdair adds:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-This issue also applies to <tt>shared_future::get()</tt>.
++Working on constraining the stream iterators, I have a few more observations
++to make on the concepts proposed while constraining the random number
++facility.
+ </p>
+-
+ <p>
+-Suggested wording:
++While I still believe the concerns are orthogonal, I don't believe the
++existing constraints go far enough either! The goal we want to achieve is
++not that a <tt>RandomNumberEngine</tt> / <tt>RandomNumberDistribution</tt> supports the stream
++operators, but that it is <tt>Serializable</tt>. I.e. there is a relationship
++between the insert and extract operations that guarantees to restore the
++state of the original object. This implies a coupling of the concepts
++together in a broader concept (<tt>Serializable</tt>) with at least one axiom to
++assert the semantics.
+ </p>
+-
+ <p>
+-Add a paragraph to 30.6.7 [futures.shared_future]:
++One problem is that <tt>istream</tt> and <tt>ostream</tt> may be fundamentally different
++types, although we can hook a relation if we are prepared to drop down to
++the <tt>char</tt> type and <tt>char_traits</tt> template parameters. Doing so ties us to a
++form of serialization that demands implementation via the std iostreams
++framework, which seems overly prescriptive. I believe the goal is generally
++to support serialization without regard to how it is expressed - although
++this is getting even more inventive in terms of concepts we do not have
++today.
+ </p>
+-
+-<blockquote><pre>void shared_future&lt;void&gt;::get() const;
+-</pre>
+-<blockquote>
+-<i>Effects:</i> If <tt>is_ready()</tt> would return <tt>false</tt>, block on the asynchronous
+-result associated with <tt>*this</tt>.
+-</blockquote>
+-</blockquote>
+ </blockquote>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-11-03 Alisdair adds:
+ ]</i></p>
+
++
+ <blockquote>
+-It is not clear to us that this is an issue,
+-because the proposed resolution's Effects clause seems to duplicate
+-information already present in the Synchronization clause.
+-Keep in Review status.
++<p>
++I can't find the record in the wiki minutes, but it was agreed at both
++Frankfurt and Santa Cruz that this issue is NAD.
++</p>
++<p>
++The agreement in SC was that I would provide you with the rationale (see
++below) to include when moving to NAD.
++</p>
+ </blockquote>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2009-11-03 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
+-
++<blockquote><p>
++Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Add a paragraph to 30.6.6 [futures.unique_future]:
+-</p>
+
+-<blockquote><pre>R&amp;&amp; unique_future::get();
+-R&amp; unique_future&lt;R&amp;&gt;::get();
+-void unique_future&lt;void&gt;::get();
+-</pre>
+-<blockquote>
+-<p><i>Note:</i>...</p>
++
++<p><b>Rationale:</b></p>
+ <p>
+-<ins><i>Effects:</i> If <tt>is_ready()</tt> would return <tt>false</tt>,
+-block on the asynchronous result associated with <tt>*this</tt>.</ins>
++The issue suggests a more refined concept should be used if we want to
++require streaming, to separate concerns from the basic
++<tt>RandomNumberEngine</tt> behaviour. In Frankfurt it was observed
++that <tt>RandomNumberEngine</tt> <em>is</em> that more refined concept,
++and the basic concept used in the framework is
++<tt>UniformRandomNumberGenerator</tt>, which it refines.
+ </p>
++
+ <p>
+-<i>Synchronization:</i> if <tt>*this</tt> is associated with a
+-<tt>promise</tt> object, the completion of <tt>set_value()</tt> or
+-<tt>set_exception()</tt> to that <tt>promise</tt> happens before (1.10)
+-<tt>get()</tt> returns.
++We concur, and expect this to have no repurcussions re-writing this
++clause now concepts are removed.
+ </p>
+-</blockquote>
+-</blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1048"></a>1048. Response to UK 335</h3>
+-<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1057"></a>1057. <tt>RandomNumberEngineAdaptor</tt></h3>
++<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 335</b></p>
+-
+ <p>
+-<tt>std::unique_future</tt> is <tt>MoveConstructible</tt>, so you can transfer the
+-association with an asynchronous result from one instance to another.
+-However, there is no way to determine whether or not an instance has
+-been moved from, and therefore whether or not it is safe to wait for it.
++The <tt>RandomNumberEngineAdaptor</tt> concept breaks precedent in the
++way the library has been specified by grouping requirements into a
++concept that is never actually used in the library.
++</p>
++<p>
++This is undoubtedly a very helpful device for documentation, but we are not
++comfortable with the precedent - especially as we have rejected national
++body comments on the same grounds.
+ </p>
+-
+-<blockquote><pre>std::promise&lt;int&gt; p;
+-std::unique_future&lt;int&gt; uf(p.get_future());
+-std::unique_future&lt;int&gt; uf2(std::move(uf));
+-uf.wait(); <font color="#C80000">// oops, uf has no result to wait for. </font>
+-</pre></blockquote>
+-
+ <p>
+-Suggest we add a <tt>waitable()</tt> function to <tt>unique_future</tt>
+-(and <tt>shared_future</tt>) akin to <tt>std::thread::joinable()</tt>,
+-which returns <tt>true</tt> if there is an associated result to wait for
+-(whether or not it is ready).
++Suggest either removing the concept, or providing an algorithm/type that
++requires this concept in their definition (such as a factory function to
++create new engines).
+ </p>
+-
+ <p>
+-Then we can say:
++The preference is to create a single new algorithm and retain the value of
++the existing documentation.
+ </p>
+
+-<blockquote><pre>if(uf.waitable()) uf.wait();
+-</pre></blockquote>
+-
+ <p><i>[
+-Summit:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+ <p>
+-Create an issue. Requires input from Howard. Probably NAD.
++Walter points out that it is unlikely that any algorithm would ever
++require this concept, but that the concept nonetheless is useful as
++documentation, and (via concept maps) as a means of checking specific adapters.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-Post Summit, Howard thows in his two cents:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-Here is a copy/paste of my last prototype of <tt>unique_future</tt> which was
+-several years ago. At that time I was calling <tt>unique_future</tt> <tt>future</tt>:
++Alisdair disagrees as to the concept's value as documentation.
+ </p>
+-
+-<blockquote><pre>template &lt;class R&gt;
+-class future
+-{
+-public:
+- typedef R result_type;
+-private:
+- future(const future&amp;);// = delete;
+- future&amp; operator=(const future&amp;);// = delete;
+-
+- template &lt;class R1, class F1&gt; friend class prommise;
+-public:
+- future();
+- ~future();
+-
+- future(future&amp;&amp; f);
+- future&amp; operator=(future&amp;&amp; f);
+-
+- void swap(future&amp;&amp; f);
+-
+- <b>bool joinable() const;</b>
+- bool is_normal() const;
+- bool is_exceptional() const;
+- bool is_ready() const;
+-
+- R get();
+-
+- void join();
+- template &lt;class ElapsedTime&gt;
+- bool timed_join(const ElapsedTime&amp;);
+-};
+-</pre></blockquote>
+-
+ <p>
+-<tt>shared_future</tt> had a similar interface. I intentionally reused
+-the <tt>thread</tt> interface where possible to lessen the learning
+-curve std::lib clients will be faced with.
++Marc points out that the <tt>RandomNumberDistribution</tt>
++is also a concept not used elsewhere in the Standard.
++</p>
++<p>
++Pete agrees that a policy of not inventing concepts
++that aren't used in the Standard is a good starting point,
++but should not be used as a criterion for rejecting a concept.
++</p>
++<p>
++Move to Open.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+ </blockquote>
+
+
+-
+ <p><b>Proposed resolution:</b></p>
+
+
+@@ -34746,213 +28279,242 @@ NAD Editorial. Solved by
+
+
+ <hr>
+-<h3><a name="1049"></a>1049. Response to UK 339</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1058"></a>1058. New container issue</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 339</b></p>
+-
+ <p>
+-Move assignment is goiing in the wrong direction, assigning from
+-<tt>*this</tt> to the passed rvalue, and then returning a reference to
+-an unusable <tt>*this</tt>.
++Sequence containers 23.2.3 [sequence.reqmts]:
+ </p>
+
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-Agree, move to Review.
++The return value of new calls added to table 83 are not specified.
+ </p>
+-</blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+ <blockquote>
+-We recommend deferring this issue until after Detlef's paper (on futures)
+-has been issued.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
++<p>
++We agree with the proposed resolution.
++</p>
++<p>
++Move to NAD Editorial.
++</p>
+ </blockquote>
+
+
+-
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Strike 30.6.5 [futures.promise] p6 and change p7:
++Add after p6 23.2.3 [sequence.reqmts]:
+ </p>
+
+-<blockquote><pre>promise&amp; operator=(promise&amp;&amp; rhs);
+-</pre>
+ <blockquote>
+ <p>
+-<del>-6- <i>Effects:</i> move assigns its associated state to <tt>rhs</tt>.</del>
+-</p>
+-<p>
+--7- <i>Postcondition:</i> <del><tt>*this</tt> has no associated
+-state.</del> <ins>associated state of <tt>*this</tt> is the same as the
+-associated state of <tt>rhs</tt> before the call. <tt>rhs</tt> has no
+-associated state.</ins>
++-6- ...
+ </p>
+-</blockquote>
++<p><ins>
++The iterator returned from <tt>a.insert(p,rv)</tt> points to the copy of <tt>rv</tt>
++inserted into <tt>a</tt>.
++</ins></p>
++<p><ins>
++The iterator returned from <tt>a.emplace(p, args)</tt> points to the new
++element constructed from <tt>args</tt> inserted into <tt>a</tt>.
++</ins></p>
+ </blockquote>
+
+
+
+
+
+-
+ <hr>
+-<h3><a name="1050"></a>1050. Response to UK 340</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1059"></a>1059. Usage of no longer existing FunctionType concept</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 340</b></p>
+-
+ <p>
+-There is an implied postcondition for <tt>get_future()</tt> that the state of the
+-<tt>promise</tt> is transferred into the <tt>future</tt> leaving the <tt>promise</tt> with no
+-associated state. It should be spelled out.
++Due to a deliberate core language decision, the earlier called
++"foundation" concept <tt>std::FunctionType</tt> had been removed in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2773.pdf">N2773</a>
++shortly
++before the first "conceptualized" version of the WP
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>)
++had been
++prepared. This caused a break of the library, which already used this
++concept in the adapted definition of <tt>std::function</tt>
++(20.9 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis and
++20.9.12.2 [func.wrap.func]).
+ </p>
+-
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-Agree, move to Review.
++A simple fix would be to either (a) make <tt>std::function</tt>'s primary template
++unconstrained or to (b) add constraints based on existing (support) concepts.
++A more advanced fix would (c) introduce a new library concept.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-04-03 Thomas J. Gritzan adds:
+-]</i></p>
+-
+-
+-<blockquote>
+ <p>
+-<tt>promise::get_future()</tt> must not invalidate the state of the promise object.
++The big disadvantage of (a) is, that users can define templates which
++cause compiler errors during instantiation time because of under-constrainedness
++and would thus violate the basic advantage of constrained
++code.
+ </p>
+ <p>
+-A promise is used like this:
++For (b), the ideal constraints for <tt>std::function</tt>'s template parameter would
++be one which excludes everything else but the single provided partial
++specialization that matches every "free function" type (i.e. any function
++type w/o cv-qualifier-seq and w/o ref-qualifier).
++Expressing such a type as as single requirement would be written as
+ </p>
+-<blockquote><pre>promise&lt;int&gt; p;
+-unique_future&lt;int&gt; f = p.get_future();
+-<font color="#C80000">// post 'p' to a thread that calculates a value </font>
+-<font color="#C80000">// use 'f' to retrieve the value. </font>
++<blockquote><pre>
++template&lt;typename T&gt;
++requires ReferentType&lt;T&gt; // Eliminate cv void and function types with cv-qual-seq
++ // or ref-qual (depending on core issue #749)
++ &amp;&amp; PointeeType&lt;T&gt; // Eliminate reference types
++ &amp;&amp; !ObjectType&lt;T&gt; // Eliminate object types
+ </pre></blockquote>
+ <p>
+-So <tt>get_future()</tt> must return an object that shares the same associated
+-state with <tt>*this</tt>.
+-</p>
+-<p>
+-But still, this function should throw an <tt>future_already_retrieved</tt> error
+-when it is called twice.
+-</p>
+-<p>
+-<tt>packaged_task::get_future()</tt> throws <tt>std::bad_function_call</tt> if its <tt>future</tt>
+-was already retrieved. It should throw
+-<tt>future_error(future_already_retrieved)</tt>, too.
++Just for completeness approach (c), which would make sense, if the
++library has more reasons to constrain for free function types:
+ </p>
++<blockquote><pre>
++auto concept FreeFunctionType&lt;typename T&gt;
++ : ReferentType&lt;T&gt;, PointeeType&lt;T&gt;, MemberPointeeType&lt;T&gt;
++{
++ requires !ObjectType&lt;T&gt;;
++}
++</pre></blockquote>
+ <p>
+-Suggested resolution:
++I mention that approach because I expect that free function types belong
++to the most natural type categories for every days coders. Potential
++candidates in the library are <tt>addressof</tt> and class template <tt>packaged_task</tt>.
+ </p>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
+ <p>
+-Replace p12/p13 30.6.5 [futures.promise]:
++Alisdair would prefer to have a core-supported <tt>FunctionType</tt> concept
++in order that any future changes be automatically correct
++without need for a library solution to catch up;
++he points to type traits as a precedent.
++Further, he believes that a published concept can't in the future
++be changed.
+ </p>
+-<blockquote>
+ <p>
+--12- <i>Throws:</i> <tt>future_error</tt> if <del><tt>*this</tt> has no associated state</del>
+-<ins>the <tt>future</tt> has already been retrieved</ins>.
++Bill feels this category of entity would change sufficiently slowly
++that he would be willing to take the risk.
+ </p>
+ <p>
+--13- <i>Error conditions:</i> <tt>future_already_retrieved</tt> if <del><tt>*this</tt>
+-has no associated state</del>
+-<ins>the <tt>future</tt> associated with
+-the associated state has already been retrieved</ins>.
++Of the discussed solutions, we tend toward option (c).
++We like the idea of having a complete taxonomy of native types,
++and perhaps erred in trimming the set.
+ </p>
+ <p>
+-<ins><i>Postcondition:</i> The returned object and <tt>*this</tt> share the associated state.</ins>
++We would like to have this issue reviewed by Core and would like
++their feedback. Move to Open.
+ </p>
+ </blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
+ <p>
+-Replace p14 30.6.10 [futures.task]:
++Change in 20.9 [function.objects]/2, Header <tt>&lt;functional&gt;</tt> synopsis:
+ </p>
+-<blockquote>
++<blockquote><pre>
++// 20.6.16 polymorphic function wrappers:
++class bad_function_call;
++template&lt;<del>FunctionType</del><ins>ReferentType F</ins>&gt;
++<ins>requires PointeeType&lt;F&gt; &amp;&amp; !ObjectType&lt;F&gt;</ins>
++class function; // undefined
++</pre></blockquote>
++</li>
++<li>
+ <p>
+--14- <i>Throws:</i> <tt><del>std::bad_function_call</del> <ins>future_error</ins></tt> if the future <del>associated with
+-the task</del> has already been retrieved.
++Change in 20.9.12.2 [func.wrap.func]:
+ </p>
++<blockquote><pre>
++namespace std {
++template&lt;<del>FunctionType</del><ins>ReferentType F</ins>&gt;
++<ins>requires PointeeType&lt;F&gt; &amp;&amp; !ObjectType&lt;F&gt;</ins>
++class function; // undefined
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1060"></a>1060. Embedded nulls in NTBS</h3>
++<p><b>Section:</b> 17.5.2.1.4.1 [byte.strings] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<p><ins>
+-<i>Error conditions:</i> <tt>future_already_retrieved</tt> if the <tt>future</tt> associated with
+-the task has already been retrieved.
+-</ins></p>
+ <p>
+-<ins><i>Postcondition:</i> The returned object and <tt>*this</tt> share the associated task.</ins>
++Definition of null-terminated sequences allow for embedded nulls. This is
++surprising, and probably not supportable with the intended use cases.
+ </p>
+-</blockquote>
+-</blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
+-Keep in Review status
+-pending Detlef's forthcoming paper on futures.
+-</blockquote>
++<blockquote><p>
++We agree with the issue, but believe this can be handled editorially.
++Move to NAD Editorial.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1061"></a>1061. Bad indexing for tuple access to pair (Editorial?)</h3>
++<p><b>Section:</b> 20.3.4 [pair.astuple] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The definition of <tt>get</tt> implies that <tt>get</tt> must return the second element if
++given a negative integer.
++</p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
++<blockquote><p>
++Move to NAD Editorial.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add after p13 30.6.5 [futures.promise]:
++20.3.4 [pair.astuple] p5:
+ </p>
+
+-<blockquote><pre>unique_future&lt;R&gt; get_future();
++<blockquote><pre>
++template&lt;<del>int</del> <ins>size_t</ins> I, class T1, class T2&gt;
++ requires True&lt;(I &lt; 2)&gt;
++ const P&amp; get(const pair&lt;T1, T2&gt;&amp;);
+ </pre>
+-<blockquote>
+-<p>
+--13- ...
+-</p>
+-<p>
+-<i>Postcondition:</i> <tt>*this</tt> has no associated state.
+-</p>
+-</blockquote>
+ </blockquote>
+
+
+@@ -34961,817 +28523,775 @@ Add after p13 30.6.5 [futures.promise]:
+
+
+ <hr>
+-<h3><a name="1051"></a>1051. Response to UK 279</h3>
+-<p><b>Section:</b> 24.5.1.3.12 [reverse.iter.opindex], 24.5.3.3.12 [move.iter.op.index] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1062"></a>1062. Missing insert_iterator for stacks/queues</h3>
++<p><b>Section:</b> 24.5.2 [insert.iterators] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 279</b></p>
+-
+ <p>
+-The reason the return type became unspecified is LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#386">386</a>. This
+-reasoning no longer applies as there are at least two ways to get the right
+-return type with the new language facilities added since the previous
+-standard.
++It is odd that we have an iterator to insert into a <tt>vector</tt>, but not an
++iterator to insert into a <tt>vector</tt> that is adapted as a <tt>stack</tt>. The standard
++container adapters all have a common interface to <tt>push</tt> and <tt>pop</tt> so it should
++be simple to create an iterator adapter to complete the library support.
+ </p>
+
+ <p>
+-Proposal: Specify the return type using either decltype or the Iter concept_map.
++We should provide an <tt>AdaptedContainer</tt> concept supporting <tt>push</tt> and <tt>pop</tt>
++operations. Create a new insert iterator and factory function that inserts
++values into the container by calling <tt>push</tt>.
+ </p>
+
+ <p><i>[
+-Summit:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+ <p>
+-Under discussion. This is a general question about all iterator
+-adapters.
++Walter recommends NAD Future.
++</p>
++<p>
++Move to Open, and recommend deferring the issue until after the next
++Committee Draft is issued.
+ </p>
+ </blockquote>
+
+ <p><i>[
+-Howard adds post Summit:
++2009-07-29 Howard moves to Tentatively NAD Future.
+ ]</i></p>
+
+
+-<blockquote>
+-I am requesting test cases to demonstrate a position.
+-</blockquote>
++<blockquote><p>
++A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future.
++</p></blockquote>
+
+ <p><i>[
+-2009-07-24 Daniel adds:
++2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-I recommend NAD. Without concepts we can no longer
+-restrict this member in a trivial way. Using <tt>decltype</tt> the
+-declaration would be along the lines of
+-</p>
+-<blockquote><pre>static const Iter&amp; __base(); // not defined
+-auto operator[](difference_type n) const -&gt; decltype(__base()[-n-1]);
+-</pre></blockquote>
+-
+-<p>
+-but once <tt>reverse_iterator</tt> is instantiated for some given type
+-<tt>Iter</tt> which cannot form a well-formed expression <tt>__base()[-n-1]</tt>
+-this would cause an ill-formed function declaration, diagnostic
+-required, and no silent SFINAE elimination.
+-</p>
++<blockquote><p>
++Moved to NAD. The intent of these adapters are to restrict the interfaces.
++</p></blockquote>
+
+-</blockquote>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-Moved to NAD.
+-</blockquote>
+
+-<p><i>[
+-2009-10-22 Daniel adds:
+-]</i></p>
+
+
+-<blockquote>
+-<p>
+-IMO, my original comment regarding ill-formedness of the described
+-construction is still correct, but I must add that I should weaken my
+-assertion "Without concepts we can no longer restrict this member in
+-a trivial way".
+-</p>
+
+-<p>
+-In fact with the existence of default template arguments for function
+-templates it is not too hard to implement this like as follows, which
+-shows that we can indeed simulate to some sense constrained
+-member functions in C++0x.
+-</p>
++<hr>
++<h3><a name="1063"></a>1063. 03 iterator compatibilty</h3>
++<p><b>Section:</b> X [iterator.backward] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+
+ <p>
+-My example does not really proof that the specification is easy, but
+-it should be possible. I assume that the implementation would not
+-be ABI compatible, though.
++Which header must a user <tt>#include</tt> to obtain the library-supplied
++<tt>concept_maps</tt> declared in this paragraph?
+ </p>
+
+ <p>
+-It is now your own decision how to proceed ;-)
++This is important information, as existing user code will break if this
++header is not included, and we should make a point of mandating this header
++is <tt>#include</tt>-d by library headers likely to make use of it, notably
++<tt>&lt;algorithm&gt;</tt>. See issue <a href="lwg-closed.html#1001">1001</a> for more details.
+ </p>
+
+-<blockquote><pre>#include &lt;type_traits&gt;
+-#include &lt;cstddef&gt;
+-
+-template&lt;class T&gt;
+-typename std::add_rvalue_reference&lt;T&gt;::type declval();
++<p><i>[
++Batavia (2009-05):
++]</i></p>
+
+-template&lt;class It&gt;
+-struct reverse_iterator {
+- It base;
+-
+- typedef std::ptrdiff_t difference_type;
+-
+- template&lt;class U = It, class Res =
+- decltype(declval&lt;const U&amp;&gt;()[declval&lt;difference_type&gt;()])
+- &gt;
+- Res operator[](difference_type n) const {
+- return base[-n-1];
+- }
+-};
++<blockquote><p>
++We agree with the direction of the proposed resolution.
++Move to Tentatively Ready.
++</p></blockquote>
+
+-struct MyIter {
+-};
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
+
+-int main() {
+- reverse_iterator&lt;int*&gt; ri;
+- ri[0] = 2;
+- reverse_iterator&lt;MyIter&gt; ri2;
+-}
+-</pre></blockquote>
+
+-<p>
+-The above declaration could be simplified, but the ideal solution
+-</p>
++<blockquote><p>
++We believe this is NAD Concepts, but this needs to be reviewed against the
++post-remove-concepts draft.
++</p></blockquote>
+
+-<blockquote><pre>template&lt;class U = It&gt;
+- decltype(declval&lt;const U&amp;&gt;()[declval&lt;difference_type&gt;()])
+- operator[](difference_type n) const;
+-</pre></blockquote>
+
+-<p>
+-does not work yet on gcc 4.4.1.
+-</p>
++<p><b>Proposed resolution:</b></p>
++<p><i>Change [depr.lib.iterator.primitives], Iterator primitives, as
++indicated:</i></p>
+
++<blockquote>
++ <p>To simplify the use of iterators and provide backward compatibility with
++ previous C++ Standard Libraries,
++ the library provides several classes and functions. <ins>Unless otherwise
++ specified, these classes and functions shall be defined in header <tt>&lt;iterator&gt;</tt>.</ins></p>
++</blockquote>
++<p><i>Change X [iterator.backward], Iterator backward compatibility, as
++indicated:</i></p>
++<blockquote>
++ <p>The library provides concept maps that allow iterators specified with
++ <tt>iterator_traits</tt> to interoperate with
++ algorithms that require iterator concepts. <ins>These concept maps shall be
++ defined in the same header that defines the iterator.</ins> [<i>Example:</i></p>
+ </blockquote>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1052"></a>1052. Response to UK 281</h3>
+-<p><b>Section:</b> 24.5.1.3.5 [reverse.iter.opref] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1064"></a>1064. Term "object state" should not refer to classes</h3>
++<p><b>Section:</b> 17.3 [defns.obj.state] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 281</b></p>
++<p><b>Addresses UK 152 [CD1]</b></p>
+
+ <p>
+-The current specification for return value for <tt>reverse_iterator::operator-&gt;</tt>
+-will always be a true pointer type, but <tt>reverse_iterator</tt> supports proxy
+-iterators where the pointer type may be some kind of 'smart pointer'.
++Object state is using a definition of object (instance of a class) from
++outside the standard, rather than the 'region of storage' definiton in
++1.8 [intro.object]p1
+ </p>
+
+ <p><i>[
+ Summit:
+ ]</i></p>
+
++<blockquote><p>
++We think we're removing this; See X [func.referenceclosure.cons].
++</p></blockquote>
+
+-<blockquote>
+-<p>
+-<tt>move_iterator</tt> avoids this problem by returning a value of the wrapped
+-Iterator type.
+-study group formed to come up with a suggested resolution.
+-</p>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark as NAD. This will not affect user or implementer code
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-<tt>move_iterator</tt> solution shown in proposed wording.
+ </p>
+-</blockquote>
+
+-<p><i>[
+-2009-07 post-Frankfurt:
+-]</i></p>
+
+
+-<blockquote>
+-Howard to deconceptize. Move to Review after that happens.
+-</blockquote>
+
+-<p><i>[
+-2009-08-01 Howard deconceptized:
+-]</i></p>
+
++<hr>
++<h3><a name="1067"></a>1067. simplified wording for inner_product</h3>
++<p><b>Section:</b> 26.7 [numeric.ops] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.ops">issues</a> in [numeric.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<blockquote>
+-</blockquote>
++<p>
++One of the motivating examples for introducing requirements-aliases was to
++simplify the wording of the <tt>inner_product</tt> requirements. As the paper
++adopting the feature and constrained wording for the library went through in
++the same meeting, it was not possible to make the change at the time. The
++simpler form should be adopted now though. Similarly, most the other
++numerical algorithms can benefit from a minor cleanup.
++</p>
++<p>
++Note that in each case, the second more generalised form of the algorithm
++does not benefit, as there are already named constraints supplied by the
++template type parameters.
++</p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2009-05-02 Daniel adds:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-We can't think of any reason we can't just define reverse
+-iterator's pointer types to be the same as the underlying iterator's
+-pointer type, and get it by calling the right arrow directly.
++one part of the suggested resolution suggests the removal of the
++<tt>MoveConstructible&lt;T&gt;</tt> requirement from
++<tt>inner_product</tt>. According to 26.7.3 [inner.product]
+ </p>
++
++<blockquote><p>
++Computes its result by initializing the accumulator <tt>acc</tt> with the
++initial value <tt>init</tt>
++</p></blockquote>
++
+ <p>
+-Here is the proposed wording that was replaced:
++this step requires at least <tt>MoveConstructible</tt>.
+ </p>
+-<blockquote><pre>template &lt;class Iterator&gt;
+-class reverse_iterator {
+- ...
+- typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
+-</pre></blockquote>
+
+ <p>
+-Change 24.5.1.3.5 [reverse.iter.opref]:
++Therefore I strongly suggest to take this removal back (Note also
++that the corresponding overload with a functor argument still has
++the same <tt>MoveConstructible&lt;T&gt;</tt> requirement).
+ </p>
+-
+-<blockquote><pre>pointer operator-&gt;() const;
+-</pre>
+-<blockquote>
+-<i>Returns:</i>
+-<blockquote><pre><del>&amp;(operator*());</del>
+-<ins>this-&gt;tmp = current;</ins>
+-<ins>--this-&gt;tmp;</ins>
+-<ins>return this-&gt;tmp;</ins>
+-</pre></blockquote>
+-</blockquote>
+-</blockquote>
+ </blockquote>
+
+ <p><i>[
+-2010-03-03 Daniel opens:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+-<ol>
+-
+-<li>
+-There is a minor problem with the exposition-only declaration of the private
+-member <tt>deref_tmp</tt> which is modified in a const member function (and the
+-same problem occurs in the specification of <tt>operator*</tt>). The fix is to
+-make it a mutable member.
+-</li>
+-
+-<li>
+ <p>
+-The more severe problem is that the resolution for some reasons
+-does not explain in the rationale why it was decided to differ from
+-the suggested fix (using <tt>deref_tmp</tt> instead of <tt>tmp</tt>) in the
+-[ 2009-10 Santa Cruz] comment:
++We agree with the proposed resolution as amended by Daniel's suggestion
++to restore <tt>MoveConstructible</tt>,
++reflected in the updated proposed resolution below.
++</p>
++<p>
++Move to Tentatively Ready.
+ </p>
++</blockquote>
+
+-<blockquote><pre>this-&gt;deref_tmp = current;
+---this-&gt;deref_tmp;
+-return this-&gt;deref_tmp;
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-combined with the change of
++Change in 26.7 [numeric.ops] and 26.7.2 [accumulate]:
+ </p>
+
+-<blockquote><pre>typedef typename iterator_traits&lt;Iterator&gt;::pointer pointer;
++<blockquote><pre>
++template &lt;InputIterator Iter, MoveConstructible T&gt;
++ requires <ins>add =</ins> HasPlus&lt;T, Iter::reference&gt;
++ &amp;&amp; HasAssign&lt;T, <del>HasPlus&lt;T, Iter::reference&gt;</del> <ins>add</ins>::result_type&gt;
++ T accumulate(Iter first, Iter last, T init);
+ </pre></blockquote>
+
+ <p>
+-to
++Change in 26.7 [numeric.ops] and 26.7.3 [inner.product]:
+ </p>
+
+-<blockquote><pre>typedef Iterator pointer;
++<blockquote><pre>
++template &lt;InputIterator Iter1, InputIterator Iter2, MoveConstructible T&gt;
++ requires <ins>mult =</ins> HasMultiply&lt;Iter1::reference, Iter2::reference&gt;
++ &amp;&amp; <ins>add =</ins> HasPlus&lt;T, <del>HasMultiply&lt;Iter1::reference, Iter2::reference&gt;</del> <ins>mult</ins>::result_type&gt;
++ &amp;&amp; HasAssign&lt;
++ T,
++ <del>HasPlus&lt;T,
++ HasMultiply&lt;Iter1::reference, Iter2::reference&gt;::result_type&gt;</del> <ins>add</ins>::result_type&gt;
++ T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);
+ </pre></blockquote>
+
+ <p>
+-The problem of the agreed on wording is that the following rather
+-typical example, that compiled with the wording before 1052 had
+-been applied, won't compile anymore:
++Change in 26.7 [numeric.ops] and 26.7.4 [partial.sum]:
+ </p>
+
+-<blockquote><pre>#include &lt;iterator&gt;
+-#include &lt;utility&gt;
+-
+-int main() {
+- typedef std::pair&lt;int, double&gt; P;
+- P op;
+- std::reverse_iterator&lt;P*&gt; ri(&amp;op + 1);
+- ri-&gt;first; // Error
+-}
++<blockquote><pre>
++template &lt;InputIterator InIter, OutputIterator&lt;auto, const InIter::value_type&amp;&gt; OutIter&gt;
++ requires <ins>add =</ins> HasPlus&lt;InIter::value_type, InIter::reference&gt;
++ &amp;&amp; HasAssign&lt;InIter::value_type,
++ <del>HasPlus&lt;InIter::value_type, InIter::reference&gt;</del> <ins>add</ins>::result_type&gt;
++ &amp;&amp; Constructible&lt;InIter::value_type, InIter::reference&gt;
++ OutIter partial_sum(InIter first, InIter last, OutIter result);
+ </pre></blockquote>
+
+ <p>
+-Comeau online returns (if a correspondingly changed
+-<tt>reverse_iterator</tt> is used):
++Change in 26.7 [numeric.ops] and 26.7.5 [adjacent.difference]:
+ </p>
+
+-<blockquote><pre>"error: expression must have class type
+- return deref_tmp.operator-&gt;();
+- ^
+- detected during instantiation of "Iterator
+- reverse_iterator&lt;Iterator&gt;::operator-&gt;() const [with
+- Iterator=std::pair&lt;int, double&gt; *]""
++<blockquote><pre>
++template &lt;InputIterator InIter, OutputIterator&lt;auto, const InIter::value_type&amp;&gt; OutIter&gt;
++ requires <ins>sub =</ins> HasMinus&lt;InIter::value_type, InIter::value_type&gt;
++ &amp;&amp; Constructible&lt;InIter::value_type, InIter::reference&gt;
++ &amp;&amp; OutputIterator&lt;OutIter, <del>HasMinus&lt;InIter::value_type, InIter::value_type&gt;</del> <ins>sub</ins>::result_type&gt;
++ &amp;&amp; MoveAssignable&lt;InIter::value_type&gt;
++ OutIter adjacent_difference(InIter first, InIter last, OutIter result);
+ </pre></blockquote>
+
+-<p>
+-Thus the change will break valid, existing code based
+-on <tt>std::reverse_iterator</tt>.
+-</p>
+
+-</li>
+
+-</ol>
+
+-<p>
+-IMO the suggestion proposed in the comment is a necessary fix, which harmonizes
+-with the similar specification of <tt>std::move_iterator</tt> and properly
+-reflects the recursive nature of the evaluation of <tt>operator-&gt;</tt>
+-overloads.
+-</p>
+
+-<p>
+-Suggested resolution:
+-</p>
+
+-<ol>
++<hr>
++<h3><a name="1068"></a>1068. class <tt>random_device</tt> should be movable</h3>
++<p><b>Section:</b> 26.5.6 [rand.device] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.device">issues</a> in [rand.device].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<li>
+ <p>
+-In the class template <tt>reverse_iterator</tt> synopsis of 24.5.1.1 [reverse.iterator] change as indicated:
++class <tt>random_device</tt> should be movable.
+ </p>
+
+-<blockquote><pre>namespace std {
+-template &lt;class Iterator&gt;
+-class reverse_iterator : public
+- iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
+- typename iterator_traits&lt;Iterator&gt;::value_type,
+- typename iterator_traits&lt;Iterator&gt;::difference_type,
+- <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del>,
+- typename iterator_traits&lt;Iterator&gt;::reference&gt; {
+-public:
+- [..]
+- typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
+- [..]
+-protected:
+- Iterator current;
+-private:
+- <ins>mutable</ins> Iterator deref_tmp; // exposition only
+-};
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated:
+-
+-<blockquote><pre>pointer operator-&gt;() const;
+-</pre>
++<p><i>[
++Batavia (2009-05):
++]</i></p>
+
+-<blockquote>
+-1 <i><del>Returns</del> <ins>Effects</ins>:</i> <del><tt>&amp;(operator*())</tt>.</del>
+-<blockquote><pre><ins>deref_tmp = current;</ins>
+-<ins>--deref_tmp;</ins>
+-<ins>return deref_tmp;</ins>
+-</pre></blockquote>
+-</blockquote>
+-</blockquote>
++<blockquote><p>
++Move to Open, and recommend this issue be deferred until after the next
++Committee Draft is issued.
++</p></blockquote>
+
+-</li>
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
+
+-</ol>
+
+-</blockquote>
++<blockquote><p>
++Leave open. Walter to provide drafting as part of his planned paper.
++</p></blockquote>
+
+ <p><i>[
+-2010 Pittsburgh:
++2010 Pittsburgh: Moved to NAD.
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-We prefer to make to use a local variable instead of <tt>deref_tmp</tt> within
+-<tt>operator-&gt;()</tt>. And although this means that the <tt>mutable</tt>
+-change is no longer needed, we prefer to keep it because it is needed for
+-<tt>operator*()</tt> anyway.
+-</p>
+
+-<p>
+-Here is the proposed wording that was replaced:
+-</p>
+
+-<blockquote class="note">
++<p><b>Rationale:</b></p>
+ <p>
+-Change 24.5.1.3.5 [reverse.iter.opref]:
++WP is correct as written.
+ </p>
+
+-<blockquote><pre>pointer operator-&gt;() const;
+-</pre>
+-
+-<blockquote>
+
+-<i>Returns:</i>
+-<blockquote><pre><del>&amp;(operator*());</del>
+-<ins>deref_tmp = current;
+---deref_tmp;
+-return deref_tmp::operator-&gt;();</ins>
+-</pre></blockquote>
++<p><b>Proposed resolution:</b></p>
+
+-</blockquote>
+-</blockquote>
+
+
+-</blockquote>
+-</blockquote>
+
+-<p><i>[
+-2010-03-10 Howard adds:
+-]</i></p>
+
++<hr>
++<h3><a name="1069"></a>1069. class <tt>seed_seq</tt> should support efficient move operations</h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<blockquote>
+ <p>
+-Here are three tests that the current proposed wording passes, and no
+-other solution I've seen passes all three:
++class <tt>seed_seq</tt> should support efficient move operations.
+ </p>
+
+-<ol>
+-<li>
+-<p>
+-Proxy pointer support:
+-</p>
+-<blockquote><pre>#include &lt;iterator&gt;
+-#include &lt;cassert&gt;
++<p><i>[
++Batavia (2009-05):
++]</i></p>
+
+-struct X { int m; };
++<blockquote><p>
++Move to Open, and recommend this issue be deferred until after the next
++Committee Draft is issued.
++</p></blockquote>
+
+-X x;
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
+
+-struct IterX {
+- typedef std::bidirectional_iterator_tag iterator_category;
+- typedef X&amp; reference;
+- struct pointer
+- {
+- pointer(X&amp; v) : value(v) {}
+- X&amp; value;
+- X* operator-&gt;() const {return &amp;value;}
+- };
+- typedef std::ptrdiff_t difference_type;
+- typedef X value_type;
+- // additional iterator requirements not important for this issue
+-
+- reference operator*() const { return x; }
+- pointer operator-&gt;() const { return pointer(x); }
+- IterX&amp; operator--() {return *this;}
+
+-};
++<blockquote><p>
++Leave open. Walter to provide drafting as part of his planned paper.
++</p></blockquote>
+
+-int main()
+-{
+- std::reverse_iterator&lt;IterX&gt; ix;
+- assert(&amp;ix-&gt;m == &amp;(*ix).m);
+-}
+-</pre></blockquote>
+-</li>
+-<li>
+-<p>
+-Raw pointer support:
+-</p>
+-<blockquote><pre>#include &lt;iterator&gt;
+-#include &lt;utility&gt;
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
+
+-int main() {
+- typedef std::pair&lt;int, double&gt; P;
+- P op;
+- std::reverse_iterator&lt;P*&gt; ri(&amp;op + 1);
+- ri-&gt;first; // Error
+-}
+-</pre></blockquote>
+-</li>
+-<li>
+-<p>
+-Caching iterator support:
+-</p>
+-<blockquote><pre>#include &lt;iterator&gt;
+-#include &lt;cassert&gt;
+
+-struct X { int m; };
++<blockquote><p>
++<tt>seed_seq</tt> is explicitly not copyable, so, much like LWG issue
++<a href="lwg-closed.html#1068">1068</a>, LWG issue 1069 could be marked NAD to be consistent
++with this.
++</p></blockquote>
+
+-struct IterX {
+- typedef std::bidirectional_iterator_tag iterator_category;
+- typedef X&amp; reference;
+- typedef X* pointer;
+- typedef std::ptrdiff_t difference_type;
+- typedef X value_type;
+- // additional iterator requirements not important for this issue
+-
+- reference operator*() const { return value; }
+- pointer operator-&gt;() const { return &amp;value; }
+- IterX&amp; operator--() {return *this;}
+
+-private:
+- mutable X value;
+-};
+
+-int main()
+-{
+- std::reverse_iterator&lt;IterX&gt; ix;
+- assert(&amp;ix-&gt;m == &amp;(*ix).m);
+-}
+-</pre></blockquote>
+-</li>
+-</ol>
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
+
+
+-<blockquote>
+-Moved to NAD Future, rationale added.
+-</blockquote>
+
+
+
++<hr>
++<h3><a name="1072"></a>1072. Is <tt>std::hash</tt> a constrained template or not?</h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-The LWG did not reach a consensus for a change to the WP.
++Is <tt>std::hash</tt> a constrained template or not?
++</p>
++<p>
++According to class template <tt>hash</tt> 20.9.13 [unord.hash], the definition is:
+ </p>
+
++<blockquote><pre>
++template &lt;class T&gt;
++struct hash : public std::unary_function&lt;T, std::size_t&gt; {
++ std::size_t operator()(T val) const;
++};
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
++<p>
++And so unconstrained.
++</p>
++<p>
++According to the <tt>&lt;functional&gt;</tt> synopsis in p2 Function objects
++20.9 [function.objects] the template is declared as:
++</p>
+
+-<ol>
++<blockquote><pre>
++template &lt;ReferentType T&gt; struct hash;
++</pre></blockquote>
+
+-<li>
+ <p>
+-In the class template <tt>reverse_iterator</tt> synopsis of 24.5.1.1 [reverse.iterator] change as indicated:
++which would make hash a constrained template.
+ </p>
+
+-<blockquote><pre>namespace std {
+-template &lt;class Iterator&gt;
+-class reverse_iterator : public
+- iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
+- typename iterator_traits&lt;Iterator&gt;::value_type,
+- typename iterator_traits&lt;Iterator&gt;::difference_type,
+- <del>typename iterator_traits&lt;</del>Iterator<ins>&amp;</ins><del>&gt;::pointer</del>,
+- typename iterator_traits&lt;Iterator&gt;::reference&gt; {
+-public:
+- [..]
+- typedef <del>typename iterator_traits&lt;</del>Iterator<ins>&amp;</ins><del>&gt;::pointer</del> pointer;
+- [..]
+-protected:
+- Iterator current;
+-private:
+- <ins>mutable</ins> Iterator deref_tmp; // exposition only
+-};
+-</pre></blockquote>
+-</li>
++<p><i>[
++2009-03-22 Daniel provided wording.
++]</i></p>
+
+-<li>
+-Change 24.5.1.3.5 [reverse.iter.opref]/1 as indicated:
+
+-<blockquote><pre>pointer operator-&gt;() const;
+-</pre>
++<p><i>[
++Batavia (2009-05):
++]</i></p>
+
+ <blockquote>
+-1 <i><del>Returns</del> <ins>Effects</ins>:</i> <del><tt>&amp;(operator*())</tt>.</del>
+-<blockquote><pre><ins>deref_tmp = current;</ins>
+-<ins>--deref_tmp;</ins>
+-<ins>return deref_tmp;</ins>
+-</pre></blockquote>
+-</blockquote>
++<p>
++Alisdair is not certain that Daniel's proposed resolution is sufficient,
++and recommends we leave the hash template unconstrained for now.
++</p>
++<p>
++Recommend that the Project Editor make the constrained declaration consistent
++with the definition in order to make the Working Paper internally consistent,
++and that the issue then be revisited.
++</p>
++<p>
++Move to Open.
++</p>
+ </blockquote>
+
+-</li>
+-
+-</ol>
+
++<p><b>Proposed resolution:</b></p>
+
++<p>
++[To the editor: This resolution is merge-compatible to the
++resolution of <a href="lwg-closed.html#1078">1078</a>]
++</p>
+
++<ol>
++<li>
++<p>
++In 20.9 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis, change as indicated:
++</p>
+
++<blockquote><pre>
++// 20.6.17, hash function base template:
++template &lt;ReferentType T&gt; struct hash; <ins>// undefined</ins>
++</pre></blockquote>
++</li>
++<li>
++<p>
++In 20.9.13 [unord.hash]/1 change as indicated:
++</p>
++<blockquote><pre>
++namespace std {
++ <del>template &lt;class T&gt;
++ struct hash : public std::unary_function&lt;T, std::size_t&gt; {
++ std::size_t operator()(T val) const;
++ };</del>
++ <ins>template &lt;ReferentType T&gt; struct hash; // undefined</ins>
++}
++</pre></blockquote>
++</li>
++<li>
++<p>
++In 20.9.13 [unord.hash]/2 change as indicated:
++</p>
+
++<blockquote><p>
++-2- <ins>For all library-provided specializations, the template
++instantiation <tt>hash&lt;T&gt;</tt>
++ shall provide a public <tt>operator()</tt> with return type <tt>std::size_t</tt> to
++satisfy the concept
++ requirement <tt>Callable&lt;const hash&lt;T&gt;, const T&amp;&gt;</tt>. If <tt>T</tt> is an object
++type or reference to
++ object, <tt>hash&lt;T&gt;</tt> shall be publicly derived from
++<tt>std::unary_function&lt;T, std::size_t&gt;</tt>.
++ </ins> The return value of <tt>operator()</tt> is unspecified, except that
++equal arguments
++ shall yield the same result. <tt>operator()</tt> shall not throw exceptions.
++</p></blockquote>
++</li>
++<li>
++<p>
++In 18.7 [support.rtti]/1, header <tt>&lt;typeinfo&gt;</tt> synopsis change as indicated:
++</p>
++<blockquote><pre>
++namespace std {
++ class type_info;
++ class type_index;
++ template &lt;<del>class</del><ins>ReferentType</ins> T&gt; struct hash;
++</pre></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1053"></a>1053. Response to UK 295</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1074"></a>1074. concept map broken by N2840</h3>
++<p><b>Section:</b> X [allocator.element.concepts] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 295</b></p>
+-
+ <p>
+-There is a level of redundancy in the library specification for many
+-algorithms that can be eliminated with the combination of concepts and
+-default parameters for function templates. Eliminating redundancy simplified
+-specification and reduces the risk of introducing accidental
+-inconsistencies.
++p7 Allocator-related element concepts X [allocator.element.concepts]
+ </p>
++
+ <p>
+-Proposed resolution: Adopt
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2743.pdf">N2743</a>.
++The changes to the <tt>AllocatableElement</tt> concept mean this <tt>concept_map</tt>
++specialization no longer matches the original concept:
+ </p>
+
++<blockquote><pre>
++template &lt;Allocator Alloc, class T, class ... Args&gt;
++ requires HasConstructor&lt;T, Args...&gt;
++ concept_map AllocatableElement&lt;Alloc, T, Args&amp;&amp;...&gt; {
++ void construct_element(Alloc&amp; a, T* t, Args&amp;&amp;... args) {
++ Alloc::rebind&lt;T&gt;(a).construct(t, forward(args)...);
++ }
++ }
++</pre></blockquote>
++
+ <p><i>[
+-Summit:
++2009-03-23 Pablo adds:
+ ]</i></p>
+
+
++<blockquote><p>
++Actually, this is incorrect,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2840.pdf">N2840</a>
++says. "In section
++X [allocator.element.concepts] paragraph 8, modify the definition of the
++<tt>AllocatableElement</tt> concept and eliminate the related concept map:" but
++then neglects to include the red-lined text of the concept map that was
++to be eliminated. Pete also missed this, but I caught it he asked me to
++review his edits. Pete's updated WP removes the concept map entirely,
++which was the original intent. The issue is, therefore, moot. Note, as
++per my presentation of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2840.pdf">N2840</a>
++in summit, <tt>construct()</tt> no longer has a
++default implementation. This regrettable fact was deemed (by David
++Abrahams, Doug, and myself) to be preferable to the complexity of
++providing a default implementation that would not under-constrain a more
++restrictive allocator (like the scoped allocators).
++</p></blockquote>
++
++<p><i>[
++2009-05-01 Daniel adds:
++]</i></p>
++
+ <blockquote>
+ <p>
+-NAD, this change would break code that takes the address of an
+-algorithm.
++it seems to me that #1074 should be resolved as a NAD, because the
++current WP has already removed the previous AllocatableElement concept map.
++It introduced auto concept AllocatableElement instead, but as of
++X [allocator.element.concepts]/7 this guy contains now
+ </p>
++<blockquote><pre>
++requires FreeStoreAllocatable&lt;T&gt;;
++void Alloc::construct(T*, Args&amp;&amp;...);
++</pre></blockquote>
+ </blockquote>
+
+ <p><i>[
+-Post Summit Alisdair adds:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+ <p>
+-Request 'Open'. The issues in the paper go beyond just reducing
+-the number of signatures, but cover unifying the idea of the ordering
+-operation used by algorithms, containers and other library components. At
+-least, it takes a first pass at the problem.
++The affected code is no longer part of the Working Draft.
+ </p>
+-
+ <p>
+-For me (personally) that was the more important part of the paper, and not
+-clearly addressed by the Summit resolution.
++Move to NAD.
+ </p>
+ </blockquote>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Too inventive, too late, would really need a paper. Moved to NAD Future.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
++<p>
++Change X [allocator.element.concepts]:
++</p>
+
++<blockquote><pre>
++template &lt;Allocator Alloc, class T, class ... Args&gt;
++ requires HasConstructor&lt;T, Args...&gt;
++ concept_map AllocatableElement&lt;Alloc, T, Args&amp;&amp;...&gt; {
++ void construct_element(<del>Alloc&amp; a,</del> T* t, Args&amp;&amp;... args) {
++ Alloc::rebind&lt;T&gt;(a).construct(t, forward(args)...);
++ }
++ }
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1056"></a>1056. Must all Engines and Distributions be Streamable?</h3>
+-<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1076"></a>1076. unary/binary_negate need constraining and move support</h3>
++<p><b>Section:</b> 20.9.9 [negators] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+ <p>
+-Both the concepts <tt>RandomNumberEngine</tt> and <tt>RandomNumberDistribution</tt> have
+-requirements to be <tt>InputStreamable</tt> and <tt>OutputStreamable</tt>.
++The class templates <tt>unary/binary_negate</tt> need constraining and move support.
+ </p>
+ <p>
+-I have no problems leaving the WP in an inconsistent state on the best-faith
+-assumption these concepts will be provided later, however disagree with the
+-proposers that these constraints are not separable, orthogonal to the basic
+-concepts of generating random number distributions.
++Ideally these classes would be deprecated, allowing <tt>unary/binary_function</tt> to
++also be deprecated. However, until a generic negate adaptor is introduced
++that can negate any <tt>Callable</tt> type, they must be supported so should be
++constrained. Likewise, they should be movable, and support adopting a
++move-only predicate type.
+ </p>
+ <p>
+-These constraints should be dropped, and applied to specific algorithms as
+-needed.
++In order to preserve ABI compatibility, new rvalue overloads are supplied in
++preference to changing the existing pass-by-const-ref to pass-by-value.
+ </p>
+ <p>
+-If a more refined concept (certainly deemed useful by the proposers) is
+-proposed there is no objection, but the basic concept should not require
+-persistence via streaming.
++Do not consider the issue of forwarding mutable lvalues at this point,
++although remain open to another issue on the topic.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-05-01 Daniel adds:
+ ]</i></p>
+
+ <blockquote>
+-Move to Open.
+-</blockquote>
+-
+-<p><i>[
+-2009-05-31 Alisdair adds:
+-]</i></p>
+-
++<p>
++IMO the currently proposed resolution needs some updates
++because it is ill-formed at several places:
++</p>
+
+-<blockquote>
++<ol>
++<li>
+ <p>
+-Working on constraining the stream iterators, I have a few more observations
+-to make on the concepts proposed while constraining the random number
+-facility.
++In concept AdaptableUnaryFunction change
+ </p>
++<blockquote><pre>
++typename X::result_type;
++typename X::argument_type;
++</pre></blockquote>
+ <p>
+-While I still believe the concerns are orthogonal, I don't believe the
+-existing constraints go far enough either! The goal we want to achieve is
+-not that a <tt>RandomNumberEngine</tt> / <tt>RandomNumberDistribution</tt> supports the stream
+-operators, but that it is <tt>Serializable</tt>. I.e. there is a relationship
+-between the insert and extract operations that guarantees to restore the
+-state of the original object. This implies a coupling of the concepts
+-together in a broader concept (<tt>Serializable</tt>) with at least one axiom to
+-assert the semantics.
++to
+ </p>
++<blockquote><pre>
++Returnable result_type = typename X::result_type;
++typename argument_type = typename X::argument_type;
++</pre></blockquote>
+ <p>
+-One problem is that <tt>istream</tt> and <tt>ostream</tt> may be fundamentally different
+-types, although we can hook a relation if we are prepared to drop down to
+-the <tt>char</tt> type and <tt>char_traits</tt> template parameters. Doing so ties us to a
+-form of serialization that demands implementation via the std iostreams
+-framework, which seems overly prescriptive. I believe the goal is generally
+-to support serialization without regard to how it is expressed - although
+-this is getting even more inventive in terms of concepts we do not have
+-today.
++[The replacement "Returnable result_type" instead of "typename
++result_type" is non-editorial, but maybe you prefer that as well]
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-11-03 Alisdair adds:
+-]</i></p>
+-
+-
+-<blockquote>
++</li>
++<li>
+ <p>
+-I can't find the record in the wiki minutes, but it was agreed at both
+-Frankfurt and Santa Cruz that this issue is NAD.
++In concept AdaptableBinaryFunction change
+ </p>
++<blockquote><pre>
++typename X::result_type;
++typename X::first_argument_type;
++typename X::second_argument_type;
++</pre></blockquote>
+ <p>
+-The agreement in SC was that I would provide you with the rationale (see
+-below) to include when moving to NAD.
++to
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-11-03 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-<p><b>Rationale:</b></p>
++<blockquote><pre>
++Returnable result_type = typename X::result_type;
++typename first_argument_type = typename X::first_argument_type;
++typename second_argument_type = typename X::second_argument_type;
++</pre></blockquote>
+ <p>
+-The issue suggests a more refined concept should be used if we want to
+-require streaming, to separate concerns from the basic
+-<tt>RandomNumberEngine</tt> behaviour. In Frankfurt it was observed
+-that <tt>RandomNumberEngine</tt> <em>is</em> that more refined concept,
+-and the basic concept used in the framework is
+-<tt>UniformRandomNumberGenerator</tt>, which it refines.
++[The replacement "Returnable result_type" instead of "typename
++result_type" is non-editorial, but maybe you prefer that as well.]
+ </p>
++</li>
+
++<li>
+ <p>
+-We concur, and expect this to have no repurcussions re-writing this
+-clause now concepts are removed.
++In class unary/binary_function
+ </p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1057"></a>1057. <tt>RandomNumberEngineAdaptor</tt></h3>
+-<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
++<ol style="list-style-type:lower-alpha">
++<li>
++I suggest to change "ReturnType" to "Returnable" in both cases.
++</li>
++<li>
++I think you want to replace the remaining occurrences of "Predicate" by "P"
++(in both classes in copy/move from a predicate)
++</li>
++</ol>
++</li>
++<li>
+ <p>
+-The <tt>RandomNumberEngineAdaptor</tt> concept breaks precedent in the
+-way the library has been specified by grouping requirements into a
+-concept that is never actually used in the library.
++I think you need to change the proposed signatures of not1 and not2, because
++they would still remain unconstrained: To make them constrained at least a
++single requirement needs to be added to enable requirement implication. This
++could be done via a dummy ("requires True&lt;true&gt;") or just explicit as follows:
+ </p>
++<ol style="list-style-type:lower-alpha">
++<li>
++<blockquote><pre>
++template &lt;AdaptableUnaryFunction P&gt;
++requires Predicate&lt; P, P::argument_type&gt;
++unary_negate&lt;P&gt; not1(const P&amp;&amp; pred);
++template &lt;AdaptableUnaryFunction P&gt;
++requires Predicate&lt; P, P::argument_type &gt;
++unary_negate&lt;P&gt; not1(P&amp;&amp; pred);
++</pre>
++<blockquote><p>
++-3- Returns: unary_negate&lt;P&gt;(pred).
++</p></blockquote>
++</blockquote>
+ <p>
+-This is undoubtedly a very helpful device for documentation, but we are not
+-comfortable with the precedent - especially as we have rejected national
+-body comments on the same grounds.
++[Don't we want a move call for the second overload as in
++</p>
++<blockquote><pre>
++unary_negate&lt;P&gt;(std::move(pred))
++</pre></blockquote>
++<p>
++in the Returns clause ?]
+ </p>
++</li>
++<li>
++<pre>
++template &lt;AdaptableBinaryFunction P&gt;
++requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;
++binary_negate&lt;P&gt; not2(const P&amp; pred);
++template &lt;AdaptableBinaryFunction P&gt;
++requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;
++binary_negate&lt;P&gt; not2(P&amp;&amp; pred);
++</pre>
+ <p>
+-Suggest either removing the concept, or providing an algorithm/type that
+-requires this concept in their definition (such as a factory function to
+-create new engines).
++-5- Returns: binary_negate&lt;P&gt;(pred).
+ </p>
+ <p>
+-The preference is to create a single new algorithm and retain the value of
+-the existing documentation.
++[Don't we want a move call for the second overload as in
++</p>
++<blockquote><pre>
++binary_negate&lt;P&gt;(std::move(pred))
++</pre></blockquote>
++<p>
++in the Returns clause ?]
+ </p>
++</li>
++</ol>
++</li>
++</ol>
++</blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -35779,225 +29299,172 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-Walter points out that it is unlikely that any algorithm would ever
+-require this concept, but that the concept nonetheless is useful as
+-documentation, and (via concept maps) as a means of checking specific adapters.
+-</p>
+-<p>
+-Alisdair disagrees as to the concept's value as documentation.
+-</p>
+-<p>
+-Marc points out that the <tt>RandomNumberDistribution</tt>
+-is also a concept not used elsewhere in the Standard.
++There is concern that complicating the solution
++to preserve the ABI seems unnecessary,
++since we're not in general preserving the ABI.
+ </p>
+ <p>
+-Pete agrees that a policy of not inventing concepts
+-that aren't used in the Standard is a good starting point,
+-but should not be used as a criterion for rejecting a concept.
++We would prefer a separate paper consolidating all Clause 20
++issues that are for the purpose of providing constrained versions
++of the existing facilities.
+ </p>
+ <p>
+ Move to Open.
+ </p>
+ </blockquote>
+
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+
++<blockquote><p>
++Leave open pending the potential move constructor paper. Note that
++we consider the "constraining" part NAD Concepts.
++</p></blockquote>
++
++<p><i>[
++2010-01-31 Alisdair removes the current proposed wording from the proposed
++wording section because it is based on concepts. That wording is proposed here:
++]</i></p>
+
+
++<blockquote class="note">
++<p>
++Add new concepts where appropriate::
++</p>
+
++<blockquote><pre>
++auto concept AdaptableUnaryFunction&lt; typename X &gt; {
++ typename X::result_type;
++ typename X::argument_type;
++}
+
+-<hr>
+-<h3><a name="1058"></a>1058. New container issue</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
++auto concept AdaptableBinaryFunction&lt; typename X &gt; {
++ typename X::result_type;
++ typename X::first_argument_type;
++ typename X::second_argument_type;
++}
++</pre></blockquote>
+
+ <p>
+-Sequence containers 23.2.3 [sequence.reqmts]:
++Revise as follows:
+ </p>
+
+ <p>
+-The return value of new calls added to table 83 are not specified.
++Base [base] (Only change is constrained Result)
+ </p>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+ <blockquote>
+ <p>
+-We agree with the proposed resolution.
+-</p>
+-<p>
+-Move to NAD Editorial.
++-1- The following classes are provided to simplify the typedefs of the
++argument and result types:
+ </p>
+-</blockquote>
++<pre>
++namespace std {
++ template &lt;class Arg, <del>class</del> <ins>ReturnType</ins> Result&gt;
++ struct unary_function {
++ typedef Arg argument_type;
++ typedef Result result_type;
++ };
+
++ template &lt;class Arg1, class Arg2, <del>class</del> <ins>ReturnType</ins> Result&gt;
++ struct binary_function {
++ typedef Arg1 first_argument_type;
++ typedef Arg2 second_argument_type;
++ typedef Result result_type;
++ };
++}
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Add after p6 23.2.3 [sequence.reqmts]:
++Negators 20.9.9 [negators]:
+ </p>
+
+ <blockquote>
+ <p>
+--6- ...
++-1- Negators <tt>not1</tt> and <tt>not2</tt> take a unary and a binary predicate,
++respectively, and return their complements (5.3.1).
+ </p>
+-<p><ins>
+-The iterator returned from <tt>a.insert(p,rv)</tt> points to the copy of <tt>rv</tt>
+-inserted into <tt>a</tt>.
+-</ins></p>
+-<p><ins>
+-The iterator returned from <tt>a.emplace(p, args)</tt> points to the new
+-element constructed from <tt>args</tt> inserted into <tt>a</tt>.
+-</ins></p>
+-</blockquote>
+
++<pre>
++template &lt;<del>class</del> <ins>AdaptableUnaryFunction</ins> P<del>redicate</del>&gt;
++ <ins>requires Predicate&lt; P, P::argument_type &gt;</ins>
++ class unary_negate
++ : public unary_function&lt;<del>typename</del> P<del>redicate</del>::argument_type,bool&gt; {
++ public:
++ <ins>unary_negate(const unary_negate &amp; ) = default;</ins>
++ <ins>unary_negate(unary_negate &amp;&amp; );</ins>
+
++ <ins>requires CopyConstructible&lt; P &gt;</ins>
++ explicit unary_negate(const Predicate&amp; pred);
++ <ins>requires MoveConstructible&lt; P &gt;
++ explicit unary_negate(Predicate &amp;&amp; pred);</ins>
+
++ bool operator()(const <del>typename</del> P<del>redicate</del>::argument_type&amp; x) const;
++ };
++</pre>
++<blockquote><p>
++-2 <tt>operator()</tt> returns <tt>!pred(x)</tt>.
++</p></blockquote>
+
++<pre>
++template &lt;class Predicate&gt;
++ unary_negate&lt;Predicate&gt; not1(const Predicate&amp;amp; pred);
++<ins>template &lt;class Predicate&gt;
++ unary_negate&lt;Predicate&gt; not1(Predicate&amp;&amp; pred);</ins>
++</pre>
++<blockquote><p>
++-3- <i>Returns:</i> <tt>unary_negate&lt;Predicate&gt;(pred)</tt>.
++</p></blockquote>
+
+-<hr>
+-<h3><a name="1059"></a>1059. Usage of no longer existing FunctionType concept</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Due to a deliberate core language decision, the earlier called
+-"foundation" concept <tt>std::FunctionType</tt> had been removed in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2773.pdf">N2773</a>
+-shortly
+-before the first "conceptualized" version of the WP
+-(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>)
+-had been
+-prepared. This caused a break of the library, which already used this
+-concept in the adapted definition of <tt>std::function</tt>
+-(20.8 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis and
+-20.8.14.2 [func.wrap.func]).
+-</p>
+-<p>
+-A simple fix would be to either (a) make <tt>std::function</tt>'s primary template
+-unconstrained or to (b) add constraints based on existing (support) concepts.
+-A more advanced fix would (c) introduce a new library concept.
+-</p>
+-<p>
+-The big disadvantage of (a) is, that users can define templates which
+-cause compiler errors during instantiation time because of under-constrainedness
+-and would thus violate the basic advantage of constrained
+-code.
+-</p>
+-<p>
+-For (b), the ideal constraints for <tt>std::function</tt>'s template parameter would
+-be one which excludes everything else but the single provided partial
+-specialization that matches every "free function" type (i.e. any function
+-type w/o cv-qualifier-seq and w/o ref-qualifier).
+-Expressing such a type as as single requirement would be written as
+-</p>
+-<blockquote><pre>template&lt;typename T&gt;
+-requires ReferentType&lt;T&gt; // Eliminate cv void and function types with cv-qual-seq
+- // or ref-qual (depending on core issue #749)
+- &amp;&amp; PointeeType&lt;T&gt; // Eliminate reference types
+- &amp;&amp; !ObjectType&lt;T&gt; // Eliminate object types
+-</pre></blockquote>
+-<p>
+-Just for completeness approach (c), which would make sense, if the
+-library has more reasons to constrain for free function types:
+-</p>
+-<blockquote><pre>auto concept FreeFunctionType&lt;typename T&gt;
+- : ReferentType&lt;T&gt;, PointeeType&lt;T&gt;, MemberPointeeType&lt;T&gt;
+-{
+- requires !ObjectType&lt;T&gt;;
+-}
+-</pre></blockquote>
+-<p>
+-I mention that approach because I expect that free function types belong
+-to the most natural type categories for every days coders. Potential
+-candidates in the library are <tt>addressof</tt> and class template <tt>packaged_task</tt>.
+-</p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-Alisdair would prefer to have a core-supported <tt>FunctionType</tt> concept
+-in order that any future changes be automatically correct
+-without need for a library solution to catch up;
+-he points to type traits as a precedent.
+-Further, he believes that a published concept can't in the future
+-be changed.
+-</p>
+-<p>
+-Bill feels this category of entity would change sufficiently slowly
+-that he would be willing to take the risk.
+-</p>
+-<p>
+-Of the discussed solutions, we tend toward option (c).
+-We like the idea of having a complete taxonomy of native types,
+-and perhaps erred in trimming the set.
+-</p>
+-<p>
+-We would like to have this issue reviewed by Core and would like
+-their feedback. Move to Open.
+-</p>
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Change in 20.8 [function.objects]/2, Header <tt>&lt;functional&gt;</tt> synopsis:
+-</p>
+-<blockquote><pre>// 20.6.16 polymorphic function wrappers:
+-class bad_function_call;
+-template&lt;<del>FunctionType</del><ins>ReferentType F</ins>&gt;
+-<ins>requires PointeeType&lt;F&gt; &amp;&amp; !ObjectType&lt;F&gt;</ins>
+-class function; // undefined
+-</pre></blockquote>
+-</li>
+-<li>
+-<p>
+-Change in 20.8.14.2 [func.wrap.func]:
+-</p>
+-<blockquote><pre>namespace std {
+-template&lt;<del>FunctionType</del><ins>ReferentType F</ins>&gt;
+-<ins>requires PointeeType&lt;F&gt; &amp;&amp; !ObjectType&lt;F&gt;</ins>
+-class function; // undefined
+-</pre></blockquote>
+-</li>
+-</ol>
++<pre>
++template &lt;<del>class</del> <ins>AdaptableBinaryFunction</ins> P<del>redicate</del> &gt;
++ <ins>requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;</ins>
++ class binary_negate
++ : public binary_function&lt;<del>typename</del> P<del>redicate</del>::first_argument_type,
++ <del>typename</del> P<del>redicate</del>::second_argument_type, bool&gt; {
++ public:
++ <ins>biary_negate(const binary_negate &amp; ) = default;</ins>
++ <ins>binary_negate(binary_negate &amp;&amp; );</ins>
+
++ <ins>requires CopyConstructible&lt; P &gt;</ins>
++ explicit binary_negate(const Predicate&amp; pred);
++ <ins>requires MoveConstructible&lt; P &gt;
++ explicit binary_negate(const Predicate&amp; pred);</ins>
+
++ bool operator()(const <del>typename</del> P<del>redicate</del>::first_argument_type&amp; x,
++ const <del>typename</del> P<del>redicate</del>::second_argument_type&amp; y) const;
++ };
++</pre>
++<blockquote><p>
++-4- <tt>operator()</tt> returns <tt>!pred(x,y)</tt>.
++</p></blockquote>
+
++<pre>
++template &lt;class Predicate&gt;
++ binary_negate&lt;Predicate&gt; not2(const Predicate&amp; pred);
++<ins>template &lt;class Predicate&gt;
++ binary_negate&lt;Predicate&gt; not2(Predicate&amp;&amp; pred);</ins>
++</pre>
+
++<blockquote><p>
++-5- <i>Returns:</i> <tt>binary_negate&lt;Predicate&gt;(pred)</tt>.
++</p></blockquote>
++</blockquote>
+
+-<hr>
+-<h3><a name="1060"></a>1060. Embedded nulls in NTBS</h3>
+-<p><b>Section:</b> 17.5.2.1.4.1 [byte.strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
++</blockquote>
+
+-<p>
+-Definition of null-terminated sequences allow for embedded nulls. This is
+-surprising, and probably not supportable with the intended use cases.
+-</p>
+
+ <p><i>[
+-Batavia (2009-05):
++2010 Rapperswil:
+ ]</i></p>
+
+-<blockquote>
+-We agree with the issue, but believe this can be handled editorially.
+-Move to NAD Editorial.
+-</blockquote>
++
++<blockquote><p>
++Move to NAD Concepts. The move-semantic part has been addressed by a core language change,
++which implicitly generates appropriate move constructors and move-assignment operators.
++</p></blockquote>
+
+
+
+@@ -36008,417 +29475,543 @@ Move to NAD Editorial.
+
+
+ <hr>
+-<h3><a name="1061"></a>1061. Bad indexing for tuple access to pair (Editorial?)</h3>
+-<p><b>Section:</b> 20.3.5.4 [pair.astuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1077"></a>1077. Nonesense <tt>tuple</tt> declarations</h3>
++<p><b>Section:</b> 20.4.2 [tuple.tuple] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.tuple">issues</a> in [tuple.tuple].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++Class template tuple 20.4.2 [tuple.tuple]:
++</p>
++
++<blockquote><pre>
++template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, const UTypes&amp;&gt;...
++template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
++</pre></blockquote>
+
+ <p>
+-The definition of <tt>get</tt> implies that <tt>get</tt> must return the second element if
+-given a negative integer.
++Somebody needs to look at this and say what it should be.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-03-21 Daniel provided wording.
+ ]</i></p>
+
+-<blockquote>
+-Move to NAD Editorial.
+-</blockquote>
+
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++The resolution looks correct; move to NAD Editorial.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-20.3.5.4 [pair.astuple] p5:
++In 20.4.2 [tuple.tuple], class <tt>tuple</tt>, change as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;<del>int</del> <ins>size_t</ins> I, class T1, class T2&gt;
+- requires True&lt;(I &lt; 2)&gt;
+- const P&amp; get(const pair&lt;T1, T2&gt;&amp;);
+-</pre>
+-</blockquote>
++<blockquote><pre>
++template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, const UTypes&amp;&gt;...
++ <ins>tuple(const pair&lt;UTypes...&gt;&amp;);</ins>
++template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
++ <ins>tuple(pair&lt;UTypes...&gt;&amp;&amp;);</ins>
++</pre></blockquote>
+
++<p>
++[NB.: The corresponding prototypes do already exist in 20.4.2.1 [tuple.cnstr]/7+8]
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1062"></a>1062. Missing insert_iterator for stacks/queues</h3>
+-<p><b>Section:</b> 24.5.2 [insert.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#insert.iterators">issues</a> in [insert.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1078"></a>1078. DE-17: Remove class type_index</h3>
++<p><b>Section:</b> 20.14 [type.index] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#type.index">issues</a> in [type.index].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+
++<p><b>Addresses DE 17</b></p>
++
+ <p>
+-It is odd that we have an iterator to insert into a <tt>vector</tt>, but not an
+-iterator to insert into a <tt>vector</tt> that is adapted as a <tt>stack</tt>. The standard
+-container adapters all have a common interface to <tt>push</tt> and <tt>pop</tt> so it should
+-be simple to create an iterator adapter to complete the library support.
++DE-17:
+ </p>
+-
+ <p>
+-We should provide an <tt>AdaptedContainer</tt> concept supporting <tt>push</tt> and <tt>pop</tt>
+-operations. Create a new insert iterator and factory function that inserts
+-values into the container by calling <tt>push</tt>.
++The class <tt>type_index</tt> should be removed; it provides no additional
++functionality beyond providing appropriate concept maps.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-03-31 Peter adds:
+ ]</i></p>
+
++
+ <blockquote>
+ <p>
+-Walter recommends NAD Future.
++It is not true, in principle, that <tt>std::type_index</tt> provides no utility
++compared to bare <tt>std::type_info*</tt>.
+ </p>
+ <p>
+-Move to Open, and recommend deferring the issue until after the next
+-Committee Draft is issued.
++<tt>std::type_index</tt> can avoid the lifetime issues with <tt>type_info</tt> when the
++DLL that has produced the <tt>type_info</tt> object is unloaded. A raw
++<tt>type_info*</tt> does not, and cannot, provide any protection in this case.
++A <tt>type_index</tt> can (if the implementor so chooses) because it can wrap a
++smart (counted or even cloning) pointer to the <tt>type_info</tt> data that is
++needed for <tt>name()</tt> and <tt>before()</tt> to work.
+ </p>
+ </blockquote>
+
+-<p><i>[
+-2009-07-29 Howard moves to Tentatively NAD Future.
+-]</i></p>
+-
+
+-<blockquote>
+-A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future.
+-</blockquote>
+
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
++<p>Modify the header &lt;typeinfo&gt; synopsis in
++ 18.7 [support.rtti]p1 as follows:</p>
+
++<blockquote><pre>
++namespace std {
++ class type_info;
++ <del>class type_index;</del>
++ template &lt;class T&gt; struct hash;
++ template&lt;&gt; struct hash&lt;<del>type_index</del><ins>const type_info *</ins>&gt; : public std::unary_function&lt;<del>type_index</del><ins>const type_info *</ins>, size_t&gt; {
++ size_t operator()(<del>type_index</del><ins>const type_info *</ins> <del>index</del><ins>t</ins>) const;
++ }<ins>;</ins>
++ <ins>concept_map LessThanComparable&lt;const type_info *&gt; <i>see below</i></ins>
++ class bad_cast;
++ class bad_typeid;
++}
++</pre></blockquote>
+
++<p>Add the following new subsection</p>
+ <blockquote>
+-Moved to NAD. The intent of these adapters are to restrict the interfaces.
++<p>
++<ins>18.7.1.1 Template specialization <code>hash&lt;const type_info *&gt;</code>
++[type.info.hash]</ins></p>
++
++<pre>
++<ins>size_t operator()(const type_info *x) const;</ins>
++</pre>
++<ol>
++<li><ins><i>Returns</i>: <code>x-&gt;hash_code()</code></ins></li>
++</ol>
+ </blockquote>
+
++ <p>Add the following new subsection</p>
++ <blockquote>
++<p><ins>18.7.1.2 <code>type_info</code> concept map [type.info.concepts]</ins></p>
+
+
+-<p><b>Proposed resolution:</b></p>
++<pre>
++<ins>concept_map LessThanComparable&lt;const type_info *&gt; {</ins>
++ <ins>bool operator&lt;(const type_info *x, const type_info *y) { return x-&gt;before(*y); }</ins>
++ <ins>bool operator&lt;=(const type_info *x, const type_info *y) { return !y-&gt;before(*x); }</ins>
++ <ins>bool operator&gt;(const type_info *x, const type_info *y) { return y-&gt;before(*x); }</ins>
++ <ins>bool operator&gt;=(const type_info *x, const type_info *y) { return !x-&gt;before(*y); }</ins>
++<ins>}</ins>
++</pre>
++<ol>
++ <li><ins><i>Note</i>: provides a well-defined ordering among
++ <code>type_info const</code> pointers, which makes such pointers
++ usable in associative containers (23.4).</ins></li>
++</ol>
++</blockquote>
++
++<p>Remove section 20.14 [type.index]</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1063"></a>1063. 03 iterator compatibilty</h3>
+-<p><b>Section:</b> X [iterator.backward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1080"></a>1080. Concept ArithmeticLike should provide explicit boolean conversion</h3>
++<p><b>Section:</b> X [concept.arithmetic] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++Astonishingly, the current concept ArithmeticLike as specified in
++X [concept.arithmetic] does not provide explicit conversion
++to <tt>bool</tt> although this is a common property of arithmetic types
++(4.12 [conv.bool]). Recent proposals that introduced such types
++(integers of arbitrary precision,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2143.pdf">n2143</a>,
++decimals
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2732.pdf">n2732</a>
++indirectly
++via conversion to <tt>long long</tt>) also took care of such a feature.
++</p>
++<p>
++Adding such an explicit conversion associated function would also
++partly solve a currently invalid effects clause in library, which bases
++on this property, 24.2.7 [random.access.iterators]/2:
++</p>
++<blockquote><pre>
++{ difference_type m = n;
++ if (m &gt;= 0) while (m--) ++r;
++ else while (m++) --r;
++ return r; }
++</pre></blockquote>
+
+ <p>
+-Which header must a user <tt>#include</tt> to obtain the library-supplied
+-<tt>concept_maps</tt> declared in this paragraph?
++Both while-loops take advantage of a contextual conversion to <tt>bool</tt>
++(Another problem is that the &gt;= comparison uses the no
++longer supported existing implicit conversion from <tt>int</tt> to <tt>IntegralLike</tt>).
+ </p>
+
++<p><b>Original proposed resolution:</b></p>
++<ol>
++<li>
+ <p>
+-This is important information, as existing user code will break if this
+-header is not included, and we should make a point of mandating this header
+-is <tt>#include</tt>-d by library headers likely to make use of it, notably
+-<tt>&lt;algorithm&gt;</tt>. See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a> for more details.
++In X [concept.arithmetic], add to the list of less refined
++concepts one further concept:
++</p>
++
++<blockquote><pre>
++concept ArithmeticLike&lt;typename T&gt;
++ : Regular&lt;T&gt;, LessThanComparable&lt;T&gt;, HasUnaryPlus&lt;T&gt;, HasNegate&lt;T&gt;,
++ HasPlus&lt;T, T&gt;, HasMinus&lt;T, T&gt;, HasMultiply&lt;T, T&gt;, HasDivide&lt;T, T&gt;,
++ HasPreincrement&lt;T&gt;, HasPostincrement&lt;T&gt;, HasPredecrement&lt;T&gt;,
++ HasPostdecrement&lt;T&gt;,
++ HasPlusAssign&lt;T, const T&amp;&gt;, HasMinusAssign&lt;T, const T&amp;&gt;,
++ HasMultiplyAssign&lt;T, const T&amp;&gt;,
++ HasDivideAssign&lt;T, const T&amp;&gt;<ins>, ExplicitlyConvertible&lt;T, bool&gt;</ins> {
++</pre></blockquote>
++</li>
++<li>
++<p>
++In 24.2.7 [random.access.iterators]/2 change the current effects clause
++as indicated [The proposed insertion fixes the problem that the previous
++implicit construction from integrals has been changed to an explicit
++constructor]:
+ </p>
++<blockquote><pre>
++{ difference_type m = n;
++ if (m &gt;= <ins>difference_type(</ins>0<ins>)</ins>) while (m--) ++r;
++ else while (m++) --r;
++ return r; }
++</pre></blockquote>
++</li>
++</ol>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+ <blockquote>
+-We agree with the direction of the proposed resolution.
+-Move to Tentatively Ready.
++<p>
++We agree that arithmetic types ought be convertible to <tt>bool</tt>,
++and we therefore agree with the proposed resolution's paragraph 1.
++</p>
++<p>
++We do not agree that the cited effects clause is invalid,
++as it expresses intent rather than specific code.
++</p>
++<p>
++Move to Review, pending input from concepts experts.
++</p>
+ </blockquote>
+
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-We believe this is NAD Concepts, but this needs to be reviewed against the
+-post-remove-concepts draft.
+-</blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>Change [depr.lib.iterator.primitives], Iterator primitives, as
+-indicated:</i></p>
++<p>
++In X [concept.arithmetic], add to the list of less refined
++concepts one further concept:
++</p>
+
+-<blockquote>
+- <p>To simplify the use of iterators and provide backward compatibility with
+- previous C++ Standard Libraries,
+- the library provides several classes and functions. <ins>Unless otherwise
+- specified, these classes and functions shall be defined in header <tt>&lt;iterator&gt;</tt>.</ins></p>
+-</blockquote>
+-<p><i>Change X [iterator.backward], Iterator backward compatibility, as
+-indicated:</i></p>
+-<blockquote>
+- <p>The library provides concept maps that allow iterators specified with
+- <tt>iterator_traits</tt> to interoperate with
+- algorithms that require iterator concepts. <ins>These concept maps shall be
+- defined in the same header that defines the iterator.</ins> [<i>Example:</i></p>
+-</blockquote>
++<blockquote><pre>
++concept ArithmeticLike&lt;typename T&gt;
++ : Regular&lt;T&gt;, LessThanComparable&lt;T&gt;, HasUnaryPlus&lt;T&gt;, HasNegate&lt;T&gt;,
++ HasPlus&lt;T, T&gt;, HasMinus&lt;T, T&gt;, HasMultiply&lt;T, T&gt;, HasDivide&lt;T, T&gt;,
++ HasPreincrement&lt;T&gt;, HasPostincrement&lt;T&gt;, HasPredecrement&lt;T&gt;,
++ HasPostdecrement&lt;T&gt;,
++ HasPlusAssign&lt;T, const T&amp;&gt;, HasMinusAssign&lt;T, const T&amp;&gt;,
++ HasMultiplyAssign&lt;T, const T&amp;&gt;,
++ HasDivideAssign&lt;T, const T&amp;&gt;<ins>, ExplicitlyConvertible&lt;T, bool&gt;</ins> {
++</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1064"></a>1064. Response to UK 152</h3>
+-<p><b>Section:</b> 17.3.18 [defns.obj.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1081"></a>1081. <tt>basic_string</tt> needs to be a concept-constrained template</h3>
++<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#strings">issues</a> in [strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK 216, JP 46, JP 48 [CD1]</b></p>
+
+-<p><b>Addresses UK 152</b></p>
++<p>
++All the containers use concepts for their iterator usage, exect for
++<tt>basic_string</tt>. This needs fixing.
++</p>
+
+ <p>
+-Object state is using a definition of object (instance of a class) from
+-outside the standard, rather than the 'region of storage' definiton in
+-1.8 [intro.object]p1
++Use concepts for iterator template parameters throughout the chapter.
+ </p>
+
+ <p><i>[
+ Summit:
+ ]</i></p>
+
+-<blockquote>
+-We think we're removing this; See X [func.referenceclosure.cons].
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD. This will not affect user or implementer code
+-</blockquote>
+-
++<blockquote><p>
++NB comments to be handled by Dave Abrahams and Howard Hinnant with
++advice from PJP: UK216 (which duplicates) JP46, JP48. JP46 supplies
++extensive proposed wording; start there.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1067"></a>1067. simplified wording for inner_product</h3>
+-<p><b>Section:</b> 26.7 [numeric.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-17 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1082"></a>1082. <tt>codecvt</tt> needs to be a concept-constrained template</h3>
++<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#localization">issues</a> in [localization].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses JP 49 [CD1]</b></p>
+
+ <p>
+-One of the motivating examples for introducing requirements-aliases was to
+-simplify the wording of the <tt>inner_product</tt> requirements. As the paper
+-adopting the feature and constrained wording for the library went through in
+-the same meeting, it was not possible to make the change at the time. The
+-simpler form should be adopted now though. Similarly, most the other
+-numerical algorithms can benefit from a minor cleanup.
+-</p>
+-<p>
+-Note that in each case, the second more generalised form of the algorithm
+-does not benefit, as there are already named constraints supplied by the
+-template type parameters.
++<tt>codecvt</tt> does not use concept. For example, create <tt>CodeConvert</tt>
++concept and change as follows.
+ </p>
+
++<blockquote><pre>
++template&lt;CodeConvert Codecvt, class Elem = wchar_t&gt;
++ class wstring_convert {
++</pre></blockquote>
++
+ <p><i>[
+-2009-05-02 Daniel adds:
++Summit:
+ ]</i></p>
+
++<blockquote><p>
++To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
++</p></blockquote>
+
+-<blockquote>
+-<p>
+-one part of the suggested resolution suggests the removal of the
+-<tt>MoveConstructible&lt;T&gt;</tt> requirement from
+-<tt>inner_product</tt>. According to 26.7.2 [inner.product]
+-</p>
+
+-<blockquote>
+-Computes its result by initializing the accumulator <tt>acc</tt> with the
+-initial value <tt>init</tt>
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-this step requires at least <tt>MoveConstructible</tt>.
+-</p>
+
+-<p>
+-Therefore I strongly suggest to take this removal back (Note also
+-that the corresponding overload with a functor argument still has
+-the same <tt>MoveConstructible&lt;T&gt;</tt> requirement).
+-</p>
+-</blockquote>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+
+-<blockquote>
+-<p>
+-We agree with the proposed resolution as amended by Daniel's suggestion
+-to restore <tt>MoveConstructible</tt>,
+-reflected in the updated proposed resolution below.
+-</p>
+-<p>
+-Move to Tentatively Ready.
+-</p>
+-</blockquote>
+
++<hr>
++<h3><a name="1083"></a>1083. <tt>InputIterator</tt> and <tt>OutputIterator</tt> template parameters need to be concept constraints</h3>
++<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#localization">issues</a> in [localization].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP 52, JP 53 [CD1]</b></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Change in 26.7 [numeric.ops] and 26.7.1 [accumulate]:
++<tt>InputIterator</tt> does not use concept.
+ </p>
+
+-<blockquote><pre>template &lt;InputIterator Iter, MoveConstructible T&gt;
+- requires <ins>add =</ins> HasPlus&lt;T, Iter::reference&gt;
+- &amp;&amp; HasAssign&lt;T, <del>HasPlus&lt;T, Iter::reference&gt;</del> <ins>add</ins>::result_type&gt;
+- T accumulate(Iter first, Iter last, T init);
+-</pre></blockquote>
+-
+ <p>
+-Change in 26.7 [numeric.ops] and 26.7.2 [inner.product]:
++<tt>OutputIterator</tt> does not use concept.
+ </p>
+
+-<blockquote><pre>template &lt;InputIterator Iter1, InputIterator Iter2, MoveConstructible T&gt;
+- requires <ins>mult =</ins> HasMultiply&lt;Iter1::reference, Iter2::reference&gt;
+- &amp;&amp; <ins>add =</ins> HasPlus&lt;T, <del>HasMultiply&lt;Iter1::reference, Iter2::reference&gt;</del> <ins>mult</ins>::result_type&gt;
+- &amp;&amp; HasAssign&lt;
+- T,
+- <del>HasPlus&lt;T,
+- HasMultiply&lt;Iter1::reference, Iter2::reference&gt;::result_type&gt;</del> <ins>add</ins>::result_type&gt;
+- T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);
+-</pre></blockquote>
+-
+ <p>
+-Change in 26.7 [numeric.ops] and 26.7.3 [partial.sum]:
++Comments include proposed wording.
+ </p>
+
+-<blockquote><pre>template &lt;InputIterator InIter, OutputIterator&lt;auto, const InIter::value_type&amp;&gt; OutIter&gt;
+- requires <ins>add =</ins> HasPlus&lt;InIter::value_type, InIter::reference&gt;
+- &amp;&amp; HasAssign&lt;InIter::value_type,
+- <del>HasPlus&lt;InIter::value_type, InIter::reference&gt;</del> <ins>add</ins>::result_type&gt;
+- &amp;&amp; Constructible&lt;InIter::value_type, InIter::reference&gt;
+- OutIter partial_sum(InIter first, InIter last, OutIter result);
+-</pre></blockquote>
++<p><i>[
++Summit:
++]</i></p>
+
+-<p>
+-Change in 26.7 [numeric.ops] and 26.7.4 [adjacent.difference]:
+-</p>
++<blockquote><p>
++To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
++</p></blockquote>
+
+-<blockquote><pre>template &lt;InputIterator InIter, OutputIterator&lt;auto, const InIter::value_type&amp;&gt; OutIter&gt;
+- requires <ins>sub =</ins> HasMinus&lt;InIter::value_type, InIter::value_type&gt;
+- &amp;&amp; Constructible&lt;InIter::value_type, InIter::reference&gt;
+- &amp;&amp; OutputIterator&lt;OutIter, <del>HasMinus&lt;InIter::value_type, InIter::value_type&gt;</del> <ins>sub</ins>::result_type&gt;
+- &amp;&amp; MoveAssignable&lt;InIter::value_type&gt;
+- OutIter adjacent_difference(InIter first, InIter last, OutIter result);
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1068"></a>1068. class random_device should be movable</h3>
+-<p><b>Section:</b> 26.5.6 [rand.device] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.device">issues</a> in [rand.device].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1084"></a>1084. Concept <tt>ForwardIterator</tt> should provide default implementation for post-increment</h3>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK 250 [CD1]</b></p>
+
+ <p>
+-class <tt>random_device</tt> should be movable.
++A default implementation should be supplied for the post-increment
++operator to simplify implementation of iterators by users.
+ </p>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-Move to Open, and recommend this issue be deferred until after the next
+-Committee Draft is issued.
+-</blockquote>
++<p>
++Copy the Effects clause into the concept description as the default
++implementation. Assumes a default value for <tt>postincrement_result</tt>.
++</p>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++Summit:
+ ]</i></p>
+
+-
+-<blockquote>
+-Leave open. Walter to provide drafting as part of his planned paper.
+-</blockquote>
++<blockquote><p>
++Howard will open an issue.
++</p></blockquote>
+
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD.
++2009-06-07 Daniel adds:
+ ]</i></p>
+
+
++<blockquote><p>
++This issue cannot currently be resolved as suggested, because
++that would render auto-detection of the return type
++<tt>postincrement_result</tt> invalid, see [concept.map.assoc]/4+5. The
++best fix would be to add a default type to that associated type, but
++unfortunately any default type will prevent auto-deduction of types of
++associated functions as quoted above. A corresponding core issue
++is in preparation.
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[
++This wording assumes the acceptance of UK 251 / <a href="lwg-closed.html#1009">1009</a>. Both
++wordings change the same paragraphs.
++]</i></p>
++
+
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-WP is correct as written.
++Change 24.2.5 [forward.iterators]:
+ </p>
+
++<blockquote>
++<pre>
++concept ForwardIterator&lt;typename X&gt; : InputIterator&lt;X&gt;, Regular&lt;X&gt; {
++
++ MoveConstructible postincrement_result;
++ requires HasDereference&lt;postincrement_result&gt;
++ &amp;&amp; Convertible&lt;HasDereference&lt;postincrement_result&gt;::result_type, const value_type&amp;&gt;;
++
++ postincrement_result operator++(X&amp; r, int)<del>;</del> <ins>{
++ X tmp = r;
++ ++r;
++ return tmp;
++ }</ins>
++
++ axiom MultiPass(X a, X b) {
++ if (a == b) *a == *b;
++ if (a == b) ++a == ++b;
++ }
++}
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1069"></a>1069. class seed_seq should support efficient move operations</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1085"></a>1085. <tt>BidirectionalIterator</tt> concept should provide default implementation for post-decrement</h3>
++<p><b>Section:</b> 24.2.6 [bidirectional.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK 258 [CD1]</b></p>
+
+ <p>
+-class <tt>seed_seq</tt> should support efficient move operations.
++A default implementation should be supplied for the post-decrement
++operator to simplify implementation of iterators by users.
++</p>
++
++<p>
++Copy the Effects clause into the concept description as the default
++implementation. Assumes a default value for <tt>postincrement_result</tt>.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++Summit:
+ ]</i></p>
+
+-<blockquote>
+-Move to Open, and recommend this issue be deferred until after the next
+-Committee Draft is issued.
+-</blockquote>
++<blockquote><p>
++Howard will open an issue.
++</p></blockquote>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2009-06-07 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Leave open. Walter to provide drafting as part of his planned paper.
+-</blockquote>
++<blockquote><p>
++This issue cannot currently be resolved as suggested, because
++that would render auto-detection of the return type
++<tt>postdecrement_result</tt> invalid, see <a href="lwg-closed.html#1084">1084</a>.
++</p></blockquote>
+
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Change 24.2.6 [bidirectional.iterators]:
++</p>
+
+ <blockquote>
+-<tt>seed_seq</tt> is explicitly not copyable, so, much like LWG issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, LWG issue 1069 could be marked NAD to be consistent
+-with this.
+-</blockquote>
++<pre>
++concept BidirectionalIterator&lt;typename X&gt; : ForwardIterator&lt;X&gt; {
++ MoveConstructible postdecrement_result;
++ requires HasDereference&lt;postdecrement_result&gt;
++ &amp;&amp; Convertible&lt;HasDereference&lt;postdecrement_result&gt;::result_type, const value_type&amp;&gt;
++ &amp;&amp; Convertible&lt;postdecrement_result, const X&amp;&gt;;
++ X&amp; operator--(X&amp;);
++ postdecrement_result operator--(X&amp; <ins>r</ins>, int)<del>;</del> <ins>{
++ X tmp = r;
++ --r;
++ return tmp;
++ }</ins>
++}
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1086"></a>1086. Stream iterators need to be concept-constrained templates</h3>
++<p><b>Section:</b> 24.6 [stream.iterators] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses UK 284 [CD1]</b></p>
+
++<p>
++The stream iterators need constraining with concepts/requrires clauses.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++<blockquote><p>
++We agree. To be handled by Howard, Martin and PJ.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -36428,123 +30021,175 @@ with this.
+
+
+ <hr>
+-<h3><a name="1072"></a>1072. Is std::hash a constrained template or not?</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1087"></a>1087. Incorrect <tt>OutputIterator</tt> concept requirements for <tt>replace</tt> algorithms</h3>
++<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK 301 [CD1]</b></p>
+
+ <p>
+-Is <tt>std::hash</tt> a constrained template or not?
++<tt>replace</tt> and <tt>replace_if</tt> have the requirement: <tt>OutputIterator&lt;Iter,
++Iter::reference&gt;</tt> Which implies they need to copy some values in the
++range the algorithm is iterating over. This is not however the case, the
++only thing that happens is <tt>const T&amp;</tt>s might be copied over existing
++elements (hence the <tt>OutputIterator&lt;Iter, const T&amp;&gt;</tt>.
+ </p>
++
+ <p>
+-According to Class template hash 20.8.15 [unord.hash], the definition is:
++Remove <tt>OutputIterator&lt;Iter, Iter::reference&gt;</tt> from <tt>replace</tt>
++and <tt>replace_if</tt>.
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
+-struct hash : public std::unary_function&lt;T, std::size_t&gt; {
+- std::size_t operator()(T val) const;
+-};
+-</pre></blockquote>
++<p><i>[
++Summit:
++]</i></p>
+
++<blockquote><p>
++We agree. To be handled by Howard.
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-And so unconstrained.
+-</p>
+-<p>
+-According to the <tt>&lt;functional&gt;</tt> synopsis in p2 Function objects
+-20.8 [function.objects] the template is declared as:
++Change in [algorithms.syn] and 25.3.5 [alg.replace]:
+ </p>
+
+-<blockquote><pre>template &lt;ReferentType T&gt; struct hash;
++<blockquote><pre>
++template&lt;ForwardIterator Iter, class T&gt;
++ requires <del>OutputIterator&lt;Iter, Iter::reference&gt;
++ &amp;&amp;</del> OutputIterator&lt;Iter, const T&amp;&gt;
++ &amp;&amp; HasEqualTo&lt;Iter::value_type, T&gt;
++ void replace(Iter first, Iter last,
++ const T&amp; old_value, const T&amp; new_value);
++
++template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred, class T&gt;
++ requires <del>OutputIterator&lt;Iter, Iter::reference&gt;
++ &amp;&amp;</del> OutputIterator&lt;Iter, const T&amp;&gt;
++ &amp;&amp; CopyConstructible&lt;Pred&gt;
++ void replace_if(Iter first, Iter last,
++ Pred pred, const T&amp; new_value);
+ </pre></blockquote>
+
++
++
++
++
++<hr>
++<h3><a name="1091"></a>1091. Multimap description confusing</h3>
++<p><b>Section:</b> 23.4.5.3 [multimap.modifiers] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 246</b></p>
+ <p>
+-which would make hash a constrained template.
++The content of this sub-clause is purely trying to describe in words the
++effect of the requires clauses on these operations, now that we have
++Concepts. As such, the description is more confusing than the signature
++itself. The semantic for these functions is adequately covered in the
++requirements tables in 23.2.4 [associative.reqmts].
+ </p>
+
+ <p><i>[
+-2009-03-22 Daniel provided wording.
++Beman adds:
+ ]</i></p>
+
+
++<blockquote><p>
++Pete is clearly right that
++this one is technical rather than editorial.
++</p></blockquote>
++
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+ <blockquote>
+ <p>
+-Alisdair is not certain that Daniel's proposed resolution is sufficient,
+-and recommends we leave the hash template unconstrained for now.
+-</p>
+-<p>
+-Recommend that the Project Editor make the constrained declaration consistent
+-with the definition in order to make the Working Paper internally consistent,
+-and that the issue then be revisited.
++We agree with the proposed resolution.
+ </p>
+ <p>
+-Move to Open.
++Move to Review.
+ </p>
+ </blockquote>
+
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark as NAD, solved by removing concepts.
++</p></blockquote>
++
+
+-<p><b>Proposed resolution:</b></p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-[To the editor: This resolution is merge-compatible to the
+-resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>]
++Strike 23.4.5.3 [multimap.modifiers] entirely
++(but do NOT strike these signatures from the class template definition!).
+ </p>
+
+-<ol>
+-<li>
++
++
++
++
++<hr>
++<h3><a name="1092"></a>1092. Class template <tt>integral_constant</tt> should be a constrained template</h3>
++<p><b>Section:</b> 20.10.3 [meta.help] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.help">issues</a> in [meta.help].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-In 20.8 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis, change as indicated:
++A first step to change the type traits predicates to constrained templates is to
++constrain their common base template <tt>integral_constant</tt>. This can be done,
++without enforcing depending classes to be constrained as well, but not
++vice versa
++without brute force <tt>late_check</tt> usages. The following proposed resolution depends
++on the resolution of LWG issue <a href="lwg-defects.html#1019">1019</a>.
+ </p>
+
+-<blockquote><pre>// 20.6.17, hash function base template:
+-template &lt;ReferentType T&gt; struct hash; <ins>// undefined</ins>
+-</pre></blockquote>
+-</li>
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++Move to Open, pending a paper that looks at constraints
++for the entirety of the type traits
++and their relationship to the foundation concepts.
++We recommend this be deferred
++until after the next Committee Draft is issued.
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
+ <li>
+ <p>
+-In 20.8.15 [unord.hash]/1 change as indicated:
++In 20.10.2 [meta.type.synop], Header <tt>&lt;type_traits&gt;</tt>
++synopsis change as indicated:
+ </p>
+-<blockquote><pre>namespace std {
+- <del>template &lt;class T&gt;
+- struct hash : public std::unary_function&lt;T, std::size_t&gt; {
+- std::size_t operator()(T val) const;
+- };</del>
+- <ins>template &lt;ReferentType T&gt; struct hash; // undefined</ins>
+-}
++<blockquote><pre>
++namespace std {
++// 20.5.3, helper class:
++template &lt;<del>class</del><ins>IntegralConstantExpressionType</ins> T, T v&gt; struct integral_constant;
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+-In 20.8.15 [unord.hash]/2 change as indicated:
+-</p>
+-
+-<blockquote>
+--2- <ins>For all library-provided specializations, the template
+-instantiation <tt>hash&lt;T&gt;</tt>
+- shall provide a public <tt>operator()</tt> with return type <tt>std::size_t</tt> to
+-satisfy the concept
+- requirement <tt>Callable&lt;const hash&lt;T&gt;, const T&amp;&gt;</tt>. If <tt>T</tt> is an object
+-type or reference to
+- object, <tt>hash&lt;T&gt;</tt> shall be publicly derived from
+-<tt>std::unary_function&lt;T, std::size_t&gt;</tt>.
+- </ins> The return value of <tt>operator()</tt> is unspecified, except that
+-equal arguments
+- shall yield the same result. <tt>operator()</tt> shall not throw exceptions.
+-</blockquote>
+-</li>
+-<li>
+-<p>
+-In 18.7 [support.rtti]/1, header <tt>&lt;typeinfo&gt;</tt> synopsis change as indicated:
++In 20.10.3 [meta.help] change as indicated:
+ </p>
+-<blockquote><pre>namespace std {
+- class type_info;
+- class type_index;
+- template &lt;<del>class</del><ins>ReferentType</ins> T&gt; struct hash;
++<blockquote><pre>
++template &lt;<del>class</del><ins>IntegralConstantExpressionType</ins> T, T v&gt;
++struct integral_constant {
++ static constexpr T value = v;
++ typedef T value_type;
++ typedef integral_constant&lt;T,v&gt; type;
++ constexpr operator value_type() { return value; }
++};
+ </pre></blockquote>
+ </li>
+ </ol>
+@@ -36554,637 +30199,554 @@ In 18.7 [support.rtti]/1, header <tt>&lt;typeinfo&gt;</tt> synopsis change as in
+
+
+ <hr>
+-<h3><a name="1074"></a>1074. concept map broken by N2840</h3>
+-<p><b>Section:</b> X [allocator.element.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1096"></a>1096. unconstrained rvalue ref parameters</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+ <p>
+-p7 Allocator-related element concepts X [allocator.element.concepts]
+-</p>
+-
+-<p>
+-The changes to the <tt>AllocatableElement</tt> concept mean this <tt>concept_map</tt>
+-specialization no longer matches the original concept:
++TODO: Look at all cases of unconstrained rvalue ref parameters and check
++that concept req'ts work when <tt>T</tt> deduced as reference.
+ </p>
+
+-<blockquote><pre>template &lt;Allocator Alloc, class T, class ... Args&gt;
+- requires HasConstructor&lt;T, Args...&gt;
+- concept_map AllocatableElement&lt;Alloc, T, Args&amp;&amp;...&gt; {
+- void construct_element(Alloc&amp; a, T* t, Args&amp;&amp;... args) {
+- Alloc::rebind&lt;T&gt;(a).construct(t, forward(args)...);
+- }
+- }
+-</pre></blockquote>
+-
+-<p><i>[
+-2009-03-23 Pablo adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-Actually, this is incorrect,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2840.pdf">N2840</a>
+-says. "In section
+-X [allocator.element.concepts] paragraph 8, modify the definition of the
+-<tt>AllocatableElement</tt> concept and eliminate the related concept map:" but
+-then neglects to include the red-lined text of the concept map that was
+-to be eliminated. Pete also missed this, but I caught it he asked me to
+-review his edits. Pete's updated WP removes the concept map entirely,
+-which was the original intent. The issue is, therefore, moot. Note, as
+-per my presentation of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2840.pdf">N2840</a>
+-in summit, <tt>construct()</tt> no longer has a
+-default implementation. This regrettable fact was deemed (by David
+-Abrahams, Doug, and myself) to be preferable to the complexity of
+-providing a default implementation that would not under-constrain a more
+-restrictive allocator (like the scoped allocators).
+-</blockquote>
+-
+-<p><i>[
+-2009-05-01 Daniel adds:
+-]</i></p>
+-
+-<blockquote>
+ <p>
+-it seems to me that #1074 should be resolved as a NAD, because the
+-current WP has already removed the previous AllocatableElement concept map.
+-It introduced auto concept AllocatableElement instead, but as of
+-X [allocator.element.concepts]/7 this guy contains now
++ We found some instances where that was not done correctly and we figure
++ the possibility of deducing <tt>T</tt> to be an lvalue reference was probably
++ overlooked elsewhere.
+ </p>
+-<blockquote><pre>requires FreeStoreAllocatable&lt;T&gt;;
+-void Alloc::construct(T*, Args&amp;&amp;...);
+-</pre></blockquote>
+-</blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
+-<p>
+-The affected code is no longer part of the Working Draft.
+-</p>
+-<p>
+-Move to NAD.
+-</p>
+-</blockquote>
++<blockquote><p>
++Move to Open, pending proposed wording from Dave for further review.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change X [allocator.element.concepts]:
+ </p>
+
+-<blockquote><pre>template &lt;Allocator Alloc, class T, class ... Args&gt;
+- requires HasConstructor&lt;T, Args...&gt;
+- concept_map AllocatableElement&lt;Alloc, T, Args&amp;&amp;...&gt; {
+- void construct_element(<del>Alloc&amp; a,</del> T* t, Args&amp;&amp;... args) {
+- Alloc::rebind&lt;T&gt;(a).construct(t, forward(args)...);
+- }
+- }
+-</pre></blockquote>
+-
+-
+
+
+
+
+ <hr>
+-<h3><a name="1076"></a>1076. unary/binary_negate need constraining and move support</h3>
+-<p><b>Section:</b> 20.8.9 [negators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1099"></a>1099. Various issues</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The class templates <tt>unary/binary_negate</tt> need constraining and move support.
+-</p>
+-<p>
+-Ideally these classes would be deprecated, allowing <tt>unary/binary_function</tt> to
+-also be deprecated. However, until a generic negate adaptor is introduced
+-that can negate any <tt>Callable</tt> type, they must be supported so should be
+-constrained. Likewise, they should be movable, and support adopting a
+-move-only predicate type.
+-</p>
+-<p>
+-In order to preserve ABI compatibility, new rvalue overloads are supplied in
+-preference to changing the existing pass-by-const-ref to pass-by-value.
++Notes
+ </p>
++<blockquote>
+ <p>
+-Do not consider the issue of forwarding mutable lvalues at this point,
+-although remain open to another issue on the topic.
++[2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1,
++MoveConstructible V2 (where V1,V2 are defined on 539). Also make_tuple
++on 550
+ </p>
+
+-<p><i>[
+-2009-05-01 Daniel adds:
+-]</i></p>
+-
+ <blockquote>
+ <p>
+-IMO the currently proposed resolution needs some updates
+-because it is ill-formed at several places:
++CD-1 reads:
+ </p>
+
+-<ol>
+-<li>
++<blockquote><pre>
++template &lt;MoveConstructible T1, MoveConstructible T2&gt;
++pair&lt;V1, V2&gt; make_pair(T1&amp;&amp;, T2&amp;&amp;);
++</pre></blockquote>
++
+ <p>
+-In concept AdaptableUnaryFunction change
++Actually I'm guessing we need something like <tt>MoveConstructible&lt;V1,T1&gt;</tt>,
++i.e. "<tt>V1</tt> can be constructed from an rvalue of type <tt>T1</tt>."
+ </p>
+-<blockquote><pre>typename X::result_type;
+-typename X::argument_type;
+-</pre></blockquote>
++
+ <p>
+-to
++Ditto for <tt>make_tuple</tt>
+ </p>
+-<blockquote><pre>Returnable result_type = typename X::result_type;
+-typename argument_type = typename X::argument_type;
+-</pre></blockquote>
++</blockquote>
++
+ <p>
+-[The replacement "Returnable result_type" instead of "typename
+-result_type" is non-editorial, but maybe you prefer that as well]
++[2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to
++talk about "copiable from generalized rvalue ref argument" for cases
++where we're going to forward and copy.
+ </p>
+-</li>
+-<li>
++<blockquote>
+ <p>
+-In concept AdaptableBinaryFunction change
++ This issue may well be quite large. Language in para 4 about "if
++ an lvalue" is wrong because types aren't expressions.
+ </p>
+-<blockquote><pre>typename X::result_type;
+-typename X::first_argument_type;
+-typename X::second_argument_type;
+-</pre></blockquote>
++
++<blockquote>
+ <p>
+-to
++Maybe we should define the term "move" so we can just say in the
++effects, "<tt>f</tt> is moved into the newly-created thread" or something, and
++agree (and ideally document) that saying "<tt>f</tt> is moved" implies
+ </p>
+-<blockquote><pre>Returnable result_type = typename X::result_type;
+-typename first_argument_type = typename X::first_argument_type;
+-typename second_argument_type = typename X::second_argument_type;
++
++<blockquote><pre>
++F x(move(f))
+ </pre></blockquote>
++
+ <p>
+-[The replacement "Returnable result_type" instead of "typename
+-result_type" is non-editorial, but maybe you prefer that as well.]
++is required to work. That would cover both ctors at once.
+ </p>
+-</li>
++</blockquote>
+
+-<li>
+ <p>
+-In class unary/binary_function
++ p1199, call_once has all the same issues.
+ </p>
+-<ol type="a">
+-<li>
+-I suggest to change "ReturnType" to "Returnable" in both cases.
+-</li>
+-<li>
+-I think you want to replace the remaining occurrences of "Predicate" by "P"
+-(in both classes in copy/move from a predicate)
+-</li>
+-</ol>
+-</li>
+-<li>
++</blockquote>
+ <p>
+-I think you need to change the proposed signatures of not1 and not2, because
+-they would still remain unconstrained: To make them constrained at least a
+-single requirement needs to be added to enable requirement implication. This
+-could be done via a dummy ("requires True&lt;true&gt;") or just explicit as follows:
++[2009-03-21 Sat] p869 InputIterator pointer type should not be required
++to be convertible to const value_type*, rather it needs to have a
++operator-> of its own that can be used for the value type.
+ </p>
+-<ol type="a">
+-<li>
+-<blockquote><pre>template &lt;AdaptableUnaryFunction P&gt;
+-requires Predicate&lt; P, P::argument_type&gt;
+-unary_negate&lt;P&gt; not1(const P&amp;&amp; pred);
+-template &lt;AdaptableUnaryFunction P&gt;
+-requires Predicate&lt; P, P::argument_type &gt;
+-unary_negate&lt;P&gt; not1(P&amp;&amp; pred);
+-</pre>
+-<blockquote>
+--3- Returns: unary_negate&lt;P&gt;(pred).
+-</blockquote>
+-</blockquote>
++
++<blockquote><p>
++This one is serious and unrelated to the move issue.
++</p></blockquote>
++
+ <p>
+-[Don't we want a move call for the second overload as in
++[2009-03-21 Sat] p818 stack has the same problem with default ctor.
+ </p>
+-<blockquote><pre>unary_negate&lt;P&gt;(std::move(pred))
+-</pre></blockquote>
+ <p>
+-in the Returns clause ?]
++[2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so
+ </p>
+-</li>
+-<li>
+-<pre>template &lt;AdaptableBinaryFunction P&gt;
+-requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;
+-binary_negate&lt;P&gt; not2(const P&amp; pred);
+-template &lt;AdaptableBinaryFunction P&gt;
+-requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;
+-binary_negate&lt;P&gt; not2(P&amp;&amp; pred);
++<blockquote><pre>
++ requires MoveConstructible&lt;Cont&gt;
++ explicit priority_queue(const Compare&amp; x = Compare(), Cont&amp;&amp; = Cont());
+ </pre>
+ <p>
+--5- Returns: binary_negate&lt;P&gt;(pred).
++ Don't require MoveConstructible when default constructing Cont.
++ Also missing semantics for move ctor.
+ </p>
++</blockquote>
+ <p>
+-[Don't we want a move call for the second overload as in
++ [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as
++ opposed to MoveConstructible?
+ </p>
+-<blockquote><pre>binary_negate&lt;P&gt;(std::move(pred))
+-</pre></blockquote>
+ <p>
+-in the Returns clause ?]
++ [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't
++ be MoveConstructible). No documented semantics for move c'tor. Or
++ *any* of its 7 ctors!
++</p>
++<p>
++ [2009-03-21 Sat] std::array should have constructors for C++0x,
++ consequently must consider move construction.
+ </p>
+-</li>
+-</ol>
+-</li>
+-</ol>
+-</blockquote>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-05-01 Daniel adds:
+ ]</i></p>
+
+-<blockquote>
+-<p>
+-There is concern that complicating the solution
+-to preserve the ABI seems unnecessary,
+-since we're not in general preserving the ABI.
+-</p>
++
++<blockquote><p>
++This could be done as part of <a href="lwg-closed.html#1035">1035</a>, which already handles
++deviation of <tt>std::array</tt> from container tables.
++</p></blockquote>
++
+ <p>
+-We would prefer a separate paper consolidating all Clause 20
+-issues that are for the purpose of providing constrained versions
+-of the existing facilities.
++ [2009-03-21 Sat] p622 all messed up.
+ </p>
++<blockquote>
+ <p>
+-Move to Open.
++ para 8 "implementation-defined" is the wrong term; should be "see
++ below" or something.
++<p/>
++ para 12 "will be selected" doesn't make any sense because we're not
++ talking about actual arg types.
++<p/>
++ paras 9-13 need to be totally rewritten for concepts.
+ </p>
+ </blockquote>
+
+-<p><i>[
+-2009-10 post-Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Leave open pending the potential move constructor paper. Note that
+-we consider the "constraining" part NAD Concepts.
+-</blockquote>
+-
+-<p><i>[
+-2010-01-31 Alisdair removes the current proposed wording from the proposed
+-wording section because it is based on concepts. That wording is proposed here:
+-]</i></p>
+-
+-
+-<blockquote class="note">
+ <p>
+-Add new concepts where appropriate::
++ [2009-03-21 Sat] Null pointer comparisons (p587) have all become
++ unconstrained. Need to fix that
++<p/>
++ [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration.
++ We think CopyConstructible is the right reqt.
++<p/>
++ make_pair needs Constructible&lt;V1, T1&amp;&amp;&gt; requirements!
++<p/>
++ make_tuple needs something similar
++<p/>
++ tuple bug in synopsis:
+ </p>
+-
+-<blockquote><pre>auto concept AdaptableUnaryFunction&lt; typename X &gt; {
+- typename X::result_type;
+- typename X::argument_type;
+-}
+-
+-auto concept AdaptableBinaryFunction&lt; typename X &gt; {
+- typename X::result_type;
+- typename X::first_argument_type;
+- typename X::second_argument_type;
+-}
+-</pre></blockquote>
+-
++<blockquote><pre>
++ template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, const UTypes&amp;&gt;...
++ template &lt;class... UTypes&gt;
++ requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
++</pre>
+ <p>
+-Revise as follows:
++ Note: removal of MoveConstructible requirements in std::function makes
++ these routines unconstrained!
+ </p>
++</blockquote>
+
+-<p>
+-Base X [base] (Only change is constrained Result)
+-</p>
++<p><i>[
++2009-05-02 Daniel adds:
++]</i></p>
+
+-<blockquote>
+-<p>
+--1- The following classes are provided to simplify the typedefs of the
+-argument and result types:
+-</p>
+-<pre>namespace std {
+- template &lt;class Arg, <del>class</del> <ins>ReturnType</ins> Result&gt;
+- struct unary_function {
+- typedef Arg argument_type;
+- typedef Result result_type;
+- };
+
+- template &lt;class Arg1, class Arg2, <del>class</del> <ins>ReturnType</ins> Result&gt;
+- struct binary_function {
+- typedef Arg1 first_argument_type;
+- typedef Arg2 second_argument_type;
+- typedef Result result_type;
+- };
+-}
+-</pre></blockquote>
++<blockquote><p>
++This part of the issue is already covered by <a href="lwg-closed.html#1077">1077</a>.
++</p></blockquote>
+
+ <p>
+-Negators 20.8.9 [negators]:
++ these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ]
+ </p>
+-
+-<blockquote>
++<blockquote><pre>
++ unique_ptr(pointer p, implementation-defined d);
++ unique_ptr(pointer p, implementation-defined d);
++</pre></blockquote>
+ <p>
+--1- Negators <tt>not1</tt> and <tt>not2</tt> take a unary and a binary predicate,
+-respectively, and return their complements (5.3.1).
++ multimap range constructor should not have MoveConstructible&lt;value_type&gt; requirement.
+ </p>
++<blockquote><p>
++ same with <tt>insert(..., P&amp;&amp;);</tt> <tt>multiset</tt> has the same issue, as do
++ <tt>unordered_multiset</tt> and <tt>unordered_multimap</tt>. Review these!
++</p></blockquote>
+
+-<pre>template &lt;<del>class</del> <ins>AdaptableUnaryFunction</ins> P<del>redicate</del>&gt;
+- <ins>requires Predicate&lt; P, P::argument_type &gt;</ins>
+- class unary_negate
+- : public unary_function&lt;<del>typename</del> P<del>redicate</del>::argument_type,bool&gt; {
+- public:
+- <ins>unary_negate(const unary_negate &amp; ) = default;</ins>
+- <ins>unary_negate(unary_negate &amp;&amp; );</ins>
+-
+- <ins>requires CopyConstructible&lt; P &gt;</ins>
+- explicit unary_negate(const Predicate&amp; pred);
+- <ins>requires MoveConstructible&lt; P &gt;
+- explicit unary_negate(Predicate &amp;&amp; pred);</ins>
+-
+- bool operator()(const <del>typename</del> P<del>redicate</del>::argument_type&amp; x) const;
+- };
+-</pre>
+-<blockquote>
+--2 <tt>operator()</tt> returns <tt>!pred(x)</tt>.
+-</blockquote>
+-
+-<pre>template &lt;class Predicate&gt;
+- unary_negate&lt;Predicate&gt; not1(const Predicate&amp;amp; pred);
+-<ins>template &lt;class Predicate&gt;
+- unary_negate&lt;Predicate&gt; not1(Predicate&amp;&amp; pred);</ins>
+-</pre>
+-<blockquote>
+--3- <i>Returns:</i> <tt>unary_negate&lt;Predicate&gt;(pred)</tt>.
+-</blockquote>
+-
+-<pre>template &lt;<del>class</del> <ins>AdaptableBinaryFunction</ins> P<del>redicate</del> &gt;
+- <ins>requires Predicate&lt; P, P::first_argument_type, P::second_argument_type &gt;</ins>
+- class binary_negate
+- : public binary_function&lt;<del>typename</del> P<del>redicate</del>::first_argument_type,
+- <del>typename</del> P<del>redicate</del>::second_argument_type, bool&gt; {
+- public:
+- <ins>biary_negate(const binary_negate &amp; ) = default;</ins>
+- <ins>binary_negate(binary_negate &amp;&amp; );</ins>
+-
+- <ins>requires CopyConstructible&lt; P &gt;</ins>
+- explicit binary_negate(const Predicate&amp; pred);
+- <ins>requires MoveConstructible&lt; P &gt;
+- explicit binary_negate(const Predicate&amp; pred);</ins>
+-
+- bool operator()(const <del>typename</del> P<del>redicate</del>::first_argument_type&amp; x,
+- const <del>typename</del> P<del>redicate</del>::second_argument_type&amp; y) const;
+- };
+-</pre>
+-<blockquote>
+--4- <tt>operator()</tt> returns <tt>!pred(x,y)</tt>.
+-</blockquote>
+-
+-<pre>template &lt;class Predicate&gt;
+- binary_negate&lt;Predicate&gt; not2(const Predicate&amp; pred);
+-<ins>template &lt;class Predicate&gt;
+- binary_negate&lt;Predicate&gt; not2(Predicate&amp;&amp; pred);</ins>
+-</pre>
+-
+-<blockquote>
+--5- <i>Returns:</i> <tt>binary_negate&lt;Predicate&gt;(pred)</tt>.
+-</blockquote>
+ </blockquote>
+
+-</blockquote>
++<p><i>[
++Batavia (2009-05):
++]</i></p>
+
++<blockquote><p>
++Move to Open, pending proposed wording from Dave for further review.
++</p></blockquote>
+
+ <p><i>[
+-2010 Rapperswil:
++2009-10 post-Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to NAD Concepts. The move-semantic part has been addressed by a core language change, which implicitly generates appropriate move constructors and move-assignment operators.
+-</blockquote>
++<blockquote><p>
++Tentatively NAD. We are not sure what has been addressed and what hasn't.
++Recommend closing unless someone sorts this out into something more readable.
++</p></blockquote>
++
++
+
++<p><b>Rationale:</b></p>
++<p>
++The issue(s) at hand not adequately communicated.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1077"></a>1077. Nonesense <tt>tuple</tt> declarations</h3>
+-<p><b>Section:</b> 20.4.2 [tuple.tuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.tuple">issues</a> in [tuple.tuple].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1101"></a>1101. <tt>unique</tt> requirements</h3>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Class template tuple 20.4.2 [tuple.tuple]:
++From Message c++std-core-14160 Howard wrote:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, const UTypes&amp;&gt;...
+-template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
+-</pre></blockquote>
++<blockquote><p>
++It was the intent of the rvalue reference proposal for unique to only require MoveAssignable:
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1860.html#25.2.9%20-%20Unique">N1860</a>.
++</p></blockquote>
+
+ <p>
+-Somebody needs to look at this and say what it should be.
++And Pete replied:
+ </p>
+
+-<p><i>[
+-2009-03-21 Daniel provided wording.
+-]</i></p>
++<blockquote><p>
++That was overridden by the subsequent changes made for concepts in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2573.pdf">N2573</a>,
++which reimposed the C++03 requirements.
++</p></blockquote>
+
++<p>
++My impression is that this overwrite was a simple (unintentional) mistake.
++Wording below to correct it.
++</p>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+ <blockquote>
+-The resolution looks correct; move to NAD Editorial.
++<p>
++Howard notes this issue resolves a discrepancy between the synopsis
++and the description.
++</p>
++<p>
++Move to NAD Editorial.
++</p>
+ </blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.4.2 [tuple.tuple], class <tt>tuple</tt>, change as indicated:
++Change 25.3.9 [alg.unique]:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, const UTypes&amp;&gt;...
+- <ins>tuple(const pair&lt;UTypes...&gt;&amp;);</ins>
+-template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
+- <ins>tuple(pair&lt;UTypes...&gt;&amp;&amp;);</ins>
++<blockquote><pre>
++template&lt;ForwardIterator Iter&gt;
++ requires OutputIterator&lt;Iter, <ins>RvalueOf&lt;</ins>Iter::reference<ins>&gt;::type</ins>&gt;
++ &amp;&amp; EqualityComparable&lt;Iter::value_type&gt;
++ Iter unique(Iter first, Iter last);
++
++template&lt;ForwardIterator Iter, EquivalenceRelation&lt;auto, Iter::value_type&gt; Pred&gt;
++ requires OutputIterator&lt;Iter, RvalueOf&lt;Iter::reference&gt;::type&gt;
++ &amp;&amp; CopyConstructible&lt;Pred&gt;
++ Iter unique(Iter first, Iter last, Pred pred);
+ </pre></blockquote>
+
+ <p>
+-[NB.: The corresponding prototypes do already exist in 20.4.2.1 [tuple.cnstr]/7+8]
++Note that the synopsis in [algorithms.syn] is already correct.
+ </p>
+
+
+
+
+
++
+ <hr>
+-<h3><a name="1078"></a>1078. DE-17: Remove class type_index</h3>
+-<p><b>Section:</b> 20.13 [type.index] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1102"></a>1102. <tt>std::vector</tt>'s reallocation policy still unclear</h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-04-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++I have the impression that even the wording of current draft
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>
++does insufficiently express the intent of <tt>vector</tt>'s
++reallocation strategy. This has produced not too old library
++implementations which release memory in the <tt>clear()</tt> function
++and even modern articles about C++ programming cultivate
++the belief that <tt>clear</tt> is allowed to do exactly this. A typical
++example is something like this:
++</p>
+
+-<p><b>Addresses DE 17</b></p>
++<blockquote><pre>
++const int buf_size = ...;
++std::vector&lt;T&gt; buf(buf_size);
++for (int i = 0; i &lt; some_condition; ++i) {
++ buf.resize(buf_size);
++ write_or_read_data(buf.data());
++ buf.clear(); // Ensure that the next round get's 'zeroed' elements
++}
++</pre></blockquote>
++<p>
++where still the myth is ubiquitous that <tt>buf</tt> might be
++allowed to reallocate it's memory *inside* the <tt>for</tt> loop.
++</p>
++<p>
++IMO the problem is due to the fact, that
++</p>
+
++<ol style="list-style-type:lower-alpha">
++<li>
++the actual memory-reallocation stability of <tt>std::vector</tt>
++is explained in 23.3.6.3 [vector.capacity]/3 and /6 which
++are describing just the effects of the <tt>reserve</tt>
++function, but in many examples (like above) there
++is no explicit call to <tt>reserve</tt> involved. Further-more
++23.3.6.3 [vector.capacity]/6 does only mention <em>insertions</em>
++and never mentions the consequences of erasing
++elements.
++</li>
++<li>
+ <p>
+-DE-17:
++the effects clause of <tt>std::vector</tt>'s <tt>erase</tt> overloads in
++23.3.6.5 [vector.modifiers]/4 is silent about capacity changes. This
++easily causes a misunderstanding, because the counter
++parting insert functions described in 23.3.6.5 [vector.modifiers]/2
++explicitly say, that
+ </p>
++<blockquote><p>
++Causes reallocation if the new size is greater than the
++old capacity. If no reallocation happens, all the iterators
++and references before the insertion point remain valid.
++</p></blockquote>
+ <p>
+-The class <tt>type_index</tt> should be removed; it provides no additional
+-functionality beyond providing appropriate concept maps.
++It requires a complex argumentation chain about four
++different places in the standard to provide the - possibly
++weak - proof that calling <tt>clear()</tt> also does <em>never</em> change
++the capacity of the <tt>std::vector</tt> container. Since <tt>std::vector</tt>
++is the de-facto replacement of C99's dynamic arrays this
++type is near to a built-in type and it's specification should
++be clear enough that usual programmers can trust their
++own reading.
+ </p>
++</li>
++</ol>
+
+ <p><i>[
+-2009-03-31 Peter adds:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+ <p>
+-It is not true, in principle, that <tt>std::type_index</tt> provides no utility
+-compared to bare <tt>std::type_info*</tt>.
++Bill believes paragraph 1 of the proposed resolution is unnecessary
++because it is already implied (even if tortuously) by the current wording.
+ </p>
+ <p>
+-<tt>std::type_index</tt> can avoid the lifetime issues with <tt>type_info</tt> when the
+-DLL that has produced the <tt>type_info</tt> object is unloaded. A raw
+-<tt>type_info*</tt> does not, and cannot, provide any protection in this case.
+-A <tt>type_index</tt> can (if the implementor so chooses) because it can wrap a
+-smart (counted or even cloning) pointer to the <tt>type_info</tt> data that is
+-needed for <tt>name()</tt> and <tt>before()</tt> to work.
++Move to Review.
+ </p>
+ </blockquote>
+
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>Modify the header &lt;typeinfo&gt; synopsis in
+- 18.7 [support.rtti]p1 as follows:</p>
+-
+-<blockquote><pre>namespace std {
+- class type_info;
+- <del>class type_index;</del>
+- template &lt;class T&gt; struct hash;
+- template&lt;&gt; struct hash&lt;<del>type_index</del><ins>const type_info *</ins>&gt; : public std::unary_function&lt;<del>type_index</del><ins>const type_info *</ins>, size_t&gt; {
+- size_t operator()(<del>type_index</del><ins>const type_info *</ins> <del>index</del><ins>t</ins>) const;
+- }<ins>;</ins>
+- <ins>concept_map LessThanComparable&lt;const type_info *&gt; <i>see below</i></ins>
+- class bad_cast;
+- class bad_typeid;
+-}
+-</pre></blockquote>
++<blockquote><p>
++Mark as NAD. Rationale: there is no consensus to clarify the standard,
++general consensus that the standard is correct as written.
++</p></blockquote>
+
+-<p>Add the following new subsection</p>
+-<blockquote>
+-<p>
+-<ins>18.7.1.1 Template specialization <code>hash&lt;const type_info *&gt;</code>
+-[type.info.hash]</ins></p>
+
+-<pre><ins>size_t operator()(const type_info *x) const;</ins>
+-</pre>
+-<ol>
+-<li><ins><i>Returns</i>: <code>x-&gt;hash_code()</code></ins></li>
+-</ol>
+-</blockquote>
+
+- <p>Add the following new subsection</p>
+- <blockquote>
+-<p><ins>18.7.1.2 <code>type_info</code> concept map [type.info.concepts]</ins></p>
++<p><b>Proposed resolution:</b></p>
++<p><i>[
++This is a minimum version. I also
++suggest that the wording explaining the allocation strategy
++of <tt>std::vector</tt> in 23.3.6.3 [vector.capacity]/3 and /6 is moved into
++a separate sub paragraph of 23.3.6.3 [vector.capacity] <em>before</em>
++any of the prototype's are discussed, but I cannot provide
++reasonable wording changes now
++]</i></p>
+
+
+-<pre><ins>concept_map LessThanComparable&lt;const type_info *&gt; {</ins>
+- <ins>bool operator&lt;(const type_info *x, const type_info *y) { return x-&gt;before(*y); }</ins>
+- <ins>bool operator&lt;=(const type_info *x, const type_info *y) { return !y-&gt;before(*x); }</ins>
+- <ins>bool operator&gt;(const type_info *x, const type_info *y) { return y-&gt;before(*x); }</ins>
+- <ins>bool operator&gt;=(const type_info *x, const type_info *y) { return !x-&gt;before(*y); }</ins>
+-<ins>}</ins>
+-</pre>
+ <ol>
+- <li><ins><i>Note</i>: provides a well-defined ordering among
+- <code>type_info const</code> pointers, which makes such pointers
+- usable in associative containers (23.4).</ins></li>
++<li>
++<p>
++Change 23.3.6.3 [vector.capacity]/6 as follows:
++</p>
++<blockquote><p>
++It is guaranteed that no reallocation takes place during
++insertions <ins>or erasures</ins> that happen after a call
++to <tt>reserve()</tt> until the time when an insertion would make
++the size of the vector greater than the value of <tt>capacity()</tt>.
++</p></blockquote>
++</li>
++<li>
++<p>
++Change 23.3.6.5 [vector.modifiers]/4 as follows:
++</p>
++<blockquote><p>
++<i>Effects:</i> <ins>The capacity shall remain unchanged and no reallocation shall
++happen.</ins>
++Invalidates iterators and references at or after the point
++of the erase.
++</p></blockquote>
++</li>
+ </ol>
+-</blockquote>
+-
+-<p>Remove section 20.13 [type.index]</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1080"></a>1080. Concept ArithmeticLike should provide explicit boolean conversion</h3>
+-<p><b>Section:</b> X [concept.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1105"></a>1105. Shouldn't <tt>Range</tt> be an <tt>auto concept</tt></h3>
++<p><b>Section:</b> X [iterator.concepts.range] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++
++<p><i>[
++2009-04-26 Herb adds:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-Astonishingly, the current concept ArithmeticLike as specified in
+-X [concept.arithmetic] does not provide explicit conversion
+-to <tt>bool</tt> although this is a common property of arithmetic types
+-(4.12 [conv.bool]). Recent proposals that introduced such types
+-(integers of arbitrary precision,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2143.pdf">n2143</a>,
+-decimals
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2732.pdf">n2732</a>
+-indirectly
+-via conversion to <tt>long long</tt>) also took care of such a feature.
++Here's a common example: We have many ISV customers who have built lots of
++in-house STL-like containers. Imagine that, for the past ten years, the user
++has been happily using his <tt>XYZCorpContainer&lt;T&gt;</tt> that has <tt>begin()</tt> and <tt>end()</tt>
++and an iterator typedef, and indeed satisfies nearly all of <tt>Container</tt>,
++though maybe not quite all just like <tt>valarray</tt>. The user upgrades to a
++range-enabled version of a library, and now <tt>lib_algo( xyz.begin(), xyz.end());</tt>
++no longer works -- compiler error.
+ </p>
+ <p>
+-Adding such an explicit conversion associated function would also
+-partly solve a currently invalid effects clause in library, which bases
+-on this property, 24.2.7 [random.access.iterators]/2:
++Even though <tt>XYZCorpContainer</tt> matches the pre-conceptized version of the
++algorithm, and has been working for years, it appears the user has to write
++at least this:
+ </p>
+-<blockquote><pre>{ difference_type m = n;
+- if (m &gt;= 0) while (m--) ++r;
+- else while (m++) --r;
+- return r; }
+-</pre></blockquote>
++<blockquote><pre>
++template&lt;class T&gt; concept_map Range&lt;XYZCorpContainer&lt;T&gt;&gt; {};
+
++template&lt;class T&gt; concept_map Range&lt;const XYZCorpContainer&lt;T&gt;&gt; {};
++</pre></blockquote>
+ <p>
+-Both while-loops take advantage of a contextual conversion to <tt>bool</tt>
+-(Another problem is that the &gt;= comparison uses the no
+-longer supported existing implicit conversion from <tt>int</tt> to <tt>IntegralLike</tt>).
++Is that correct?
+ </p>
+-
+-<b>Original proposed resolution:</b>
+-<ol>
+-<li>
+ <p>
+-In X [concept.arithmetic], add to the list of less refined
+-concepts one further concept:
++But he may actually have to write this as we do for initializer list:
+ </p>
++<blockquote><pre>
++template&lt;class T&gt;
++concept_map Range&lt;XYZCorpContainer&lt;T&gt;&gt; {
++ typedef T* iterator;
++ iterator begin(XYZCorpContainer&lt;T&gt; c) { return c.begin(); }
++ iterator end(XYZCorpContainer&lt;T&gt; c) { return c.end(); }
++};
+
+-<blockquote><pre>concept ArithmeticLike&lt;typename T&gt;
+- : Regular&lt;T&gt;, LessThanComparable&lt;T&gt;, HasUnaryPlus&lt;T&gt;, HasNegate&lt;T&gt;,
+- HasPlus&lt;T, T&gt;, HasMinus&lt;T, T&gt;, HasMultiply&lt;T, T&gt;, HasDivide&lt;T, T&gt;,
+- HasPreincrement&lt;T&gt;, HasPostincrement&lt;T&gt;, HasPredecrement&lt;T&gt;,
+- HasPostdecrement&lt;T&gt;,
+- HasPlusAssign&lt;T, const T&amp;&gt;, HasMinusAssign&lt;T, const T&amp;&gt;,
+- HasMultiplyAssign&lt;T, const T&amp;&gt;,
+- HasDivideAssign&lt;T, const T&amp;&gt;<ins>, ExplicitlyConvertible&lt;T, bool&gt;</ins> {
++template&lt;class T&gt;
++concept_map Range&lt;const XYZCorpContainer&lt;T&gt;&gt; {
++ typedef T* iterator;
++ iterator begin(XYZCorpContainer&lt;T&gt; c) { return c.begin(); }
++ iterator end(XYZCorpContainer&lt;T&gt; c) { return c.end(); }
++};
+ </pre></blockquote>
+-</li>
+-<li>
++
++</blockquote>
++
++<p><i>[
++2009-04-28 Alisdair adds:
++]</i></p>
++
++
++<blockquote>
+ <p>
+-In 24.2.7 [random.access.iterators]/2 change the current effects clause
+-as indicated [The proposed insertion fixes the problem that the previous
+-implicit construction from integrals has been changed to an explicit
+-constructor]:
++I recommend NAD, although remain concerned about header organisation.
+ </p>
+-<blockquote><pre>{ difference_type m = n;
+- if (m &gt;= <ins>difference_type(</ins>0<ins>)</ins>) while (m--) ++r;
+- else while (m++) --r;
+- return r; }
+-</pre></blockquote>
+-</li>
+-</ol>
++<p>
++A user container will satisfy the <tt>MemberContainer</tt> concept, which IS auto.
++There is a concept_map for all <tt>MemberContainers</tt> to <tt>Container</tt>, and then a
++further concept_map for all <tt>Container</tt> to <tt>Range</tt>, so the stated problem is not
++actually true. User defined containers will automatically match the <tt>Range</tt>
++concept without explicitly declaring a concept_map.
++</p>
++<p>
++The problem is that they should now provide an additional two headers,
++<tt>&lt;iterator_concepts&gt;</tt> and <tt>&lt;container_concepts&gt;</tt>.
++ The only difference from
++making <tt>Range</tt> an auto concept would be this reduces to a single header,
++<tt>&lt;iterator_concepts&gt;</tt>.
++</p>
++<p>
++I am strongly in favour of any resolution that tackles the issue of
++explicitly requiring concept headers to make these concept maps available.
++</p>
++</blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -37192,1410 +30754,1568 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-We agree that arithmetic types ought be convertible to <tt>bool</tt>,
+-and we therefore agree with the proposed resolution's paragraph 1.
++We observe there is a recent paper by Bjarne that overlaps this issue.
+ </p>
+ <p>
+-We do not agree that the cited effects clause is invalid,
+-as it expresses intent rather than specific code.
++Alisdair continues to recommend NAD.
+ </p>
+ <p>
+-Move to Review, pending input from concepts experts.
++Move to Open, and recommend the issue be deferred until after the next
++Committee Draft is issued.
+ </p>
+ </blockquote>
+
+
+-
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-In X [concept.arithmetic], add to the list of less refined
+-concepts one further concept:
+-</p>
+-
+-<blockquote><pre>concept ArithmeticLike&lt;typename T&gt;
+- : Regular&lt;T&gt;, LessThanComparable&lt;T&gt;, HasUnaryPlus&lt;T&gt;, HasNegate&lt;T&gt;,
+- HasPlus&lt;T, T&gt;, HasMinus&lt;T, T&gt;, HasMultiply&lt;T, T&gt;, HasDivide&lt;T, T&gt;,
+- HasPreincrement&lt;T&gt;, HasPostincrement&lt;T&gt;, HasPredecrement&lt;T&gt;,
+- HasPostdecrement&lt;T&gt;,
+- HasPlusAssign&lt;T, const T&amp;&gt;, HasMinusAssign&lt;T, const T&amp;&gt;,
+- HasMultiplyAssign&lt;T, const T&amp;&gt;,
+- HasDivideAssign&lt;T, const T&amp;&gt;<ins>, ExplicitlyConvertible&lt;T, bool&gt;</ins> {
+-</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1081"></a>1081. Response to UK 216</h3>
+-<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#strings">issues</a> in [strings].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1107"></a>1107. constructor <tt>shared_future(unique_future)</tt> by value?</h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Thomas J. Gritzan <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 216, JP 46, JP 48</b></p>
+-
+ <p>
+-All the containers use concepts for their iterator usage, exect for
+-<tt>basic_string</tt>. This needs fixing.
++In the <tt>shared_future</tt> class definition in 30.6.7 [futures.shared_future]
++the move constructor
++that constructs a <tt>shared_future</tt> from an <tt>unique_future</tt> receives the
++parameter by value. In paragraph 3, the same constructor receives it as
++const value.
+ </p>
+
+ <p>
+-Use concepts for iterator template parameters throughout the chapter.
++I think that is a mistake and the constructor should take a r-value
++reference:
+ </p>
+
++<blockquote><pre>
++shared_future(unique_future&lt;R&gt;&amp;&amp; rhs);
++</pre></blockquote>
++
+ <p><i>[
+-Summit:
++Batavia (2009-05):
+ ]</i></p>
+
+ <blockquote>
+-NB comments to be handled by Dave Abrahams and Howard Hinnant with
+-advice from PJP: UK216 (which duplicates) JP46, JP48. JP46 supplies
+-extensive proposed wording; start there.
++<p>
++We agree with the proposed resolution.
++<p/>
++Move to Tentatively Ready.
++</p>
+ </blockquote>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-
++<p><i>[
++2009-07-05 Daniel notes:
++]</i></p>
+
+
++<blockquote><p>
++The proposed change has already been incorported into the current working draft
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>.
++</p></blockquote>
+
+
+-<hr>
+-<h3><a name="1082"></a>1082. Response to JP 49</h3>
+-<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#localization">issues</a> in [localization].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses JP 49</b></p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-<tt>codecvt</tt> does not use concept. For example, create <tt>CodeConvert</tt>
+-concept and change as follows.
++Change the synopsis in 30.6.7 [futures.shared_future]:
+ </p>
+
+-<blockquote><pre>template&lt;CodeConvert Codecvt, class Elem = wchar_t&gt;
+- class wstring_convert {
++<blockquote><pre>
++shared_future(unique_future&lt;R&gt;<ins>&amp;&amp;</ins> rhs);
+ </pre></blockquote>
+
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-<blockquote>
+-To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+-</blockquote>
++<p>
++Change the definition of the constructor in 30.6.7 [futures.shared_future]:
++</p>
+
++<blockquote><pre>
++shared_future(<del>const</del> unique_future&lt;R&gt;<ins>&amp;&amp;</ins> rhs);
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1083"></a>1083. Response to JP 52, 53</h3>
+-<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#localization">issues</a> in [localization].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1109"></a>1109. <tt>std::includes</tt> should require <tt>CopyConstructible</tt> predicate</h3>
++<p><b>Section:</b> 25.4.5.1 [includes] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#includes">issues</a> in [includes].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP 52, JP 53</b></p>
+-
+-<p>
+-<tt>InputIterator</tt> does not use concept.
+-</p>
+-
+-<p>
+-<tt>OutputIterator</tt> does not use concept.
+-</p>
+-
+ <p>
+-Comments include proposed wording.
++All the set operation algorithms require a <tt>CopyConstructible</tt> predicate, with
++the exception of <tt>std::includes</tt>. This looks like a typo as much as anything,
++given the general library requirement that predicates are copy
++constructible, and wording style of other set-like operations.
+ </p>
+
+ <p><i>[
+-Summit:
++Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
+-To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+-</blockquote>
++<blockquote><p>
++We agree with the proposed resolution.
++Move to NAD Editorial.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++Change [algorithms.syn] and 25.4.5.1 [includes]:
++</p>
++
++<blockquote><pre>
++template&lt;InputIterator Iter1, InputIterator Iter2,
++ <del>typename</del> <ins>CopyConstructible</ins> Compare&gt;
++ requires Predicate&lt;Compare, Iter1::value_type, Iter2::value_type&gt;
++ &amp;&amp; Predicate&lt;Compare, Iter2::value_type, Iter1::value_type&gt;
++ bool includes(Iter1 first1, Iter1 last1,
++ Iter2 first2, Iter2 last2,
++ Compare comp);
++</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1084"></a>1084. Response to UK 250</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1111"></a>1111. associative containers underconstrained</h3>
++<p><b>Section:</b> 23.4 [associative] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative">active issues</a> in [associative].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative">issues</a> in [associative].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 250</b></p>
+-
+ <p>
+-A default implementation should be supplied for the post-increment
+-operator to simplify implementation of iterators by users.
++According to table 87 (n2857) the expression <tt>X::key_equal</tt> for an unordered
++container shall return a value of type <tt>Pred</tt>, where <tt>Pred</tt> is an equivalence
++relation.
+ </p>
+
+ <p>
+-Copy the Effects clause into the concept description as the default
+-implementation. Assumes a default value for postincrement_result
++However, all 4 containers constrain <tt>Pred</tt> to be merely a <tt>Predicate</tt>,
++and not <tt>EquivalenceRelation</tt>.
+ </p>
+
+ <p><i>[
+-Summit:
+-]</i></p>
+-
+-<blockquote>
+-Howard will open an issue.
+-</blockquote>
+-
+-<p><i>[
+-2009-06-07 Daniel adds:
++Batavia (2009-05):
+ ]</i></p>
+
+-
+ <blockquote>
+-This issue cannot currently be resolved as suggested, because
+-that would render auto-detection of the return type
+-<tt>postincrement_result</tt> invalid, see [concept.map.assoc]/4+5. The
+-best fix would be to add a default type to that associated type, but
+-unfortunately any default type will prevent auto-deduction of types of
+-associated functions as quoted above. A corresponding core issue
+-is in preparation.
++<p>
++We agree with the proposed resolution.
++</p>
++<p>
++Move to Review.
++</p>
+ </blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>[
+-This wording assumes the acceptance of UK 251 / <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>. Both
+-wordings change the same paragraphs.
+-]</i></p>
+-
++<p>
++For ordered containers, replace
++</p>
++<blockquote><pre>
++Predicate&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
++</pre></blockquote>
++<p>
++with
++</p>
++<blockquote><pre>
++StrictWeakOrder&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
++</pre></blockquote>
+
+ <p>
+-Change 24.2.5 [forward.iterators]:
++For unordered containers, replace
++</p>
++<blockquote><pre>
++Predicate&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
++</pre></blockquote>
++<p>
++with
++</p>
++<blockquote><pre>
++EquivalenceRelation&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
++</pre></blockquote>
++<p>
++As in the following declarations:
+ </p>
+
+ <blockquote>
+-<pre>concept ForwardIterator&lt;typename X&gt; : InputIterator&lt;X&gt;, Regular&lt;X&gt; {
++<p>
++Associative containers 23.4 [associative]
++</p>
++<p>
++ 1 Headers <tt>&lt;map&gt;</tt> and <tt>&lt;set&gt;</tt>:
++</p>
++<p>
++ Header <tt>&lt;map&gt;</tt> synopsis
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, ValueType T,
++ <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class map;
+
+- MoveConstructible postincrement_result;
+- requires HasDereference&lt;postincrement_result&gt;
+- &amp;&amp; Convertible&lt;HasDereference&lt;postincrement_result&gt;::result_type, const value_type&amp;&gt;;
++ ...
+
+- postincrement_result operator++(X&amp; r, int)<del>;</del> <ins>{
+- X tmp = r;
+- ++r;
+- return tmp;
+- }</ins>
++ template &lt;ValueType Key, ValueType T,
++ <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class multimap;
+
+- axiom MultiPass(X a, X b) {
+- if (a == b) *a == *b;
+- if (a == b) ++a == ++b;
+- }
+-}
+-</pre></blockquote>
++ ...
+
++ }
++</pre></blockquote>
+
++<p>
++ Header &lt;set&gt; synopsis
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;Key&gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class set;
+
++ ...
+
++ template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;Key&gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class multiset;
+
++ ...
+
+-<hr>
+-<h3><a name="1085"></a>1085. Response to UK 258</h3>
+-<p><b>Section:</b> 24.2.6 [bidirectional.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses UK 258</b></p>
++ }
++</pre></blockquote>
+
+ <p>
+-A default implementation should be supplied for the post-decrement
+-operator to simplify implementation of iterators by users.
++ 23.4.1p2 Class template map [map]
+ </p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, ValueType T,
++ <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class map {
++ ...
++ };
++ }
++</pre></blockquote>
++
+
+ <p>
+-Copy the Effects clause into the concept description as the default
+-implementation. Assumes a default value for postincrement_result
++ 23.4.2p2 Class template multimap [multimap]
+ </p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, ValueType T,
++ <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class multimap {
++ ...
++ };
++ }
++</pre></blockquote>
+
+-<p><i>[
+-Summit:
+-]</i></p>
+-
+-<blockquote>
+-Howard will open an issue.
+-</blockquote>
+-
+-<p><i>[
+-2009-06-07 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-This issue cannot currently be resolved as suggested, because
+-that would render auto-detection of the return type
+-<tt>postdecrement_result</tt> invalid, see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>.
+-</blockquote>
+
++<p>
++ 23.4.3p2 Class template set [set]
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;Key&gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class set {
++ ...
++ };
++ }
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 24.2.6 [bidirectional.iterators]:
++ 23.4.4p2 Class template multiset [multiset]
+ </p>
+-
+-<blockquote>
+-<pre>concept BidirectionalIterator&lt;typename X&gt; : ForwardIterator&lt;X&gt; {
+- MoveConstructible postdecrement_result;
+- requires HasDereference&lt;postdecrement_result&gt;
+- &amp;&amp; Convertible&lt;HasDereference&lt;postdecrement_result&gt;::result_type, const value_type&amp;&gt;
+- &amp;&amp; Convertible&lt;postdecrement_result, const X&amp;&gt;;
+- X&amp; operator--(X&amp;);
+- postdecrement_result operator--(X&amp; <ins>r</ins>, int)<del>;</del> <ins>{
+- X tmp = r;
+- --r;
+- return tmp;
+- }</ins>
+-}
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;Key&gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
++ class multiset {
++ ...
++ };
++ }
+ </pre></blockquote>
+
++<p>
++ 23.5 Unordered associative containers [unord]
++</p>
++<p>
++ 1 Headers &lt;unordered_map&gt; and &lt;unordered_set&gt;:
++</p>
++<p>
++ Header &lt;unordered_map&gt; synopsis
++</p>
++<blockquote><pre>
++ namespace std {
++ // 23.5.1, class template unordered_map:
++ template &lt;ValueType Key,
++ ValueType T,
++ Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_map;
+
++ // 23.5.2, class template unordered_multimap:
++ template &lt;ValueType Key,
++ ValueType T,
++ Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_multimap;
+
++ ...
++ }
++</pre></blockquote>
+
++<p>
++ Header &lt;unordered_set&gt; synopsis
++</p>
++<blockquote><pre>
++ namespace std {
++ // 23.5.3, class template unordered_set:
++ template &lt;ValueType Value,
++ Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
++ Allocator Alloc = allocator&lt;Value&gt; &gt;
++ requires NothrowDestructible&lt;Value&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_set;
+
++ // 23.5.4, class template unordered_multiset:
++ template &lt;ValueType Value,
++ Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
++ Allocator Alloc = allocator&lt;Value&gt; &gt;
++ requires NothrowDestructible&lt;Value&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_multiset;
+
+-<hr>
+-<h3><a name="1086"></a>1086. Response to UK 284</h3>
+-<p><b>Section:</b> 24.6 [stream.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses UK 284</b></p>
++ ...
++ }
++</pre></blockquote>
+
+ <p>
+-The stream iterators need constraining with concepts/requrires clauses.
++ 23.5.1p3 Class template unordered_map [unord.map]
+ </p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key,
++ ValueType T,
++ Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_map
++ {
++ ...
++ };
++ }
++</pre></blockquote>
+
+-<p><i>[
+-Summit:
+-]</i></p>
++<p>
++ 23.5.2p3 Class template unordered_multimap [unord.multimap]
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Key,
++ ValueType T,
++ Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
++ Allocator Alloc = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++ requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_multimap
++ {
++ ...
++ };
++ }
++</pre></blockquote>
+
+-<blockquote>
+-We agree. To be handled by Howard, Martin and PJ.
+-</blockquote>
++<p>
++ 23.5.3p3 Class template unordered_set [unord.set]
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Value,
++ Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
++ Allocator Alloc = allocator&lt;Value&gt; &gt;
++ requires NothrowDestructible&lt;Value&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_set
++ {
++ ...
++ };
++ }
++</pre></blockquote>
++<p>
++ 23.5.4p3 Class template unordered_multiset [unord.multiset]
++</p>
++<blockquote><pre>
++ namespace std {
++ template &lt;ValueType Value,
++ Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
++ <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
++ Allocator Alloc = allocator&lt;Value&gt; &gt;
++ requires NothrowDestructible&lt;Value&gt;
++ &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
++ &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
++ &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
++ class unordered_multiset
++ {
++ ...
++ };
++ }
++</pre></blockquote>
+
++</blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1087"></a>1087. Response to UK 301</h3>
+-<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1115"></a>1115. <tt>va_copy</tt> missing from Standard macros table</h3>
++<p><b>Section:</b> C.5 [diff.library] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Miles Zhao <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#diff.library">issues</a> in [diff.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 301</b></p>
+-
+-<p>
+-<tt>replace</tt> and <tt>replace_if</tt> have the requirement: <tt>OutputIterator&lt;Iter,
+-Iter::reference&gt;</tt> Which implies they need to copy some values in the
+-range the algorithm is iterating over. This is not however the case, the
+-only thing that happens is <tt>const T&amp;</tt>s might be copied over existing
+-elements (hence the <tt>OutputIterator&lt;Iter, const T&amp;&gt;</tt>.
+-</p>
+-
+ <p>
+-Remove <tt>OutputIterator&lt;Iter, Iter::reference&gt;</tt> from <tt>replace</tt>
+-and <tt>replace_if</tt>.
++In "Table 122 &mdash; Standard macros" of C.5 [diff.library], which lists the 56 macros
++inherited from C library, <tt>va_copy</tt> seems to be missing. But in
++"Table 21 &mdash; Header <tt>&lt;cstdarg&gt;</tt> synopsis" (18.10 [support.runtime]), there is.
+ </p>
+
+ <p><i>[
+-Summit:
++2009-10 post-Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-We agree. To be handled by Howard.
+-</blockquote>
++
++<blockquote><p>
++Mark as Tentatively NAD Editorial, if Pete disagrees, Howard
++will move to Tentatively Ready
++</p></blockquote>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change in [algorithms.syn] and 25.3.5 [alg.replace]:
++Add <tt>va_copy</tt> to Table 122 -- Standard macros in C.5 [diff.library].
+ </p>
+
+-<blockquote><pre>template&lt;ForwardIterator Iter, class T&gt;
+- requires <del>OutputIterator&lt;Iter, Iter::reference&gt;
+- &amp;&amp;</del> OutputIterator&lt;Iter, const T&amp;&gt;
+- &amp;&amp; HasEqualTo&lt;Iter::value_type, T&gt;
+- void replace(Iter first, Iter last,
+- const T&amp; old_value, const T&amp; new_value);
+-
+-template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred, class T&gt;
+- requires <del>OutputIterator&lt;Iter, Iter::reference&gt;
+- &amp;&amp;</del> OutputIterator&lt;Iter, const T&amp;&gt;
+- &amp;&amp; CopyConstructible&lt;Pred&gt;
+- void replace_if(Iter first, Iter last,
+- Pred pred, const T&amp; new_value);
+-</pre></blockquote>
+-
+
+
+
+
+ <hr>
+-<h3><a name="1088"></a>1088. Response to UK 342</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1119"></a>1119. tuple query APIs do not support references</h3>
++<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 342</b></p>
+-
+ <p>
+-<tt>std::promise</tt> is missing a non-member overload of <tt>swap</tt>. This is
+-inconsistent with other types that provide a <tt>swap</tt> member function.
++The <tt>tuple</tt> query APIs <tt>tuple_size</tt> and
++<tt>tuple_element</tt> do not support references-to-tuples. This can be
++annoying when a template deduced a parameter type to be a reference,
++which must be explicitly stripped with <tt>remove_reference</tt> before calling
++these APIs.
+ </p>
+-
+ <p>
+-Add a non-member overload <tt>void swap(promise&amp;&amp; x,promise&amp;&amp; y){ x.swap(y); }</tt>
++I am not proposing a resolution at this point, as there is a
++combinatorial explosion with lvalue/rvalue references and
++cv-qualification (see previous issue) that suggests some higher
++refactoring is in order. This might be something to kick back over to
++Core/Evolution.
++</p>
++<p>
++Note that we have the same problem in numeric_limits.
+ </p>
+
+ <p><i>[
+-Summit:
++2009-10 post-Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-Create an issue. Move to review, attention: Howard. Detlef will also
+-look into it.
+-</blockquote>
+
+-<p><i>[
+-Post Summit Daniel provided wording.
+-]</i></p>
++<blockquote><p>
++Move to Open. Alisdair to provide wording.
++</p></blockquote>
+
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2010 Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
++<blockquote><p>
++Move to NAD. This is an extension after the FCD, without a clear motivation.
++May consider as NAD Future if motivating examples come forward.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
++
++
++
++
++
++<hr>
++<h3><a name="1124"></a>1124. Invalid definition of concept RvalueOf</h3>
++<p><b>Section:</b> X [concept.transform] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#concept.transform">issues</a> in [concept.transform].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-In 30.6.5 [futures.promise], before p.1, immediately after class template
+-promise add:
++A recent news group
++<a href="http://groups.google.de/group/comp.std.c++/browse_frm/thread/8eb92768a19fb46f">article</a>
++points to several defects in the
++specification of reference-related concepts.
+ </p>
+-<blockquote><pre><ins>
+-template &lt;class R&gt;
+-void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
+-</ins>
+-</pre></blockquote>
+-</li>
+-<li>
+ <p>
+-Change 30.6.5 [futures.promise]/10 as indicated (to fix a circular definition):
++One problem of the concept <tt>RvalueOf</tt> as currently defined in
++X [concept.transform]:
+ </p>
+-<blockquote>
+-<p>
+--10- <i>Effects:</i> <del>swap(*this, other)</del><ins>Swaps the associated state
+-of <tt>*this</tt> and <tt>other</tt></ins>
+-</p>
+-<p>
+-<ins><i>Throws:</i> Nothing.</ins>
+-</p>
+-</blockquote>
+-</li>
+-<li>
+-<p>
+-After the last paragraph in 30.6.5 [futures.promise] add the following
+-prototype description:
+-</p>
+-<blockquote><pre><ins>
+-template &lt;class R&gt;
+-void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
+-</ins></pre>
+-<blockquote>
++
++<blockquote><pre>
++concept RvalueOf&lt;typename T&gt; {
++ typename type = T&amp;&amp;;
++ requires ExplicitlyConvertible&lt;T&amp;,type&gt; &amp;&amp; Convertible&lt;T&amp;&amp;,type&gt;;
++}
++
++template&lt;typename T&gt; concept_map RvalueOf&lt;T&amp;&gt; {
++ typedef T&amp;&amp; type;
++}
++</pre></blockquote>
++
+ <p>
+-<ins><i>Effects:</i> <tt>x.swap(y)</tt></ins>
++is that if <tt>T</tt> is an lvalue-reference, the requirement
++<tt>Convertible&lt;T&amp;&amp;,type&gt;</tt> isn't satisfied for
++lvalue-references, because after reference-collapsing in the concept
++definition we have <tt>Convertible&lt;T&amp;,type&gt;</tt> in this case,
++which isn't satisfied in the concept map template and also is not the
++right constraint either. I think that the reporter is right that
++<tt>SameType</tt> requirements should do the job and that we also should
++use the new <tt>RvalueReference</tt> concept to specify a best matching
++type requirement.
+ </p>
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-<ins><i>Throws:</i> Nothing.</ins>
++In X [concept.transform] before p. 4 change as indicated:
+ </p>
+-</blockquote>
+-</blockquote>
+-</li>
+-
+-</ol>
+
++<blockquote><pre>
++auto concept RvalueOf&lt;typename T&gt; {
++ <del>typename</del><ins>RvalueReference</ins> type = T&amp;&amp;;
++ requires <del>ExplicitlyConvertible&lt;T&amp;, type&gt; &amp;&amp; Convertible&lt;T&amp;&amp;, type&gt;</del><ins>SameType&lt;T&amp;, type&amp;&gt;</ins>;
++}
++</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1090"></a>1090. Missing description of <tt>packaged_task</tt> member <tt>swap</tt>, missing non-member <tt>swap</tt></h3>
+-<p><b>Section:</b> 30.6.10 [futures.task] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.task">issues</a> in [futures.task].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1125"></a>1125. ostream_iterator does not work with movable types</h3>
++<p><b>Section:</b> 24.6.2.2 [ostream.iterator.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Class template <tt>packaged_task</tt> in 30.6.10 [futures.task] shows a member <tt>swap</tt>
+-declaration, but misses to
+-document it's effects (No prototype provided). Further on this class
+-misses to provide a non-member
+-swap.
+-</p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-Alisdair notes that paragraph 2 of the proposed resolution has already been
+-applied in the current Working Draft.
+-</p>
+-<p>
+-We note a pending <tt>future</tt>-related paper by Detlef;
+-we would like to wait for this paper before proceeding.
+-</p>
+-<p>
+-Move to Open.
++<tt>ostream_iterator</tt> has not been updated to support moveable types, in a
++similar manner to the insert iterators.
++Note that this is not a problem for <tt>ostreambuf_iterator</tt>, as the types it is
++restricted to dealing with do not support extra-efficient moving.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-05-24 Daniel removed part 2 of the proposed resolution.
+-]</i></p>
+-
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2009-11-10 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to Tentatively Ready, removing bullet 3 from the proposed
+-resolution but keeping the other two bullets.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
++<blockquote><p>
++Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale
++added below.
++</p></blockquote>
+
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
++<p>
++Add second <tt>operator=</tt> overload to class <tt>template ostream_iterator</tt>
++in 24.6.2 [ostream.iterator], para 2:
++</p>
+
++<blockquote><pre>
++ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(const T&amp; value);
++<ins>ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(T&amp;&amp; value);</ins>
++</pre></blockquote>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by N3058.
++Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]:
+ </p>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
++<blockquote>
++<pre>
++ostream_iterator&amp; operator=(T&amp;&amp; value);
++</pre>
++<blockquote>
+ <p>
+-In 30.6.10 [futures.task], immediately after the definition of class
+-template packaged_task add:
++-2- <i>Effects:</i>
+ </p>
+-<blockquote><pre><ins>
+-template&lt;class R, class... Argtypes&gt;
+-void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp;, packaged_task&lt;R(ArgTypes...)&gt;&amp;);
+-</ins>
++<blockquote><pre>
++*out_stream &lt;&lt; std::move(value);
++if(delim != 0)
++ *out_stream &lt;&lt; delim;
++return (*this);
+ </pre></blockquote>
+-</li>
+-</ol>
++</blockquote>
++</blockquote>
+
+-<ol start="4">
+
+-<li>
++
++<p><b>Rationale:</b></p>
+ <p>
+-At the end of 30.6.10 [futures.task] (after p. 20), add add the following
+-prototype description:
++Several objections to move forward with this issue were voiced in the thread
++starting with c++std-lib-25438. Among them is that we know of no motivating
++use case to make streaming rvalues behave differently than streaming const
++lvalues.
+ </p>
+
+-<blockquote><pre><ins>
+-template&lt;class R, class... Argtypes&gt;
+-void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp; x, packaged_task&lt;R(ArgTypes...)&gt;&amp; y);
+-</ins></pre>
+-<blockquote>
+-<p><ins>
+-<i>Effects:</i> <tt>x.swap(y)</tt>
+-</ins></p>
+-<p><ins>
+-<i>Throws:</i> Nothing.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+
+
+
+
+ <hr>
+-<h3><a name="1091"></a>1091. Multimap description confusing</h3>
+-<p><b>Section:</b> 23.6.2.2 [multimap.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1127"></a>1127. rvalue references and iterator traits</h3>
++<p><b>Section:</b> 24.4.1 [iterator.traits] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.traits">issues</a> in [iterator.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 246</b></p>
+ <p>
+-The content of this sub-clause is purely trying to describe in words the
+-effect of the requires clauses on these operations, now that we have
+-Concepts. As such, the description is more confusing than the signature
+-itself. The semantic for these functions is adequately covered in the
+-requirements tables in 23.2.4 [associative.reqmts].
++The deprecated support for <tt>iterator_traits</tt> and legacy (unconstrained)
++iterators features the (exposition only) concept:
+ </p>
+
+-<p><i>[
+-Beman adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-Pete is clearly right that
+-this one is technical rather than editorial.
+-</blockquote>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
++<blockquote><pre>
++concept IsReference&lt;typename T&gt; { } // exposition only
++template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&gt; { }
++</pre></blockquote>
+ <p>
+-We agree with the proposed resolution.
++Now this looks exactly like the <tt>LvalueReference</tt> concept recently added to
++clause 20, so I wonder if we should use that instead?
++Then I consider the lack of rvalue-reference support, which means that
++<tt>move_iterator</tt> would always flag as merely supporting the <tt>input_iterator_tag</tt>
++category. This suggests we retain the exposition concept, but add a second
++concept_map to support rvalue references.
+ </p>
+ <p>
+-Move to Review.
++I would suggest adding the extra concept_map is the right way forward, but
++still wonder if the two exposition-only concepts in this clause might be
++worth promoting to clause 20. That question might better be answered with a
++fuller investigation of type_trait/concept unification though.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as NAD, solved by removing concepts.
+-</blockquote>
+-
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Strike 23.6.2.2 [multimap.modifiers] entirely
+-(but do NOT strike these signatures from the class template definition!).
++In Iterator traits 24.4.1 [iterator.traits] para 4 add:
+ </p>
+
++<blockquote><pre>
++concept IsReference&lt;typename T&gt; { } // exposition only
++template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&gt; { }
++<ins>template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&amp;&gt; { }</ins>
++</pre></blockquote>
++
++
+
+
+
+
+ <hr>
+-<h3><a name="1092"></a>1092. Class template <tt>integral_constant</tt> should be a constrained template</h3>
+-<p><b>Section:</b> 20.7.3 [meta.help] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.help">issues</a> in [meta.help].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1128"></a>1128. Missing definition of <tt>iterator_traits&lt;T*&gt;</tt></h3>
++<p><b>Section:</b> X [iterator.syn] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-A first step to change the type traits predicates to constrained templates is to
+-constrain their common base template <tt>integral_constant</tt>. This can be done,
+-without enforcing depending classes to be constrained as well, but not
+-vice versa
+-without brute force <tt>late_check</tt> usages. The following proposed resolution depends
+-on the resolution of LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.
++The <tt>&lt;iterator&gt;</tt> header synopsis declares a partial specialization of
++<tt>iterator_traits</tt> to support pointers, X [iterator.syn]. The implication
++is that specialization will be described in D10, yet it did not follow the
++rest of the deprecated material into this clause.
+ </p>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-Move to Open, pending a paper that looks at constraints
+-for the entirety of the type traits
+-and their relationship to the foundation concepts.
+-We recommend this be deferred
+-until after the next Committee Draft is issued.
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+ <p>
+-In 20.7.2 [meta.type.synop], Header <tt>&lt;type_traits&gt;</tt>
+-synopsis change as indicated:
++However, this is not as bad as it first seems!
++There are partial specializations of <tt>iterator_traits</tt> for types that satisfy
++the various Iterator concepts, and there are concept_maps for pointers to
++explicitly support the <tt>RandomAccessIterator</tt> concept, so the required
++template will be present - just not in the manner advertised.
+ </p>
+-<blockquote><pre>namespace std {
+-// 20.5.3, helper class:
+-template &lt;<del>class</del><ins>IntegralConstantExpressionType</ins> T, T v&gt; struct integral_constant;
+-</pre></blockquote>
+-</li>
+-<li>
+ <p>
+-In 20.7.3 [meta.help] change as indicated:
++I can see two obvious solutions:
+ </p>
+-<blockquote><pre>template &lt;<del>class</del><ins>IntegralConstantExpressionType</ins> T, T v&gt;
+-struct integral_constant {
+- static constexpr T value = v;
+- typedef T value_type;
+- typedef integral_constant&lt;T,v&gt; type;
+- constexpr operator value_type() { return value; }
+-};
+-</pre></blockquote>
++
++<ol style="list-style-type:lower-roman">
++<li>
++Restore the <tt>iterator_traits&lt;T*&gt;</tt> partial specialization in D.10
++</li>
++<li>
++Remove the declaration of <tt>iterator_traits&lt;T*&gt;</tt> from 24.3 synopsis
+ </li>
+ </ol>
++<p>
++I recommend option (ii) in the wording below
++</p>
++<p>
++Option (ii) could be extended to strike all the declarations of deprecated
++material from the synopsis, as it is effectively duplicating D.10 anyway.
++This is the approach taken for deprecated library components in the 98/03
++standards. This is probably a matter best left to the Editor though.
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>
++In X [iterator.syn] strike:
++</p>
+
++<blockquote><pre>
++<del>template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;</del>
++</pre></blockquote>
+
+
+-<hr>
+-<h3><a name="1093"></a>1093. Multiple definitions for random_shuffle algorithm</h3>
+-<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+
+-<p>
+-There are a couple of issues with the declaration of the <tt>random_shuffle</tt>
+-algorithm accepting a random number engine.
+-</p>
+
+-<ol type="i">
+-<li>
+-The Iterators must be shuffle iterators, yet this requirement is missing.
+-</li>
+-<li>
+-The <tt>RandomNumberEngine</tt> concept is now provided by the random number
+-library
+-(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">n2836</a>)
+-and the placeholder should be removed.
+-</li>
+-</ol>
+
+-<p><i>[
+-2009-05-02 Daniel adds:
+-]</i></p>
+
++<hr>
++<h3><a name="1132"></a>1132. JP-30: nested exceptions</h3>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Seiji Hayashida <b>Opened:</b> 2009-06-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP 30</b></p>
+
+-<blockquote>
+ <p>
+-this issue completes adding necessary requirement to the
+-third new <tt>random_shuffle</tt> overload. The current suggestion is:
++C++0x <tt>nested_exception</tt> cannot handle a structured exception well. The
++following codes show two types of tree structured exception handling.
+ </p>
+-
+-<blockquote><pre>template&lt;RandomAccessIterator Iter, UniformRandomNumberGenerator Rand&gt;
+-requires ShuffleIterator&lt;Iter&gt;
+-void random_shuffle(Iter first, Iter last, Rand&amp;&amp; g);
+-</pre></blockquote>
+-
+ <p>
+-IMO this is still insufficient and I suggest to add the requirement
++The first one is based on <tt>nested_exception</tt> in C++0x,
++while the second one is based on my library <tt>trickerr.h</tt> (in Japanese).
++<a href="http://tricklib.com/cxx/dagger/trickerr.h">http://tricklib.com/cxx/dagger/trickerr.h</a>
+ </p>
+-<blockquote><pre>Convertible&lt;Rand::result_type, Iter::difference_type&gt;
+-</pre></blockquote>
+ <p>
+-to the list (as the two other overloads already have).
++Assume that Function <tt>A()</tt> calls two sub functions <tt>A_a()</tt> and <tt>A_b()</tt>, both might
++throw tree structured exceptions, and <tt>A_b()</tt> must be called even if <tt>A_a()</tt>
++throws an exception.
+ </p>
+-
+ <p>
+-Rationale:
++List A (code of tree structured exception handling based on nested_exception
++in C++0x)
+ </p>
+
+-<blockquote>
++<blockquote><pre>
++void A()
++{
++ try
++ {
++ std::vector&lt;exception_ptr&gt; exception_list;
++ try
++ {
++ // A_a() does a similar processing as A().
++ A_a();
++ }
++ catch(...)
++ {
++ exception_list.push_back(current_exception());
++ }
++
++ // ***The processing A() has to do even when A_a() fails. ***
++ try
++ {
++ // A_b() does a similar processing as A().
++ A_b();
++ }
++ catch(...)
++ {
++ exception_list.push_back(current_exception());
++ }
++ if (!exception_list.empty())
++ {
++ throw exception_list;
++ }
++ }
++ catch(...)
++ {
++ throw_with_nested(A_exception("someone error"));
++ }
++}
++void print_tree_exception(exception_ptr e, const std::string &amp; indent ="")
++{
++ const char * indent_unit = " ";
++ const char * mark = "- ";
++ try
++ {
++ rethow_exception(e);
++ }
++ catch(const std::vector&lt;exception_ptr&gt; e)
++ {
++ for(std::vector&lt;exception_ptr&gt;::const_iterator i = e.begin(); i!=e.end(); ++i)
++ {
++ print_tree_exception(i, indent);
++ }
++ }
++ catch(const std::nested_exception e)
++ {
++ print_tree_exception(evil_i(e), indent +indent_unit);
++ }
++ catch(const std::exception e)
++ {
++ std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; e.what() &lt;&lt; std::endl;
++ }
++ catch(...)
++ {
++ std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; "unknown exception" &lt;&lt; std::endl;
++ }
++}
++int main(int, char * [])
++{
++ try
++ {
++ A();
++ }
++ catch()
++ {
++ print_tree_exception(current_exception());
++ }
++ return EXIT_SUCCESS;
++}
++</pre></blockquote>
++
+ <p>
+-Its true that this third overload is somewhat different from the remaining
+-two. Nevertheless we know from <tt>UniformRandomNumberGenerator</tt>, that
+-it's <tt>result_type</tt> is an integral type and that it satisfies
+-<tt>UnsignedIntegralLike&lt;result_type&gt;</tt>.
++List B ( code of tree structured exception handling based on <tt>trickerr.h</tt>. )
++"trickerr.h" (in Japanese), refer to:
++<a href="http://tricklib.com/cxx/dagger/trickerr.h">http://tricklib.com/cxx/dagger/trickerr.h</a>.
+ </p>
++
++<blockquote><pre>
++void A()
++{
++ tricklib::error_listener_type error_listener;
++ // A_a() is like A(). A_a() can throw tree structured exception.
++ A_a();
++
++ // *** It must do process so that A_a() throws exception in A(). ***
++ // A_b() is like A(). A_b() can throw tree structured exception.
++ A_b();
++
++ if (error_listener.has_error()) // You can write this "if block" in destructor
++ // of class derived from error_listener_type.
++ {
++ throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
++ }
++}
++void print_tree_error(const tricklib::error_type &amp;a_error, const std::string &amp; indent = "")
++{
++ const char * indent_unit = " ";
++ const char * mark = "- ";
++
++ tricklib::error_type error = a_error;
++ while(error)
++ {
++ std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; error-&gt;message &lt;&lt; std::endl;
++ if (error-&gt;children)
++ {
++ print_tree_error(error-&gt;children, indent +indent_unit);
++ }
++ error = error-&gt;next;
++ }
++}
++int main(int, char * [])
++{
++ tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.
++
++ try
++ {
++ A();
++ }
++ catch(error_type error)
++ {
++ print_tree_error(error);
++ }
++ catch(...)
++ {
++ std::cout &lt;&lt; "- unknown exception" &lt;&lt; std::endl;
++ }
++ return EXIT_SUCCESS;
++}
++</pre></blockquote>
++
+ <p>
+-To realize it's designated task, the algorithm has to invoke the
+-<tt>Callable</tt> aspect of <tt>g</tt> and needs to perform some algebra involving
+-it's <tt>min()/max()</tt> limits to compute another index value that
+-at this point is converted into <tt>Iter::difference_type</tt>. This is so,
+-because 24.2.7 [random.access.iterators] uses this type as argument
+-of it's algebraic operators. Alternatively consider the equivalent
+-iterator algorithms in 24.4.4 [iterator.operations] with the same result.
++Prospect
+ </p>
+ <p>
+-This argument leads us to the conclusion that we also need
+-<tt>Convertible&lt;Rand::result_type, Iter::difference_type&gt;</tt> here.
++We will focus on the method A() since the other methods, also main(), occur
++only once respectively.
+ </p>
+-</blockquote>
+-
+-</blockquote>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
++<ul>
++<li>
++ In the List A above (of the nested exception handling), it is hard to
++ find out an active reason to use the nested exception handling at this
++ scene. Rather, we can take a simpler description by throwing the entire
++ exception_list directly to the top level.
++</li>
++<li>
++ The code in the same example gives us a kind of redundant impression,
++ which might have come from the fact that the try-throw-catch framework does
++ not assume a tree structured exception handling.
++</li>
++</ul>
+
+-<blockquote>
+-<p>
+-Alisdair notes that point (ii) has already been addressed.
+-</p>
+ <p>
+-We agree with the proposed resolution to point (i)
+-with Daniel's added requirement.
++According to the above observation, we cannot help concluding that it is not
++so easy to use the nested_exception handling as a tree structured exception
++handling mechanism in a practical sense.
+ </p>
+ <p>
+-Move to Review.
++This text is based on the web page below (in Japanese).
++<a href="http://d.hatena.ne.jp/wraith13/20081231/1230715424">http://d.hatena.ne.jp/wraith13/20081231/1230715424</a>
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2009-06-05 Daniel updated proposed wording as recommended in Batavia.
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<p><i>[
+-2009-07-28 Alisdair adds:
+-]</i></p>
++<blockquote><p>
++Mark as NAD. The committee agrees that <tt>nested_exception</tt> is not a good
++match for this usage model. The committee did not see a way of improving
++this within the timeframe allowed.
++</p></blockquote>
+
+
+-<blockquote>
+-Revert to Open, with a note there is consensus on direction but the
+-wording needs updating to reflect removal of concepts.
+-</blockquote>
+
+-<p><i>[
+-2009-10 post-Santa Cruz:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
+
+
+-<blockquote>
+-Leave Open, Walter to work on it.
+-</blockquote>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial, solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3056.pdf">N3056</a>.
+-]</i></p>
+
+
++<hr>
++<h3><a name="1139"></a>1139. Thread support library not concept enabled</h3>
++<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread">issues</a> in [thread].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+
++<p><b>Addresses US 93, JP 79, UK 333, JP 81</b></p>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3056.pdf">N3056</a>.
++The thread chapter is not concept enabled.
+ </p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]:
+-</p>
+-
+-<blockquote><pre><del>concept UniformRandomNumberGenerator&lt;typename Rand&gt; { }</del>
+-template&lt;RandomAccessIterator Iter, UniformRandomNumberGenerator Rand&gt;
+- <ins>requires ShuffleIterator&lt;Iter&gt; &amp;&amp;
+- Convertible&lt;Rand::result_type, Iter::difference_type&gt;</ins>
+- void random_shuffle(Iter first, Iter last, Rand&amp;&amp; g);
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1096"></a>1096. unconstrained rvalue ref parameters</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1140"></a>1140. Numerics library not concept enabled</h3>
++<p><b>Section:</b> 26 [numerics] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numerics">issues</a> in [numerics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++
++<p><b>Addresses US 84</b></p>
++
+ <p>
+-TODO: Look at all cases of unconstrained rvalue ref parameters and check
+-that concept req'ts work when <tt>T</tt> deduced as reference.
++The numerics chapter is not concept enabled.
+ </p>
+
+ <p>
+- We found some instances where that was not done correctly and we figure
+- the possibility of deducing <tt>T</tt> to be an lvalue reference was probably
+- overlooked elsewhere.
++The portion of this comment dealing with random numbers was resolved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>,
++which was accepted in Summit.
+ </p>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-Move to Open, pending proposed wording from Dave for further review.
+-</blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1099"></a>1099. Various issues</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-03-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1141"></a>1141. Input/Output library not concept enabled</h3>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+ <p><b>Discussion:</b></p>
++
++<p><b>Addresses US 85, JP 67, JP 68, JP 69, JP 72, UK 308</b></p>
++
+ <p>
+-Notes
+-</p>
+-<blockquote>
+-<p>
+-[2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1,
+-MoveConstructible V2 (where V1,V2 are defined on 539). Also make_tuple
+-on 550
++The input/output chapter is not concept enabled.
+ </p>
+
+-<blockquote>
+-<p>
+-CD-1 reads:
+-</p>
+
+-<blockquote><pre>template &lt;MoveConstructible T1, MoveConstructible T2&gt;
+-pair&lt;V1, V2&gt; make_pair(T1&amp;&amp;, T2&amp;&amp;);
+-</pre></blockquote>
+
+-<p>
+-Actually I'm guessing we need something like <tt>MoveConstructible&lt;V1,T1&gt;</tt>,
+-i.e. "<tt>V1</tt> can be constructed from an rvalue of type <tt>T1</tt>."
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-Ditto for <tt>make_tuple</tt>
+-</p>
+-</blockquote>
+
+-<p>
+-[2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to
+-talk about "copiable from generalized rvalue ref argument" for cases
+-where we're going to forward and copy.
+-</p>
+-<blockquote>
+-<p>
+- This issue may well be quite large. Language in para 4 about "if
+- an lvalue" is wrong because types aren't expressions.
+-</p>
+
+-<blockquote>
+-<p>
+-Maybe we should define the term "move" so we can just say in the
+-effects, "<tt>f</tt> is moved into the newly-created thread" or something, and
+-agree (and ideally document) that saying "<tt>f</tt> is moved" implies
+-</p>
+
+-<blockquote><pre>F x(move(f))
+-</pre></blockquote>
+
+-<p>
+-is required to work. That would cover both ctors at once.
+-</p>
+-</blockquote>
++<hr>
++<h3><a name="1142"></a>1142. Regular expressions library not concept enabled</h3>
++<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re">active issues</a> in [re].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re">issues</a> in [re].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 86, UK 309, UK 310</b></p>
+
+ <p>
+- p1199, call_once has all the same issues.
+-</p>
+-</blockquote>
+-<p>
+-[2009-03-21 Sat] p869 InputIterator pointer type should not be required
+-to be convertible to const value_type*, rather it needs to have a
+-operator-&gt; of its own that can be used for the value type.
++The regular expressions chapter is not concept enabled.
+ </p>
+
+-<blockquote>
+-This one is serious and unrelated to the move issue.
+-</blockquote>
+
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1148"></a>1148. Wrong argument type of I/O stream manipulators <tt>setprecision()</tt>
++and <tt>setw()</tt></h3>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Marc Steinbach <b>Opened:</b> 2009-06-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-[2009-03-21 Sat] p818 stack has the same problem with default ctor.
+-</p>
+-<p>
+-[2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so
+-</p>
+-<blockquote><pre> requires MoveConstructible&lt;Cont&gt;
+- explicit priority_queue(const Compare&amp; x = Compare(), Cont&amp;&amp; = Cont());
+-</pre>
+-<p>
+- Don't require MoveConstructible when default constructing Cont.
+- Also missing semantics for move ctor.
+-</p>
+-</blockquote>
+-<p>
+- [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as
+- opposed to MoveConstructible?
++The header <tt>&lt;iomanip&gt;</tt> synopsis in 27.7 [iostream.format] specifies
+ </p>
++<blockquote><pre>
++T5 setprecision(int n);
++T6 setw(int n);
++</pre></blockquote>
++
+ <p>
+- [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't
+- be MoveConstructible). No documented semantics for move c'tor. Or
+- *any* of its 7 ctors!
++The argument types should be streamsize, as in class <tt>ios_base</tt>
++(see 27.5.3 [ios.base]):
+ </p>
++<blockquote><pre>
++streamsize precision() const;
++streamsize precision(streamsize prec);
++streamsize width() const;
++streamsize width(streamsize wide);
++</pre></blockquote>
++
+ <p>
+- [2009-03-21 Sat] std::array should have constructors for C++0x,
+- consequently must consider move construction.
++(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.)
+ </p>
+
+ <p><i>[
+-2009-05-01 Daniel adds:
++2009-07-29 Daniel clarified wording.
+ ]</i></p>
+
+
+-<blockquote>
+-This could be done as part of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, which already handles
+-deviation of <tt>std::array</tt> from container tables.
+-</blockquote>
++<p><i>[
++2009 Santa Cruz:
++]</i></p>
++
+
+-<p>
+- [2009-03-21 Sat] p622 all messed up.
+-</p>
+ <blockquote>
+ <p>
+- para 8 "implementation-defined" is the wrong term; should be "see
+- below" or something.
+-</p>
+-<p>
+- para 12 "will be selected" doesn't make any sense because we're not
+- talking about actual arg types.
++No concensus for this change. There was some interest in doing the opposite
++fix: Change the <tt>streamsize</tt> in <tt>&lt;ios&gt;</tt> to <tt>int</tt>.
++But ultimately there was no concensus for that change either.
+ </p>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
+ <p>
+- paras 9-13 need to be totally rewritten for concepts.
++In 27.7 [iostream.format], header <tt>&lt;iomanip&gt;</tt> synopsis change as indicated:
+ </p>
+-</blockquote>
+
++<blockquote><pre>
++T5 setprecision(<del>int</del><ins>streamsize</ins> n);
++T6 setw(<del>int</del><ins>streamsize</ins> n);
++</pre></blockquote>
++</li>
++
++<li>
+ <p>
+- [2009-03-21 Sat] Null pointer comparisons (p587) have all become
+- unconstrained. Need to fix that
++In 27.7.4 [std.manip], just before p. 6 change as indicated:
+ </p>
++
++<blockquote><pre>
++unspecified setprecision(<del>int</del><ins>streamsize</ins> n);
++</pre></blockquote>
++</li>
++
++<li>
+ <p>
+- [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration.
+- We think CopyConstructible is the right reqt.
++In 27.7.4 [std.manip], just before p. 7 change as indicated:
+ </p>
++
++<blockquote><pre>
++unspecified setw(<del>int</del><ins>streamsize</ins> n);
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++
++
++<hr>
++<h3><a name="1149"></a>1149. Reformulating NonemptyRange axiom</h3>
++<p><b>Section:</b> X [rand.concept.urng] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2009-06-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+- make_pair needs Constructible&lt;V1, T1&amp;&amp;&gt; requirements!
++In X [rand.concept.urng], we have the following:
+ </p>
++<blockquote><pre>
++concept UniformRandomNumberGenerator&lt;typename G&gt; : Callable&lt;G&gt; {
++ ...
++ axiom NonemptyRange(G&amp; g) {
++ G::min() &lt; G::max();
++ }
++ ...
++}
++</pre></blockquote>
++
+ <p>
+- make_tuple needs something similar
++Since the parameter <tt>G</tt> is in scope throughout the concept, there is no
++need for the axiom to be further parameterized, and so the axiom can be
++slightly simplified as:
+ </p>
++
++<blockquote><pre>
++axiom NonemptyRange() {
++ G::min() &lt; G::max();
++}
++</pre></blockquote>
++
+ <p>
+- tuple bug in synopsis:
++We can further reformulate so as to avoid any axiom machinery as:
+ </p>
+-<blockquote><pre> template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, const UTypes&amp;&gt;...
+- template &lt;class... UTypes&gt;
+- requires Constructible&lt;Types, RvalueOf&lt;UTypes&gt;::type&gt;...
+-</pre>
++
++<blockquote><pre>
++requires True&lt; G::min() &lt; G::max() &gt;;
++</pre></blockquote>
++
+ <p>
+- Note: removal of MoveConstructible requirements in std::function makes
+- these routines unconstrained!
++This is not only a simpler statement of the same requirement, but also
++forces the requirement to be checked.
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2009-05-02 Daniel adds:
++Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
+-This part of the issue is already covered by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>.
+-</blockquote>
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+- these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ]
++In X [rand.concept.urng], replace the <tt>NonemptyRange</tt> axiom by:
+ </p>
+-<blockquote><pre> unique_ptr(pointer p, implementation-defined d);
+- unique_ptr(pointer p, implementation-defined d);
++
++<blockquote><pre>
++<del>axiom NonemptyRange(G&amp; g) {
++ G::min() &lt; G::max();
++}</del>
++<ins>requires True&lt; G::min() &lt; G::max() &gt;;</ins>
+ </pre></blockquote>
+-<p>
+- multimap range constructor should not have MoveConstructible&lt;value_type&gt; requirement.
+-</p>
+-<blockquote>
+- same with insert(..., P&amp;&amp;); multiset has the same issue, as do
+- unordered_multiset and unordered_multimap. Review these!
+-</blockquote>
+
+-</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1153"></a>1153. Standard library needs review for constructors to be
++explicit to avoid treatment as initializer-list constructor</h3>
++<p><b>Section:</b> 17 [library], 30 [thread], D [depr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses DE 2</b></p>
++
++<p><b>Description</b></p>
++ <p>Marking a constructor with <tt>explicit</tt> has semantics
++ even for a constructor with zero or several parameters:
++ Such a constructor cannot be used with list-initialization
++ in a copy-initialization context, see 13.3.1.7 [over.match.list]. The
++ standard library apparently has not been reviewed for
++ marking non-single-parameter constructors as <tt>explicit</tt>.</p>
++<p><b>Suggestion</b></p>
++ <p>Consider marking zero-parameter and multi-parameter
++ constructors <tt>explicit</tt> in classes that have at least one
++ constructor marked <tt>explicit</tt> and that do not have an
++ initializer-list constructor.</p>
++
++<p><b>Notes</b></p>
++ <p>Robert Klarer to address this one.</p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009 Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-Move to Open, pending proposed wording from Dave for further review.
+-</blockquote>
++
++<blockquote><p>
++Move to "Open". Robert Klarer has promised to provide wording.
++</p></blockquote>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2010 Pittsburgh: Moved to NAD, rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-Tentatively NAD. We are not sure what has been addressed and what hasn't.
+-Recommend closing unless someone sorts this out into something more readable.
+-</blockquote>
+-
+
+
+ <p><b>Rationale:</b></p>
+ <p>
+-The issue(s) at hand not adequately communicated.
++We are unaware of any cases where initializer lists cause problem in this
++context, but if problems arise in the future the issue can be reopened.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1101"></a>1101. <tt>unique</tt> requirements</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1155"></a>1155. Reference should be to C99</h3>
++<p><b>Section:</b> C.5 [diff.library] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#diff.library">issues</a> in [diff.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>
+-From Message c++std-core-14160 Howard wrote:
+-</p>
+-
+-<blockquote>
+-It was the intent of the rvalue reference proposal for unique to only require MoveAssignable:
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1860.html#25.2.9%20-%20Unique">N1860</a>.
+-</blockquote>
+-
+-<p>
+-And Pete replied:
+-</p>
+
+-<blockquote>
+-That was overridden by the subsequent changes made for concepts in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2573.pdf">N2573</a>,
+-which reimposed the C++03 requirements.
+-</blockquote>
++<p><b>Addresses FR 38</b></p>
+
+-<p>
+-My impression is that this overwrite was a simple (unintentional) mistake.
+-Wording below to correct it.
+-</p>
++<p><b>Description</b></p>
++ <p>What is ISO/IEC 1990:9899/DAM
++ 1? My guess is that's a typo for ISO/IEC
++ 9899/Amd.1:1995 which I'd
++ have expected to be referenced here (the tables
++ make reference to things
++ which were introduced by Amd.1).</p>
++<p><b>Suggestion</b></p>
++ <p>One need probably a reference
++ to the document which introduce <tt>char16_t</tt> and
++ <tt>char32_t</tt> in C (ISO/IEC TR 19769:2004?).</p>
++<p><b>Notes</b></p>
++<p>Create issue. Document in question should be C99, not C90+amendment1. The
++ rest of the section requires careful review for completeness. Example &lt;cstdint&gt;
++ 18.4.1 [cstdint.syn]. Assign to C liasons.</p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-10 Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-<p>
+-Howard notes this issue resolves a discrepancy between the synopsis
+-and the description.
+-</p>
+-<p>
+-Move to NAD Editorial.
+-</p>
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 25.3.9 [alg.unique]:
+-</p>
+
+-<blockquote><pre>template&lt;ForwardIterator Iter&gt;
+- requires OutputIterator&lt;Iter, <ins>RvalueOf&lt;</ins>Iter::reference<ins>&gt;::type</ins>&gt;
+- &amp;&amp; EqualityComparable&lt;Iter::value_type&gt;
+- Iter unique(Iter first, Iter last);
++<blockquote><p>
++NAD Editorial. Already fixed.
++</p></blockquote>
+
+-template&lt;ForwardIterator Iter, EquivalenceRelation&lt;auto, Iter::value_type&gt; Pred&gt;
+- requires OutputIterator&lt;Iter, RvalueOf&lt;Iter::reference&gt;::type&gt;
+- &amp;&amp; CopyConstructible&lt;Pred&gt;
+- Iter unique(Iter first, Iter last, Pred pred);
+-</pre></blockquote>
+
+-<p>
+-Note that the synopsis in [algorithms.syn] is already correct.
+-</p>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1102"></a>1102. <tt>std::vector</tt>'s reallocation policy still unclear</h3>
+-<p><b>Section:</b> 23.4.1.2 [vector.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-04-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1156"></a>1156. Constraints on bitmask and enumeration types to be tightened</h3>
++<p><b>Section:</b> 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>
+-I have the impression that even the wording of current draft
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>
+-does insufficiently express the intent of <tt>vector</tt>'s
+-reallocation strategy. This has produced not too old library
+-implementations which release memory in the <tt>clear()</tt> function
+-and even modern articles about C++ programming cultivate
+-the belief that <tt>clear</tt> is allowed to do exactly this. A typical
+-example is something like this:
+-</p>
+
+-<blockquote><pre>const int buf_size = ...;
+-std::vector&lt;T&gt; buf(buf_size);
+-for (int i = 0; i &lt; some_condition; ++i) {
+- buf.resize(buf_size);
+- write_or_read_data(buf.data());
+- buf.clear(); // Ensure that the next round get's 'zeroed' elements
+-}
+-</pre></blockquote>
+-<p>
+-where still the myth is ubiquitous that <tt>buf</tt> might be
+-allowed to reallocate it's memory *inside* the <tt>for</tt> loop.
+-</p>
+-<p>
+-IMO the problem is due to the fact, that
+-</p>
++<p><b>Addresses UK 165</b></p>
+
+-<ol type="a">
+-<li>
+-the actual memory-reallocation stability of <tt>std::vector</tt>
+-is explained in 23.4.1.2 [vector.capacity]/3 and /6 which
+-are describing just the effects of the <tt>reserve</tt>
+-function, but in many examples (like above) there
+-is no explicit call to <tt>reserve</tt> involved. Further-more
+-23.4.1.2 [vector.capacity]/6 does only mention <em>insertions</em>
+-and never mentions the consequences of erasing
+-elements.
+-</li>
+-<li>
+-<p>
+-the effects clause of <tt>std::vector</tt>'s <tt>erase</tt> overloads in
+-23.4.1.4 [vector.modifiers]/4 is silent about capacity changes. This
+-easily causes a misunderstanding, because the counter
+-parting insert functions described in 23.4.1.4 [vector.modifiers]/2
+-explicitly say, that
+-</p>
+-<blockquote>
+-Causes reallocation if the new size is greater than the
+-old capacity. If no reallocation happens, all the iterators
+-and references before the insertion point remain valid.
+-</blockquote>
+-<p>
+-It requires a complex argumentation chain about four
+-different places in the standard to provide the - possibly
+-weak - proof that calling <tt>clear()</tt> also does <em>never</em> change
+-the capacity of the <tt>std::vector</tt> container. Since <tt>std::vector</tt>
+-is the de-facto replacement of C99's dynamic arrays this
+-type is near to a built-in type and it's specification should
+-be clear enough that usual programmers can trust their
+-own reading.
+-</p>
+-</li>
+-</ol>
++<p><b>Description</b></p>
++ <p>Constraints on
++ bitmask and enumeration types were supposed to be tightened
++ up as part of the motivation for the <tt>constexpr</tt> feature -
++ see paper
++ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a>
++ for details</p>
++<p><b>Suggestion</b></p>
++ <p>Adopt wording in line with the motivation
++ described in
++ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a></p>
++<p><b>Notes</b></p>
++ <p>Robert Klarer to review</p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009 Santa Cruz:
+ ]</i></p>
+
+-<blockquote>
+-<p>
+-Bill believes paragraph 1 of the proposed resolution is unnecessary
+-because it is already implied (even if tortuously) by the current wording.
+-</p>
+-<p>
+-Move to Review.
+-</p>
+-</blockquote>
++
++<blockquote><p>
++Move to Open. Ping Robert Klarer to provide wording, using N2235 as guidance.
++</p></blockquote>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as NAD. Rationale: there is no consensus to clarify the standard,
+-general consensus that the standard is correct as written.
+-</blockquote>
+-
+-
++<blockquote><p>
++Moved to NAD. Rationale added.
++</p></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-<p><i>[
+-This is a minimum version. I also
+-suggest that the wording explaining the allocation strategy
+-of <tt>std::vector</tt> in 23.4.1.2 [vector.capacity]/3 and /6 is moved into
+-a separate sub paragraph of 23.4.1.2 [vector.capacity] <em>before</em>
+-any of the prototype's are discussed, but I cannot provide
+-reasonable wording changes now
+-]</i></p>
+
+
+-<ol>
+-<li>
+-<p>
+-Change 23.4.1.2 [vector.capacity]/6 as follows:
+-</p>
+-<blockquote>
+-It is guaranteed that no reallocation takes place during
+-insertions <ins>or erasures</ins> that happen after a call
+-to <tt>reserve()</tt> until the time when an insertion would make
+-the size of the vector greater than the value of <tt>capacity()</tt>.
+-</blockquote>
+-</li>
+-<li>
++<p><b>Rationale:</b></p>
+ <p>
+-Change 23.4.1.4 [vector.modifiers]/4 as follows:
++UK NB did not sufficiently describe how to resolve their comment, and
++therefore we cannot make a change for the FCD. If a resolution were
++provided in the future, we would be happy to apply it.
+ </p>
+-<blockquote>
+-<i>Effects:</i> <ins>The capacity shall remain unchanged and no reallocation shall
+-happen.</ins>
+-Invalidates iterators and references at or after the point
+-of the erase.
+-</blockquote>
+-</li>
+-</ol>
++
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1105"></a>1105. Shouldn't <tt>Range</tt> be an <tt>auto concept</tt></h3>
+-<p><b>Section:</b> X [iterator.concepts.range] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-04-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1164"></a>1164. <tt>promise::swap</tt> should pass by rvalue reference</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
++<p><b>Addresses UK 341</b></p>
++
++<p><b>Description</b></p>
++<p><tt>promise::swap</tt> accepts its parameter by lvalue reference. This is
++inconsistent with other types that provide a swap member function,
++where those swap functions accept an rvalue reference</p>
++
++<p><b>Suggestion</b></p>
++<p>Change <tt>promise::swap</tt> to take an rvalue reference.</p>
++
++<p><b>Notes</b></p>
++<p>Create an issue. Detlef will look into it. Probably ready as it.</p>
++
+ <p><i>[
+-2009-04-26 Herb adds:
++2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
++NAD, by virtue of the changed rvalue rules and swap signatures from Summit.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1167"></a>1167. <tt>pair&lt;T,U&gt;</tt> doesn't model <tt>LessThanComparable</tt> in unconstrained code even if
++ <tt>T</tt> and <tt>U</tt> do.</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2009-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Here's a common example: We have many ISV customers who have built lots of
+-in-house STL-like containers. Imagine that, for the past ten years, the user
+-has been happily using his <tt>XYZCorpContainer&lt;T&gt;</tt> that has <tt>begin()</tt> and <tt>end()</tt>
+-and an iterator typedef, and indeed satisfies nearly all of <tt>Container</tt>,
+-though maybe not quite all just like <tt>valarray</tt>. The user upgrades to a
+-range-enabled version of a library, and now <tt>lib_algo( xyz.begin(), xyz.end());</tt>
+-no longer works -- compiler error.
++<tt>LessThanComparable</tt> requires (and provides default
++ implementations for) &lt;=,&gt;, and &gt;=. However, the defaults
++ don't take effect in unconstrained code.
+ </p>
+ <p>
+-Even though <tt>XYZCorpContainer</tt> matches the pre-conceptized version of the
+-algorithm, and has been working for years, it appears the user has to write
+-at least this:
+-</p>
+-<blockquote><pre>template&lt;class T&gt; concept_map Range&lt;XYZCorpContainer&lt;T&gt;&gt; {};
+-
+-template&lt;class T&gt; concept_map Range&lt;const XYZCorpContainer&lt;T&gt;&gt; {};
+-</pre></blockquote>
+-<p>
+-Is that correct?
+-</p>
+-<p>
+-But he may actually have to write this as we do for initializer list:
+-</p>
+-<blockquote><pre>template&lt;class T&gt;
+-concept_map Range&lt;XYZCorpContainer&lt;T&gt;&gt; {
+- typedef T* iterator;
+- iterator begin(XYZCorpContainer&lt;T&gt; c) { return c.begin(); }
+- iterator end(XYZCorpContainer&lt;T&gt; c) { return c.end(); }
+-};
+-
+-template&lt;class T&gt;
+-concept_map Range&lt;const XYZCorpContainer&lt;T&gt;&gt; {
+- typedef T* iterator;
+- iterator begin(XYZCorpContainer&lt;T&gt; c) { return c.begin(); }
+- iterator end(XYZCorpContainer&lt;T&gt; c) { return c.end(); }
+-};
+-</pre></blockquote>
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-04-28 Alisdair adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I recommend NAD, although remain concerned about header organisation.
++Still, it's a problem to have types acting one way in
++constrained code and another in unconstrained code, except in cases of
++syntax adaptation. It's also inconsistent with the containers, which
++supply all those operators.
+ </p>
+ <p>
+-A user container will satisfy the <tt>MemberContainer</tt> concept, which IS auto.
+-There is a concept_map for all <tt>MemberContainers</tt> to <tt>Container</tt>, and then a
+-further concept_map for all <tt>Container</tt> to <tt>Range</tt>, so the stated problem is not
+-actually true. User defined containers will automatically match the <tt>Range</tt>
+-concept without explicitly declaring a concept_map.
++Totally Unbiased
++Suggested Resolution:
+ </p>
+ <p>
+-The problem is that they should now provide an additional two headers,
+-<tt>&lt;iterator_concepts&gt;</tt> and <tt>&lt;container_concepts&gt;</tt>.
+- The only difference from
+-making <tt>Range</tt> an auto concept would be this reduces to a single header,
+-<tt>&lt;iterator_concepts&gt;</tt>.
++accept the exported concept maps proposal and
++ change the way this stuff is handled to use an
++ explicit exported concept map rather than nested
++ function templates
+ </p>
+ <p>
+-I am strongly in favour of any resolution that tackles the issue of
+-explicitly requiring concept headers to make these concept maps available.
++e.g., remove from the body of <tt>std::list</tt>
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
++<blockquote><pre>
++template &lt;LessThanComparable T, class Allocator&gt;
++bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
++template &lt;LessThanComparable T, class Allocator&gt;
++bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
++template &lt;LessThanComparable T, class Allocator&gt;
++bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
++template &lt;LessThanComparable T, class Allocator&gt;
++bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
++</pre></blockquote>
+ <p>
+-We observe there is a recent paper by Bjarne that overlaps this issue.
++and add this concept_map afterwards:
+ </p>
++<blockquote><pre>
++template &lt;LessThanComparable T, class Allocator&gt;
++export concept_map LessThanComparable&lt;list&lt;T,Allocator&gt; &gt;
++{
++ bool operator&lt;(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
++}
++</pre></blockquote>
+ <p>
+-Alisdair continues to recommend NAD.
++do similarly for <tt>std::pair</tt>. While you're at it, do the same for
++<tt>operator==</tt> and <tt>!=</tt> everywhere, and seek out other such opportunities.
+ </p>
+ <p>
+-Move to Open, and recommend the issue be deferred until after the next
+-Committee Draft is issued.
++Alternative Resolution: keep the ugly, complex specification and add the
++ missing operators to <tt>std::pair</tt>.
+ </p>
+-</blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -38605,90 +32325,83 @@ Committee Draft is issued.
+
+
+ <hr>
+-<h3><a name="1106"></a>1106. Multiple exceptions from connected <tt>shared_future::get()</tt>?</h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Thomas J. Gritzan <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1168"></a>1168. Odd wording for bitset equality operators</h3>
++<p><b>Section:</b> 20.6.2 [bitset.members] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-It is not clear, if multiple threads are waiting in a
+-<tt>shared_future::get()</tt> call, if each will rethrow the stored exception.
++The following wording seems a little unusual to me:
+ </p>
+ <p>
+-Paragraph 9 reads:
++p42/43 20.6.2 [bitset.members]
+ </p>
++
+ <blockquote>
+-<i>Throws:</i> the stored exception, if an exception was stored and not
+-retrieved before.
++<pre>
++bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
++</pre>
++<blockquote><p>
++-42- <i>Returns:</i> A nonzero value if the value of each bit in
++<tt>*this</tt> equals the value of the corresponding bit in
++<tt>rhs</tt>.
++</p></blockquote>
++<pre>
++bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
++</pre>
++<blockquote><p>
++-43- <i>Returns:</i> A nonzero value if <tt>!(*this == rhs)</tt>.
++</p></blockquote>
+ </blockquote>
++
+ <p>
+-The "not retrieved before" suggests that only one exception is thrown,
+-but one exception for each call to <tt>get()</tt> is needed, and multiple calls
+-to <tt>get()</tt> even on the same <tt>shared_future</tt> object seem to be allowed.
+-</p>
+-<p>
+-I suggest removing "and not retrieved before" from the Throws paragraph.
+-I recommend adding a note that explains that multiple calls on <tt>get()</tt> are
+-allowed, and each call would result in an exception if an exception was
+-stored.
++"A nonzero value" may be well defined as equivalent to the literal '<tt>true</tt>'
++for Booleans, but the wording is clumsy. I suggest replacing "A nonzero value"
++with the literal '<tt>true</tt>' (in appropriate font) in each case.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-07-24 Alisdair recommends NAD Editorial.
+ ]</i></p>
+
+-<blockquote>
+-<p>
+-We note there is a pending paper by Detlef
+-on such <tt>future</tt>-related issues;
+-we would like to wait for his paper before proceeding.
+-</p>
+-<p>
+-Alisdair suggests we may want language to clarify that this
+-<tt>get()</tt> function can be called from several threads
+-with no need for explicit locking.
+-</p>
+-<p>
+-Move to Open.
+-</p>
+-</blockquote>
+
+ <p><i>[
+-2010-01-23 Moved to Tentatively NAD Editorial after 5 positive votes on
+-c++std-lib.
++2009-07-27 Pete adds:
+ ]</i></p>
+
+
++<blockquote><p>
++It's obviously editorial. There's no need for further discussion.
++</p></blockquote>
++
++<p><i>[
++2009-07-27 Howard sets to NAD Editorial.
++]</i></p>
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-Resolved by paper
+-<a href="file:///Users/hinnant/std%20documents/C++Mailings/papers/2009/n2997.htm">N2997</a>.
+-</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 30.6.7 [futures.shared_future]:
++Change 20.6.2 [bitset.members] p42-43:
+ </p>
+
+-<blockquote><pre>const R&amp; shared_future::get() const;
+-R&amp; shared_future&lt;R&amp;&gt;::get() const;
+-void shared_future&lt;void&gt;::get() const;
+-</pre>
+ <blockquote>
+-<p>...</p>
+-<p>
+--9- <i>Throws:</i> the stored exception, if an exception was stored<del> and not retrieved before</del>.
+-<ins>
+-[<i>Note:</i> Multiple calls on <tt>get()</tt> are
+-allowed, and each call would result in an exception if an exception was
+-stored. — <i>end note</i>]
+-</ins>
+-</p>
+-</blockquote>
++<pre>
++bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
++</pre>
++<blockquote><p>
++-42- <i>Returns:</i> <del>A nonzero value</del> <ins><tt>true</tt></ins> if the value of each bit in
++<tt>*this</tt> equals the value of the corresponding bit in
++<tt>rhs</tt>.
++</p></blockquote>
++<pre>
++bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
++</pre>
++<blockquote><p>
++-43- <i>Returns:</i> <del>A nonzero value</del> <ins><tt>true</tt></ins> if <tt>!(*this == rhs)</tt>.
++</p></blockquote>
+ </blockquote>
+
+
+@@ -38697,721 +32410,697 @@ stored.
+
+
+ <hr>
+-<h3><a name="1107"></a>1107. constructor <tt>shared_future(unique_future)</tt> by value?</h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Thomas J. Gritzan <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1176"></a>1176. Make <tt>thread</tt> constructor non-variadic</h3>
++<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In the <tt>shared_future</tt> class definition in 30.6.7 [futures.shared_future]
+-the move constructor
+-that constructs a <tt>shared_future</tt> from an <tt>unique_future</tt> receives the
+-parameter by value. In paragraph 3, the same constructor receives it as
+-const value.
+-</p>
+-
+-<p>
+-I think that is a mistake and the constructor should take a r-value
+-reference:
++The variadic <tt>thread</tt> constructor is causing controversy, e.g.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2901.pdf">N2901</a>.
++This issue has been created as a placeholder for this course of action.
+ </p>
+
+-<blockquote><pre>shared_future(unique_future&lt;R&gt;&amp;&amp; rhs);
++<blockquote><pre>
++template &lt;class F<del>, class ...Args</del>&gt; thread(F&amp;&amp; f<del>, Args&amp;&amp;... args</del>);
+ </pre></blockquote>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-<p>
+-We agree with the proposed resolution.
+-</p>
+ <p>
+-Move to Tentatively Ready.
++See <a href="lwg-defects.html#929">929</a> for wording which specifies an rvalue-ref signature but
++with "decay behavior", but using variadics.
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2009-07-05 Daniel notes:
++2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-The proposed change has already been incorported into the current working draft
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>.
+-</blockquote>
+-
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in 30.6.7 [futures.shared_future]:
+ </p>
+
+-<blockquote><pre>shared_future(unique_future&lt;R&gt;<ins>&amp;&amp;</ins> rhs);
+-</pre></blockquote>
+
++<p><b>Rationale:</b></p>
+ <p>
+-Change the definition of the constructor in 30.6.7 [futures.shared_future]:
++The (tentative) concensus of the LWG is to keep the variadic thread constructor.
+ </p>
+
+-<blockquote><pre>shared_future(<del>const</del> unique_future&lt;R&gt;<ins>&amp;&amp;</ins> rhs);
+-</pre></blockquote>
+-
+-
+
+
+
+
+ <hr>
+-<h3><a name="1109"></a>1109. <tt>std::includes</tt> should require <tt>CopyConstructible</tt> predicate</h3>
+-<p><b>Section:</b> 25.4.5.1 [includes] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#includes">issues</a> in [includes].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1179"></a>1179. Probably editorial in [structure.specifications]</h3>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2009-07-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-All the set operation algorithms require a <tt>CopyConstructible</tt> predicate, with
+-the exception of <tt>std::includes</tt>. This looks like a typo as much as anything,
+-given the general library requirement that predicates are copy
+-constructible, and wording style of other set-like operations.
++While reviewing <a href="lwg-closed.html#971">971</a> I noted that 17.5.1.4 [structure.specifications]/7 says:
++</p>
++
++<blockquote><p>
++-7- Error conditions specify conditions where a function may fail. The
++conditions are listed, together with a suitable explanation, as the <tt>enum
++class errc</tt> constants (19.5) that could be used as an argument to
++function <tt>make_error_condition</tt> (19.5.3.6).
++</p></blockquote>
++
++<p>
++This paragraph should mention <tt>make_error_code</tt> or the text "that
++could be used as an argument to function <tt>make_error_condition</tt>
++(19.5.3.6)" should be deleted. I believe this is editorial.
+ </p>
+
+ <p><i>[
+-Batavia (2009-05):
++2009-07-21 Chris adds:
+ ]</i></p>
+
+-<blockquote>
+-We agree with the proposed resolution.
+-Move to NAD Editorial.
+-</blockquote>
+-
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote>
+ <p>
+-Change [algorithms.syn] and 25.4.5.1 [includes]:
++I'm not convinced there's a problem there, because as far as the "Error
++conditions" clauses are concerned, make_error_condition() is used by a
++user to test for the condition, whereas make_error_code is not. For
++example:
+ </p>
+
+-<blockquote><pre>template&lt;InputIterator Iter1, InputIterator Iter2,
+- <del>typename</del> <ins>CopyConstructible</ins> Compare&gt;
+- requires Predicate&lt;Compare, Iter1::value_type, Iter2::value_type&gt;
+- &amp;&amp; Predicate&lt;Compare, Iter2::value_type, Iter1::value_type&gt;
+- bool includes(Iter1 first1, Iter1 last1,
+- Iter2 first2, Iter2 last2,
+- Compare comp);
++<blockquote><pre>
++void foobar(error_code&amp; ec = throws());
+ </pre></blockquote>
+
++<p>
++ Error conditions:
++</p>
++<blockquote><p>
++permission_denied - Insufficient privilege to perform operation.
++</p></blockquote>
++
++<p>
++When a user writes:
++</p>
+
++<blockquote><pre>
++error_code ec;
++foobar(ec);
++if (ec == errc::permission_denied)
++ ...
++</pre></blockquote>
+
++<p>
++the implicit conversion <tt>errc-&gt;error_condition</tt> makes the if-test
++equivalent to:
++</p>
+
++<blockquote><pre>
++if (ec == make_error_condition(errc::permission_denied))
++</pre></blockquote>
+
+-<hr>
+-<h3><a name="1111"></a>1111. associative containers underconstrained</h3>
+-<p><b>Section:</b> 23.6 [associative] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-29 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative">issues</a> in [associative].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-According to table 87 (n2857) the expression <tt>X::key_equal</tt> for an unordered
+-container shall return a value of type <tt>Pred</tt>, where <tt>Pred</tt> is an equivalence
+-relation.
++On the other hand, if the user had written:
+ </p>
+
++<blockquote><pre>
++if (ec == make_error_code(errc::permission_denied))
++</pre></blockquote>
++
+ <p>
+-However, all 4 containers constrain <tt>Pred</tt> to be merely a <tt>Predicate</tt>,
+-and not <tt>EquivalenceRelation</tt>.
++the test is now checking for a specific error code. The test may
++evaluate to <tt>false</tt> even though <tt>foobar()</tt> failed due to the documented
++error condition "Insufficient privilege".
+ </p>
++</blockquote>
+
+ <p><i>[
+-Batavia (2009-05):
++2009 Santa Cruz:
+ ]</i></p>
+
++
+ <blockquote>
+ <p>
+-We agree with the proposed resolution.
++NAD Editorial.
+ </p>
+ <p>
+-Move to Review.
++What the WP says right now is literally true: these codes can be used as
++an argument to <tt>make_error_condition</tt>. (It is also true that they can be
++used as an argument to <tt>make_error_code</tt>, which the WP doesn't say.) Maybe
++it would be clearer to just delete "that could be used as an argument to
++function <tt>make_error_condition</tt>", since that fact is already implied by
++other things that we say. We believe that this is editorial.
+ </p>
+ </blockquote>
+
+
++
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-For ordered containers, replace
+-</p>
+-<blockquote><pre>Predicate&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
+-</pre></blockquote>
+-<p>
+-with
+ </p>
+-<blockquote><pre>StrictWeakOrder&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
+-</pre></blockquote>
+
++
++
++
++
++<hr>
++<h3><a name="1186"></a>1186. Forward list could model a stack</h3>
++<p><b>Section:</b> 23.6.5 [stack] <b>Status:</b> <a href="lwg-active.html#NAD Concepts">NAD Concepts</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-For unordered containers, replace
+-</p>
+-<blockquote><pre>Predicate&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
+-</pre></blockquote>
+-<p>
+-with
+-</p>
+-<blockquote><pre>EquivalenceRelation&lt;auto, Key, Key&gt; Compare = less&lt;Key&gt;
+-</pre></blockquote>
+-<p>
+-As in the following declarations:
++The library template <tt>forward_list</tt> could easily model the idea of a
++<tt>stack</tt>, where the operations work on the front of the list rather than
++the back. However, the standard library <tt>stack</tt> adaptor cannot support
++this.
+ </p>
+
+-<blockquote>
+ <p>
+-Associative containers 23.6 [associative]
++It would be relatively easy to write a partial specialization for <tt>stack</tt>
++to support <tt>forward_list</tt>, but that opens the question of which header to
++place it in. A much better solution would be to add a <tt>concept_map</tt> for
++the <tt>StackLikeContainer</tt> concept to the <tt>&lt;forward_list&gt;</tt> header and then
++everything just works, including a user's own further uses in a
++stack-like context.
+ </p>
++
+ <p>
+- 1 Headers &lt;map&gt; and &lt;set&gt;:
++Therefore while I am submitting the issue now so that it is on record, I
++<em>strongly recommend</em> we resolve as "NAD Concepts" as any non-concepts
++based solution will be inferior to the final goal, and the feature is
++not so compelling it must be supported ahead of the concepts-based
++library.
+ </p>
++
++<p><i>[
++2009-11-02 Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++
++<p><b>Rationale:</b></p>
+ <p>
+- Header &lt;map&gt; synopsis
++Any non-concepts based solution will be inferior to the final goal, and the
++feature is not so compelling it must be supported ahead of the concepts-based
++library.
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, ValueType T,
+- <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class map;
+
+- ...
+
+- template &lt;ValueType Key, ValueType T,
+- <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class multimap;
+
+- ...
++<p><b>Proposed resolution:</b></p>
+
+- }
+-</pre></blockquote>
+
++
++
++
++<hr>
++<h3><a name="1190"></a>1190. Setting the maximum load factor should return the previous value</h3>
++<p><b>Section:</b> 23.2.5 [unord.req], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+- Header &lt;set&gt; synopsis
++The unordered associative container requirements table specifies that
++<tt>a.set_max_load_factor(z)</tt> has return type <tt>void</tt>. However, there is a
++useful piece of information to return: the previous value. Users who
++don't need it can always ignore it.
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;Key&gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class set;
+
+- ...
+
+- template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;Key&gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class multiset;
++<p><i>[
++2010 Rapperswil:
++]</i></p>
+
+- ...
+
+- }
+-</pre></blockquote>
++<blockquote><p>
++The benefit seems minor, while breaking with the getter/setter idiom these overloads support.
+
++Move to Tentatively NAD.
++</p></blockquote>
++
++<p><i>[
++Moved to NAD at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+- 23.4.1p2 Class template map [map]
++In the unordered associative container requirements table, change:
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, ValueType T,
+- <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class map {
+- ...
+- };
+- }
+-</pre></blockquote>
+
++<blockquote>
++<table border="1">
++<caption>Table 87 &mdash; Unordered associative container requirements
++(in addition to container)</caption>
++
++<tr>
++<th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td><tt>a.max_load_factor(z)</tt></td>
++<td><tt><del>void</del> <ins>float</ins></tt></td>
++<td>Pre: <tt>z</tt> shall be positive. Changes the container's maximum
++<del>load</del> load factor, using <tt>z</tt> as a hint.
++<ins>Returns: the previous value of
++<tt>a.max_load_factor()</tt>.</ins>
++</td>
++<td>
++constant
++</td>
++</tr>
++</table>
++</blockquote>
+
+ <p>
+- 23.4.2p2 Class template multimap [multimap]
++Change the return type of <tt>set_max_load_factor</tt>
++in the class synopses in 23.5.4 [unord.map], 23.5.5 [unord.multimap], 23.5.6 [unord.set],
++and 23.5.7 [unord.multiset].
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, ValueType T,
+- <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class multimap {
+- ...
+- };
+- }
+-</pre></blockquote>
+-
+
+ <p>
+- 23.4.3p2 Class template set [set]
++If issue <a href="lwg-active.html#1188">1188</a> is also accepted, make the same changes for
++<tt>min_load_factor</tt>.
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;Key&gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class set {
+- ...
+- };
+- }
+-</pre></blockquote>
+
+
++
++
++
++<hr>
++<h3><a name="1200"></a>1200. "surprising" <tt>char_traits&lt;T&gt;::int_type</tt> requirements</h3>
++<p><b>Section:</b> 21.2.2 [char.traits.typedefs] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-09-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits.typedefs">issues</a> in [char.traits.typedefs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+- 23.4.4p2 Class template multiset [multiset]
++The footnote for <tt>int_type</tt> in 21.2.2 [char.traits.typedefs] says that
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key, <del>Predicate</del><ins>StrictWeakOrder</ins>&lt;auto, Key<del>, Key</del>&gt; Compare = less&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;Key&gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; CopyConstructible&lt;Compare&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, const Compare&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Compare, Compare&amp;&amp;&gt;
+- class multiset {
+- ...
+- };
+- }
+-</pre></blockquote>
++
++<blockquote><p>
++If <tt>eof()</tt> can be held in <tt>char_type</tt> then some iostreams implementations
++may give surprising results.
++</p></blockquote>
+
+ <p>
+- 23.5 Unordered associative containers [unord]
++This implies that <tt>int_type</tt> should be a superset of
++<tt>char_type</tt>. However, the requirements for <tt>char16_t</tt> and <tt>char32_t</tt> define
++<tt>int_type</tt> to be equal to <tt>int_least16_t</tt> and <tt>int_least32_t</tt> respectively.
++<tt>int_least16_t</tt> is likely to be the same size as <tt>char_16_t</tt>, which may lead
++to surprising behavior, even if <tt>eof()</tt> is not a valid UTF-16 code unit.
++The standard should not prescribe surprising behavior, especially
++without saying what it is (it's apparently not undefined, just
++surprising). The same applies for 32-bit types.
+ </p>
++
+ <p>
+- 1 Headers &lt;unordered_map&gt; and &lt;unordered_set&gt;:
++I personally recommend that behavior be undefined if <tt>eof()</tt> is a member
++of <tt>char_type</tt>, and another type be chosen for <tt>int_type</tt> (my personal
++favorite has always been a <tt>struct {bool eof; char_type c;}</tt>).
++Alternatively, the exact results of such a situation should be defined,
++at least so far that I/O could be conducted on these types as long as
++the code units remain valid. Note that the argument that no one streams
++<tt>char16_t</tt> or <tt>char32_t</tt> is not really valid as it would be perfectly
++reasonable to use a <tt>basic_stringstream</tt> in conjunction with UTF character
++types.
+ </p>
++
++<p><i>[
++2009-10-28 Ganesh provides two possible resolutions and expresses a preference
++for the second:
++]</i></p>
++
++
++<blockquote>
++<ol>
++<li>
+ <p>
+- Header &lt;unordered_map&gt; synopsis
++Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+ </p>
+-<blockquote><pre> namespace std {
+- // 23.5.1, class template unordered_map:
+- template &lt;ValueType Key,
+- ValueType T,
+- Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_map;
+-
+- // 23.5.2, class template unordered_multimap:
+- template &lt;ValueType Key,
+- ValueType T,
+- Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_multimap;
+
+- ...
+- }
+-</pre></blockquote>
++<blockquote><p>
++The member <tt>eof()</tt> shall return <del>an implementation-defined
++constant that cannot appear as a valid UTF-16 code unit</del>
++<ins><tt>UINT_LEAST16_MAX</tt> [<i>Note:</i> this value is guaranteed to
++be a permanently reserved UCS-2 code position if <tt>UINT_LEAST16_MAX ==
++0xFFFF</tt> and it's not a UCS-2 code position otherwise &mdash; <i>end
++note</i>]</ins>.
++</p></blockquote>
+
+ <p>
+- Header &lt;unordered_set&gt; synopsis
++Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
+ </p>
+-<blockquote><pre> namespace std {
+- // 23.5.3, class template unordered_set:
+- template &lt;ValueType Value,
+- Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
+- Allocator Alloc = allocator&lt;Value&gt; &gt;
+- requires NothrowDestructible&lt;Value&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_set;
+-
+- // 23.5.4, class template unordered_multiset:
+- template &lt;ValueType Value,
+- Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
+- Allocator Alloc = allocator&lt;Value&gt; &gt;
+- requires NothrowDestructible&lt;Value&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_multiset;
+-
+- ...
+- }
+-</pre></blockquote>
+
++<blockquote><p>
++The member <tt>eof()</tt> shall return <del>an implementation-defined constant that
++cannot appear as a Unicode code point</del>
++<ins>
++<tt>UINT_LEAST32_MAX</tt> [<i>Note:</i> this value is guaranteed to be a
++permanently reserved UCS-4 code position if <tt>UINT_LEAST32_MAX ==
++0xFFFFFFFF</tt> and it's not a UCS-4 code position otherwise &mdash; <i>end
++note</i>]</ins>.
++</p></blockquote>
++</li>
++<li>
+ <p>
+- 23.5.1p3 Class template unordered_map [unord.map]
++In 21.2.3.2 [char.traits.specializations.char16_t], in the
++definition of <tt>char_traits&lt;char16_t&gt;</tt> replace the definition of nested
++typedef <tt>int_type</tt> with:
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key,
+- ValueType T,
+- Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_map
+- {
++
++<blockquote><pre>
++namespace std {
++ template&lt;&gt; struct char_traits&lt;char16_t&gt; {
++ typedef char16_t char_type;
++ typedef <del>uint_least16_t</del> <ins>uint_fast16_t</ins> int_type;
+ ...
+- };
+- }
+ </pre></blockquote>
+
+ <p>
+- 23.5.2p3 Class template unordered_multimap [unord.multimap]
++Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Key,
+- ValueType T,
+- Callable&lt;auto, const Key&amp;&gt; Hash = hash&lt;Key&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Key<del>, Key</del>&gt; Pred = equal_to&lt;Key&gt;,
+- Allocator Alloc = allocator&lt;pair&amp;lt;&lt;b&gt;const Key, T&gt; &gt; &gt;
+- requires NothrowDestructible&lt;Key&gt; &amp;&amp; NothrowDestructible&lt;T&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_multimap
+- {
+- ...
+- };
+- }
+-</pre></blockquote>
++
++<blockquote><p>
++The member <tt>eof()</tt> shall return <del>an implementation-defined
++constant that cannot appear as a valid UTF-16 code unit</del>
++<ins><tt>UINT_FAST16_MAX</tt> [<i>Note:</i> this value is guaranteed to
++be a permanently reserved UCS-2 code position if <tt>UINT_FAST16_MAX ==
++0xFFFF</tt> and it's not a UCS-2 code position otherwise &mdash; <i>end
++note</i>]</ins>.
++</p></blockquote>
+
+ <p>
+- 23.5.3p3 Class template unordered_set [unord.set]
++In 21.2.3.3 [char.traits.specializations.char32_t], in the
++definition of <tt>char_traits&lt;char32_t&gt;</tt> replace the definition of nested
++typedef <tt>int_type</tt> with:
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Value,
+- Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
+- Allocator Alloc = allocator&lt;Value&gt; &gt;
+- requires NothrowDestructible&lt;Value&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_set
+- {
++
++<blockquote><pre>
++namespace std {
++ template&lt;&gt; struct char_traits&lt;char32_t&gt; {
++ typedef char32_t char_type;
++ typedef <del>uint_least32_t</del> <ins>uint_fast32_t</ins> int_type;
+ ...
+- };
+- }
+ </pre></blockquote>
++
+ <p>
+- 23.5.4p3 Class template unordered_multiset [unord.multiset]
++Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
+ </p>
+-<blockquote><pre> namespace std {
+- template &lt;ValueType Value,
+- Callable&lt;auto, const Value&amp;&gt; Hash = hash&lt;Value&gt;,
+- <del>Predicate</del><ins>EquivalenceRelation</ins>&lt;auto, Value<del>, Value</del>&gt; class Pred = equal_to&lt;Value&gt;,
+- Allocator Alloc = allocator&lt;Value&gt; &gt;
+- requires NothrowDestructible&lt;Value&gt;
+- &amp;&amp; SameType&lt;Hash::result_type, size_t&gt;
+- &amp;&amp; CopyConstructible&lt;Hash&gt; &amp;&amp; CopyConstructible&lt;Pred&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, const Pred&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Pred, Pred&amp;&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, const Hash&amp;&gt;
+- &amp;&amp; AllocatableElement&lt;Alloc, Hash, Hash&amp;&amp;&gt;
+- class unordered_multiset
+- {
+- ...
+- };
+- }
+-</pre></blockquote>
+
++<blockquote><p>
++The member <tt>eof()</tt> shall return <del>an implementation-defined constant that
++cannot appear as a Unicode code point</del>
++<ins>
++<tt>UINT_FAST32_MAX</tt> [<i>Note:</i> this value is guaranteed to be a
++permanently reserved UCS-4 code position if <tt>UINT_FAST32_MAX ==
++0xFFFFFFFF</tt> and it's not a UCS-4 code position otherwise &mdash; <i>end
++note</i>]</ins>.
++</p></blockquote>
++</li>
++</ol>
+ </blockquote>
+
+
++<p><i>[
++2010 Rapperswil:
++]</i></p>
++
++
++<blockquote><p>
++This seems an overspecification, and it is not clear what problem is being solved -
++these values can be used portably by using the named functions; there is no need
++for the value itself to be portable.
++
++Move to Tentatively NAD.
++</p></blockquote>
++
++<p><i>[
++Moved to NAD at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1112"></a>1112. bitsets and new style for loop</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-06 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1202"></a>1202. <tt>integral_constant</tt> needs a spring clean</h3>
++<p><b>Section:</b> 20.10.3 [meta.help] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.help">issues</a> in [meta.help].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-<tt>Std::bitset</tt> is a homogeneous container-like sequence of bits, yet it does
+-not model the Range concept so cannot be used with the new for-loop syntax.
+-It is the only such type in the library that does NOT support the new for
+-loop.
++The specification of <tt>integral_constant</tt> has been inherited
++essentially unchanged from TR1:
++</p>
++
++<blockquote><pre>
++template &lt;class T, T v&gt;
++struct integral_constant {
++ static const T value = v;
++ typedef T value_type;
++ typedef integral_constant&lt;T,v&gt; type;
++};
++</pre></blockquote>
++
++<p>
++In light of 0x language changes there are several things we might
++consider changing, notably the form of specification for value.
+ </p>
++
+ <p>
+-The obvious reason is that bitset does not support iterators.
++The current form requires a static data member have storage allocated
++for it, where we could now implement without this using the new enum
++syntax:
+ </p>
++
++<blockquote><pre>
++template &lt;class T, T v&gt;
++struct integral_constant {
++ <b>enum : T { value = v };</b>
++ typedef T value_type;
++ typedef integral_constant type;
++};
++</pre></blockquote>
++
+ <p>
+-At least two reasonable solutions are available:
++The effective difference between these two implementation is:
+ </p>
+-<ol type="i">
++
++<ol style="list-style-type:lower-roman">
+ <li>
+-Add an iterator interface to <tt>bitset</tt>, bringing its interface close to that
+-of <tt>std::array</tt>
++No requirement to allocate storage for data member (which we hope but do
++not guarantee compilers strip today)
+ </li>
++
+ <li>
+-Provide an unspecified concept_map for <tt>Range&lt;bitset&gt;</tt>.
++You can no longer take the address of the constant as
++<tt>&amp;integral_constant&lt;T,v&gt;::value;</tt>
+ </li>
+ </ol>
++
+ <p>
+-The latter will still need some kind of iterator-like adapter for <tt>bitset</tt>,
+-but gives implementers greater freedom on the details. E.g. begin/end return
+-some type that simply invokes <tt>operator[]</tt> on the object it wraps, and
+-increments its index on <tt>operator++</tt>. A vendor can settle for <tt>InputIterator</tt>
+-support, rather than wrapping up a full <tt>RandomAccessIterator</tt>.
+-</p>
+-<p>
+-I have a mild preference for option (ii) as I think it is less work to
+-specify at this stage of the process, although (i) is probably more useful
+-in the long run.
++Also note the editorial change to drop the explicit qualification of
++<tt>integral_constant</tt> in the <tt>typedef type</tt>. This makes it quite clear we
++mean the current instantiation, and cannot be mistaken for a recursive
++metaprogram.
+ </p>
++
+ <p>
+-Hmm, my wording looks a little woolly, as it does not say what the element
+-type of the range is. Do I get a range of <tt>bool</tt>, <tt>bitset&lt;N&gt;::reference</tt>, or
+-something else entirely?
++Even if we don't mandate this implementation, it would be nice to give
++vendors freedom under QoI to choose their preferred representation.
+ </p>
++
+ <p>
+-I guess most users will assume the behaviour of reference, but expect to
+-work with <tt>bool</tt>. <tt>Bool</tt> is OK for read-only traversal, but you really need to
+-take a reference to a <tt>bitset::reference</tt> if you want to write back.
++The other side of this issue is if we choose to retain the static
++constant form. In that case we should go further and insist on
++<tt>constexpr</tt>, much like we did throughout <tt>numeric_limits</tt>:
+ </p>
+
+-<p><i>[
+-Batavia (2009-05):
+-]</i></p>
+-
+-<blockquote>
+-Move to Open.
+-We further recommend this be deferred until after the next Committee Draft.
+-</blockquote>
+-
+-<p><i>[
+-2009-05-25 Alisdair adds:
+-]</i></p>
+-
++<blockquote><pre>
++template &lt;class T, T v&gt;
++struct integral_constant {
++ static <b>constexpr</b> T value = v;
++ typedef T value_type;
++ typedef integral_constant type;
++};
++</pre></blockquote>
+
+-<blockquote>
+ <p>
+-I just stumbled over the <tt>Range concept_map</tt> for <tt>valarray</tt> and this should
+-probably set the precedent on how to write the wording.
++[Footnote] It turns out <tt>constexpr</tt> is part of the Tentatively Ready
++resolution for <a href="lwg-defects.html#1019">1019</a>. I don't want to interfere with that issue, but
++would like a new issue to consider if the fixed-base enum implementation
++should be allowed.
+ </p>
+
+ <p><i>[
+-Howard: I've replaced the proposed wording with Alisdair's suggestion.
+-]</i></p>
+-
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-07-24 Daniel modifies the proposed wording for non-concepts.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 post-Santa Cruz:
++2009-09-05 Daniel adds:
+ ]</i></p>
+
+
+ <blockquote>
+-Mark as Tentatively NAD Future due to the loss of concepts.
+-</blockquote>
++<p>
++I think that the suggested resolution is incomplete and
++may have some possible unwanted side-effects. To understand
++why, note that <tt>integral_constant</tt> is <em>completely</em> specified
++by code in 20.10.3 [meta.help]. While this is usually considered
++as a good thing, let me give a possible user-defined
++specialization that would break given the suggested changes:
++</p>
+
++<blockquote><pre>
++enum NodeColor { Red, Black };
+
++std::integral_constant&lt;NodeColor, Red&gt; red;
++</pre></blockquote>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-All concepts-related text has been removed from the draft.
++The reason why that breaks is due to the fact that
++current core language rules does only allow integral
++types as enum-bases, see 7.2 [dcl.enum]/2.
+ </p>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+ <p>
+-Modify the section 20.5 [template.bitset] <tt>&lt;bitset&gt;</tt> synopsis by adding
+-the following at the end of the synopsis:
++So, I think that we cannot leave the implementation the
++freedom to decide which way they would like to provide
++the implementation, because that is easily user-visible
++(I don't speak of addresses, but of instantiation errors),
++therefore if applied, this should be either specified or
++wording must be added that gives a note about this
++freedom of implementation.
+ </p>
+-<blockquote><pre><ins>
+-// XX.X.X bitset range access [bitset.range]
+-template&lt;size_t N&gt; <i>unspecified-1</i> begin(bitset&lt;N&gt;&amp;);
+-template&lt;size_t N&gt; <i>unspecified-2</i> begin(const bitset&lt;N&gt;&amp;);
+-template&lt;size_t N&gt; <i>unspecified-1</i> end(bitset&lt;N&gt;&amp;);
+-template&lt;size_t N&gt; <i>unspecified-2</i> end(const bitset&lt;N&gt;&amp;);
+-</ins>
+-</pre></blockquote>
+-</li>
+-<li>
++
+ <p>
+-Add a new section <ins>"bitset range access" [bitset.range]</ins>
+-after the current section 20.5.4 [bitset.operators] with the following series of
+-paragraphs:
++Another possible disadvantage seems to me that user-expectations
++are easy to disappoint if they see a failure
++of the test
+ </p>
+-<blockquote>
++
++<blockquote><pre>
++assert(typeid(std::integral_constant&lt;int, 0&gt;::value) == typeid(int));
++</pre></blockquote>
++
+ <p>
+-<ins>
+-1. In the <tt>begin</tt> and <tt>end</tt> function templates that follow, <i>unspecified-1</i>
+-is a type that meets the requirements of a mutable random access
+-iterator (24.2.7 [random.access.iterators]) whose <tt>value_type</tt> is <tt>bool</tt> and
+-whose reference type is <tt>bitset&lt;N&gt;::reference</tt>.
+-<i>unspecified-2</i> is a type that meets the requirements of a constant
+-random access iterator (24.2.7 [random.access.iterators]) whose <tt>value_type</tt>
+-is <tt>bool</tt> and whose reference type is <tt>bool</tt>.
+-</ins>
++or of
+ </p>
+-<pre><ins>
+-template&lt;size_t N&gt; <i>unspecified-1</i> begin(bitset&lt;N&gt;&amp;);
+-template&lt;size_t N&gt; <i>unspecified-2</i> begin(const bitset&lt;N&gt;&amp;);
+-</ins>
+-</pre>
+-<blockquote>
+-<ins>2. Returns: an iterator referencing the first bit in the bitset.</ins>
+-</blockquote>
+
+-<pre><ins>
+-template&lt;size_t N&gt; <i>unspecified-1</i> end(bitset&lt;N&gt;&amp;);
+-template&lt;size_t N&gt; <i>unspecified-2</i> end(const bitset&lt;N&gt;&amp;);
+-</ins></pre>
++<blockquote><pre>
++static_assert(std::is_same&lt;decltype(std::integral_constant&lt;int, 0&gt;::value), const int&gt;::value, "Bad library");
++</pre></blockquote>
+
+-<blockquote>
+-<ins>3. Returns: an iterator referencing one past the last bit in the
+-bitset.</ins>
+ </blockquote>
+-</blockquote>
+-</li>
+-</ol>
+
++<p><i>[
++2010-01-14 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++]</i></p>
+
+
+
+
++<p><b>Rationale:</b></p>
++<p>
++We think that the suggested resolution is incomplete and may have some possible
++unwanted side-effects. (see Daniel's 2009-09-05 comment for details).
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1115"></a>1115. <tt>va_copy</tt> missing from Standard macros table</h3>
+-<p><b>Section:</b> C.2 [diff.library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Miles Zhao <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#diff.library">issues</a> in [diff.library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1219"></a>1219. unique_lock::lock and resource_deadlock_would_occur</h3>
++<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1159">1159</a></p>
+ <p><b>Discussion:</b></p>
++
++
++
+ <p>
+-In "Table 122 -- Standard macros" of C.2 [diff.library], which lists the 56 macros
+-inherited from C library, <tt>va_copy</tt> seems to be missing. But in
+-"Table 21 -- Header <tt>&lt;cstdarg&gt;</tt> synopsis" (18.10 [support.runtime]), there is.
++<tt>unique_lock::lock</tt> and friends raise
++"<tt>resource_deadlock_would_occur</tt> -- if the current thread already
++owns the mutex (i.e., on entry, <tt>owns</tt> is <tt>true</tt>)." 1)
++The current thread owning a mutex is not the same as any particular
++<tt>unique_lock::owns</tt> being <tt>true</tt>. 2) There's no need to
++raise this exception for a <tt>recursive_mutex</tt> if <tt>owns</tt> is
++<tt>false</tt>. 3) If <tt>owns</tt> is true, we need to raise some
++exception or the unique_lock will lose track of whether to unlock itself
++on destruction, but "deadlock" isn't it. For (3), s/bool owns/int
++ownership_level/ would fix it.
+ </p>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2009-11-11 Alisdair notes that this issue is very closely related to <a href="lwg-defects.html#1159">1159</a>,
++if not a dup.
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as Tentatively NAD Editorial, if Pete disagrees, Howard
+-will move to Tentatively Ready
+-</blockquote>
++<p><i>[
++2009-11-14 Moved to Tentatively Dup after 5 positive votes on c++std-lib.
++]</i></p>
++
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Add <tt>va_copy</tt> to Table 122 -- Standard macros in C.2 [diff.library].
+-</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1119"></a>1119. tuple query APIs do not support references</h3>
+-<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1223"></a>1223. condition_variable_any lock matching?</h3>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The <tt>tuple</tt> query APIs <tt>tuple_size</tt> and
+-<tt>tuple_element</tt> do not support references-to-tuples. This can be
+-annoying when a template deduced a parameter type to be a reference,
+-which must be explicitly stripped with <tt>remove_reference</tt> before calling
+-these APIs.
+-</p>
+-<p>
+-I am not proposing a resolution at this point, as there is a
+-combinatorial explosion with lvalue/rvalue references and
+-cv-qualification (see previous issue) that suggests some higher
+-refactoring is in order. This might be something to kick back over to
+-Core/Evolution.
+-</p>
+-<p>
+-Note that we have the same problem in numeric_limits.
++For <tt>condition_variable_any</tt>, must all lock arguments to concurrent wait calls
++"match" in some way, similar to the requirement in
++30.5.1 [thread.condition.condvar] that <tt>lock.mutex()</tt> returns the same
++value for each of the lock arguments supplied by all concurrently
++waiting threads (via <tt>wait</tt> or <tt>timed_wait</tt>)?
+ </p>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2010-02-12 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-Move to Open. Alisdair to provide wording.
+-</blockquote>
+-
+-
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
+
+-<blockquote>
+-Move to NAD. This is an extension after the FCD, without a clear motivation. May consider as NAD Future if motivating examples come forward.
+-</blockquote>
+
++<p><b>Rationale:</b></p>
++<p>
++The rationale is that it doesn't matter, and you can't check: the lock types may
++be different, or the same and user-defined, so the implementation must provide
++internal synchronization anyway.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -39421,6095 +33110,2798 @@ Move to NAD. This is an extension after the FCD, without a clear motivation. M
+
+
+ <hr>
+-<h3><a name="1120"></a>1120. New type trait - remove_all</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1224"></a>1224. condition_variable_any support for recursive mutexes?</h3>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Sometimes it is necessary to remove all qualifiers from a type before
+-passing on to a further API. A good example would be calling the
+-<tt>tuple</tt> query APIs <tt>tuple_size</tt> or <tt>tuple_element</tt>
+-with a deduced type inside a function template. If the deduced type is
+-cv-qualified or a reference then the call will fail. The solution is to
+-chain calls to
+-<tt>remove_cv&lt;remove_reference&lt;T&gt;::type&gt;::type</tt>, and
+-note that the order matters.
+-</p>
+-<p>
+-Suggest it would be helpful to add a new type trait,
+-<tt>remove_all</tt>, that removes all top-level qualifiers from a type
+-i.e. cv-qualification and any references. Define the term in such a way
+-that if additional qualifiers are added to the language, then
+-<tt>remove_all</tt> is defined as stripping those as well.
++For <tt>condition_variable_any</tt>, are recursive mutexes allowed? (I think "no")
+ </p>
+
+ <p><i>[
+-2009-10-14 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<tt>remove_all</tt> seems too generic, a possible alternative matching
+-the current naming style could be <tt>remove_cv_reference</tt> or
+-<tt>remove_reference_cv</tt>. It should also be considered whether this
+-trait should also remove 'extents', or pointer 'decorations'. Especially
+-if the latter situations are considered as well, it might be easier to
+-chose the name not in terms of what it <em>removes</em> (which might be
+-a lot), but in terms of it <em>creates</em>. In this case I could think
+-of e.g. <tt>extract_value_type</tt>.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
++2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Future.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Rationale:</b></p>
++<p>
++<tt>condition_variable_any::wait</tt> accepts any type of mutex. It calls
++<tt>unlock</tt> precisely once on entry and <tt>lock</tt> precisely once on
++exit. It is up to the user to ensure that this provides the required
++synchronization. Use of a recursive mutex is safe if either its lock count is 1,
++so after the single unlock it can be acquired by another thread, or another
++mechanism is used to synchronize the data.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1121"></a>1121. Support for multiple arguments</h3>
+-<p><b>Section:</b> 20.6.2 [ratio.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1228"></a>1228. User-specialized nothrow type traits</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Both add and multiply could sensibly be called with more than two arguments.
+-The variadic template facility makes such declarations simple, and is likely
+-to be frequently wrapped by end users if we do not supply the variant
+-ourselves.
+-</p>
+-<p>
+-We deliberately ignore divide at this point as it is not transitive.
+-Likewise, subtract places special meaning on the first argument so I do not
+-suggest extending that immediately. Both could be supported with analogous
+-wording to that for add/multiply below.
+-</p>
+-<p>
+-Note that the proposed resolution is potentially incompatible with that
+-proposed for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, although the addition of the typedef to ratio would be
+-equally useful.
+-</p>
+-
+-<p><i>[
+-2009-10-30 Alisdair adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-The consensus of the group when we reviewed this in Santa Cruz was that
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a> would proceed to Ready as planned, and the
+-multi-paramater add/multiply templates should be renamed as
+-<tt>ratio_sum</tt> and <tt>ratio_product</tt> to avoid the problem
+-mixing template aliases with partial specializations.
++According to p1 20.10.2 [meta.type.synop]:
+ </p>
+
+-<p>
+-It was also suggested to close this issue as NAD Future as it does not
+-correspond directly to any NB comment. NBs are free to submit a
+-specific comment (and re-open) in CD2 though.
+-</p>
++<blockquote><p>
++The behavior of a program that adds specializations for any of the class
++templates defined in this subclause is undefined unless otherwise
++specified.
++</p></blockquote>
+
+ <p>
+-Walter Brown also had concerns on better directing the order of
+-evaluation to avoid overflows if we do proceed for 0x rather than TR1,
+-so wording may not be complete yet.
++I believe we should 'otherwise specify' for the nothrow traits, are
++these are exactly the use cases where the end user actually has more
++information than the compiler.
+ </p>
+
+ <p><i>[
+-Alisdair updates wording.
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-</blockquote>
++<blockquote><p>
++Moved to Open. Definitely need to give the users the ability to ensure
++that the traits give the right answers. Unsure we want to give them the
++ability to say this in more than one way. Believes the noexcept proposal
++already gives this.
++</p></blockquote>
+
+ <p><i>[
+-2009-10-30 Howard:
++2010 Pittsburgh: Moved to NAD, rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+
+
+ <p><b>Rationale:</b></p>
+ <p>
+-Does not have sufficient support at this time. May wish to reconsider for a
+-future standard.
++We believe the solution offered by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html">N3050</a>
++is superior.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-
+ <p>
+-Add the following type traits to p3 20.6 [ratio]
++Add the following comment:
+ </p>
+
+-<blockquote><pre>// ratio arithmetic
+-template &lt;class R1, class R2&gt; struct ratio_add;
+-template &lt;class R1, class R2&gt; struct ratio_subtract;
+-template &lt;class R1, class R2&gt; struct ratio_multiply;
+-template &lt;class R1, class R2&gt; struct ratio_divide;
+-<ins>template &lt;class R1, class ... RList&gt; struct ratio_sum;</ins>
+-<ins>template &lt;class R1, class ... RList&gt; struct ratio_product;</ins>
+-</pre></blockquote>
++<blockquote><p>
++user specialization permitted to derive from <tt>std::true_type</tt> when the
++operation is known not to throw.
++</p></blockquote>
+
+ <p>
+-after 20.6.2 [ratio.arithmetic] p1: add
++to the following traits in 20.10.4.3 [meta.unary.prop] Table 43 Type
++property predicates.
+ </p>
+
+-<blockquote><pre>template &lt;class R1, class ... RList&gt; struct ratio_sum; // declared, never defined
++<p><i>[
++This may require a new Comments column
++]</i></p>
+
+-template &lt;class R1&gt; struct ratio_sum&lt;R1&gt; : R1 {};
+-</pre>
+
+-<blockquote>
+-<i>Requires:</i> <tt>R1</tt> is a specialization of class template <tt>ratio</tt>
+-</blockquote>
++<blockquote><pre>
++has_nothrow_default_constructor
++has_nothrow_copy_constructor
++has_nothrow_assign
++</pre></blockquote>
+
+-<pre>template &lt;class R1, class R2, class ... RList&gt;
+- struct ratio_sum&lt;R1, R2, RList...&gt;
+- : ratio_add&lt; R1, ratio_sum&lt;R2, RList...&gt;&gt; {
+-};
+-</pre>
+
+-<blockquote>
+-<i>Requires:</i> <tt>R1</tt> and each element in parmater pack
+-<tt>RList</tt> is a specialization of class template <tt>ratio</tt>
+-</blockquote>
+-</blockquote>
+
+-<p>
+-after 20.6.2 [ratio.arithmetic] p3: add
+-</p>
+
+-<blockquote><pre>template &lt;class R1, class ... RList&gt; struct ratio_product; // declared, never defined
+
+-template &lt;class R1&gt; struct ratio_product&lt;R1&gt; : R1 {};
+-</pre>
++<hr>
++<h3><a name="1230"></a>1230. <tt>mem_fn</tt> and variadic templates</h3>
++<p><b>Section:</b> 20.9.11 [func.memfn] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.memfn">issues</a> in [func.memfn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#920">920</a></p>
++<p><b>Discussion:</b></p>
+
+-<blockquote>
+-<i>Requires:</i> <tt>R1</tt> is a specialization of class template <tt>ratio</tt>
+-</blockquote>
+
+-<pre>template &lt;class R1, class R2, class ... RList&gt;
+- struct ratio_sum&lt;R1, R2, RList...&gt;
+- : ratio_add&lt; R1, ratio_product&lt;R2, RList...&gt;&gt; {
+-};
+-</pre>
+-
+-<blockquote>
+-<i>Requires:</i> <tt>R1</tt> and each element in parmater pack
+-<tt>RList</tt> is a specialization of class template <tt>ratio</tt>
+-</blockquote>
+-</blockquote>
+
++<p>
++Since we have removed the entry in B [implimits] for the
++library-specific limit for number of arguments passed to
++<tt>function</tt>/<tt>tuple</tt>/etc. I believe we need to update the
++spec for <tt>mem_fn</tt> to reflect this.
++</p>
+
++<p>
++The "<i>Remarks:</i> Implementations may implement <tt>mem_fn</tt> as a set of
++overloaded function templates." no longer holds, as we cannot create an
++arbitrary number of such overloads. I believe we should strike the
++remark and add a second signature:
++</p>
+
++<blockquote><pre>
++template&lt;class R, class T, typename ... ArgTypes&gt;
++ unspecified mem_fn(R (T::*pm)(ArgTypes...));
++</pre></blockquote>
+
++<p>
++I believe we need two signatures as pointer-to-data-member and
++pointer-to-member-function-taking-no-args appear to use subtly different
++syntax.
++</p>
+
++<p><i>[
++<a href="lwg-defects.html#920">920</a> as a similar proposed resolution.
++]</i></p>
+
+
+
+-<hr>
+-<h3><a name="1124"></a>1124. Invalid definition of concept RvalueOf</h3>
+-<p><b>Section:</b> X [concept.transform] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#concept.transform">issues</a> in [concept.transform].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-A recent news group
+-<a href="http://groups.google.de/group/comp.std.c++/browse_frm/thread/8eb92768a19fb46f">article</a>
+-points to several defects in the
+-specification of reference-related concepts.
+-</p>
++<p><b>Proposed resolution:</b></p>
+ <p>
+-One problem of the concept <tt>RvalueOf</tt> as currently defined in
+-X [concept.transform]:
++Add to 20.9 [function.objects] and 20.9.11 [func.memfn]:
+ </p>
++<blockquote><pre>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm)
+
+-<blockquote><pre>concept RvalueOf&lt;typename T&gt; {
+- typename type = T&amp;&amp;;
+- requires ExplicitlyConvertible&lt;T&amp;,type&gt; &amp;&amp; Convertible&lt;T&amp;&amp;,type&gt;;
+-}
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...));</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile);</ins>
+
+-template&lt;typename T&gt; concept_map RvalueOf&lt;T&amp;&gt; {
+- typedef T&amp;&amp; type;
+-}
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...)&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile&amp;);</ins>
++
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...)&amp;&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const&amp;&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile&amp;&amp;);</ins>
++<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile&amp;&amp;);</ins>
+ </pre></blockquote>
+
+ <p>
+-is that if <tt>T</tt> is an lvalue-reference, the requirement
+-<tt>Convertible&lt;T&amp;&amp;,type&gt;</tt> isn't satisfied for
+-lvalue-references, because after reference-collapsing in the concept
+-definition we have <tt>Convertible&lt;T&amp;,type&gt;</tt> in this case,
+-which isn't satisfied in the concept map template and also is not the
+-right constraint either. I think that the reporter is right that
+-<tt>SameType</tt> requirements should do the job and that we also should
+-use the new <tt>RvalueReference</tt> concept to specify a best matching
+-type requirement.
++Strike 20.9.11 [func.memfn], p5:
+ </p>
+
++<blockquote><p>
++<del><i>Remarks:</i> Implementations may implement <tt>mem_fn</tt> as a set
++of overloaded function templates.</del>
++</p></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In X [concept.transform] before p. 4 change as indicated:
+-</p>
+-
+-<blockquote><pre>auto concept RvalueOf&lt;typename T&gt; {
+- <del>typename</del><ins>RvalueReference</ins> type = T&amp;&amp;;
+- requires <del>ExplicitlyConvertible&lt;T&amp;, type&gt; &amp;&amp; Convertible&lt;T&amp;&amp;, type&gt;</del><ins>SameType&lt;T&amp;, type&amp;&gt;</ins>;
+-}
+-</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1125"></a>1125. ostream_iterator does not work with movable types</h3>
+-<p><b>Section:</b> 24.6.2.2 [ostream.iterator.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1232"></a>1232. Still <tt>swap</tt>'s with rvalue-references</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-<tt>ostream_iterator</tt> has not been updated to support moveable types, in a
+-similar manner to the insert iterators.
+-Note that this is not a problem for <tt>ostreambuf_iterator</tt>, as the types it is
+-restricted to dealing with do not support extra-efficient moving.
++The current library contains still rvalue reference-swaps that seem to be
++overlooked in the process of switching back to lvalue-ref swaps.
+ </p>
+
+ <p><i>[
+-2009-11-10 Howard adds:
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale
+-added below.
+-</blockquote>
++<blockquote><p>
++Editor accepts as NAD Editorial.
++</p></blockquote>
++
+
+
+ <p><b>Proposed resolution:</b></p>
++<ol>
++<li>
+ <p>
+-Add second <tt>operator=</tt> overload to class <tt>template ostream_iterator</tt>
+-in 24.6.2 [ostream.iterator], para 2:
++Change 20.3 [pairs]/1 as indicated:
+ </p>
+
+-<blockquote><pre>ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(const T&amp; value);
+-<ins>ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(T&amp;&amp; value);</ins>
++<blockquote><pre>
++template &lt;class T1, class T2&gt;
++struct pair {
++ ...
++ void swap(pair&amp;<del>&amp;</del> p);
++};
+ </pre></blockquote>
++</li>
+
++<li>
+ <p>
+-Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]:
++Change 20.3 [pairs] before p. 17 as indicated:
+ </p>
+
+-<blockquote>
+-<pre>ostream_iterator&amp; operator=(T&amp;&amp; value);
+-</pre>
+-<blockquote>
+-<p>
+--2- <i>Effects:</i>
+-</p>
+-<blockquote><pre>*out_stream &lt;&lt; std::move(value);
+-if(delim != 0)
+- *out_stream &lt;&lt; delim;
+-return (*this);
++<blockquote><pre>
++void swap(pair&amp;<del>&amp;</del> p);
+ </pre></blockquote>
+-</blockquote>
+-</blockquote>
+
++</li>
+
++<li>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-Several objections to move forward with this issue were voiced in the thread
+-starting with c++std-lib-25438. Among them is that we know of no motivating
+-use case to make streaming rvalues behave differently than streaming const
+-lvalues.
++Change 20.3 [pairs] before p. 21 as indicated:
+ </p>
+
++<blockquote><pre>
++template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp; y);
++<del>template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp;&amp; x, pair&lt;T1, T2&gt;&amp; y);</del>
++<del>template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-
+-
+-<hr>
+-<h3><a name="1127"></a>1127. rvalue references and iterator traits</h3>
+-<p><b>Section:</b> 24.4.1 [iterator.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.traits">issues</a> in [iterator.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
++<li>
+ <p>
+-The deprecated support for <tt>iterator_traits</tt> and legacy (unconstrained)
+-iterators features the (exposition only) concept:
++Change 20.4.1 [tuple.general]/2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
+ </p>
+
+-<blockquote><pre>concept IsReference&lt;typename T&gt; { } // exposition only
+-template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&gt; { }
++<blockquote><pre>
++// 20.5.2.9, specialized algorithms:
++template &lt;class... Types&gt;
++void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y);
++<del>template &lt;class... Types&gt;
++void swap(tuple&lt;Types...&gt;&amp;&amp; x, tuple&lt;Types...&gt;&amp; y);
++template &lt;class... Types&gt;
++void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
++
++</li>
++
++<li>
+ <p>
+-Now this looks exactly like the <tt>LvalueReference</tt> concept recently added to
+-clause 20, so I wonder if we should use that instead?
+-Then I consider the lack of rvalue-reference support, which means that
+-<tt>move_iterator</tt> would always flag as merely supporting the <tt>input_iterator_tag</tt>
+-category. This suggests we retain the exposition concept, but add a second
+-concept_map to support rvalue references.
++Change 20.4.2 [tuple.tuple] as indicated:
+ </p>
++
++<blockquote><pre>
++// 20.5.2.3, tuple swap
++void swap(tuple&amp;<del>&amp;</del>)
++</pre></blockquote>
++
++</li>
++
++<li>
+ <p>
+-I would suggest adding the extra concept_map is the right way forward, but
+-still wonder if the two exposition-only concepts in this clause might be
+-worth promoting to clause 20. That question might better be answered with a
+-fuller investigation of type_trait/concept unification though.
++Change 20.4.2.3 [tuple.swap] before 1 as indicated:
+ </p>
+
++<blockquote><pre>
++void swap(tuple&amp;<del>&amp;</del> rhs);
++</pre></blockquote>
++
++</li>
+
+-<p><b>Proposed resolution:</b></p>
++<li>
+ <p>
+-In Iterator traits 24.4.1 [iterator.traits] para 4 add:
++Change 20.9 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis, as indicated:
+ </p>
+
+-<blockquote><pre>concept IsReference&lt;typename T&gt; { } // exposition only
+-template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&gt; { }
+-<ins>template&lt;typename T&gt; concept_map IsReference&lt;T&amp;&amp;&gt; { }</ins>
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
++<del>template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
++template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&amp;&amp;);</del>
+ </pre></blockquote>
+
++</li>
++
++<li>
++<p>
++Change 20.9.12.2 [func.wrap.func], as indicated:
++</p>
+
++<blockquote><pre>
++// 20.7.15.2.2, function modifiers:
++void swap(function&amp;<del>&amp;</del>);
++template&lt;class F, class A&gt; void assign(F, const A&amp;);
+
++[..]
+
++// 20.7.15.2.7, specialized algorithms:
++template &lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
++<del>template &lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
++template &lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;&amp;);</del>
++</pre></blockquote>
+
++</li>
+
+-<hr>
+-<h3><a name="1128"></a>1128. Missing definition of <tt>iterator_traits&lt;T*&gt;</tt></h3>
+-<p><b>Section:</b> X [iterator.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The <tt>&lt;iterator&gt;</tt> header synopsis declares a partial specialization of
+-<tt>iterator_traits</tt> to support pointers, X [iterator.syn]. The implication
+-is that specialization will be described in D10, yet it did not follow the
+-rest of the deprecated material into this clause.
+-</p>
++<li>
+ <p>
+-However, this is not as bad as it first seems!
+-There are partial specializations of <tt>iterator_traits</tt> for types that satisfy
+-the various Iterator concepts, and there are concept_maps for pointers to
+-explicitly support the <tt>RandomAccessIterator</tt> concept, so the required
+-template will be present - just not in the manner advertised.
++Change 20.9.12.2.7 [func.wrap.func.alg] before 1 as indicated:
+ </p>
++
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2);
++<del>template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2);
++template&lt;class R, class... ArgTypes&gt;
++void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp;&amp; f2);</del>
++</pre></blockquote>
++
++</li>
++
++<li>
+ <p>
+-I can see two obvious solutions:
++Change 20.8.2.2 [util.smartptr.shared]/1 as indicated:
+ </p>
+
+-<ol type="i">
+-<li>
+-Restore the <tt>iterator_traits&lt;T*&gt;</tt> partial specialization in D.10
++<blockquote><pre>
++// 20.8.12.2.4, modifiers:
++void swap(shared_ptr&amp;<del>&amp;</del> r);
++
++[..]
++
++// 20.8.12.2.9, shared_ptr specialized algorithms:
++template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b);
++<del>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp;&amp; a, shared_ptr&lt;T&gt;&amp; b);
++template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp;&amp; b);</del>
++</pre></blockquote>
++
+ </li>
++
+ <li>
+-Remove the declaration of <tt>iterator_traits&lt;T*&gt;</tt> from 24.3 synopsis
+-</li>
+-</ol>
+ <p>
+-I recommend option (ii) in the wording below
++Change 21.3 [string.classes]/1, header <tt>&lt;string&gt;</tt> synopsis, as indicated:
+ </p>
++
++<blockquote><pre>
++// 21.4.8.8: swap
++template&lt;class charT, class traits, class Allocator&gt;
++void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
++<del>template&lt;class charT, class traits, class Allocator&gt;
++void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
++template&lt;class charT, class traits, class Allocator&gt;
++void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);</del>
++</pre></blockquote>
++
++</li>
++
++<li>
+ <p>
+-Option (ii) could be extended to strike all the declarations of deprecated
+-material from the synopsis, as it is effectively duplicating D.10 anyway.
+-This is the approach taken for deprecated library components in the 98/03
+-standards. This is probably a matter best left to the Editor though.
++Change 23.3 [sequences]/1, header <tt>&lt;deque&gt;</tt> synopsis, as indicated:
+ </p>
+
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
++</li>
+
+-<p><b>Proposed resolution:</b></p>
++<li>
+ <p>
+-In X [iterator.syn] strike:
++Change 23.3 [sequences]/1, header <tt>&lt;list&gt;</tt> synopsis, as indicated:
+ </p>
+
+-<blockquote><pre><del>template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;</del>
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
+
++</li>
+
++<li>
++<p>
++Change 23.3 [sequences]/1, header <tt>&lt;queue&gt;</tt> synopsis, as indicated:
++</p>
+
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
++<del>template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
++template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
+
++template &lt;class T, class Container = vector&lt;T&gt;, class Compare = less&lt;typename Container::value_type&gt; &gt;
++class priority_queue;
++template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++<del>template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<hr>
+-<h3><a name="1129"></a>1129. <tt>istream(buf)_iterator</tt> should support literal sentinel value</h3>
+-<p><b>Section:</b> 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator.cons">issues</a> in [istream.iterator.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
++<li>
+ <p>
+-<tt>istream_iterator</tt> and <tt>istreambuf_iterator</tt> should support literal sentinel
+-values. The default constructor is frequently used to terminate ranges, and
+-could easily be a literal value for <tt>istreambuf_iterator</tt>, and
+-<tt>istream_iterator</tt> when iterating value types. A little more work using a
+-suitably sized/aligned char-array for storage (or an updated component like
+-<tt>boost::optional</tt> proposed for TR2) would allow <tt>istream_iterator</tt> to support
+-<tt>constexpr</tt> default constructor in all cases, although we might leave this
+-tweak as a QoI issue. Note that requiring <tt>constexpr</tt> be supported also
+-allows us to place no-throw guarantees on this constructor too.
++Change 23.3 [sequences]/1, header <tt>&lt;stack&gt;</tt> synopsis, as indicated:
+ </p>
+
+-<p><i>[
+-2009-06-02 Daniel adds:
+-]</i></p>
++<blockquote><pre>
++template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y);
++<del>template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp;&amp; x, stack&lt;T, Container&gt;&amp; y);
++template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<blockquote>
+-<p>
+-I agree with the usefulness of the issue suggestion, but we need
+-to ensure that <tt>istream_iterator</tt> <em>can</em> satisfy be literal if needed.
+-Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares
+-a copy constructor and a destructor and explains their semantic in
+-24.6.1.1 [istream.iterator.cons]/3+4.
+-</p>
+-<p>
+-The prototype semantic specification is ok (although it seems
+-somewhat redundant to me, because the semantic doesn't say
+-anything interesting in both cases), but for support of trivial class
+-types we also need a trivial copy constructor and destructor as of
+-9 [class]/6. The current non-informative specification of these
+-two special members suggests to remove their explicit declaration
+-in the class and add explicit wording that says that if <tt>T</tt> is
+-trivial a default constructed iterator is also literal, alternatively it
+-would be possible to mark both as defaulted and add explicit
+-(memberwise) wording that guarantees that they are trivial.
+-</p>
+-<p>
+-Btw.: I'm quite sure that the <tt>istreambuf_iterator</tt> additions to
+-ensure triviality are not sufficient as suggested, because the
+-library does not yet give general guarantees that a defaulted
+-special member declaration makes this member also trivial.
+-Note that e.g. the atomic types do give a general statement!
+-</p>
+-<p>
+-Finally there is a wording issue: There does not exist something
+-like a "literal constructor". The core language uses the term
+-"constexpr constructor" for this.
+-</p>
++<li>
+ <p>
+-Suggestion:
++Change 23.3 [sequences]/1, header <tt>&lt;vector&gt;</tt> synopsis, as indicated:
+ </p>
+-<ol>
++
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
++</li>
++
+ <li>
+ <p>
+-Change 24.6.1 [istream.iterator]/3 as indicated:
++Change 23.3.3 [deque]/2 as indicated:
+ </p>
+-<blockquote><pre><ins>constexpr</ins> istream_iterator();
+-istream_iterator(istream_type&amp; s);
+-istream_iterator(const istream_iterator<del>&lt;T,charT,traits,Distance&gt;</del>&amp; x)<ins> = default</ins>;
+-~istream_iterator()<ins> = default</ins>;
++
++<blockquote><pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator first, const_iterator last);
++void swap(deque&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
++
++[..]
++
++// specialized algorithms:
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
++
+ </li>
++
+ <li>
+ <p>
+-Change 24.6.1.1 [istream.iterator.cons]/1 as indicated:
++Change 23.3.3.5 [deque.special] as indicated:
+ </p>
+-<blockquote><pre><ins>constexpr</ins> istream_iterator();
+-</pre>
+-<blockquote>
+--1- <i>Effects:</i> Constructs the end-of-stream iterator. <ins>If <tt>T</tt> is a literal type,
+-then this constructor shall be a constexpr constructor.</ins>
+-</blockquote>
+-</blockquote>
++
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
+ </li>
++
+ <li>
+ <p>
+-Change 24.6.1.1 [istream.iterator.cons]/3 as indicated:
++Change 23.3.4 [forwardlist]/2 as indicated:
+ </p>
+-<blockquote><pre>istream_iterator(const istream_iterator<del>&lt;T,charT,traits,Distance&gt;</del>&amp; x)<ins> = default</ins>;
+-</pre>
+-<blockquote>
+--3- <i>Effects:</i> Constructs a copy of <tt>x</tt>. <ins>If <tt>T</tt> is a literal type, then
+-this constructor shall be a trivial copy constructor.</ins>
+-</blockquote>
+-</blockquote>
++
++<blockquote><pre>
++iterator erase_after(const_iterator position);
++iterator erase_after(const_iterator position, iterator last);
++void swap(forward_list&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
++
++[..]
++
++// 23.3.3.6 specialized algorithms:
++template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
+ </li>
++
+ <li>
+ <p>
+-Change 24.6.1.1 [istream.iterator.cons]/4 as indicated:
++Change 23.3.4.7 [forwardlist.spec] as indicated:
+ </p>
+
+-<blockquote><pre>~istream_iterator()<ins> = default</ins>;
+-</pre>
+-<blockquote>
+--4- <i>Effects:</i> The iterator is destroyed. <ins>If <tt>T</tt> is a literal type, then
+-this destructor shall be a trivial
+-destructor.</ins>
+-</blockquote>
+-</blockquote>
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
+ </li>
++
+ <li>
+ <p>
+-Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated:
++Change 23.3.5 [list]/2 as indicated:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> istreambuf_iterator() throw();
+-<ins>istreambuf_iterator(const istreambuf_iterator&amp;) throw() = default;</ins>
+-<ins>~istreambuf_iterator() throw() = default;</ins>
++<blockquote><pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator position, const_iterator last);
++void swap(list&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
++
++[..]
++
++// specialized algorithms:
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
++
+ </li>
++
+ <li>
+ <p>
+-Change 24.6.3 [istreambuf.iterator]/1 as indicated:
++Change 23.3.5.6 [list.special] as indicated:
+ </p>
+-<blockquote>
+-[..] The default constructor <tt>istreambuf_iterator()</tt> and the constructor
+-<tt>istreambuf_iterator(0)</tt> both
+-construct an end of stream iterator object suitable for use as an
+-end-of-range. <ins>All
+-specializations of <tt>istreambuf_iterator</tt> shall have a trivial copy
+-constructor, a constexpr default
+-constructor and a trivial destructor.</ins>
+-</blockquote>
++
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
+ </li>
+-</ol>
+-</blockquote>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
++<li>
++<p>
++Change 23.6.3.1 [queue.defn] as indicated:
++</p>
+
++<blockquote><pre>
++void swap(queue&amp;<del>&amp;</del> q) { c.swap(q.c); }
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.html">N2994</a>.
+-</blockquote>
++[..]
+
++template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
++<del>template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
++template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<p><b>Proposed resolution:</b></p>
++<li>
+ <p>
+-24.6.1 [istream.iterator] para 3
++Change 23.6.3.5 [queue.special] as indicated:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> istream_iterator();
++<blockquote><pre>
++template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
++<del>template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
++template &lt;class T, class Container&gt;
++void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
+
++</li>
++
++<li>
+ <p>
+-24.6.1.1 [istream.iterator.cons]
++Change 23.6.4 [priority.queue]/1 as indicated:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> istream_iterator();
+-</pre>
+-<blockquote>
+--1- <i>Effects:</i> Constructs the end-of-stream iterator.
+-<ins>If <tt>T</tt> is a literal type, then this constructor shall
+-be a literal constructor.</ins>
+-</blockquote>
+-</blockquote>
++<blockquote><pre>
++void swap(priority_queue&amp;<del>&amp;</del>);
++
++// no equality is provided
++template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++<del>template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++template &lt;class T, class Container, class Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
++</pre></blockquote>
++
++</li>
+
++<li>
+ <p>
+-24.6.3 [istreambuf.iterator]
++Change 23.6.4.4 [priqueue.special] as indicated:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> istreambuf_iterator() throw();
++<blockquote><pre>
++template &lt;class T, class Container, Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++<del>template &lt;class T, class Container, Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
++template &lt;class T, class Container, Compare&gt;
++void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
+
++</li>
++
++<li>
++<p>
++Change 23.6.5.2 [stack.defn] as indicated:
++</p>
+
++<blockquote><pre>
++void swap(stack&amp;<del>&amp;</del> s) { c.swap(s.c); }
+
++[..]
+
++template &lt;class T, class Allocator&gt;
++void swap(stack&lt;T,Allocator&gt;&amp; x, stack&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(stack&lt;T,Allocator&gt;&amp;&amp; x, stack&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(stack&lt;T,Allocator&gt;&amp; x, stack&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
+
+-<hr>
+-<h3><a name="1132"></a>1132. JP-30: nested exceptions</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Seiji Hayashida <b>Opened:</b> 2009-06-01 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses JP 30</b></p>
++</li>
+
++<li>
+ <p>
+-C++0x <tt>nested_exception</tt> cannot handle a structured exception well. The
+-following codes show two types of tree structured exception handling.
+-</p>
+-<p>
+-The first one is based on <tt>nested_exception</tt> in C++0x,
+-while the second one is based on my library <tt>trickerr.h</tt> (in Japanese).
+-<a href="http://tricklib.com/cxx/dagger/trickerr.h">http://tricklib.com/cxx/dagger/trickerr.h</a>
++Change 23.6.5.6 [stack.special] as indicated:
+ </p>
+-<p>
+-Assume that Function <tt>A()</tt> calls two sub functions <tt>A_a()</tt> and <tt>A_b()</tt>, both might
+-throw tree structured exceptions, and <tt>A_b()</tt> must be called even if <tt>A_a()</tt>
+-throws an exception.
+-</p>
+-<p>
+-List A (code of tree structured exception handling based on nested_exception
+-in C++0x)
+-</p>
+-
+-<blockquote><pre>void A()
+-{
+- try
+- {
+- std::vector&lt;exception_ptr&gt; exception_list;
+- try
+- {
+- // A_a() does a similar processing as A().
+- A_a();
+- }
+- catch(...)
+- {
+- exception_list.push_back(current_exception());
+- }
+
+- // ***The processing A() has to do even when A_a() fails. ***
+- try
+- {
+- // A_b() does a similar processing as A().
+- A_b();
+- }
+- catch(...)
+- {
+- exception_list.push_back(current_exception());
+- }
+- if (!exception_list.empty())
+- {
+- throw exception_list;
+- }
+- }
+- catch(...)
+- {
+- throw_with_nested(A_exception("someone error"));
+- }
+-}
+-void print_tree_exception(exception_ptr e, const std::string &amp; indent ="")
+-{
+- const char * indent_unit = " ";
+- const char * mark = "- ";
+- try
+- {
+- rethow_exception(e);
+- }
+- catch(const std::vector&lt;exception_ptr&gt; e)
+- {
+- for(std::vector&lt;exception_ptr&gt;::const_iterator i = e.begin(); i!=e.end(); ++i)
+- {
+- print_tree_exception(i, indent);
+- }
+- }
+- catch(const std::nested_exception e)
+- {
+- print_tree_exception(evil_i(e), indent +indent_unit);
+- }
+- catch(const std::exception e)
+- {
+- std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; e.what() &lt;&lt; std::endl;
+- }
+- catch(...)
+- {
+- std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; "unknown exception" &lt;&lt; std::endl;
+- }
+-}
+-int main(int, char * [])
+-{
+- try
+- {
+- A();
+- }
+- catch()
+- {
+- print_tree_exception(current_exception());
+- }
+- return EXIT_SUCCESS;
+-}
++<blockquote><pre>
++template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y);
++<del>template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp;&amp; x, stack&lt;T, Container&gt;&amp; y);
++template &lt;class T, class Container&gt;
++void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
+
++</li>
++
++<li>
+ <p>
+-List B ( code of tree structured exception handling based on <tt>trickerr.h</tt>. )
+-"trickerr.h" (in Japanese), refer to:
+-<a href="http://tricklib.com/cxx/dagger/trickerr.h">http://tricklib.com/cxx/dagger/trickerr.h</a>.
++Change 23.3.6 [vector]/2 as indicated:
+ </p>
+
+-<blockquote><pre>void A()
+-{
+- tricklib::error_listener_type error_listener;
+- // A_a() is like A(). A_a() can throw tree structured exception.
+- A_a();
+-
+- // *** It must do process so that A_a() throws exception in A(). ***
+- // A_b() is like A(). A_b() can throw tree structured exception.
+- A_b();
+-
+- if (error_listener.has_error()) // You can write this "if block" in destructor
+- // of class derived from error_listener_type.
+- {
+- throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
+- }
+-}
+-void print_tree_error(const tricklib::error_type &amp;a_error, const std::string &amp; indent = "")
+-{
+- const char * indent_unit = " ";
+- const char * mark = "- ";
++<blockquote><pre>
++void swap(vector&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
+
+- tricklib::error_type error = a_error;
+- while(error)
+- {
+- std::cout &lt;&lt; indent &lt;&lt; mark &lt;&lt; error-&gt;message &lt;&lt; std::endl;
+- if (error-&gt;children)
+- {
+- print_tree_error(error-&gt;children, indent +indent_unit);
+- }
+- error = error-&gt;next;
+- }
+-}
+-int main(int, char * [])
+-{
+- tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.
++[..]
+
+- try
+- {
+- A();
+- }
+- catch(error_type error)
+- {
+- print_tree_error(error);
+- }
+- catch(...)
+- {
+- std::cout &lt;&lt; "- unknown exception" &lt;&lt; std::endl;
+- }
+- return EXIT_SUCCESS;
+-}
++// specialized algorithms:
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
+ </pre></blockquote>
+
++</li>
++
++<li>
+ <p>
+-Prospect
+-</p>
+-<p>
+-We will focus on the method A() since the other methods, also main(), occur
+-only once respectively.
++Change 23.3.6.3 [vector.capacity] before p. 8 as indicated:
+ </p>
+
+-<ul>
+-<li>
+- In the List A above (of the nested exception handling), it is hard to
+- find out an active reason to use the nested exception handling at this
+- scene. Rather, we can take a simpler description by throwing the entire
+- exception_list directly to the top level.
+-</li>
+-<li>
+- The code in the same example gives us a kind of redundant impression,
+- which might have come from the fact that the try-throw-catch framework does
+- not assume a tree structured exception handling.
++<blockquote><pre>
++void swap(vector&lt;T,Allocator&gt;&amp;<del>&amp;</del> x);
++</pre></blockquote>
++
+ </li>
+-</ul>
+
++<li>
+ <p>
+-According to the above observation, we cannot help concluding that it is not
+-so easy to use the nested_exception handling as a tree structured exception
+-handling mechanism in a practical sense.
+-</p>
+-<p>
+-This text is based on the web page below (in Japanese).
+-<a href="http://d.hatena.ne.jp/wraith13/20081231/1230715424">http://d.hatena.ne.jp/wraith13/20081231/1230715424</a>
++Change 23.3.6.6 [vector.special] as indicated:
+ </p>
+
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
++<blockquote><pre>
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++<del>template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
++template &lt;class T, class Allocator&gt;
++void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<blockquote>
+-Mark as NAD. The committee agrees that nested_exception is not a good
+-match for this usage model. The committee did not see a way of improving
+-this within the timeframe allowed.
+-</blockquote>
++<li>
++<p>
++Change 23.3.7 [vector.bool]/1 as indicated:
++</p>
+
++<blockquote><pre>
++iterator erase(const_iterator first, const_iterator last);
++void swap(vector&lt;bool,Allocator&gt;&amp;<del>&amp;</del>);
++static void swap(reference x, reference y);
++</pre></blockquote>
+
++</li>
+
+-<p><b>Proposed resolution:</b></p>
++<li>
+ <p>
++Change 23.4 [associative]/1, header <tt>&lt;map&gt;</tt> synopsis as indicated:
+ </p>
+
++<blockquote><pre>
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+
++[..]
+
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<hr>
+-<h3><a name="1139"></a>1139. Thread support library not concept enabled</h3>
+-<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread">issues</a> in [thread].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 93, JP 79, UK 333, JP 81</b></p>
+-
++<li>
+ <p>
+-The thread chapter is not concept enabled.
++Change 23.4 [associative]/1, header <tt>&lt;set&gt;</tt> synopsis as indicated:
+ </p>
+
++<blockquote><pre>
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(set&lt;Key,Compare,Allocator&gt;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(set&lt;Key,T,Compare,Allocator&amp;&amp; x, set&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(set&lt;Key,T,Compare,Allocator&amp; x, set&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+
++[..]
+
+-<p><b>Proposed resolution:</b></p>
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,T,Compare,Allocator&amp;&amp; x, multiset&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,T,Compare,Allocator&amp; x, multiset&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
++<li>
++<p>
++Change 23.4.4 [map]/2 as indicated:
++</p>
+
++<blockquote><pre>
++iterator erase(const_iterator first, const_iterator last);
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
+
++[..]
+
+-<hr>
+-<h3><a name="1140"></a>1140. Numerics library not concept enabled</h3>
+-<p><b>Section:</b> 26 [numerics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numerics">issues</a> in [numerics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
++// specialized algorithms:
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
+-<p><b>Addresses US 84</b></p>
++</li>
+
++<li>
+ <p>
+-The numerics chapter is not concept enabled.
++Change 23.4.4.5 [map.special] as indicated:
+ </p>
+
+-<p>
+-The portion of this comment dealing with random numbers was resolved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>,
+-which was accepted in Summit.
+-</p>
++<blockquote><pre>
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
++<li>
++<p>
++Change 23.4.5 [multimap]/2 as indicated:
++</p>
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote><pre>
++iterator erase(const_iterator first, const_iterator last);
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
+
++[..]
+
++// specialized algorithms:
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
++<li>
++<p>
++Change 23.4.5.4 [multimap.special] as indicated:
++</p>
+
+-<hr>
+-<h3><a name="1141"></a>1141. Input/Output library not concept enabled</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
++<blockquote><pre>
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class T, class Compare, class Allocator&gt;
++void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
+-<p><b>Addresses US 85, JP 67, JP 68, JP 69, JP 72, UK 308</b></p>
++</li>
+
++<li>
+ <p>
+-The input/output chapter is not concept enabled.
++Change 23.4.6 [set]/2 and 23.4.6.3 [set.special] as indicated: (twice!)
+ </p>
+
++<blockquote><pre>
++// specialized algorithms:
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(set&lt;Key,Compare,Allocator&gt;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class Compare, class Allocator&gt;
++void swap(set&lt;Key,Compare,Allocator&amp;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(set&lt;Key,Compare,Allocator&amp; x, set&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
++</li>
+
+-<p><b>Proposed resolution:</b></p>
+-
+-
++<li>
++<p>
++Change 23.4.7 [multiset]/2 as indicated:
++</p>
+
++<blockquote><pre>
++iterator erase(const_iterator first, const_iterator last);
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;<del>&amp;</del>);
++void clear();
+
++[..]
+
+-<hr>
+-<h3><a name="1142"></a>1142. Regular expressions library not concept enabled</h3>
+-<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re">issues</a> in [re].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
++// specialized algorithms:
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&amp;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
+-<p><b>Addresses US 86, UK 309, UK 310</b></p>
++</li>
+
++<li>
+ <p>
+-The regular expressions chapter is not concept enabled.
++Change 23.4.7.3 [multiset.special] as indicated:
+ </p>
+
++<blockquote><pre>
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
++<del>template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
++template &lt;class Key, class Compare, class Allocator&gt;
++void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
++</pre></blockquote>
+
+-
+-<p><b>Proposed resolution:</b></p>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1143"></a>1143. Atomic operations library not concept enabled</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1233"></a>1233. Missing <tt>unique_ptr</tt> signatures in synopsis</h3>
++<p><b>Section:</b> 20.7 [memory] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#memory">issues</a> in [memory].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 87, UK 311</b></p>
+-
+ <p>
+-The atomics chapter is not concept enabled.
+-</p>
+-
+-<p>
+-Needs to also consider issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>.
++Related to <a href="lwg-defects.html#296">296</a>. Some <tt>unique_ptr</tt> signatures are missing
++from the synopsis in 20.7 [memory].
+ </p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2009-11-04 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
++<blockquote><p>
++Moved to Tentatively NAD Editorial. The editor has adopted the fix.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++Add in 20.7 [memory], Header <tt>&lt;memory&gt;</tt> synopsis
++missing declarations as shown below:
++</p>
++
++<blockquote><pre>
++// 20.8.11 Class unique_ptr:
++template &lt;class X&gt; class default_delete;
++<ins>template&lt;class T&gt; struct default_delete&lt;T[]&gt;;</ins>
++template &lt;class X, class D = default_delete&lt;T&gt;&gt; class unique_ptr;
++<ins>template&lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;</ins>
++
++<ins>template&lt;class T, class D&gt; void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y);</ins>
++
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++<ins>template&lt;class T1, class D1, class T2, class D2&gt;
++bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
++</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1145"></a>1145. inappropriate headers for atomics</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1236"></a>1236. reserved identifiers in programs not using the library</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++I wasn't sure whether to consider this a library or a language issue,
++because the issue is I think it's incorrectly categorized as being part
++of the library, so I thought I'd send a message to both of you and let
++you sort it out.
++</p>
+
+-<p><b>Addresses UK 312</b></p>
++<p>
++Most reserved identifiers are treated as unilaterally available to the
++implementation, such as to implement language extensions, or provide
++macros documenting its functionality. However, the requirements for
++reserved identifers are in 17.6.4.3 [reserved.names], which are a
++subsection of 17.6.4 [constraints]. 17.6.4.1 [constraints.overview] appears only to apply to "C++ programs
++that use the facilities of the C++ standard library", meaning that, in
++theory, all implementations are erroneous in having any non-standard
++identifiers predefined for programs that do not, at some point, include
++a standard library header.
++</p>
+
+ <p>
+-The contents of the <tt>&lt;stdatomic.h&gt;</tt> header are not listed anywhere,
+-and <tt>&lt;cstdatomic&gt;</tt> is listed as a C99 header in chapter 17.
+-If we intend to use these for compatibility with a future C standard,
+-we should not use them now.
++Furthermore, it's unclear whether the use of certain identifiers is UB
++or results in an ill-formed program. In particular, 17.6.4.3.1 [macro.names] uses a "shall not", where [global.names] says that names are "reserved to the
++implementation". 17.6.4.3 [reserved.names] seems only to cover the
++instance of a name being described as "reserved", so are implementations
++required to diagnose a program that performs, as an example, "<tt>#undef
++get</tt>"?
+ </p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
++<blockquote><p>
++Move to NAD. There may in theory be multiple interpretations possible,
++but there's no evidence that this causes any genuine problems or
++uncertainty about what implementations are allowed to do. We do not
++believe this rises to the level of a defect.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Remove <tt>&lt;cstdatomic&gt;</tt> from the C99 headers in table 14.
+-Add a new header <tt>&lt;atomic&gt;</tt> to the headers in table 13.
+-Update chapter 29 to remove reference to <tt>&lt;stdatomic.h&gt;</tt>
+-and replace the use of <tt>&lt;cstdatomic&gt;</tt> with <tt>&lt;atomic&gt;</tt>.
+-</p>
+-<p><i>[
+-If and when WG14 adds atomic operations to C
+-we can add corresponding headers to table 14 with a TR.
+-]</i></p>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="1146"></a>1146. "lockfree" does not say enough</h3>
+-<p><b>Section:</b> 29.4 [atomics.lockfree] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.lockfree">issues</a> in [atomics.lockfree].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1239"></a>1239. Defect report</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-10-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 88</b></p>
+-
+-<p>
+-The "lockfree" facilities do not tell the programmer enough.
+-</p>
+-
+ <p>
+-There are 2 problems here.
+-First, at least on x86,
+-it's less important to me whether some integral types are lock free
+-than what is the largest type I can pass to atomic and have it be lock-free.
+-For example, if <tt>long long</tt>s are not lock-free,
+-<tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> is probably 1,
+-but I'd still be interested in knowing whether longs are always lock-free.
+-Or if long longs at any address are lock-free,
+-I'd expect <tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> to be 2,
+-but I may actually care whether I have access to
+-the <code>cmpxchg16b</code> instruction.
+-None of the support here helps with that question.
+-(There are really 2 related questions here:
+-what alignment requirements are there for lock-free access;
+-and what processor is the program actually running on,
+-as opposed to what it was compiled for?)
++Table 43 defines a number of traits that yield true for arrays of class
++types with the trait's property, but not arrays of other types with that
++property. For example, <tt>has_trivial_default_constructor</tt>:
+ </p>
+
+-<p>
+-Second, having <tt>atomic_is_lock_free</tt> only apply to individual objects
+-is pretty useless
+-(except, as Lawrence Crowl points out,
+-for throwing an exception when an object is unexpectedly not lock-free).
+-I'm likely to want to use its result to decide what algorithm to use,
+-and that algorithm is probably going to allocate new memory
+-containing atomic objects and then try to act on them.
+-If I can't predict the lock-freedom of the new object
+-by checking the lock-freedom of an existing object,
+-I may discover after starting the algorithm that I can't continue.
+-</p>
++<blockquote><p>
++<tt>T</tt> is a trivial type (3.9) or a class type with a trivial default
++constructor (12.1) or an array of such a class type.
++</p></blockquote>
+
+ <p><i>[
+-2009-06-16 Jeffrey Yasskin adds:
++2009-10 post-Santa Cruz:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-To solve the first problem, I think 2 macros would help:
+-<tt>MAX_POSSIBLE_LOCK_FREE_SIZE</tt> and <tt>MAX_GUARANTEED_LOCK_FREE_SIZE</tt>,
+-which expand to the maximum value of <tt>sizeof(T)</tt> for which atomic may
+-(or will, respectively) use lock-free operations.
+-Lawrence points out that this
+-"relies heavily on implementations
+-using word-size compare-swap on sub-word-size types,
+-which in turn requires address modulation."
+-He expects that to be the end state anyway, so it doesn't bother him much.
++An array of a trivial type is a trivial type.
+ </p>
+-
+ <p>
+-To solve the second,
+-I think one could specify that equally aligned objects of the same type
+-will return the same value from <tt>atomic_is_lock_free()</tt>.
+-I don't know how to specify "equal alignment".
+-Lawrence suggests an additional function, <tt>atomic_is_always_lock_free()</tt>.
++Mark as Tentatively NAD Editorial. The wording is OK as is,
++since an array of a trivial type is a trivial type, but the wording as
++proposed might be clearer.
+ </p>
+ </blockquote>
+
+-<p><i>[
+-2009-10-22 Benjamin Kosnik:
+-]</i></p>
+
+
+-<blockquote>
++<p><b>Rationale:</b></p>
+ <p>
+-In the evolution discussion of N2925, "More Collected Issues with
+-Atomics," there is an action item with respect to
+-LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, US 88
++The wording is OK as is, since an array of a trivial type is a trivial type.
++Project editor may wish to accept the suggested wording as editorial.
+ </p>
+
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-This is stated in the paper as:
+-</p>
+-<p>
+-Relatedly, Mike Sperts will create an issue to propose adding a traits
+-mechanism to check the compile-time properties through a template
+-mechanism rather than macros
++Change all the traits in question following this pattern:
+ </p>
+
++<blockquote><p>
++<tt>T</tt> is a trivial type (3.9) or a class type with a trivial default
++ constructor (12.1)<ins>,</ins> or an array of such a <del>class</del> type.
++</p></blockquote>
++
+ <p>
+-Here is my attempt to do this. I don't believe that a separate trait is
+-necessary for this, and that instead <tt>atomic_integral::is_lock_free</tt> can
+-be re-purposed with minimal work as follows.
++i.e., add a comma and delete a "class."
+ </p>
+
+-<p><i>[
+-Howard: Put Benjamin's wording in the proposed wording section.
+-]</i></p>
+
+
+-</blockquote>
+
+-<p><i>[
+-2009-10-22 Alberto Ganesh Barbati:
+-]</i></p>
+
++<hr>
++<h3><a name="1243"></a>1243. Missing <tt>operator+= (initializer_list&lt;T&gt;)</tt> for <tt>valarray</tt></h3>
++<p><b>Section:</b> 26.6.2.7 [valarray.cassign] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cassign">issues</a> in [valarray.cassign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP 64</b></p>
+
+-<blockquote>
+ <p>
+-Just a thought... wouldn't it be better to use a scoped enum instead of
+-plain integers? For example:
++During the additions of <tt>initializer_list</tt> overloads
++<tt>basic_string</tt> added:
+ </p>
+
+-<blockquote><pre>enum class is_lock_free
+-{
+- never = 0, sometimes = 1, always = 2;
+-};
++<blockquote><pre>
++basic_string&amp; operator+=(initializer_list&lt;charT&gt;);
+ </pre></blockquote>
+
+ <p>
+-if compatibility with C is deemed important, we could use an unscoped
+-enum with suitably chosen names. It would still be more descriptive
+-than 0, 1 and 2.
++but
+ </p>
+
+-</blockquote>
++<blockquote><pre>
++valarray&lt;T&gt;&amp; operator+= (initializer_list&lt;T&gt;);
++</pre></blockquote>
++
++<p>
++was not defined.
++</p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++Daniel adds on opening:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
++<blockquote><p>
++Recommend NAD. The <tt>operator+=</tt> overload of <tt>basic_string</tt>
++behaves as-if calling <tt>append</tt>, which is completely different in
++meaning as the existing <tt>operator+=</tt> overloads in
++<tt>valarray</tt> which just sum the value or values to the existing
++elements. The suggestion to add a corresponding append function to
++<tt>valarray</tt> was not considered as appropriate and the request was
++withdrawn (c++std-lib-24968).
++</p></blockquote>
+
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Header <tt>&lt;cstdatomic&gt;</tt> synopsis [atomics.synopsis]
+-</p>
++<blockquote><p>
++Mark as NAD. Request has been withdrawn by NB.
++</p></blockquote>
+
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Edit as follows:
++Add to 26.6.2.7 [valarray.cassign]:
+ </p>
+
+-<blockquote><pre>namespace std {
+-...
+-// 29.4, lock-free property
+-<del>#define ATOMIC_INTEGRAL_LOCK_FREE unspecified</del>
+-<ins>#define ATOMIC_CHAR_LOCK_FREE unspecified
+-#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+-#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+-#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+-#define ATOMIC_SHORT_LOCK_FREE unspecified
+-#define ATOMIC_INT_LOCK_FREE unspecified
+-#define ATOMIC_LONG_LOCK_FREE unspecified
+-#define ATOMIC_LLONG_LOCK_FREE unspecified</ins>
+-#define ATOMIC_ADDRESS_LOCK_FREE unspecified
++<blockquote><pre>
++valarray&lt;T&gt;&amp; operator+= (initializer_list&lt;T&gt;);
+ </pre></blockquote>
+
+-<p>
+-Lock-free Property 29.4 [atomics.lockfree]
+-</p>
+
+-<p>
+-Edit the synopsis as follows.
+-</p>
+
+-<blockquote><pre>namespace std {
+- <del>#define ATOMIC_INTEGRAL_LOCK_FREE unspecified</del>
+- <ins>#define ATOMIC_CHAR_LOCK_FREE unspecified
+- #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+- #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+- #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+- #define ATOMIC_SHORT_LOCK_FREE unspecified
+- #define ATOMIC_INT_LOCK_FREE unspecified
+- #define ATOMIC_LONG_LOCK_FREE unspecified
+- #define ATOMIC_LLONG_LOCK_FREE unspecified</ins>
+- #define ATOMIC_ADDRESS_LOCK_FREE unspecified
+-}
+-</pre></blockquote>
+
++
++<hr>
++<h3><a name="1246"></a>1246. <tt>vector::resize()</tt> missing efficiency guarantee</h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Edit paragraph 1 as follows.
++If <tt>v</tt> is a <tt>vector</tt>, I think repeated calls to
++<tt>v.resize( v.size() + 1 )</tt> should be amortized O(1), but it's not
++clear that's true from the text of the standard:
+ </p>
+
+-<blockquote>
+-The <ins>ATOMIC_...._LOCK_FREE</ins> macros <del>ATOMIC_INTEGRAL_LOCK_FREE and ATOMIC_ADDRESS_LOCK_FREE</del> indicate the general lock-free
+-property of <del>integral and address atomic</del> <ins>the corresponding atomic integral</ins> types<ins>, with the
+-signed and unsigned variants grouped together</ins>.
+-<del>The properties also apply to the corresponding specializations of the atomic template.</del>
+-A value of 0
+-indicates that the types are never lock-free. A value of 1
+-indicates that the types are sometimes lock-free. A value of 2
+-indicates that the types are always lock-free.
++<blockquote><pre>
++void resize(size_type sz);
++</pre>
++<blockquote><p>
++<i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent to <tt>erase(begin() + sz, end());</tt>. If
++<tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> default constructed elements to the
++sequence.
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Operations on Atomic Types 29.6 [atomics.types.operations]
++Seems to me if we used <tt>push_back</tt> instead of appends, we might be giving
++the guarantee I'd like. Thoughts?
+ </p>
+
++<p><i>[
++2009-11-10 Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale added
++below.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Edit as follows.
++In 23.3.6.3 [vector.capacity]/10, change
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>static constexpr bool</ins> A::is_lock_free() const volatile;
++<blockquote><pre>
++void resize(size_type sz);
+ </pre>
+-<blockquote>
+-<i>Returns:</i> True if the <del>object's</del> <ins>types's</ins> operations are lock-free, false
+-otherwise.
+-<ins>
+-[<i>Note:</i> In the same way that <tt>&lt;limits&gt;</tt>
+-<tt>std::numeric_limits&lt;short&gt;::max()</tt> is related to
+-<tt>&lt;limits.h&gt;</tt> <tt>__LONG_LONG_MAX__</tt>, <tt>&lt;atomic&gt;
+-std::atomic_short::is_lock_free</tt> is related to
+-<tt>&lt;stdatomic.h&gt;</tt> and <tt>ATOMIC_SHORT_LOCK_FREE</tt> —
+-<i>end note</i>]
+-</ins>
+-</blockquote>
++<blockquote><p>
++<i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent to <tt>erase(begin() + sz, end());</tt>. If
++<tt>size() &lt; sz</tt>, <del>appends <tt>sz - size()</tt> default constructed elements to the
++sequence</del>
++<ins>equivalent to <tt>sz - size()</tt> consecutive evaluations of <tt>push_back(T())</tt></ins>.
++</p></blockquote>
+ </blockquote>
+
+
+
++<p><b>Rationale:</b></p>
++<p>
++The description in terms of <tt>push_back</tt> led some to believe that
++one could expect the exact same growth pattern from both <tt>resize</tt> and
++<tt>push_back</tt> (e.g.) which could lead to sub-optimal implementations.
++Additionally, 23.3.6 [vector], p1 includes a statement that this container
++"supports (amortized) constant time insert and erase operations at the end;",
++therefore addressing the concern of this issue.
++</p>
+
+
+
+-<hr>
+-<h3><a name="1147"></a>1147. non-volatile atomic functions</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+
+-<p><b>Addresses US 90</b></p>
+
++<hr>
++<h3><a name="1251"></a>1251. move constructing <tt>basic_stringbuf</tt></h3>
++<p><b>Section:</b> 27.8.2.1 [stringbuf.cons] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.cons">issues</a> in [stringbuf.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-The C++0X draft
+-declares all of the functions dealing with atomics (section 29.6 [atomics.types.operations])
+-to take volatile arguments.
+-Yet it also says (29.4-3),
++I just came across issue <a href="lwg-defects.html#1204">1204</a> -- Global permission to move, which
++seems to address the concern raised by the example in c++std-lib-25030.
+ </p>
+-
+-<blockquote>
+ <p>
+-[ Note: Many operations are volatile-qualified.
+-The "volatile as device register" semantics have not changed in the standard.
+-This qualification means that volatility is preserved
+-when applying these operations to volatile objects.
+-It does not mean that operations on non-volatile objects become volatile.
+-Thus, volatile qualified operations on non-volatile objects
+-may be merged under some conditions. —end note ]
++IIUC, the example violates the permission to assume that arguments
++bound to rvalue references are unnamed temporaries granted to
++implementations by the resolution of issue <a href="lwg-defects.html#1204">1204</a> - Global permission
++to move.
+ </p>
+-</blockquote>
+
+ <p>
+-I was thinking about how to implement this in gcc,
+-and I believe that we'll want to overload most of the functions
+-on volatile and non-volatile.
+-Here's why:
++I.e., the <tt>ostringstream(ostringstream &amp;&amp;rhs)</tt> ctor can leave the <tt>rhs</tt>
++pointers pointing to the newly constructed object's buffer just as
++long as the dtor doesn't change or invalidate the buffer. The caller
++may not make any assumptions about rhs after the move beyond it being
++safe to destroy or reassign.
+ </p>
+
+ <p>
+-To let the compiler take advantage of the permission
+-to merge non-volatile atomic operations and reorder atomics in certain,
+-we'll need to tell the compiler backend
+-about exactly which atomic operation was used.
+-So I expect most of the functions of the form atomic_&lt;op&gt;_explicit()
+-(e.g. atomic_load_explicit, atomic_exchange_explicit,
+-atomic_fetch_add_explicit, etc.)
+-to become compiler builtins.
+-A builtin can tell whether its argument was volatile or not,
+-so those functions don't really need extra explicit overloads.
+-However, I don't expect that we'll want to add builtins
+-for every function in chapter 29,
+-since most can be implemented in terms of the _explicit free functions:
++So unless I misunderstood something, I still think the <tt>basic_stringbuf</tt>
++move ctor is overspecified. Specifically, I think the third sentence
++in the Effects clause and the last 6 bullets in the Postconditions
++clause can, and IMO should, be stricken.
+ </p>
+
+-<pre><code>class atomic_int {
+- __atomic_int_storage value;
+- public:
+- int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+- // &amp;value has type "volatile __atomic_int_storage*".
+- atomic_fetch_add_explicit(&amp;value, increment, order);
+- }
+- ...
+-};
+-</code></pre>
++<p><i>[
++2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
++]</i></p>
++
+
++
++<p><b>Rationale:</b></p>
+ <p>
+-But now this <em>always</em> calls
+-the volatile builtin version of atomic_fetch_add_explicit(),
+-even if the atomic_int wasn't declared volatile.
+-To preserve volatility and the compiler's permission to optimize,
+-I'd need to write:
++The sense of 1251 appears to be that the <tt>basic_stringbuf</tt> move
++constructor offers more guarantees than the minimum. This is true, and quite
++correct. The additional words guarantee that the internal buffer has genuinely
++transferred from one object to another, and further operations on the original
++will not affect the buffer of the newly created object. This is a very
++important guarantee, much as we see that a moved-from <tt>unique_ptr</tt> is
++guaranteed to be empty.
+ </p>
+
+-<pre><code>class atomic_int {
+- __atomic_int_storage value;
+- public:
+- int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+- atomic_fetch_add_explicit(&amp;value, increment, order);
+- }
+- int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
+- atomic_fetch_add_explicit(&amp;value, increment, order);
+- }
+- ...
+-};
+-</code></pre>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-But this is visibly different from the declarations in the standard
+-because it's now overloaded.
+-(Consider passing &amp;atomic_int::fetch_add as a template parameter.)
++Strike from 27.8.2.1 [stringbuf.cons]:
+ </p>
+
++<blockquote><pre>
++basic_stringbuf(basic_stringbuf&amp;&amp; rhs);
++</pre>
++<blockquote>
+ <p>
+-The implementation may already have permission to add overloads
+-to the member functions:
++<i>Effects:</i> Move constructs from the rvalue <tt>rhs</tt>. It is
++implementation-defined whether the sequence pointers in <tt>*this</tt>
++(<tt>eback()</tt>, <tt>gptr()</tt>, <tt>egptr()</tt>, <tt>pbase()</tt>,
++<tt>pptr()</tt>, <tt>epptr()</tt>) obtain the values which <tt>rhs</tt>
++had. <del>Whether they do or not, <tt>*this</tt> and <tt>rhs</tt> reference
++separate buffers (if any at all) after the construction.</del> The openmode,
++locale and any other state of <tt>rhs</tt> is also copied.
+ </p>
+
+-<blockquote>
+ <p>
+-17.6.4.5 [member.functions] An implementation may declare additional non-virtual
+-member function signatures within a class:<br>
+-...
++<i>Postconditions:</i> Let <tt>rhs_p</tt> refer to the state of
++<tt>rhs</tt> just prior to this construction and let <tt>rhs_a</tt>
++referto the state of <tt>rhs</tt> just after this construction.
+ </p>
+ <ul>
+-<li>by adding a member function signature for a member function name.</li>
++<li>
++<tt>str() == rhs_p.str()</tt>
++</li>
++<li>
++<tt>gptr() - eback() == rhs_p.gptr() - rhs_p.eback()</tt>
++</li>
++<li>
++<tt>egptr() - eback() == rhs_p.egptr() - rhs_p.eback()</tt>
++</li>
++<li>
++<tt>pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()</tt>
++</li>
++<li>
++<tt>epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()</tt>
++</li>
++<li><del>
++if <tt>(eback()) eback() != rhs_a.eback()</tt>
++</del></li>
++<li><del>
++if <tt>(gptr()) gptr() != rhs_a.gptr()</tt>
++</del></li>
++<li><del>
++if <tt>(egptr()) egptr() != rhs_a.egptr()</tt>
++</del></li>
++<li><del>
++if <tt>(pbase()) pbase() != rhs_a.pbase()</tt>
++</del></li>
++<li><del>
++if <tt>(pptr()) pptr() != rhs_a.pptr()</tt>
++</del></li>
++<li><del>
++if <tt>(epptr()) epptr() != rhs_a.epptr()</tt>
++</del></li>
+ </ul>
+ </blockquote>
++</blockquote>
+
+-<p>
+-but I don't see an equivalent permission to add overloads to the free functions.
+-</p>
+
+-<p><i>[
+-2009-06-16 Lawrence adds:
+-]</i></p>
+
+
+-<blockquote>
++
++
++<hr>
++<h3><a name="1259"></a>1259. Should initializer-list constructors move elements?</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-11-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-I recommend allowing non-volatile overloads.
++According to 23.2.3 [sequence.reqmts], <tt>X(il)</tt> is
++equivalent to <tt>X(il.begin(), il.end())</tt>. Should it instead be
++equivalent to <tt>X(move_iterator(il.begin()),
++move_iterator(il.end()))</tt> so that needless copies are not made? This
++doesn't seem ideal either - it may make more sense to provide two
++overloads for the constructor, one for move and one for copy.
+ </p>
+-</blockquote>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2009-11-10 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.html">N2992</a>.
+-</blockquote>
+-
++<blockquote><p>
++I've moved this issue to Tentatively NAD after 5 positive votes on c++std-lib,
++and added a rationale below.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
++
++<p><b>Rationale:</b></p>
++<p>
++There is no consensus at this time within EWG or CWG to make the
++required language changes. Therefore this is not something that the LWG
++can even consider. Should such language changes be made for a future
++standard, no doubt there would need to be an accompanying library impact
++survey.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1148"></a>1148. Wrong argument type of I/O stream manipulators <tt>setprecision()</tt>
+-and <tt>setw()</tt></h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Marc Steinbach <b>Opened:</b> 2009-06-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1263"></a>1263. missing <tt>swap</tt> overloads for <tt>regex</tt></h3>
++<p><b>Section:</b> 28.4 [re.syn] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.syn">issues</a> in [re.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>
+-The header <tt>&lt;iomanip&gt;</tt> synopsis in 27.7 [iostream.format] specifies
+-</p>
+-<blockquote><pre>T5 setprecision(int n);
+-T6 setw(int n);
+-</pre></blockquote>
+
+-<p>
+-The argument types should be streamsize, as in class <tt>ios_base</tt>
+-(see 27.5.2 [ios.base]):
+-</p>
+-<blockquote><pre>streamsize precision() const;
+-streamsize precision(streamsize prec);
+-streamsize width() const;
+-streamsize width(streamsize wide);
+-</pre></blockquote>
++<p><b>Addresses: UK 314</b></p>
+
+ <p>
+-(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.)
++In Message c++std-lib-25529, Alisdair writes:
+ </p>
+
+-<p><i>[
+-2009-07-29 Daniel clarified wording.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+ <blockquote>
+ <p>
+-No concensus for this change. There was some interest in doing the opposite
+-fix: Change the <tt>streamsize</tt> in <tt>&lt;ios&gt;</tt> to <tt>int</tt>.
+-But ultimately there was no concensus for that change either.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3009.html#UK314">UK comment 314</a>
++requests rvalue swap overloads in a couple of places they
++were missed.
+ </p>
+-</blockquote>
+-
+-
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+ <p>
+-In 27.7 [iostream.format], header <tt>&lt;iomanip&gt;</tt> synopsis change as indicated:
++We have in general reverted to the single swap signature taking lvalue
++references, which could be seen as the alternative solution to
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3009.html#UK314">UK 314</a>,
++bringing consistency to the standard &lt;g&gt;
+ </p>
+
+-<blockquote><pre>T5 setprecision(<del>int</del><ins>streamsize</ins> n);
+-T6 setw(<del>int</del><ins>streamsize</ins> n);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+ <p>
+-In 27.7.3 [std.manip], just before p. 6 change as indicated:
++Either way, I no longer expect to see any work to resolve this comment -
++the work is complete and it should be either marked Rejected, or
++Accepted with Modifications (namely, removing all other rvalue swaps!)
+ </p>
++</blockquote>
+
+-<blockquote><pre>unspecified setprecision(<del>int</del><ins>streamsize</ins> n);
+-</pre></blockquote>
+-</li>
++<p><i>[
++Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++]</i></p>
+
+-<li>
+-<p>
+-In 27.7.3 [std.manip], just before p. 7 change as indicated:
+-</p>
+
+-<blockquote><pre>unspecified setw(<del>int</del><ins>streamsize</ins> n);
+-</pre></blockquote>
+-</li>
+-</ol>
+
++<p><b>Proposed resolution:</b></p>
+
+
++<p><b>Rationale:</b></p>
++<p>
++We have in general reverted to the single swap signature taking
++lvalue references, which could be seen as the alternative solution to
++UK 314, bringing consistency to the standard.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1149"></a>1149. Reformulating NonemptyRange axiom</h3>
+-<p><b>Section:</b> X [rand.concept.urng] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2009-06-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
++<h3><a name="1265"></a>1265. <tt>longjmp</tt> and destructors</h3>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In X [rand.concept.urng], we have the following:
++18.10 [support.runtime]/4 says that <tt>longjmp</tt> is undefined if
++unwinding by the mechanism used by catch and throw would invoke any nontrivial
++destructors. However, the text as written is rather vague, in particular when
++dealing with <tt>catch(...)</tt>:
+ </p>
+-<blockquote><pre>concept UniformRandomNumberGenerator&lt;typename G&gt; : Callable&lt;G&gt; {
+- ...
+- axiom NonemptyRange(G&amp; g) {
+- G::min() &lt; G::max();
++
++<blockquote><pre>
++void foo() {
++ jump_buf buf;
++ non_trivial_dtor n1; // 1
++ if (!setjmp(buf)) {
++ non_trivial_dtor n2; // 2
++ try {
++ longjmp(buf, 1);
++ } catch (...) {
++ }
+ }
+- ...
+ }
+ </pre></blockquote>
+
+ <p>
+-Since the parameter <tt>G</tt> is in scope throughout the concept, there is no
+-need for the axiom to be further parameterized, and so the axiom can be
+-slightly simplified as:
++My interpretation of the meaning of 18.10 [support.runtime]/4 is that
++declaration 2, but not 1, would cause the <tt>longjmp</tt> to be undefined
++behavior. However, it's not entirely clear from the text. Arguably, replacing
++the <tt>setjmp</tt> and <tt>longjmp</tt> with <tt>catch</tt> would still cause
++the destructor for <tt>n1</tt> to be called after the unwinding, which would
++lead to undefined behavior. This is clearly not an intended consequence of the
++wording. However, it is probably still UB, as <tt>n1</tt> now has
++"indeterminate" value, and running its destructor on <tt>foo</tt>'s exit will
++cause Bad Things.
+ </p>
+
+-<blockquote><pre>axiom NonemptyRange() {
+- G::min() &lt; G::max();
+-}
+-</pre></blockquote>
+-
+ <p>
+-We can further reformulate so as to avoid any axiom machinery as:
++Declarations 2 has a more interesting issue. The <tt>catch(...)</tt> muddles up
++the definition that uses <tt>throw</tt> and <tt>catch</tt> - if
++<tt>longjmp()</tt> were indeed a <tt>throw</tt>, control would never return to
++the <tt>setjmp</tt>. As such, <tt>n2</tt>'s destructor wouldn't be called
++(except by the argument for <tt>n1</tt>, which is that the destructor would be
++called later as the frame was left in the normal control flow).
+ </p>
+
+-<blockquote><pre>requires True&lt; G::min() &lt; G::max() &gt;;
+-</pre></blockquote>
+-
+ <p>
+-This is not only a simpler statement of the same requirement, but also
+-forces the requirement to be checked.
++I suggest that paragraph 4 of 18.10 [support.runtime] should be replaced
++with the following, or something that reads better but has the same effect:
+ </p>
+
++<blockquote><p>
++The function signature <tt>longjmp(jmp_buf jbuf, int val)</tt> has more
++restricted behavior in this International Standard. A call to <tt>longjmp</tt>
++has undefined behavior if any non-trivial destructors would be called were the
++<tt>longjmp</tt> call replaced with a throw-expression whose nearest matching
++handler were a (possibly imaginary) function-try-block on the function
++containing the corresponding <tt>setjmp</tt> call.
++</p></blockquote>
++
+ <p><i>[
+-Post-Rapperswil:
++2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In X [rand.concept.urng], replace the <tt>NonemptyRange</tt> axiom by:
++Change 18.10 [support.runtime]/4:
+ </p>
+
+-<blockquote><pre><del>axiom NonemptyRange(G&amp; g) {
+- G::min() &lt; G::max();
+-}</del>
+-<ins>requires True&lt; G::min() &lt; G::max() &gt;;</ins>
+-</pre></blockquote>
++<blockquote><p>
++The function signature <tt>longjmp(jmp_buf jbuf, int val)</tt> has more
++restricted behavior in this International Standard. <del>A
++<tt>setjmp</tt>/<tt>longjmp</tt> call pair has undefined behavior if replacing
++the <tt>setjmp</tt> and <tt>longjmp</tt> by <tt>catch</tt> and <tt>throw</tt>
++would invoke any non-trivial destructors for any automatic objects.</del>
++<ins>A call to <tt>longjmp</tt> has undefined behavior if any non-trivial
++destructors would be called were the <tt>longjmp</tt> call replaced with a
++throw-expression whose nearest matching handler were a (possibly imaginary)
++function-try-block on the function containing the corresponding <tt>setjmp</tt>
++call.</ins>
++</p></blockquote>
+
+
++<p><b>Rationale:</b></p>
++<p>
++In the given example, it is clear that it is only <tt>n2</tt> and not
++<tt>n1</tt> that is destroyed by the <tt>longjmp</tt>.
++</p>
++<p>
++At this late stage in the standards process, we are focusing on issues that
++impact users or implementers. Trying to rewrite complex wording just for the
++sake of improved clarity is likely to do more harm than good.
++</p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1150"></a>1150. wchar_t, char16_t and char32_t filenames</h3>
+-<p><b>Section:</b> 27.9.1.14 [fstream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1296"></a>1296. <tt>map</tt> and <tt>multimap value_compare</tt> overspecified</h3>
++<p><b>Section:</b> 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map">issues</a> in [map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP 73</b></p>
++<p>
++The container class templates <tt>map</tt> and <tt>multimap</tt> both contain a
++nested type called <tt>value_compare</tt>, that is used to compare the
++<tt>value_type pair</tt> elements, an adaptor of the user-supplied comparison
++function-like object.
++</p>
+
+- <p><b>Description</b></p>
+- <p>It is a problem
+- from C++98, <tt>fstream</tt> cannot appoint a filename of wide
+- character string(<tt>const wchar_t</tt> and <tt>const wstring&amp;</tt>).</p>
+-<p><b>Suggestion</b></p>
+- <p>Add
+- interface corresponding to <tt>wchar_t</tt>, <tt>char16_t</tt> and <tt>char32_t</tt>.</p>
++<p>
++I believe these types are over-specified, as we require a distinct type for each
++template, even though the allocator plays no part in the comparator, and
++<tt>map</tt> and <tt>multimap value_compare</tt> classes could easily be shared.
++ The benefits are similar to the SCARY iterator proposal (although on a much
++smaller scale!) but unlike SCARY, this is not a QoI issue today but actively
++prohibited.
++</p>
+
+-<p><i>[
+-2009-07-01 Alisdair notes that this is a duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a> which has more
+-in-depth rationale.
+-]</i></p>
++<p>
++If the <tt>value_compare</tt> classes were marked 'exposition only', a vendor
++would be free to experiment with implementations that do not produce so many
++template instantiations with negligible impact on conforming programs. (There
++is a minor risk that programs could no longer portably overload functions taking
++<tt>value_compare</tt> types. This scenario is extremely unlikely outside
++conformance suites.)
++</p>
+
++<p>
++(Note that there are no similar problems for unordered maps, nor any of the set
++variants)
++</p>
+
+ <p><i>[
+-2009-09-21 Daniel adds:
++2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Rationale added below.
+ ]</i></p>
+
+
+-<blockquote>
+-I suggest to mark this issue as NAD Future with the intend to
+-solve the issue with a single file path c'tor template assuming
+-a provision of a TR2 filesystem library.
+-</blockquote>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
++<p><b>Rationale:</b></p>
++<p>
++The <tt>value_compare</tt> specification is an unfortunate bit from the past
++that we have to live with. Fortunately vendors can work around the problems
++mentioned in this issue.
++</p>
+
+-<blockquote>
+-NAD Future. This is a duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a>.
+-</blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++p2 23.4.4 [map]:
++Above the declaration of class <tt>value_compare</tt> in the map synopsis, add:
++</p>
+
++<blockquote><pre>
++template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++class map {
++public:
++ // types:
++ ...
++ <ins>// exposition only.</ins>
++ class value_compare
++ : public binary_function&lt;value_type,value_type,bool&gt; {
++ ...
++</pre></blockquote>
+
+
+
++<p>
++p2 23.4.5 [multimap]:
++Above the declaration of class <tt>value_compare</tt> in the map synopsis, add:
++</p>
+
+-<hr>
+-<h3><a name="1153"></a>1153. Standard library needs review for constructors to be
+-explicit to avoid treatment as initializer-list constructor</h3>
+-<p><b>Section:</b> 17 [library], 30 [thread], D [depr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
++<blockquote><pre>
++template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
++class multimap {
++public:
++ // types:
++ ...
++ <ins>// exposition only.</ins>
++ class value_compare
++ : public binary_function&lt;value_type,value_type,bool&gt; {
++ ...
++</pre></blockquote>
+
+-<p><b>Addresses DE 2</b></p>
+
+-<p><b>Description</b></p>
+- <p>Marking a constructor with <tt>explicit</tt> has semantics
+- even for a constructor with zero or several parameters:
+- Such a constructor cannot be used with list-initialization
+- in a copy-initialization context, see 13.3.1.7 [over.match.list]. The
+- standard library apparently has not been reviewed for
+- marking non-single-parameter constructors as <tt>explicit</tt>.</p>
+-<p><b>Suggestion</b></p>
+- <p>Consider marking zero-parameter and multi-parameter
+- constructors <tt>explicit</tt> in classes that have at least one
+- constructor marked <tt>explicit</tt> and that do not have an
+- initializer-list constructor.</p>
+
+-<p><b>Notes</b></p>
+- <p>Robert Klarer to address this one.</p>
+
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+
++<hr>
++<h3><a name="1301"></a>1301. <tt>clear()</tt> and assignment</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I propose that <tt>clear()</tt> be defined to be equivalent to
++<tt>erase(begin(),end())</tt> except not using copy or move of elements.
++</p>
+
+ <blockquote>
+-Move to "Open". Robert Klarer has promised to provide wording.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD, rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-We are unaware of any cases where initializer lists cause problem in this
+-context, but if problems arise in the future the issue can be reopened.
++To: C++ libraries mailing list<br/>
++Message c++std-lib-26465
+ </p>
+
++<p>
++and specifiying as post: <tt>size()==0</tt> might also not be appropriate
++because forward-Lists provide no <tt>size()</tt>, this it should be:
++post: <tt>empty()==true</tt>
++</p>
+
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
++<p>
++Bjarne Stroustrup schrieb/wrote:
++</p>
+
++<blockquote>
++<p>
++To: C++ libraries mailing list<br/>
++Message c++std-lib-26458
++</p>
+
+-<hr>
+-<h3><a name="1154"></a>1154. <tt>complex</tt> should accept integral types</h3>
+-<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
++<p>
++in table 94 we define <tt>clear()</tt> as:
++</p>
+
+-<p><b>Addresses FR 35</b></p>
++<blockquote><pre>
++a.clear() void erase(begin(), end())
++post: size() == 0
++</pre></blockquote>
+
+-<p><b>Description</b></p>
+- <p>Instantiations of the class
+- template <tt>complex&lt;&gt;</tt> have to be allowed for integral
+- types, to reflect existing practice and ISO standards
+- (LIA-III).</p>
+-
+-<p><b>Suggestion</b></p>
++<p>
++Now <tt>erase</tt> requires assignment (<tt>MoveAssignable</tt>) which makes
++sense if we have to move an element, but why should that be required from
++<tt>clear()</tt> where all elements are destroyed?
++</p>
++</blockquote>
++</blockquote>
+
+ <p><i>[
+-2009-10-26 Proposed wording in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3002.pdf">N3002</a>.
++2010-01-23 Alisdiar provides wording.
+ ]</i></p>
+
+
+ <p><i>[
+-2010 Pittsburgh:
++2010-01-30 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to NAD Future. Rationale added.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-There is no consensus for making this change at this time.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-Adopt
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3002.pdf">N3002</a>.
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1155"></a>1155. Reference should be to C99</h3>
+-<p><b>Section:</b> C.2 [diff.library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#diff.library">issues</a> in [diff.library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses FR 38</b></p>
+-
+-<p><b>Description</b></p>
+- <p>What is ISO/IEC 1990:9899/DAM
+- 1? My guess is that's a typo for ISO/IEC
+- 9899/Amd.1:1995 which I'd
+- have expected to be referenced here (the tables
+- make reference to things
+- which were introduced by Amd.1).</p>
+-<p><b>Suggestion</b></p>
+- <p>One need probably a reference
+- to the document which introduce <tt>char16_t</tt> and
+- <tt>char32_t</tt> in C (ISO/IEC TR 19769:2004?).</p>
+-<p><b>Notes</b></p>
+-<p>Create issue. Document in question should be C99, not C90+amendment1. The
+- rest of the section requires careful review for completeness. Example &lt;cstdint&gt;
+- 18.4.1 [cstdint.syn]. Assign to C liasons.</p>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Already fixed.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1156"></a>1156. Constraints on bitmask and enumeration types to be tightened</h3>
+-<p><b>Section:</b> 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 165</b></p>
+-
+-<p><b>Description</b></p>
+- <p>Constraints on
+- bitmask and enumeration types were supposed to be tightened
+- up as part of the motivation for the <tt>constexpr</tt> feature -
+- see paper
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a>
+- for details</p>
+-<p><b>Suggestion</b></p>
+- <p>Adopt wording in line with the motivation
+- described in
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf">N2235</a></p>
+-<p><b>Notes</b></p>
+- <p>Robert Klarer to review</p>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to Open. Ping Robert Klarer to provide wording, using N2235 as
+-guidance.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to NAD. Rationale added.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-UK NB did not sufficiently describe how to resolve their comment, and
+-therefore we cannot make a change for the FCD. If a resolution were
+-provided in the future, we would be happy to apply it.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1160"></a>1160. <tt>future_error</tt> public constructor is 'exposition only'</h3>
+-<p><b>Section:</b> 30.6.3 [futures.future_error] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 331</b></p>
+-
+-<p><b>Description</b></p>
+- <p>Not clear what
+- it means for a public constructor to be 'exposition only'.
+- If the intent is purely to support the library calling this
+- constructor then it can be made private and accessed
+- through friendship. Otherwise it should be documented for
+- public consumption.</p>
+-<p><b>Suggestion</b></p>
+- <p>Declare the constructor as private with a
+- note about intended friendship, or remove the
+- exposition-only comment and document the semantics.</p>
+-<p><b>Notes</b></p>
+-<p>Create an issue. Assigned to Detlef. Suggested resolution probably makes
+- sense.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Pending a paper from Anthony Williams / Detleff Volleman.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-14 Pending paper:
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1161"></a>1161. Unnecessary <tt>unique_future</tt> limitations</h3>
+-<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 336</b></p>
+-
+-<p><b>Description</b></p>
+-
+- <p>It is possible
+- to transfer ownership of the asynchronous result from one
+- unique_future instance to another via the move-constructor.
+- However, it is not possible to transfer it back, and nor is
+- it possible to create a default-constructed unique_future
+- instance to use as a later move target. This unduly limits
+- the use of <tt>unique_future</tt> in code. Also, the lack of a
+- move-assignment operator restricts the use of <tt>unique_future</tt>
+- in containers such as <tt>std::vector</tt> - <tt>vector::insert</tt> requires
+- move-assignable for example.</p>
+-<p><b>Suggestion</b></p>
+- <p>Add a default constructor with the
+- semantics that it creates a <tt>unique_future</tt> with no
+- associated asynchronous result. Add a move-assignment
+- operator which transfers ownership.</p>
+-<p><b>Notes</b></p>
+-<p>Create an issue. Detlef will look into it.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Pending a paper from Anthony Williams / Detleff Volleman.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-14 Pending paper:
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1162"></a>1162. <tt>shared_future</tt> should support an efficient move constructor</h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 337</b></p>
+-
+-<p><b>Description</b></p>
+- <p><tt>shared_future</tt>
+- should support an efficient move constructor that can avoid
+- unnecessary manipulation of a reference count, much like
+- <tt>shared_ptr</tt></p>
+-<p><b>Suggestion</b></p>
+- <p>Add a move constructor</p>
+-<p><b>Notes</b></p>
+-<p>Create an issue. Detlef will look into it.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Pending a paper from Anthony Williams / Detleff Volleman.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-14 Pending paper:
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1163"></a>1163. <tt>shared_future</tt> is inconsistent with <tt>shared_ptr</tt></h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 338</b></p>
+-
+-<p><b>Description</b></p>
+-
+- <p><tt>shared_future</tt> is currently
+- CopyConstructible, but not CopyAssignable. This is
+- inconsistent with <tt>shared_ptr</tt>, and will surprise users.
+- Users will then write work-arounds to provide this
+- behaviour. We should provide it simply and efficiently as
+- part of shared_future. Note that since the shared_future
+- member functions for accessing the state are all declared
+- const, the original usage of an immutable shared_future
+- value that can be freely copied by multiple threads can be
+- retained by declaring such an instance as "<tt>const
+- shared_future</tt>".</p>
+-<p><b>Suggestion</b></p>
+- <p>Remove "=delete"
+- from the copy-assignment operator of shared_future. Add a
+- move-constructor <tt>shared_future(shared_future&amp;&amp;
+- rhs)</tt>, and a move-assignment operator <tt>shared_future&amp;
+- operator=(shared_future&amp;&amp; rhs)</tt>. The postcondition
+- for the copy-assignment operator is that <tt>*this</tt> has the same
+- associated state as <tt>rhs</tt>. The postcondition for the
+- move-constructor and move assignment is that <tt>*this</tt> has the
+- same associated as <tt>rhs</tt> had before the
+- constructor/assignment call and that <tt>rhs</tt> has no associated
+- state.</p>
+-<p><b>Notes</b></p>
+-<p>Create an issue. Detlef will look into it.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Pending a paper from Anthony Williams / Detleff Volleman.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-14 Pending paper:
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1164"></a>1164. <tt>promise::swap</tt> should pass by rvalue reference</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 341</b></p>
+-
+-<p><b>Description</b></p>
+-<p><tt>promise::swap</tt> accepts its parameter by lvalue reference. This is
+-inconsistent with other types that provide a swap member function,
+-where those swap functions accept an rvalue reference</p>
+-
+-<p><b>Suggestion</b></p>
+-<p>Change <tt>promise::swap</tt> to take an rvalue reference.</p>
+-
+-<p><b>Notes</b></p>
+-<p>Create an issue. Detlef will look into it. Probably ready as it.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD, by virtue of the changed rvalue rules and swap signatures from Summit.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1165"></a>1165. Unneeded promise move constructor</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses UK 343</b></p>
+-
+-<p><b>Description</b></p>
+- <p>The move constructor of a std::promise
+- object does not need to allocate any memory, so the
+- move-construct-with-allocator overload of the constructor
+- is superfluous.</p>
+-<p><b>Suggestion</b></p>
+- <p>Remove the
+- constructor with the signature <tt>template &lt;class
+- Allocator&gt; promise(allocator_arg_t, const Allocator&amp;
+- a, promise&amp; rhs);</tt></p>
+-<p><b>Notes</b></p>
+-<p>Create an issue. Detlef will look into it. Will solicit feedback from Pablo.
+- Note that “rhs” argument should also be an rvalue reference in any case.</p>
+-
+-<p><i>[
+-2009-07 Frankfurt
+-]</i></p>
+-
+-
+-<blockquote>
+-Pending a paper from Anthony Williams / Detleff Volleman.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.html">N2997</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1166"></a>1166. Allocator-specific move/copy break model of move-constructor and
+- move-assignment</h3>
+-<p><b>Section:</b> X [allocator.propagation], X [allocator.propagation.map], 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-
+-<p><b>Addresses US 77</b></p>
+-
+-<p><b>Description</b></p>
+- <p>Allocator-specific move and copy behavior for containers
+- (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a>) complicates a little-used and already-complicated
+- portion of the standard library (allocators), and breaks
+- the conceptual model of move-constructor and
+- move-assignment operations on standard containers being
+- efficient operations. The extensions for allocator-specific
+- move and copy behavior should be removed from the working
+- paper.</p>
+- <p>With the
+- introduction of rvalue references, we are teaching
+- programmers that moving from a standard container (e.g., a
+- <tt>vector&lt;string&gt;</tt>) is an efficient, constant-time
+- operation. The introduction of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a> removed that
+- guarantee; depending on the behavior of four different
+- traits (20.8.4), the complexity of copy and move operations
+- can be constant or linear time. This level of customization
+- greatly increases the complexity of standard containers,
+- and benefits only a tiny fraction of the C++ community.</p>
+-<p><b>Suggestion</b></p>
+-
+- <p>Remove 20.8.4.</p>
+-
+- <p>Remove 20.8.5.</p>
+-
+- <p>Remove all references to the facilities in
+- 20.8.4 and 20.8.5 from clause 23.</p>
+-
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1167"></a>1167. <tt>pair&lt;T,U&gt;</tt> doesn't model <tt>LessThanComparable</tt> in unconstrained code even if
+- <tt>T</tt> and <tt>U</tt> do.</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2009-07-01 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-<tt>LessThanComparable</tt> requires (and provides default
+- implementations for) &lt;=,&gt;, and &gt;=. However, the defaults
+- don't take effect in unconstrained code.
+-</p>
+-<p>
+-Still, it's a problem to have types acting one way in
+-constrained code and another in unconstrained code, except in cases of
+-syntax adaptation. It's also inconsistent with the containers, which
+-supply all those operators.
+-</p>
+-<p>
+-Totally Unbiased
+-Suggested Resolution:
+-</p>
+-<p>
+-accept the exported concept maps proposal and
+- change the way this stuff is handled to use an
+- explicit exported concept map rather than nested
+- function templates
+-</p>
+-<p>
+-e.g., remove from the body of <tt>std::list</tt>
+-</p>
+-<blockquote><pre>template &lt;LessThanComparable T, class Allocator&gt;
+-bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
+-template &lt;LessThanComparable T, class Allocator&gt;
+-bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
+-template &lt;LessThanComparable T, class Allocator&gt;
+-bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
+-template &lt;LessThanComparable T, class Allocator&gt;
+-bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
+-</pre></blockquote>
+-<p>
+-and add this concept_map afterwards:
+-</p>
+-<blockquote><pre>template &lt;LessThanComparable T, class Allocator&gt;
+-export concept_map LessThanComparable&lt;list&lt;T,Allocator&gt; &gt;
+-{
+- bool operator&lt;(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
+-}
+-</pre></blockquote>
+-<p>
+-do similarly for <tt>std::pair</tt>. While you're at it, do the same for
+-<tt>operator==</tt> and <tt>!=</tt> everywhere, and seek out other such opportunities.
+-</p>
+-<p>
+-Alternative Resolution: keep the ugly, complex specification and add the
+- missing operators to <tt>std::pair</tt>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1168"></a>1168. Odd wording for bitset equality operators</h3>
+-<p><b>Section:</b> 20.5.2 [bitset.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-02 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The following wording seems a little unusual to me:
+-</p>
+-<p>
+-p42/43 20.5.2 [bitset.members]
+-</p>
+-
+-<blockquote>
+-<pre>bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
+-</pre>
+-<blockquote>
+--42- <i>Returns:</i> A nonzero value if the value of each bit in
+-<tt>*this</tt> equals the value of the corresponding bit in
+-<tt>rhs</tt>.
+-</blockquote>
+-<pre>bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
+-</pre>
+-<blockquote>
+--43- <i>Returns:</i> A nonzero value if <tt>!(*this == rhs)</tt>.
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-"A nonzero value" may be well defined as equivalent to the literal '<tt>true</tt>'
+-for Booleans, but the wording is clumsy. I suggest replacing "A nonzero value"
+-with the literal '<tt>true</tt>' (in appropriate font) in each case.
+-</p>
+-
+-<p><i>[
+-2009-07-24 Alisdair recommends NAD Editorial.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-07-27 Pete adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-It's obviously editorial. There's no need for further discussion.
+-</blockquote>
+-
+-<p><i>[
+-2009-07-27 Howard sets to NAD Editorial.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 20.5.2 [bitset.members] p42-43:
+-</p>
+-
+-<blockquote>
+-<pre>bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
+-</pre>
+-<blockquote>
+--42- <i>Returns:</i> <del>A nonzero value</del> <ins><tt>true</tt></ins> if the value of each bit in
+-<tt>*this</tt> equals the value of the corresponding bit in
+-<tt>rhs</tt>.
+-</blockquote>
+-<pre>bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
+-</pre>
+-<blockquote>
+--43- <i>Returns:</i> <del>A nonzero value</del> <ins><tt>true</tt></ins> if <tt>!(*this == rhs)</tt>.
+-</blockquote>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1172"></a>1172. <tt>select_on_container_(copy|move)_construction</tt> over-constrained</h3>
+-<p><b>Section:</b> X [allocator.concepts.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-07-08 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I believe the two functions
+-<tt>select_on_container_(copy|move)_construction()</tt> are over-constrained. For
+-example, the return value of the "copy" version is (see
+-X [allocator.concepts.members]/21):
+-</p>
+-<blockquote>
+-<i>Returns:</i> <tt>x</tt> if the allocator should propagate from the existing
+-container to the new container on copy construction, otherwise <tt>X()</tt>.
+-</blockquote>
+-<p>
+-Consider the case where a user decides to provide an explicit concept
+-map for Allocator to adapt some legacy allocator class, as he wishes to
+-provide customizations that the <tt>LegacyAllocator</tt> concept map template
+-does not provide. Now, although it's true that the legacy class is
+-required to have a default constructor, the user might have reasons to
+-prefer a different constructor to implement
+-<tt>select_on_container_copy_construction()</tt>. However, the current wording
+-requires the use of the default constructor.
+-</p>
+-<p>
+-Moreover, it's not said explicitly that <tt>x</tt> is supposed to be the
+-allocator of the existing container. A clarification would do no harm.
+-</p>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Editorial. Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Replace X [allocator.concepts.members]/21 with:
+-</p>
+-
+-<blockquote><pre>X select_on_container_copy_construction(const X&amp; x);
+-</pre>
+-<p>
+--21- <i>Returns:</i> <del><tt>x</tt> if the allocator should propagate from the existing
+-container to the new container on copy construction, otherwise <tt>X()</tt>.</del>
+-<ins>an allocator object to be used by the new container on copy
+-construction. [<i>Note:</i> <tt>x</tt> is the allocator of the existing container that
+-is being copied. The most obvious choices for the return value are <tt>x</tt>, if
+-the allocator should propagate from the existing container, and <tt>X()</tt>.
+-<i>— end note</i>]</ins>
+-</p>
+-</blockquote>
+-
+-<p>
+-Replace X [allocator.concepts.members]/25 with:
+-</p>
+-
+-<blockquote><pre>X select_on_container_move_construction(X&amp;&amp; x);
+-</pre>
+-<p>
+--25- <i>Returns:</i> <del><tt>move(x)</tt> if the allocator should propagate from the existing
+-container to the new container on move construction, otherwise <tt>X()</tt>.</del>
+-<ins>an allocator object to be used by the new container on move
+-construction. [<i>Note:</i> <tt>x</tt> is the allocator of the existing container that
+-is being moved. The most obvious choices for the return value are <tt>move(x)</tt>, if
+-the allocator should propagate from the existing container, and <tt>X()</tt>.
+-<i>— end note</i>]</ins>
+-</p>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1173"></a>1173. "Equivalence" wishy-washiness</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-07-14 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Issue: The <tt>CopyConstructible</tt> requirements are wishy-washy. It requires
+-that the copy is "equivalent" to the original, but "equivalent" is never
+-defined.
+-</p>
+-<p>
+-I believe this to be an example of a more general lack of rigor around
+-copy and assignment, although I haven't done the research to dig up all
+-the instances.
+-</p>
+-<p>
+-It's a problem because if you don't know what <tt>CopyConstructible</tt> means,
+-you also don't know what it means to copy a pair of <tt>CopyConstructible</tt>
+-types. It doesn't prevent us from writing code, but it is a hole in our
+-ability to understand the meaning of copy.
+-</p>
+-<p>
+-Furthermore, I'm pretty sure that vector's copy constructor doesn't
+-require the elements to be <tt>EqualityComparable</tt>, so that table is actually
+-referring to some ill-defined notion of equivalence when it uses ==.
+-</p>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to "Open". Dave is right that this is a big issue. Paper D2987
+-("Defining Move Special Member Functions", Bjarne Stroustrup and
+-Lawrence Crowl) touches on this but does not solve it. This issue is
+-discussed in Elements of Programming.
+-</blockquote>
+-
+-
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
+-
+-<blockquote>
+-This issue is quite vague, so it is difficult to know if and when it has been resolved.
+-
+-John Lakos wrote a paper covering this area a while back, and there is a real interest in providing some sort of clean-up in the future.
+-
+-We need a more clearly draughted issues with an addressable set of concerns, ideally with a paper proposing a resolution, but for a future revision of the standard.
+-
+-Move to Tentatively NAD Future.
+-</blockquote>
+-
+-<p><i>[
+-Moved to NAD Future at 2010-11 Batavia
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1176"></a>1176. Make <tt>thread</tt> constructor non-variadic</h3>
+-<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The variadic <tt>thread</tt> constructor is causing controversy, e.g.
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2901.pdf">N2901</a>.
+-This issue has been created as a placeholder for this course of action.
+-</p>
+-
+-<blockquote><pre>template &lt;class F<del>, class ...Args</del>&gt; thread(F&amp;&amp; f<del>, Args&amp;&amp;... args</del>);
+-</pre></blockquote>
+-
+-<p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a> for wording which specifies an rvalue-ref signature but
+-with "decay behavior", but using variadics.
+-</p>
+-
+-<p><i>[
+-2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
+-]</i></p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-The (tentative) concensus of the LWG is to keep the variadic thread constructor.
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1179"></a>1179. Probably editorial in [structure.specifications]</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2009-07-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-While reviewing <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a> I noted that 17.5.1.4 [structure.specifications]/7 says:
+-</p>
+-
+-<blockquote>
+--7- Error conditions specify conditions where a function may fail. The
+-conditions are listed, together with a suitable explanation, as the <tt>enum
+-class errc</tt> constants (19.5) that could be used as an argument to
+-function <tt>make_error_condition</tt> (19.5.3.6).
+-</blockquote>
+-
+-<p>
+-This paragraph should mention <tt>make_error_code</tt> or the text "that
+-could be used as an argument to function <tt>make_error_condition</tt>
+-(19.5.3.6)" should be deleted. I believe this is editorial.
+-</p>
+-
+-<p><i>[
+-2009-07-21 Chris adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I'm not convinced there's a problem there, because as far as the "Error
+-conditions" clauses are concerned, make_error_condition() is used by a
+-user to test for the condition, whereas make_error_code is not. For
+-example:
+-</p>
+-
+-<blockquote><pre>void foobar(error_code&amp; ec = throws());
+-</pre></blockquote>
+-
+-<p>
+- Error conditions:
+-</p>
+-<blockquote>
+-permission_denied - Insufficient privilege to perform operation.
+-</blockquote>
+-
+-<p>
+-When a user writes:
+-</p>
+-
+-<blockquote><pre>error_code ec;
+-foobar(ec);
+-if (ec == errc::permission_denied)
+- ...
+-</pre></blockquote>
+-
+-<p>
+-the implicit conversion <tt>errc-&gt;error_condition</tt> makes the if-test
+-equivalent to:
+-</p>
+-
+-<blockquote><pre>if (ec == make_error_condition(errc::permission_denied))
+-</pre></blockquote>
+-
+-<p>
+-On the other hand, if the user had written:
+-</p>
+-
+-<blockquote><pre>if (ec == make_error_code(errc::permission_denied))
+-</pre></blockquote>
+-
+-<p>
+-the test is now checking for a specific error code. The test may
+-evaluate to <tt>false</tt> even though <tt>foobar()</tt> failed due to the documented
+-error condition "Insufficient privilege".
+-</p>
+-</blockquote>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-NAD Editorial.
+-</p>
+-<p>
+-What the WP says right now is literally true: these codes can be used as
+-an argument to <tt>make_error_condition</tt>. (It is also true that they can be
+-used as an argument to <tt>make_error_code</tt>, which the WP doesn't say.) Maybe
+-it would be clearer to just delete "that could be used as an argument to
+-function <tt>make_error_condition</tt>", since that fact is already implied by
+-other things that we say. We believe that this is editorial.
+-</p>
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1184"></a>1184. Feature request: dynamic bitset</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-29 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Opened at Alisdair's request, steming from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.
+-Alisdair recommends NAD Future.
+-</p>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Future. We want a heap allocated bitset, but we don't have one today and
+-don't have time to add one.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1185"></a>1185. iterator categories and output iterators</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-31 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-(wording relative to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+-pending new working paper)
+-</p>
+-
+-<p>
+-According to p3 24.2 [iterator.requirements], Forward iterators,
+-Bidirectional iterators and Random Access iterators all satisfy the
+-requirements for an Output iterator:
+-</p>
+-
+-<blockquote>
+-XXX iterators satisfy all the requirements of the input and output iterators
+-and can be used whenever either kind is specified ...
+-</blockquote>
+-
+-<p>
+-Meanwhile, p4 goes on to contradict this:
+-</p>
+-
+-<blockquote>
+-Besides its category, a forward, bidirectional, or random access
+-iterator can also be mutable or constant...
+-</blockquote>
+-
+-<blockquote>
+-... Constant iterators do not satisfy the requirements for output iterators
+-</blockquote>
+-
+-<p>
+-The latter seems to be the overriding concern, as the iterator tag
+-hierarchy does not define <tt>forward_iterator_tag</tt> as multiply derived from
+-both <tt>input_iterator_tag</tt> and <tt>output_iterator_tag</tt>.
+-</p>
+-
+-<p>
+-The work on concepts for iterators showed us that output iterator really
+-is fundamentally a second dimension to the iterator categories, rather
+-than part of the linear input -&gt; forward -&gt; bidirectional -&gt;
+-random-access sequence. It would be good to clear up these words to
+-reflect that, and separately list output iterator requirements in the
+-requires clauses for the appropriate algorithms and operations.
+-</p>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1186"></a>1186. Forward list could model a stack</h3>
+-<p><b>Section:</b> 23.5.3 [stack] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Concepts">NAD Concepts</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-31 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Concepts">NAD Concepts</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The library template <tt>forward_list</tt> could easily model the idea of a
+-<tt>stack</tt>, where the operations work on the front of the list rather than
+-the back. However, the standard library <tt>stack</tt> adaptor cannot support
+-this.
+-</p>
+-
+-<p>
+-It would be relatively easy to write a partial specialization for <tt>stack</tt>
+-to support <tt>forward_list</tt>, but that opens the question of which header to
+-place it in. A much better solution would be to add a <tt>concept_map</tt> for
+-the <tt>StackLikeContainer</tt> concept to the <tt>&lt;forward_list&gt;</tt> header and then
+-everything just works, including a user's own further uses in a
+-stack-like context.
+-</p>
+-
+-<p>
+-Therefore while I am submitting the issue now so that it is on record, I
+-<em>strongly recommend</em> we resolve as "NAD Concepts" as any non-concepts
+-based solution will be inferior to the final goal, and the feature is
+-not so compelling it must be supported ahead of the concepts-based
+-library.
+-</p>
+-
+-<p><i>[
+-2009-11-02 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Any non-concepts based solution will be inferior to the final goal, and the
+-feature is not so compelling it must be supported ahead of the concepts-based
+-library.
+-</p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1188"></a>1188. Unordered containers should have a minimum load factor as well as a maximum</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req], 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Unordered associative containers have a notion of a maximum load factor:
+-when the number of elements grows large enough, the containers
+-automatically perform a rehash so that the number of elements per bucket
+-stays below a user-specified bound. This ensures that the hash table's
+-performance characteristics don't change dramatically as the size
+-increases.
+-</p>
+-
+-<p>
+-For similar reasons, Google has found it useful to specify a minimum
+-load factor: when the number of elements shrinks by a large enough, the
+-containers automatically perform a rehash so that the number of elements
+-per bucket stays above a user-specified bound. This is useful for two
+-reasons. First, it prevents wasting a lot of memory when an unordered
+-associative container grows temporarily. Second, it prevents amortized
+-iteration time from being arbitrarily large; consider the case of a hash
+-table with a billion buckets and only one element. (This was discussed
+-even before TR1 was published; it was TR issue 6.13, which the LWG
+-closed as NAD on the grounds that it was a known design feature.
+-However, the LWG did not consider the approach of a minimum load
+-factor.)
+-</p>
+-
+-<p>
+-The only interesting question is when shrinking is allowed. In principle
+-the cleanest solution would be shrinking on erase, just as we grow on
+-insert. However, that would be a usability problem; it would break a
+-number of common idioms involving erase. Instead, Google's hash tables
+-only shrink on insert and rehash.
+-</p>
+-
+-<p>
+-The proposed resolution allows, but does not require, shrinking in
+-rehash, mostly because a postcondition for rehash that involves the
+-minimum load factor would be fairly complicated. (It would probably have
+-to involve a number of special cases and it would probably have to
+-mention yet another parameter, a minimum bucket count.)
+-</p>
+-
+-<p>
+-The current behavior is equivalent to a minimum load factor of 0. If we
+-specify that 0 is the default, this change will have no impact on
+-backward compatibility.
+-</p>
+-
+-
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
+-
+-<blockquote>
+-This seems to a useful extension, but is too late for 0x.
+-
+-Move to Tentatively NAD Future.
+-</blockquote>
+-
+-<p><i>[
+-Moved to NAD Future at 2010-11 Batavia
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add two new rows, and change rehash's postcondition in the unordered
+-associative container requirements table in 23.2.5 [unord.req]:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<caption>Table 87 — Unordered associative container requirements
+-(in addition to container)</caption>
+-
+-<tbody><tr>
+-<th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+-<th>Complexity</th>
+-</tr>
+-<tr>
+-<td><ins>
+-<tt>a.min_load_factor()</tt>
+-</ins></td>
+-<td><ins>
+-<tt>float</tt>
+-</ins></td>
+-<td><ins>
+-Returns a non-negative number that the container attempts to keep the
+-load factor greater than or equal to. The container automatically
+-decreases the number of buckets as necessary to keep the load factor
+-above this number.
+-</ins></td>
+-<td><ins>
+-constant
+-</ins></td>
+-</tr>
+-
+-<tr>
+-<td><ins><tt>a.min_load_factor(z)</tt></ins></td>
+-<td><ins><tt>void</tt></ins></td>
+-<td><ins>Pre: <tt>z</tt> shall be non-negative. Changes the container's minimum
+-load factor, using <tt>z</tt> as a hint. [<i>Footnote:</i> the minimum
+-load factor should be significantly smaller than the maximum.
+-If <tt>z</tt> is too large, the implementation may reduce it to a more sensible value.]
+-</ins></td>
+-<td><ins>
+-constant
+-</ins></td>
+-</tr>
+-<tr>
+-<td><tt>a.rehash(n)</tt></td>
+-<td><tt>void</tt></td>
+-<td>
+-Post: <ins><tt>a.bucket_count() &gt;= n</tt>, and <tt>a.size() &lt;= a.bucket_count()
+-* a.max_load_factor()</tt>. [<i>Footnote:</i> It is intentional that the
+-postcondition does not mention the minimum load factor.
+-This member function is primarily intended for cases where the user knows
+-that the container's size will increase soon, in which case the container's
+-load factor will temporarily fall below <tt>a.min_load_factor()</tt>.]</ins>
+-<del>
+-<tt>a.bucket_cout &gt; a.size() / a.max_load_factor()</tt> and <tt>a.bucket_count()
+-&gt;= n</tt>.
+-</del>
+-</td>
+-<td>
+-Average case linear in <tt>a.size()</tt>, worst case quadratic.
+-</td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-Add a footnote to 23.2.5 [unord.req] p12:
+-</p>
+-
+-<blockquote>
+-<p>
+-The insert members shall not affect the validity of references to
+-container elements, but may invalidate all iterators to the container.
+-The erase members shall invalidate only iterators and references to the
+-erased elements.
+-</p>
+-
+-<blockquote><ins>
+-[A consequence of these requirements is that while insert may change the
+-number of buckets, erase may not. The number of buckets may be reduced
+-on calls to insert or rehash.]
+-</ins></blockquote>
+-</blockquote>
+-
+-<p>
+-Change paragraph 13:
+-</p>
+-
+-<blockquote>
+-The insert members shall not affect the validity of iterators if
+-<del><tt>(N+n) &lt; z * B</tt></del> <ins><tt>zmin * B &lt;= (N+n) &lt;= zmax * B</tt></ins>,
+-where <tt>N</tt> is the number of elements in
+-the container prior to the insert operation, <tt>n</tt> is the number of
+-elements inserted, <tt>B</tt> is the container's bucket count,
+-<ins><tt>zmin</tt> is the container's minimum load factor,</ins>
+-and <tt>z<ins>max</ins></tt> is the container's maximum load factor.
+-</blockquote>
+-
+-<p>
+-Add to the <tt>unordered_map</tt> class synopsis in section 23.7.1 [unord.map],
+-the <tt>unordered_multimap</tt> class synopsis
+-in 23.7.2 [unord.multimap], the <tt>unordered_set</tt> class synopsis in
+-23.7.3 [unord.set], and the <tt>unordered_multiset</tt> class synopsis
+-in 23.7.4 [unord.multiset]:
+-</p>
+-
+-<blockquote><pre><ins>
+-float min_load_factor() const;
+-void min_load_factor(float z);
+-</ins></pre></blockquote>
+-
+-<p>
+-In 23.7.1.1 [unord.map.cnstr], 23.7.2.1 [unord.multimap.cnstr], 23.7.3.1 [unord.set.cnstr], and
+-23.7.4.1 [unord.multiset.cnstr], change:
+-</p>
+-
+-<blockquote>
+-... <tt>max_load_factor()</tt> returns 1.0 <ins>and
+-<tt>min_load_factor()</tt> returns 0</ins>.
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1190"></a>1190. Setting the maximum load factor should return the previous value</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req], 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The unordered associative container requirements table specifies that
+-<tt>a.set_max_load_factor(z)</tt> has return type <tt>void</tt>. However, there is a
+-useful piece of information to return: the previous value. Users who
+-don't need it can always ignore it.
+-</p>
+-
+-
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
+-
+-<blockquote>
+-The benefit seems minor, while breaking with the getter/setter idiom these overloads support.
+-
+-Move to Tentatively NAD.
+-</blockquote>
+-
+-<p><i>[
+-Moved to NAD at 2010-11 Batavia
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In the unordered associative container requirements table, change:
+-</p>
+-
+-<blockquote>
+-<table border="1">
+-<caption>Table 87 — Unordered associative container requirements
+-(in addition to container)</caption>
+-
+-<tbody><tr>
+-<th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+-<th>Complexity</th>
+-</tr>
+-
+-<tr>
+-<td><tt>a.max_load_factor(z)</tt></td>
+-<td><tt><del>void</del> <ins>float</ins></tt></td>
+-<td>Pre: <tt>z</tt> shall be positive. Changes the container's maximum
+-<del>load</del> load factor, using <tt>z</tt> as a hint.
+-<ins>Returns: the previous value of
+-<tt>a.max_load_factor()</tt>.</ins>
+-</td>
+-<td>
+-constant
+-</td>
+-</tr>
+-<tr></tr>
+-</tbody></table>
+-</blockquote>
+-
+-<p>
+-Change the return type of <tt>set_max_load_factor</tt>
+-in the class synopses in 23.7.1 [unord.map], 23.7.2 [unord.multimap], 23.7.3 [unord.set],
+-and 23.7.4 [unord.multiset].
+-</p>
+-
+-<p>
+-If issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a> is also accepted, make the same changes for
+-<tt>min_load_factor</tt>.
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1196"></a>1196. move semantics undefined for priority_queue</h3>
+-<p><b>Section:</b> 23.5.2.1 [priqueue.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-08-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The class template <tt>priority_queue</tt> declares signatures for a move
+-constructor and move assignment operator in its class definition.
+-However, it does not provide a definition (unlike <tt>std::queue</tt>, and
+-proposed resolution for <tt>std::stack</tt>.) Nor does it provide a text clause
+-specifying their behaviour.
+-</p>
+-
+-<p><i>[
+-2009-08-23 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a> provides wording that solves this issue.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark NAD Editorial, solved by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1200"></a>1200. "surprising" <tt>char_traits&lt;T&gt;::int_type</tt> requirements</h3>
+-<p><b>Section:</b> 21.2.2 [char.traits.typedefs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-09-03 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits.typedefs">issues</a> in [char.traits.typedefs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The footnote for <tt>int_type</tt> in 21.2.2 [char.traits.typedefs] says that
+-</p>
+-
+-<blockquote>
+-If <tt>eof()</tt>
+-can be held in <tt>char_type</tt> then some iostreams implementations may give
+-surprising results.
+-</blockquote>
+-
+-<p>
+-This implies that <tt>int_type</tt> should be a superset of
+-<tt>char_type</tt>. However, the requirements for <tt>char16_t</tt> and <tt>char32_t</tt> define
+-<tt>int_type</tt> to be equal to <tt>int_least16_t</tt> and <tt>int_least32_t</tt> respectively.
+-<tt>int_least16_t</tt> is likely to be the same size as <tt>char_16_t</tt>, which may lead
+-to surprising behavior, even if <tt>eof()</tt> is not a valid UTF-16 code unit.
+-The standard should not prescribe surprising behavior, especially
+-without saying what it is (it's apparently not undefined, just
+-surprising). The same applies for 32-bit types.
+-</p>
+-
+-<p>
+-I personally recommend that behavior be undefined if <tt>eof()</tt> is a member
+-of <tt>char_type</tt>, and another type be chosen for <tt>int_type</tt> (my personal
+-favorite has always been a <tt>struct {bool eof; char_type c;}</tt>).
+-Alternatively, the exact results of such a situation should be defined,
+-at least so far that I/O could be conducted on these types as long as
+-the code units remain valid. Note that the argument that no one streams
+-<tt>char16_t</tt> or <tt>char32_t</tt> is not really valid as it would be perfectly
+-reasonable to use a <tt>basic_stringstream</tt> in conjunction with UTF character
+-types.
+-</p>
+-
+-<p><i>[
+-2009-10-28 Ganesh provides two possible resolutions and expresses a preference
+-for the second:
+-]</i></p>
+-
+-
+-<blockquote>
+-<ol>
+-<li>
+-<p>
+-Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+-</p>
+-
+-<blockquote>
+-The member <tt>eof()</tt> shall return <del>an implementation-defined
+-constant that cannot appear as a valid UTF-16 code unit</del>
+-<ins><tt>UINT_LEAST16_MAX</tt> [<i>Note:</i> this value is guaranteed to
+-be a permanently reserved UCS-2 code position if <tt>UINT_LEAST16_MAX ==
+-0xFFFF</tt> and it's not a UCS-2 code position otherwise — <i>end
+-note</i>]</ins>.
+-</blockquote>
+-
+-<p>
+-Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
+-</p>
+-
+-<blockquote>
+-The member <tt>eof()</tt> shall return <del>an implementation-defined constant that
+-cannot appear as a Unicode code point</del>
+-<ins>
+-<tt>UINT_LEAST32_MAX</tt> [<i>Note:</i> this value is guaranteed to be a
+-permanently reserved UCS-4 code position if <tt>UINT_LEAST32_MAX ==
+-0xFFFFFFFF</tt> and it's not a UCS-4 code position otherwise — <i>end
+-note</i>]</ins>.
+-</blockquote>
+-</li>
+-<li>
+-<p>
+-In 21.2.3.2 [char.traits.specializations.char16_t], in the
+-definition of <tt>char_traits&lt;char16_t&gt;</tt> replace the definition of nested
+-typedef <tt>int_type</tt> with:
+-</p>
+-
+-<blockquote><pre>namespace std {
+- template&lt;&gt; struct char_traits&lt;char16_t&gt; {
+- typedef char16_t char_type;
+- typedef <del>uint_least16_t</del> <ins>uint_fast16_t</ins> int_type;
+- ...
+-</pre></blockquote>
+-
+-<p>
+-Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+-</p>
+-
+-<blockquote>
+-The member <tt>eof()</tt> shall return <del>an implementation-defined
+-constant that cannot appear as a valid UTF-16 code unit</del>
+-<ins><tt>UINT_FAST16_MAX</tt> [<i>Note:</i> this value is guaranteed to
+-be a permanently reserved UCS-2 code position if <tt>UINT_FAST16_MAX ==
+-0xFFFF</tt> and it's not a UCS-2 code position otherwise — <i>end
+-note</i>]</ins>.
+-</blockquote>
+-
+-<p>
+-In 21.2.3.3 [char.traits.specializations.char32_t], in the
+-definition of <tt>char_traits&lt;char32_t&gt;</tt> replace the definition of nested
+-typedef <tt>int_type</tt> with:
+-</p>
+-
+-<blockquote><pre>namespace std {
+- template&lt;&gt; struct char_traits&lt;char32_t&gt; {
+- typedef char32_t char_type;
+- typedef <del>uint_least32_t</del> <ins>uint_fast32_t</ins> int_type;
+- ...
+-</pre></blockquote>
+-
+-<p>
+-Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
+-</p>
+-
+-<blockquote>
+-The member <tt>eof()</tt> shall return <del>an implementation-defined constant that
+-cannot appear as a Unicode code point</del>
+-<ins>
+-<tt>UINT_FAST32_MAX</tt> [<i>Note:</i> this value is guaranteed to be a
+-permanently reserved UCS-4 code position if <tt>UINT_FAST32_MAX ==
+-0xFFFFFFFF</tt> and it's not a UCS-4 code position otherwise — <i>end
+-note</i>]</ins>.
+-</blockquote>
+-</li>
+-</ol>
+-</blockquote>
+-
+-
+-<p><i>[
+-2010 Rapperswil:
+-]</i></p>
+-
+-
+-<blockquote>
+-This seems an overspecification, and it is not clear what problem is being solved - these values can be used portably by using the named functions; there is no need for the value itself to be portable.
+-
+-Move to Tentatively NAD.
+-</blockquote>
+-
+-<p><i>[
+-Moved to NAD at 2010-11 Batavia
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1201"></a>1201. Do we always want to unwrap <tt>ref</tt>-wrappers in <tt>make_tuple</tt></h3>
+-<p><b>Section:</b> 20.4.2.4 [tuple.creation], 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Spotting a recent thread on the boost lists regarding collapsing
+-optional representations in <tt>optional&lt;optional&lt;T&gt;&gt;</tt> instances, I wonder if
+-we have some of the same issues with <tt>make_tuple</tt>, and now <tt>make_pair</tt>?
+-</p>
+-
+-<p>
+-Essentially, if my generic code in my own library is handed a
+-<tt>reference_wrapper</tt> by a user, and my library in turn delegates some logic
+-to <tt>make_pair</tt> or <tt>make_tuple</tt>, then I am going to end up with a <tt>pair</tt>/<tt>tuple</tt>
+-holding a real reference rather than the intended reference wrapper.
+-</p>
+-
+-<p>
+-There are two things as a library author I can do at this point:
+-</p>
+-
+-<ol type="i">
+-<li>
+-document my library also has the same reference-wrapper behaviour as
+-<tt>std::make_tuple</tt>
+-</li>
+-<li>
+-roll my own <tt>make_tuple</tt> that does not unwrap rereferences, a lost
+-opportunity to re-use the standard library.
+-</li>
+-</ol>
+-
+-<p>
+-(There may be some metaprogramming approaches my library can use to wrap
+-the <tt>make_tuple</tt> call, but all will be significantly more complex than
+-simply implementing a simplified <tt>make_tuple</tt>.)
+-</p>
+-
+-<p>
+-Now I don't propose we lose this library facility, I think unwrapping
+-references will be the common behaviour. However, we might want to
+-consider adding another overload that does nothing special with
+-<tt>ref</tt>-wrappers. Note that we already have a second overload of <tt>make_tuple</tt>
+-in the library, called <tt>tie</tt>.
+-</p>
+-
+-<p><i>[
+-2009-09-30 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I suggest to change the currently proposed paragraph for
+-<tt>make_simple_pair</tt>
+-</p>
+-
+-<blockquote><pre>template&lt;typename... Types&gt;
+- pair&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_pair(Types&amp;&amp;... t);
+-</pre>
+-<blockquote>
+-<p>
+-<del><i>Type requirements:</i> <tt>sizeof...(Types) == 2</tt>.</del>
+-<ins><i>Remarks:</i> The program shall be ill-formed, if
+-<tt>sizeof...(Types) != 2</tt>.</ins>
+-</p>
+-<p>
+-...
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-or alternatively (but with a slightly different semantic):
+-</p>
+-
+-<blockquote>
+-<blockquote>
+-<i>Remarks:</i> If <tt>sizeof...(Types) != 2</tt>, this function shall not
+-participate in overload resolution.
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-to follow a currently introduced style and because the library does
+-not have yet a specific "<i>Type requirements</i>" element. If such thing
+-would be considered as useful this should be done as a separate
+-issue. Given the increasing complexity of either of these wordings
+-it might be preferable to use the normal two-argument-declaration
+-style again in either of the following ways:
+-</p>
+-
+-<ol type="A">
+-<li>
+-<pre>template&lt;class T1, class T2&gt;
+-pair&lt;typename decay&lt;T1&gt;::type, typename decay&lt;T2&gt;::type&gt;
+-make_simple_pair(T1&amp;&amp; t1, T2&amp;&amp; t2);
+-</pre>
+-</li>
+-<li>
+-<pre>template&lt;class T1, class T2&gt;
+-pair&lt;V1, V2&gt; make_simple_pair(T1&amp;&amp; t1, T2&amp;&amp; t2);
+-</pre>
+-<blockquote>
+-Let <tt>V1</tt> be <tt>typename decay&lt;T1&gt;::type</tt> and <tt>V2</tt> be
+-<tt>typename decay&lt;T2&gt;::type</tt>.
+-</blockquote>
+-</li>
+-</ol>
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-10 post-Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Mark as Tentatively NAD Future.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Does not have sufficient support at this time. May wish to reconsider for a
+-future standard.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add the following function to 20.3.5 [pairs] and signature in
+-appropriate synopses:
+-</p>
+-
+-<blockquote><pre>template&lt;typename... Types&gt;
+- pair&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_pair(Types&amp;&amp;... t);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Type requirements:</i> <tt>sizeof...(Types) == 2</tt>.
+-</p>
+-<p>
+-<i>Returns:</i> <tt>pair&lt;typename decay&lt;Types&gt;::type...&gt;(std::forward&lt;Types&gt;(t)...)</tt>.
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-<p><i>[
+-Draughting note: I chose a variadic representation similar to <tt>make_tuple</tt>
+-rather than naming both types as it is easier to read through the
+-clutter of metaprogramming this way. Given there are exactly two
+-elements, the committee may prefer to draught with two explicit template
+-type parameters instead
+-]</i></p>
+-
+-
+-<p>
+-Add the following function to 20.4.2.4 [tuple.creation] and
+-signature in appropriate synopses:
+-</p>
+-
+-<blockquote><pre>template&lt;typename... Types&gt;
+- tuple&lt;typename decay&lt;Types&gt;::type...&gt; make_simple_tuple(Types&amp;&amp;... t);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Returns:</i> <tt>tuple&lt;typename decay&lt;Types&gt;::type...&gt;(std::forward&lt;Types&gt;(t)...)</tt>.
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1202"></a>1202. <tt>integral_constant</tt> needs a spring clean</h3>
+-<p><b>Section:</b> 20.7.3 [meta.help] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.help">issues</a> in [meta.help].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The specification of <tt>integral_constant</tt> has been inherited
+-essentially unchanged from TR1:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, T v&gt;
+-struct integral_constant {
+- static const T value = v;
+- typedef T value_type;
+- typedef integral_constant&lt;T,v&gt; type;
+-};
+-</pre></blockquote>
+-
+-<p>
+-In light of 0x language changes there are several things we might
+-consider changing, notably the form of specification for value.
+-</p>
+-
+-<p>
+-The current form requires a static data member have storage allocated
+-for it, where we could now implement without this using the new enum
+-syntax:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, T v&gt;
+-struct integral_constant {
+- <b>enum : T { value = v };</b>
+- typedef T value_type;
+- typedef integral_constant type;
+-};
+-</pre></blockquote>
+-
+-<p>
+-The effective difference between these two implementation is:
+-</p>
+-
+-<ol type="i">
+-<li>
+-No requirement to allocate storage for data member (which we hope but do
+-not guarantee compilers strip today)
+-</li>
+-
+-<li>
+-You can no longer take the address of the constant as
+-<tt>&amp;integral_constant&lt;T,v&gt;::value;</tt>
+-</li>
+-</ol>
+-
+-<p>
+-Also note the editorial change to drop the explicit qualification of
+-<tt>integral_constant</tt> in the <tt>typedef type</tt>. This makes it quite clear we
+-mean the current instantiation, and cannot be mistaken for a recursive
+-metaprogram.
+-</p>
+-
+-<p>
+-Even if we don't mandate this implementation, it would be nice to give
+-vendors freedom under QoI to choose their preferred representation.
+-</p>
+-
+-<p>
+-The other side of this issue is if we choose to retain the static
+-constant form. In that case we should go further and insist on
+-<tt>constexpr</tt>, much like we did throughout <tt>numeric_limits</tt>:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, T v&gt;
+-struct integral_constant {
+- static <b>constexpr</b> T value = v;
+- typedef T value_type;
+- typedef integral_constant type;
+-};
+-</pre></blockquote>
+-
+-<p>
+-[Footnote] It turns out <tt>constexpr</tt> is part of the Tentatively Ready
+-resolution for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>. I don't want to interfere with that issue, but
+-would like a new issue to consider if the fixed-base enum implementation
+-should be allowed.
+-</p>
+-
+-<p><i>[
+-2009-09-05 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I think that the suggested resolution is incomplete and
+-may have some possible unwanted side-effects. To understand
+-why, note that <tt>integral_constant</tt> is <em>completely</em> specified
+-by code in 20.7.3 [meta.help]. While this is usually considered
+-as a good thing, let me give a possible user-defined
+-specialization that would break given the suggested changes:
+-</p>
+-
+-<blockquote><pre>enum NodeColor { Red, Black };
+-
+-std::integral_constant&lt;NodeColor, Red&gt; red;
+-</pre></blockquote>
+-
+-<p>
+-The reason why that breaks is due to the fact that
+-current core language rules does only allow integral
+-types as enum-bases, see 7.2 [dcl.enum]/2.
+-</p>
+-
+-<p>
+-So, I think that we cannot leave the implementation the
+-freedom to decide which way they would like to provide
+-the implementation, because that is easily user-visible
+-(I don't speak of addresses, but of instantiation errors),
+-therefore if applied, this should be either specified or
+-wording must be added that gives a note about this
+-freedom of implementation.
+-</p>
+-
+-<p>
+-Another possible disadvantage seems to me that user-expectations
+-are easy to disappoint if they see a failure
+-of the test
+-</p>
+-
+-<blockquote><pre>assert(typeid(std::integral_constant&lt;int, 0&gt;::value) == typeid(int));
+-</pre></blockquote>
+-
+-<p>
+-or of
+-</p>
+-
+-<blockquote><pre>static_assert(std::is_same&lt;decltype(std::integral_constant&lt;int, 0&gt;::value), const int&gt;::value, "Bad library");
+-</pre></blockquote>
+-
+-</blockquote>
+-
+-<p><i>[
+-2010-01-14 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-We think that the suggested resolution is incomplete and may have some possible
+-unwanted side-effects. (see Daniel's 2009-09-05 comment for details).
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1203"></a>1203. More useful rvalue stream insertion</h3>
+-<p><b>Section:</b> 27.7.2.9 [ostream.rvalue], 27.7.1.6 [istream.rvalue] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-06 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-27.7.2.9 [ostream.rvalue] was created to preserve the ability to insert
+-into (and extract from 27.7.1.6 [istream.rvalue]) rvalue streams:
+-</p>
+-
+-<blockquote><pre>template &lt;class charT, class traits, class T&gt;
+- basic_ostream&lt;charT, traits&gt;&amp;
+- operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;&amp; os, const T&amp; x);
+-</pre>
+-<blockquote>
+-<p>
+-1 <i>Effects:</i> <tt>os &lt;&lt; x</tt>
+-</p>
+-<p>
+-2 <i>Returns:</i> <tt>os</tt>
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-This is good as it allows code that wants to (for example) open, write to, and
+-close an <tt>ofstream</tt> all in one statement:
+-</p>
+-
+-<blockquote><pre>std::ofstream("log file") &lt;&lt; "Some message\n";
+-</pre></blockquote>
+-
+-<p>
+-However, I think we can easily make this "rvalue stream helper" even easier to
+-use. Consider trying to quickly create a formatted string. With the current
+-spec you have to write:
+-</p>
+-
+-<blockquote><pre>std::string s = static_cast&lt;std::ostringstream&amp;&gt;(std::ostringstream() &lt;&lt; "i = " &lt;&lt; i).str();
+-</pre></blockquote>
+-
+-<p>
+-This will store "<tt>i = 10</tt>" (for example) in the string <tt>s</tt>. Note
+-the need to cast the stream back to <tt>ostringstream&amp;</tt> prior to using
+-the member <tt>.str()</tt>. This is necessary because the inserter has cast
+-the <tt>ostringstream</tt> down to a more generic <tt>ostream</tt> during the
+-insertion process.
+-</p>
+-
+-<p>
+-I believe we can re-specify the rvalue-inserter so that this cast is unnecessary.
+-Thus our customer now has to only type:
+-</p>
+-
+-<blockquote><pre>std::string s = (std::ostringstream() &lt;&lt; "i = " &lt;&lt; i).str();
+-</pre></blockquote>
+-
+-<p>
+-This is accomplished by having the rvalue stream inserter return an rvalue of
+-the same type, instead of casting it down to the base class. This is done by
+-making the stream generic, and constraining it to be an rvalue of a type derived
+-from <tt>ios_base</tt>.
+-</p>
+-
+-<p>
+-The same argument and solution also applies to the inserter. This code has been
+-implemented and tested.
+-</p>
+-
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Future. No concensus for change.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 27.7.1.6 [istream.rvalue]:
+-</p>
+-
+-<blockquote><pre>template &lt;class <del>charT, class traits</del> <ins>Istream</ins>, class T&gt;
+- <del>basic_istream&lt;charT, traits&gt;&amp;</del> <ins>Istream&amp;&amp;</ins>
+- operator&gt;&gt;(<del>basic_istream&lt;charT, traits&gt;</del> <ins>Istream</ins>&amp;&amp; is, T&amp; x);
+-</pre>
+-<blockquote>
+-<p>
+-1 <i>Effects:</i> <tt>is &gt;&gt; x</tt>
+-</p>
+-<p>
+-2 <i>Returns:</i> <tt><ins>std::move(</ins>is<ins>)</ins></tt>
+-</p>
+-<p><ins>
+-3 <i>Remarks:</i> This signature shall participate in overload resolution if
+-and only if <tt>Istream</tt> is not an lvalue reference type and is derived from
+-<tt>ios_base</tt>.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-Change 27.7.2.9 [ostream.rvalue]:
+-</p>
+-
+-<blockquote><pre>template &lt;class <del>charT, class traits</del> <ins>Ostream</ins>, class T&gt;
+- <del>basic_ostream&lt;charT, traits&gt;&amp;</del> <ins>Ostream&amp;&amp;</ins>
+- operator&lt;&lt;(<del>basic_ostream&lt;charT, traits&gt;</del> <ins>Ostream</ins>&amp;&amp; os, const T&amp; x);
+-</pre>
+-<blockquote>
+-<p>
+-1 <i>Effects:</i> <tt>os &lt;&lt; x</tt>
+-</p>
+-<p>
+-2 <i>Returns:</i> <tt><ins>std::move(</ins>os<ins>)</ins></tt>
+-</p>
+-<p><ins>
+-3 <i>Remarks:</i> This signature shall participate in overload resolution if
+-and only if <tt>Ostream</tt> is not an lvalue reference type and is derived from
+-<tt>ios_base</tt>.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1210"></a>1210. iterator reachability should not require a container</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-p6 Iterator requirements 24.2 [iterator.requirements]
+-</p>
+-
+-<blockquote>
+-An iterator <tt>j</tt> is called reachable from an iterator <tt>i</tt> if and only if
+-there is a finite sequence of applications of the expression <tt>++i</tt> that
+-makes <tt>i == j</tt>. If <tt>j</tt> is reachable from <tt>i</tt>, they refer to the same
+-container.
+-</blockquote>
+-
+-<p>
+-A good example would be stream iterators, which do not refer to a
+-container. Typically, the end iterator from a range of stream iterators
+-will compare equal for many such ranges. I suggest striking the second
+-sentence.
+-</p>
+-
+-<p>
+-An alternative wording might be:
+-</p>
+-
+-<blockquote>
+-If <tt>j</tt> is reachable from <tt>i</tt>, and both <tt>i</tt> and
+-<tt>j</tt> are dereferencable iterators, then they refer to the same
+-range.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 24.2 [iterator.requirements], p6:
+-</p>
+-
+-<blockquote>
+-An iterator <tt>j</tt> is called <i>reachable</i> from an iterator
+-<tt>i</tt> if and only if there is a finite sequence of applications of
+-the expression <tt>++i</tt> that makes <tt>i == j</tt>. <del>If
+-<tt>j</tt> is reachable from <tt>i</tt>, they refer to the same
+-container.</del>
+-</blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1211"></a>1211. move iterators should be restricted as input iterators</h3>
+-<p><b>Section:</b> 24.5.3.1 [move.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#move.iterator">issues</a> in [move.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I contend that while we can support both bidirectional and random access
+-traversal, the category of a move iterator should never be better than
+-<tt>input_iterator_tag</tt>.
+-</p>
+-
+-<p>
+-The contentious point is that you cannot truly have a multipass property
+-when values are moved from a range. This is contentious if you view a
+-moved-from object as still holding a valid value within the range.
+-</p>
+-
+-<p>
+-The second reason comes from the Forward Iterator requirements table:
+-</p>
+-
+-<blockquote>
+-<p>
+-Forward iterators 24.2.5 [forward.iterators]
+-</p>
+-
+-<p>
+-Table 102 -- Forward iterator requirements
+-</p>
+-
+-<blockquote>
+-For expression <tt>*a</tt> the return type is:
+-"<tt>T&amp;</tt> if <tt>X</tt> is mutable, otherwise <tt>const T&amp;</tt>"
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-There is a similar constraint on <tt>a-&gt;m</tt>.
+-</p>
+-
+-<p>
+-There is no support for rvalue references, nor do I believe their should
+-be. Again, opinions may vary but either this table or the definition of
+-<tt>move_iterator</tt> need updating.
+-</p>
+-
+-<p>
+-Note: this requirement probably need updating anyway if we wish to
+-support proxy iterators but I am waiting to see a new working paper
+-before filing that issue.
+-</p>
+-
+-<p><i>[
+-2009-10 post-Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Move to Open. Howard to put his rationale mentioned above into the issue
+-as a note.
+-</blockquote>
+-
+-<p><i>[
+-2009-10-26 Howard adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-<tt>vector::insert(pos, iter, iter)</tt> is significantly more effcient when
+-<tt>iter</tt> is a random access iterator, as compared to when it is an
+-input iterator.
+-</p>
+-
+-<p>
+-When <tt>iter</tt> is an input iterator, the best algorithm
+-is to append the inserted range to the end of the <tt>vector</tt> using
+-<tt>push_back</tt>. This may involve several reallocations before the input
+-range is exhausted. After the append, then one can use <tt>std::rotate</tt>
+-to place the inserted range into the correct position in the vector.
+-</p>
+-
+-<p>
+-But when <tt>iter</tt> is a random access iterator, the best algorithm
+-is to first compute the size of the range to be inserted (<tt>last - first</tt>),
+-do a buffer reallocation if necessary, scoot existing elements in the <tt>vector</tt>
+-down to make the "hole", and then insert the new elements directly to their correct
+-place.
+-</p>
+-
+-<blockquote><b>
+-The insert-with-random-access-iterators algorithm is considerably more efficient
+-than the insert-with-input-iterators algorithm
+-</b></blockquote>
+-
+-<p>
+-Now consider:
+-</p>
+-
+-<blockquote><pre>vector&lt;A&gt; v;
+-<font color="#C80000">// ... build up a large vector of A ...</font>
+-vector&lt;A&gt; temp;
+-<font color="#C80000">// ... build up a large temporary vector of A to later be inserted ...</font>
+-typedef move_iterator&lt;vector&lt;A&gt;::iterator&gt; MI;
+-<font color="#C80000">// Now insert the temporary elements:</font>
+-v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));
+-</pre></blockquote>
+-
+-<p>
+-A major motivation for using <tt>move_iterator</tt> in the above example is the
+-expectation that <tt>A</tt> is cheap to move but expensive to copy. I.e. the
+-customer is looking for <em>high performance</em>. If we allow <tt>vector::insert</tt>
+-to subtract two <tt>MI</tt>'s to get the distance between them, the customer enjoys
+-substantially better performance, compared to if we say that <tt>vector::insert</tt>
+-can not subtract two <tt>MI</tt>'s.
+-</p>
+-
+-<p>
+-I can find no rationale for not giving this performance boost to our customers.
+-Therefore I am strongly against restricting <tt>move_iterator</tt> to the
+-<tt>input_iterator_tag</tt> category.
+-</p>
+-
+-<p>
+-I believe that the requirement that forward
+-iterators have a dereference that returns an lvalue reference to cause unacceptable
+-pessimization. For example <tt>vector&lt;bool&gt;::iterator</tt> also does not return
+-a <tt>bool&amp;</tt> on dereference. Yet I am not aware of a single vendor that
+-is willing to ship <tt>vector&lt;bool&gt;::iterator</tt> as an input iterator.
+-Everyone classifies it as a random access iterator. Not only does this not
+-cause any problems, it prevents significant performance problems.
+-</p>
+-
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Class template move_iterator 24.5.3.1 [move.iterator]
+-</p>
+-
+-<blockquote><pre>namespace std {
+-template &lt;class Iterator&gt;
+-class move_iterator {
+-public:
+- ...
+- typedef <del>typename iterator_traits&lt;Iterator&gt;::iterator_category</del> <ins>input_iterator_tag</ins> iterator_category;
+-</pre></blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1212"></a>1212. result of post-increment/decrement operator</h3>
+-<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Forward iterator and bidirectional iterator place different requirements on the result of post-increment/decrement operator. The same form should be used in each case.
+-</p>
+-
+-<p>
+-Merging row from:
+-</p>
+-
+-<blockquote><pre>Table 102 -- Forward iterator requirements
+-Table 103 -- Bidirectional iterator requirements
+-
+- r++ : convertible to const X&amp;
+- r-- : convertible to const X&amp;
+-
+- *r++ : T&amp; if X is mutable, otherwise const T&amp;
+- *r-- : convertible to T
+-</pre></blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1217"></a>1217. Quaternion support</h3>
+-<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Ted Shaneyfelt <b>Opened:</b> 2009-09-26 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Concerning mathematically proper operation of the type:
+-</p>
+-
+-<blockquote><pre>complex&lt;complex&lt;T&gt; &gt;
+-</pre></blockquote>
+-
+-<p>
+-Generally accepted mathematical semantics of such a construct correspond
+-to quaternions through Cayly-Dickson construct
+-</p>
+-
+-<blockquote><pre>(w+xi) + (y+zi) j
+-</pre></blockquote>
+-
+-<p>
+-The proper implementation seems straightforward by adding a few
+-declarations like those below. I have included operator definition for
+-combining real scalars and complex types, as well, which seems
+-appropriate, as algebra of complex numbers allows mixing complex and
+-real numbers with operators. It also allows for constructs such as
+-<tt>complex&lt;double&gt; i=(0,1), x = 12.34 + 5*i;</tt>
+-</p>
+-
+-<p>
+-Quaternions are often used in areas such as computer graphics, where,
+-for example, they avoid the problem of Gimbal lock when rotating objects
+-in 3D space, and can be more efficient than matrix multiplications,
+-although I am applying them to a different field.
+-</p>
+-
+-<pre>/////////////////////////ALLOW OPERATORS TO COMBINE REAL SCALARS AND COMPLEX VALUES /////////////////////////
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt; x,const S a) {
+- complex&lt;T&gt; result(x.real()+a, x.imag());
+- return result;
+-}
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator+(const S a,const complex&lt;T&gt; x) {
+- complex&lt;T&gt; result(a+x.real(), x.imag());
+- return result;
+-}
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt; x,const S a) {
+- complex&lt;T&gt; result(x.real()-a, x.imag());
+- return result;
+-}
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator-(const S a,const complex&lt;T&gt; x) {
+- complex&lt;T&gt; result(a-x.real(), x.imag());
+- return result;
+-}
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt; x,const S a) {
+- complex&lt;T&gt; result(x.real()*a, x.imag()*a);
+- return result;
+-}
+-template&lt;typename T,typename S&gt; complex&lt;T&gt; operator*(const S a,const complex&lt;T&gt; x) {
+- complex&lt;T&gt; result(a*x.real(), a*x.imag());
+- return result;
+-}
+-
+-/////////////////////////PROPERLY IMPLEMENT QUATERNION SEMANTICS/////////////////////////
+-template&lt;typename T&gt; double normSq(const complex&lt;complex&lt;T&gt; &gt;q) {
+- return q.real().real()*q.real().real()
+- + q.real().imag()*q.real().imag()
+- + q.imag().real()*q.imag().real()
+- + q.imag().imag()*q.imag().imag();
+-}
+-template&lt;typename T&gt; double norm(const complex&lt;complex&lt;T&gt; &gt;q) {
+- return sqrt(normSq(q));
+-}
+-/////// Cayley-Dickson Construction
+-template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; conj(const complex&lt;complex&lt;T&gt; &gt; x) {
+- complex&lt;complex&lt;T&gt; &gt; result(conj(x.real()),-x.imag());
+- return result;
+-}
+-template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator*(const complex&lt;complex&lt;T&gt; &gt; ab,const complex&lt;complex&lt;T&gt; &gt; cd) {
+- complex&lt;T&gt; re(ab.real()*cd.real()-conj(cd.imag())*ab.imag());
+- complex&lt;T&gt; im(cd.imag()*ab.real()+ab.imag()*conj(cd.real()));
+- complex&lt;complex&lt;double&gt; &gt; q(re,im);
+- return q;
+-}
+-//// Quaternion division
+-template&lt;typename S,typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const complex&lt;complex&lt;T&gt; &gt; q,const S a) {
+- return q * (1/a);
+-}
+-template&lt;typename S,typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const S a,const complex&lt;complex&lt;T&gt; &gt; q) {
+- return a*conj(q)/normSq(q);
+-}
+-template&lt;typename T&gt; complex&lt;complex&lt;T&gt; &gt; operator/(const complex&lt;complex&lt;T&gt; &gt; n, const complex&lt;complex&lt;T&gt; &gt; d) {
+- return n * (conj(d)/normSq(d));
+-}
+-</pre>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD Future. There is no consensus or time to move this into C++0X.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1219"></a>1219. unique_lock::lock and resource_deadlock_would_occur</h3>
+-<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a></p>
+-<p><b>Discussion:</b></p>
+-
+-
+-
+-<p>
+-<tt>unique_lock::lock</tt> and friends raise
+-"<tt>resource_deadlock_would_occur</tt> -- if the current thread already
+-owns the mutex (i.e., on entry, <tt>owns</tt> is <tt>true</tt>)." 1)
+-The current thread owning a mutex is not the same as any particular
+-<tt>unique_lock::owns</tt> being <tt>true</tt>. 2) There's no need to
+-raise this exception for a <tt>recursive_mutex</tt> if <tt>owns</tt> is
+-<tt>false</tt>. 3) If <tt>owns</tt> is true, we need to raise some
+-exception or the unique_lock will lose track of whether to unlock itself
+-on destruction, but "deadlock" isn't it. For (3), s/bool owns/int
+-ownership_level/ would fix it.
+-</p>
+-
+-<p><i>[
+-2009-11-11 Alisdair notes that this issue is very closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>,
+-if not a dup.
+-]</i></p>
+-
+-
+-<p><i>[
+-2009-11-14 Moved to Tentatively Dup after 5 positive votes on c++std-lib.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1223"></a>1223. condition_variable_any lock matching?</h3>
+-<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-For <tt>condition_variable_any</tt>, must all lock arguments to concurrent wait calls
+-"match" in some way, similar to the requirement in
+-30.5.1 [thread.condition.condvar] that <tt>lock.mutex()</tt> returns the same
+-value for each of the lock arguments supplied by all concurrently
+-waiting threads (via <tt>wait</tt> or <tt>timed_wait</tt>)?
+-</p>
+-
+-<p><i>[
+-2010-02-12 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-The rationale is that it doesn't matter, and you can't check: the lock types may
+-be different, or the same and user-defined, so the implementation must provide
+-internal synchronization anyway.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1224"></a>1224. condition_variable_any support for recursive mutexes?</h3>
+-<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-For <tt>condition_variable_any</tt>, are recursive mutexes allowed? (I think "no")
+-</p>
+-
+-<p><i>[
+-2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
+-]</i></p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-<tt>condition_variable_any::wait</tt> accepts any type of mutex. It calls
+-<tt>unlock</tt> precisely once on entry and <tt>lock</tt> precisely once on
+-exit. It is up to the user to ensure that this provides the required
+-synchronization. Use of a recursive mutex is safe if either its lock count is 1,
+-so after the single unlock it can be acquired by another thread, or another
+-mechanism is used to synchronize the data.
+-</p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1225"></a>1225. C++0x result_of issue </h3>
+-<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Sebastian Gesemann <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.ret">issues</a> in [func.ret].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-I think the text about <tt>std::result_of</tt> could be a little more precise.
+-Quoting from
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>...
+-</p>
+-
+-<blockquote>
+-<p>
+-X [func.ret] Function object return types
+-</p>
+-
+-<pre>template&lt;class&gt; class result_of;
+-
+-template&lt;class Fn, class... ArgTypes&gt;
+-class result_of&lt;Fn(ArgTypes...)&gt; {
+-public:
+- typedef <i>see below</i> type;
+-};
+-</pre>
+-
+-<p>
+-Given an rvalue <tt>fn</tt> of type <tt>Fn</tt> and values <tt>t1, t2,
+-..., tN</tt> of types <tt>T1, T2, ... TN</tt> in <tt>ArgTypes</tt>
+-respectivly, the <tt>type</tt> member is the result type of the
+-expression <tt>fn(t1,t2,...,tN)</tt>. the values <tt>ti</tt> are lvalues
+-when the corresponding type <tt>Ti</tt> is an lvalue-reference type, and
+-rvalues otherwise.
+-</p>
+-</blockquote>
+-
+-<p>
+-This text doesn't seem to consider lvalue reference types for <tt>Fn</tt>.
+-Also, it's not clear whether this class template can be used for
+-"SFINAE" like <tt>std::enable_if</tt>. Example:
+-</p>
+-
+-<blockquote><pre>template&lt;typename Fn, typename... Args&gt;
+-typename std::result_of&lt;Fn(Args...)&gt;::type
+-apply(Fn &amp;&amp; fn, Args &amp;&amp; ...args)
+-{
+- // Fn may be an lvalue reference, too
+- return std::forward&lt;Fn&gt;(fn)(std::forward&lt;Args&gt;(args)...);
+-}
+-</pre></blockquote>
+-
+-<p>
+-Either <tt>std::result_of&lt;...&gt;</tt> can be instantiated and simply may not have
+-a typedef "<tt>type</tt>" (--&gt;SFINAE) or instantiating the class template for
+-some type combinations will be a "hard" compile-time error.
+-</p>
+-
+-<p><i>[
+-2010-02-14 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-This issue should be considered resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>. The wish to change <tt>result_of</tt> into a compiler-support
+-trait was beyond the actual intention of the submitter Sebastian.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial, rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p><i>[
+-These changes will require compiler support
+-]</i></p>
+-
+-
+-<p>
+-Change X [func.ret]:
+-</p>
+-
+-<blockquote><pre>template&lt;class&gt; class result_of; // <i>undefined</i>
+-
+-template&lt;class Fn, class... ArgTypes&gt;
+-class result_of&lt;Fn(ArgTypes...)&gt; {
+-public:
+- <del>typedef</del> <i>see below</i> <del>type;</del>
+-};
+-</pre>
+-
+-<p><del>
+-Given an rvalue <tt>fn</tt> of type <tt>Fn</tt> and values <tt>t1, t2,
+-..., tN</tt> of types <tt>T1, T2, ... TN</tt> in <tt>ArgTypes</tt>
+-respectivly, the <tt>type</tt> member is the result type of the
+-expression <tt>fn(t1,t2,...,tN)</tt>. the values <tt>ti</tt> are lvalues
+-when the corresponding type <tt>Ti</tt> is an lvalue-reference type, and
+-rvalues otherwise.
+-</del></p>
+-
+-<p>
+-<ins>The class template <tt>result_of</tt> shall meet the requirements of a
+-<i>TransformationTrait</i>: Given the types <tt>Fn</tt>, <tt>T1</tt>, <tt>T2</tt>, ..., <tt>TN</tt> every
+-template specialization <tt>result_of&lt;Fn(T1,T2,...,TN)&gt;</tt> shall define the
+-member typedef type equivalent to <tt>decltype(<i>RE</i>)</tt> if and only if
+-the expression <tt><i>RE</i></tt>
+-</ins></p>
+-
+-<blockquote><pre><ins>
+-value&lt;Fn&gt;() ( value&lt;T1&gt;(), value&lt;T2&gt;(), ... value&lt;TN&gt;() )
+-</ins></pre></blockquote>
+-
+-<p><ins>
+-would be well-formed. Otherwise, there shall be no member typedef
+-<tt>type</tt> defined.
+-</ins></p>
+-
+-</blockquote>
+-
+-<p><i>[
+-The <tt>value&lt;&gt;</tt> helper function is a utility Daniel Krügler
+-proposed in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html">N2958</a>.
+-]</i></p>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1226"></a>1226. Incomplete changes of #890</h3>
+-<p><b>Section:</b> 30.6.2 [futures.errors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Defect issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a> overlooked to adapt the <tt>future_category</tt> from
+-30.6.1 [futures.overview] and 30.6.2 [futures.errors]:
+-</p>
+-
+-<blockquote><pre>extern const error_category* const future_category;
+-</pre></blockquote>
+-
+-<p>
+-which should be similarly transformed into function form.
+-</p>
+-
+-<p><i>[
+-2009-10-27 Howard:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+-<p><i>[
+-2009-11-11 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-I just observe that the proposed resolution of this issue
+-is incomplete and needs to reworded. The problem is that the
+-corresponding declarations
+-</p>
+-
+-<blockquote><pre>constexpr error_code make_error_code(future_errc e);
+-constexpr error_condition make_error_condition(future_errc e);
+-</pre></blockquote>
+-
+-<p>
+-as constexpr functions are incompatible to the requirements of constexpr
+-functions given their specified implementation. Note that the incompatibility
+-is <em>not</em> a result of the modifications proposed by the issue resolution,
+-but already existed within the
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
+-state where we have
+-</p>
+-
+-<blockquote><pre>extern const error_category* const future_category;
+-</pre></blockquote>
+-
+-<p>
+-combined with
+-</p>
+-
+-<blockquote><pre>constexpr error_code make_error_code(future_errc e);
+-</pre>
+-<blockquote>
+-3 <i>Returns:</i> <tt>error_code(static_cast&lt;int&gt;(e), *future_category)</tt>.
+-</blockquote>
+-
+-<pre>constexpr error_code make_error_condition(future_errc e);
+-</pre>
+-<blockquote>
+-4 <i>Returns:</i> <tt>error_condition(static_cast&lt;int&gt;(e), *future_category)</tt>.
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-Neither is any of the constructors of <tt>error_code</tt> and <tt>error_condition</tt>
+-constexpr, nor does the expression <tt>*future_category</tt> satisfy the
+-requirements for a constant expression (5.19 [expr.const]/2 bullet 6 in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>).
+-</p>
+-
+-<p>
+-The simple solution is just to remove the constexpr qualifiers for both
+-functions, which makes sense, because none of the remaining <tt>make_error_*</tt>
+-overloads in the library is constexpr. One might consider to realize that
+-those <tt>make_*</tt> functions could satisfy the constexpr requirements, but this
+-looks not like an easy task to me, because it would need to rely on a not
+-yet existing language feature. If such a change is wanted, a new issue
+-should be opened after the language extension approval (if at all) [1].
+-</p>
+-
+-<p>
+-If no-one complaints I would like to ask Howard to add the following
+-modifications to this issue, alternatively a new issue could be opened but I
+-don't know what the best solution is that would cause as little overhead
+-as possible.
+-</p>
+-<p>
+-What-ever the route is, the following is my proposed resolution for this issue
+-interaction part of the story:
+-</p>
+-
+-<blockquote>
+-<p>
+-In 30.6.1 [futures.overview]/1, Header <tt>&lt;future&gt;</tt> synopsis <em>and</em>
+-in 30.6.2 [futures.errors]/3+4
+-change as indicated:
+-</p>
+-
+-<blockquote><pre><del>constexpr</del> error_code make_error_code(future_errc e);
+-<del>constexpr</del> error_condition make_error_condition(future_errc e);
+-</pre></blockquote>
+-</blockquote>
+-
+-<p>
+-[1] Let me add that we have a related NAD issue here: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>
+-so the chances for realization are little IMO.
+-</p>
+-
+-<p><i>[
+-Howard: I've updated the proposed wording as Daniel suggests and set to Review.
+-]</i></p>
+-
+-</blockquote>
+-
+-<p><i>[
+-2009-11-13 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-]</i></p>
+-
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by N3058.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Change in 30.6.1 [futures.overview], header <tt>&lt;future&gt;</tt> synopsis:
+-</p>
+-
+-<blockquote><pre><del>extern</del> const error_category<ins>&amp;</ins><del>* const</del> future_category<ins>()</ins>;
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-In 30.6.1 [futures.overview]/1, Header <tt>&lt;future&gt;</tt> synopsis
+-change as indicated:
+-</p>
+-
+-<blockquote><pre><del>constexpr</del> error_code make_error_code(future_errc e);
+-<del>constexpr</del> error_condition make_error_condition(future_errc e);
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change in 30.6.2 [futures.errors]:
+-</p>
+-
+-<blockquote><pre><del>extern</del> const error_category<ins>&amp;</ins><del>* const</del> future_category<ins>()</ins>;
+-</pre>
+-
+-<blockquote>
+-<p>
+-<del>1- <tt>future_category</tt> shall point to a statically initialized object
+-of a type derived from class <tt>error_category</tt>.</del>
+-</p>
+-<p>
+-<ins>1- <i>Returns:</i> A reference to an object of a type
+-derived from class <tt>error_category</tt>.</ins>
+-</p>
+-</blockquote>
+-
+-<pre><del>constexpr</del> error_code make_error_code(future_errc e);
+-</pre>
+-
+-<blockquote>
+-3 <i>Returns:</i> <tt>error_code(static_cast&lt;int&gt;(e),
+-<del>*</del>future_category<ins>()</ins>)</tt>.
+-</blockquote>
+-
+-<pre><del>constexpr</del> error_<del>code</del><ins>condition</ins> make_error_condition(future_errc e);
+-</pre>
+-
+-<blockquote>
+-4 <i>Returns:</i> <tt>error_condition(static_cast&lt;int&gt;(e),
+-<del>*</del>future_category<ins>()</ins>)</tt>.
+-</blockquote>
+-</blockquote>
+-</li>
+-</ol>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1228"></a>1228. User-specialized nothrow type traits</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-According to p1 20.7.2 [meta.type.synop]:
+-</p>
+-
+-<blockquote>
+-The behavior of a program that adds specializations for any of the class
+-templates defined in this subclause is undefined unless otherwise
+-specified.
+-</blockquote>
+-
+-<p>
+-I believe we should 'otherwise specify' for the nothrow traits, are
+-these are exactly the use cases where the end user actually has more
+-information than the compiler.
+-</p>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Moved to Open. Definitely need to give the users the ability to ensure
+-that the traits give the right answers. Unsure we want to give them the
+-ability to say this in more than one way. Believes the noexcept proposal
+-already gives this.
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD, rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-We believe the solution offered by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html">N3050</a>
+-is superior.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add the following comment:
+-</p>
+-
+-<blockquote>
+-user specialization permitted to derive from <tt>std::true_type</tt> when the
+-operation is known not to throw.
+-</blockquote>
+-
+-<p>
+-to the following traits in 20.7.4.3 [meta.unary.prop] Table 43 Type
+-property predicates.
+-</p>
+-
+-<p><i>[
+-This may require a new Comments column
+-]</i></p>
+-
+-
+-<blockquote><pre>has_nothrow_default_constructor
+-has_nothrow_copy_constructor
+-has_nothrow_assign
+-</pre></blockquote>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1229"></a>1229. <tt>error_code operator=</tt> typo</h3>
+-<p><b>Section:</b> 19.5.2.3 [syserr.errcode.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-10-08 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
+-19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers] say:
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorCodeEnum&gt;
+- typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value&gt;::type&amp;
+- operator=(ErrorCodeEnum e);
+-</pre></blockquote>
+-
+-<p>
+-They should say:
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorCodeEnum&gt;
+- typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value, error_code&gt;::type&amp;
+- operator=(ErrorCodeEnum e);
+-</pre></blockquote>
+-
+-<p>
+-Or (I prefer this form):
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorCodeEnum&gt;
+- typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value, error_code&amp;&gt;::type
+- operator=(ErrorCodeEnum e);
+-</pre></blockquote>
+-
+-<p>
+-This is because <tt>enable_if</tt> is declared as (20.7.7.6 [meta.trans.other]):
+-</p>
+-
+-<blockquote><pre>
+-template &lt;bool B, class T = void&gt; struct enable_if;
+-</pre></blockquote>
+-
+-<p>
+-So, the current wording makes <tt>operator=</tt> return
+-<tt>void&amp;</tt>, which is not good.
+-</p>
+-
+-<p>
+-19.5.2.3 [syserr.errcode.modifiers]/4 says
+-</p>
+-
+-<blockquote>
+-<i>Returns:</i> <tt>*this</tt>.
+-</blockquote>
+-<p>
+-which is correct.
+-</p>
+-
+-<p>
+-Additionally,
+-</p>
+-
+-<p>
+-19.5.3.1 [syserr.errcondition.overview]/1 says:
+-</p>
+-
+-<blockquote><pre>
+-template&lt;typename ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;, error_code&gt;::type &amp;
+- operator=( ErrorConditionEnum e );
+-</pre></blockquote>
+-
+-<p>
+-Which contains several problems (<tt>typename</tt> versus <tt>class</tt>
+-inconsistency, lack of <tt>::value</tt>, <tt>error_code</tt> instead of
+-<tt>error_condition</tt>), while 19.5.3.3 [syserr.errcondition.modifiers] says:
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value&gt;::type&amp;
+- operator=(ErrorConditionEnum e);
+-</pre></blockquote>
+-
+-<p>
+-Which returns <tt>void&amp;</tt>. They should both say:
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value, error_condition&gt;::type&amp;
+- operator=(ErrorConditionEnum e);
+-</pre></blockquote>
+-
+-<p>
+-Or (again, I prefer this form):
+-</p>
+-
+-<blockquote><pre>
+-template &lt;class ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value, error_condition&amp;&gt;::type
+- operator=(ErrorConditionEnum e);
+-</pre></blockquote>
+-
+-<p>
+-Additionally, 19.5.3.3 [syserr.errcondition.modifiers] lacks a
+-"<i>Returns:</i> <tt>*this</tt>." paragraph, which is presumably
+-necessary.
+-</p>
+-
+-<p><i>[
+-2009-10-18 Beman adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-The proposed resolution for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a> makes this issue
+-moot, so it should become NAD.
+-</blockquote>
+-
+-<p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-NAD, solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-<p>
+-Change 19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers]:
+-</p>
+-
+-<blockquote><pre>template &lt;class ErrorCodeEnum&gt;
+- typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value<ins>, error_code&amp;</ins>&gt;::type<del>&amp;</del>
+- operator=(ErrorCodeEnum e);
+-</pre></blockquote>
+-
+-<p>
+-Change 19.5.3.1 [syserr.errcondition.overview]:
+-</p>
+-
+-<blockquote><pre>template&lt;<del>typename</del> <ins>class</ins> ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;<ins>::value</ins>, error_co<ins>ndition</ins><del>de</del><ins>&amp;</ins>&gt;::type<del> &amp;</del>
+- operator=( ErrorConditionEnum e );
+-</pre></blockquote>
+-
+-<p>
+-Change 19.5.3.3 [syserr.errcondition.modifiers]:
+-</p>
+-
+-<blockquote><pre>template &lt;class ErrorConditionEnum&gt;
+- typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value<ins>, error_condition&amp;</ins>&gt;::type<del>&amp;</del>
+- operator=(ErrorConditionEnum e);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Postcondition:</i> <tt>*this == make_error_condition(e)</tt>.
+-</p>
+-<p><ins>
+-<i>Returns:</i> <tt>*this</tt>.
+-</ins></p>
+-<p>
+-<i>Throws:</i> Nothing.
+-</p>
+-</blockquote>
+-</blockquote>
+-
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1230"></a>1230. <tt>mem_fn</tt> and variadic templates</h3>
+-<p><b>Section:</b> 20.8.13 [func.memfn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.memfn">issues</a> in [func.memfn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a></p>
+-<p><b>Discussion:</b></p>
+-
+-
+-
+-<p>
+-Since we have removed the entry in B [implimits] for the
+-library-specific limit for number of arguments passed to
+-<tt>function</tt>/<tt>tuple</tt>/etc. I believe we need to update the
+-spec for <tt>mem_fn</tt> to reflect this.
+-</p>
+-
+-<p>
+-The "<i>Remarks:</i> Implementations may implement <tt>mem_fn</tt> as a set of
+-overloaded function templates." no longer holds, as we cannot create an
+-arbitrary number of such overloads. I believe we should strike the
+-remark and add a second signature:
+-</p>
+-
+-<blockquote><pre>template&lt;class R, class T, typename ... ArgTypes&gt;
+- unspecified mem_fn(R (T::*pm)(ArgTypes...));
+-</pre></blockquote>
+-
+-<p>
+-I believe we need two signatures as pointer-to-data-member and
+-pointer-to-member-function-taking-no-args appear to use subtly different
+-syntax.
+-</p>
+-
+-<p><i>[
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a> as a similar proposed resolution.
+-]</i></p>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-Add to 20.8 [function.objects] and 20.8.13 [func.memfn]:
+-
+-
+-<blockquote><pre>template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm)
+-
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...));</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile);</ins>
+-
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...)&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile&amp;);</ins>
+-
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...)&amp;&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const&amp;&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) volatile&amp;&amp;);</ins>
+-<ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const volatile&amp;&amp;);</ins>
+-</pre></blockquote>
+-
+-<p>
+-Strike 20.8.13 [func.memfn], p5:
+-</p>
+-
+-<blockquote>
+-<del><i>Remarks:</i> Implementations may implement <tt>mem_fn</tt> as a set
+-of overloaded function templates.</del>
+-</blockquote>
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1232"></a>1232. Still <tt>swap</tt>'s with rvalue-references</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-The current library contains still rvalue reference-swaps that seem to be
+-overlooked in the process of switching back to lvalue-ref swaps.
+-</p>
+-
+ <p><i>[
+-2009-10 Santa Cruz:
+-]</i></p>
+-
+-
+-<blockquote>
+-Editor accepts as NAD Editorial.
+-</blockquote>
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-Change 20.3.5 [pairs]/1 as indicated:
+-</p>
+-
+-<blockquote><pre>template &lt;class T1, class T2&gt;
+-struct pair {
+- ...
+- void swap(pair&amp;<del>&amp;</del> p);
+-};
+-</pre></blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 20.3.5 [pairs] before p. 17 as indicated:
+-</p>
+-
+-<blockquote><pre>void swap(pair&amp;<del>&amp;</del> p);
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+-
+-<p>
+-Change 20.3.5 [pairs] before p. 21 as indicated:
+-</p>
+-
+-<blockquote><pre>template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp; y);
+-<del>template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp;&amp; x, pair&lt;T1, T2&gt;&amp; y);</del>
+-<del>template&lt;class T1, class T2&gt; void swap(pair&lt;T1, T2&gt;&amp; x, pair&lt;T1, T2&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+-<p>
+-Change 20.4.1 [tuple.general]/2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
+-</p>
+-
+-<blockquote><pre>// 20.5.2.9, specialized algorithms:
+-template &lt;class... Types&gt;
+-void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y);
+-<del>template &lt;class... Types&gt;
+-void swap(tuple&lt;Types...&gt;&amp;&amp; x, tuple&lt;Types...&gt;&amp; y);
+-template &lt;class... Types&gt;
+-void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+-<p>
+-Change 20.4.2 [tuple.tuple] as indicated:
+-</p>
+-
+-<blockquote><pre>// 20.5.2.3, tuple swap
+-void swap(tuple&amp;<del>&amp;</del>)
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+-<p>
+-Change 20.4.2.3 [tuple.swap] before 1 as indicated:
+-</p>
+-
+-<blockquote><pre>void swap(tuple&amp;<del>&amp;</del> rhs);
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+-<p>
+-Change 20.8 [function.objects]/2, header <tt>&lt;functional&gt;</tt> synopsis, as indicated:
+-</p>
+-
+-<blockquote><pre>template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+-<del>template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+-template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&amp;&amp;);</del>
+-</pre></blockquote>
++2010-01-30 Daniel opens:
++]</i></p>
+
+-</li>
+
+-<li>
++<blockquote>
+ <p>
+-Change 20.8.14.2 [func.wrap.func], as indicated:
++First, I read the newly proposed spec for <tt>clear()</tt> that it does in
++general <em>not</em> invalidate a previous past-the-end iterator value, but
++<tt>deque</tt> says in 23.3.3.4 [deque.modifiers] for the semantics of
++<tt>erase</tt> that erasures at the end will invalidate the past-the-end
++iterator. With removal of a direct binding between <tt>clear()</tt> and
++<tt>erase()</tt> there seem to be some fixes necessary. One way to fix that
++would be to mention in Table 94 that this "may also invalidate the past-the-end
++iterator" and then to mention for all specific containers where this does not
++happen, the exception, [1] e.g. in <tt>std::vector</tt>. <tt>std::vector</tt>
++has no own specification of <tt>clear()</tt> and one aspect of the closed issue
++<a href="lwg-closed.html#1102">1102</a> was to realize just that (indirectly via <tt>erase</tt>). IMO
++we should now add an extra specification for <tt>clear()</tt>. Btw.:
++<tt>std::vector::erase</tt> reads to me that it would invalidate previous
++past-the-end values (and that seems correct in general).
+ </p>
+-
+-<blockquote><pre>// 20.7.15.2.2, function modifiers:
+-void swap(function&amp;<del>&amp;</del>);
+-template&lt;class F, class A&gt; void assign(F, const A&amp;);
+-
+-[..]
+-
+-// 20.7.15.2.7, specialized algorithms:
+-template &lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+-<del>template &lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+-template &lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;&amp;);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+ <p>
+-Change 20.8.14.2.7 [func.wrap.func.alg] before 1 as indicated:
++Before I will provide explicit wording, I would like to
++discuss these points.
+ </p>
+
+-<blockquote><pre>template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2);
+-<del>template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2);
+-template&lt;class R, class... ArgTypes&gt;
+-void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp;&amp; f2);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+ <p>
+-Change 20.9.10.2 [util.smartptr.shared]/1 as indicated:
++[1] <tt>std::list</tt> does fortunately specify that clear does not invalidate
++the past-the-end iterator.
+ </p>
++</blockquote>
+
+-<blockquote><pre>// 20.8.12.2.4, modifiers:
+-void swap(shared_ptr&amp;<del>&amp;</del> r);
++<p><i>[
++2010-02-08 Moved to Tentatively NAD Editorial after 5 positive votes on c++std-lib.
++Rationale added below.
++]</i></p>
+
+-[..]
+
+-// 20.8.12.2.9, shared_ptr specialized algorithms:
+-template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+-<del>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+-template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp;&amp; b);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
++<p><b>Rationale:</b></p>
+ <p>
+-Change 21.3 [string.classes]/1, header <tt>&lt;string&gt;</tt> synopsis, as indicated:
++Solved as proposed by LWG <a href="lwg-defects.html#704">704</a>.
+ </p>
+
+-<blockquote><pre>// 21.4.8.8: swap
+-template&lt;class charT, class traits, class Allocator&gt;
+-void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
+-<del>template&lt;class charT, class traits, class Allocator&gt;
+-void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
+-template&lt;class charT, class traits, class Allocator&gt;
+-void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);</del>
+-</pre></blockquote>
+
+-</li>
++<p><b>Proposed resolution:</b></p>
+
+-<li>
+ <p>
+-Change 23.3 [sequences]/1, header <tt>&lt;deque&gt;</tt> synopsis, as indicated:
++Change 23.2.1 [container.requirements.general]/10:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
++<blockquote>
+ <p>
+-Change 23.3 [sequences]/1, header <tt>&lt;list&gt;</tt> synopsis, as indicated:
++Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4) all
++container types defined in this Clause meet the following additional
++requirements:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
++<ul>
++<li>
++..
+ </li>
+
+ <li>
+-<p>
+-Change 23.3 [sequences]/1, header <tt>&lt;queue&gt;</tt> synopsis, as indicated:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-<del>template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
+-
+-template &lt;class T, class Container = vector&lt;T&gt;, class Compare = less&lt;typename Container::value_type&gt; &gt;
+-class priority_queue;
+-template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-<del>template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
++no <tt>erase()</tt>, <ins><tt>clear()</tt>,</ins> <tt>pop_back()</tt> or
++<tt>pop_front()</tt> function throws an exception.
+ </li>
+
+ <li>
+-<p>
+-Change 23.3 [sequences]/1, header <tt>&lt;stack&gt;</tt> synopsis, as indicated:
+-</p>
+-
+-<blockquote><pre>template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y);
+-<del>template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp;&amp; x, stack&lt;T, Container&gt;&amp; y);
+-template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
++...
+ </li>
++</ul>
++
++</blockquote>
+
+-<li>
+ <p>
+-Change 23.3 [sequences]/1, header <tt>&lt;vector&gt;</tt> synopsis, as indicated:
++Replace the following words from Table 94 &mdash; Sequence container
++requirements (in addition to container) in 23.2.3 [sequence.reqmts]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
++<blockquote>
++<table border="1">
++<caption>Table 94 &mdash; Sequence container requirements (in addition to
++container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++</tr>
+
+-</li>
++<tr>
++<td><tt>a.clear()</tt></td>
++<td><tt>void</tt></td>
++<td><del><tt>erase(begin(), end())</tt></del><br/>
++<ins>Destroys all elements in the container a. Invalidates all references,
++pointers, and iterators referring to the elements of <tt>a</tt> and may
++invalidate the past-the-end iterator.</ins><br/>
++post: <tt><del>size() == 0</del> <ins>a.empty() == true</ins></tt>. </td>
++</tr>
++</table>
++</blockquote>
+
+-<li>
+ <p>
+-Change 23.3.2 [deque]/2 as indicated:
++Add a new paragraph after 23.3.4.5 [forwardlist.modifiers]/23:
+ </p>
+
+-<blockquote><pre>iterator erase(const_iterator position);
+-iterator erase(const_iterator first, const_iterator last);
+-void swap(deque&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
++<blockquote><pre>
+ void clear();
++</pre>
+
+-[..]
++<blockquote>
++<p>
++23 <i>Effects:</i> Erases all elements in the range <tt>[begin(),end())</tt>.
++</p>
++<p><ins>
++<i>Remarks:</i> Does not invalidate past-the-end iterators.
++</ins></p>
++</blockquote>
++</blockquote>
+
+-// specialized algorithms:
+-template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
+-<p>
+-Change 23.3.2.4 [deque.special] as indicated:
+-</p>
+
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
++<hr>
++<h3><a name="1302"></a>1302. different <tt>emplace</tt> semantics for sequence and associated containers</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Change 23.3.3 [forwardlist]/2 as indicated:
++According to the new naming scheme introduced with
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680</a>
+ </p>
+
+-<blockquote><pre>iterator erase_after(const_iterator position);
+-iterator erase_after(const_iterator position, iterator last);
+-void swap(forward_list&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
+-
+-[..]
+-
+-// 23.3.3.6 specialized algorithms:
+-template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++vector&lt;T&gt; v;
++v.emplace(v.begin(),x,y,z)
+ </pre></blockquote>
+
+-</li>
+-
+-<li>
+ <p>
+-Change 23.3.3.6 [forwardlist.spec] as indicated:
++now has a different semantics than
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++set&lt;T&gt; s;
++s.emplace(s.begin(),x,y,z);
+ </pre></blockquote>
+
+-</li>
+-
+-<li>
+ <p>
+-Change 23.3.4 [list]/2 as indicated:
++While the version for <tt>vector</tt>s takes the first argument as position and
++the remaining for construction, the version for <tt>set</tt>s takes all
++arguments for construction.
+ </p>
+
+-<blockquote><pre>iterator erase(const_iterator position);
+-iterator erase(const_iterator position, const_iterator last);
+-void swap(list&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
+-void clear();
+-
+-[..]
+-
+-// specialized algorithms:
+-template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
++<p>
++IMO, this is a serious design mistake for a couple of reasons:
++</p>
+
++<ul>
+ <li>
+ <p>
+-Change 23.3.4.5 [list.special] as indicated:
++First, in principle, all STL member functions should have the same behavior with
++the same member function to avoid confusion and allow to write proper generic
++code.
+ </p>
+-
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp;&amp; x, list&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp;&amp; y);</del>
++<p>
++In fact, when I write the following simple function template:
++</p>
++<blockquote><pre>
++template &lt;typename T&gt;
++void doEmplace (T&amp; cont)
++{
++ cont.emplace(cont.begin(),"nico","josuttis",42);
++}
+ </pre></blockquote>
+-
++<p>
++the semantics depends on the type of the container.
++</p>
+ </li>
+-
+ <li>
+ <p>
+-Change 23.5.1.1 [queue.defn] as indicated:
++In addition, I also guess using the name <tt>emplace_hint()</tt> instead of
++<tt>emplace()</tt> for associative containers is a design mistake. According to
++my knowledge, it was a design goal of the original STL to provide ONE
++<tt>insert</tt> function, which works for ALL containers. This was
++<tt>insert(pos,val)</tt>.
++</p>
++<p>
++The trick to declare <tt>pos</tt> as a hint, allowed that we could implement a
++generic <tt>insert</tt> for all containers. Now, with the new <tt>emplace</tt>
++naming scheme, this trick is gone for the new kind of insertion.
+ </p>
+-
+-<blockquote><pre>void swap(queue&amp;<del>&amp;</del> q) { c.swap(q.c); }
+-
+-[..]
+-
+-template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-<del>template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+ </li>
++</ul>
+
+-<li>
+ <p>
+-Change 23.5.1.5 [queue.special] as indicated:
++I consider this to be a serious design penalty because once this
++is specified we can't fix that without breaking backward compatibility.
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-<del>template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp;&amp; x, queue&lt;T, Container&gt;&amp; y);
+-template &lt;class T, class Container&gt;
+-void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
++<p>
++However, we have two choices for a fix:
++</p>
+
++<ul>
++<li>
++rename <tt>emplace_hint(pos,val)</tt> for associative containers back to
++<tt>emplace(pos,val)</tt>. However to avoid the overloading problems, we also
++have to rename the existing <tt>emplace(val)</tt> functions to something else (I
++don't have a good name here at hand).
+ </li>
+-
+ <li>
+-<p>
+-Change 23.5.2 [priority.queue]/1 as indicated:
+-</p>
++Keep <tt>emplace(val)</tt> for associative containers as it is, but rename
++<tt>emplace(pos,val)</tt> for sequence containers and
++<tt>emplace_hint(pos,val)</tt> to something like <tt>emplace_at(pos,val)</tt>,
++declaring that <tt>pos</tt> is a hint for associative containers.
++</li>
++</ul>
+
+-<blockquote><pre>void swap(priority_queue&amp;<del>&amp;</del>);
++<p><i>[
++2010 Pittsburgh: Moved to NAD, rationale added below.
++]</i></p>
+
+-// no equality is provided
+-template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-<del>template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-template &lt;class T, class Container, class Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
++
++<p><b>Rationale:</b></p>
+ <p>
+-Change 23.5.2.4 [priqueue.special] as indicated:
++There was no consensus to make this change.
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container, Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-<del>template &lt;class T, class Container, Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp; y);
+-template &lt;class T, class Container, Compare&gt;
+-void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x, priority_queue&lt;T, Container, Compare&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
++<p><b>Proposed resolution:</b></p>
++<p> In 23.2.5 [unord.req], change: </p>
++<blockquote>
++ <table border="1">
++ <caption>Table 96 &mdash; Associative container requirements (in addition to
++ container)</caption>
++ <tr>
++ <th>expression</th>
++ <th>Return type</th>
++ <th>Assertion/note pre-/post-condition</th>
++ <th>Post-condition</th>
++ </tr>
++ <tr>
++ <td colspan="4">...</td>
++ </tr>
++ <tr>
++ <td><tt>a_uniq.emplace<ins>_value</ins>(args)</tt></td>
++ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
++ <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...<br/>
++ if and only if there is no element in the container with key equivalent
++ to the key of t.<br/>
++ The bool component of the returned pair is true if and only if the insertion
++ takes place, and the iterator component of the pair points to the element
++ with key equivalent to the key of t.</td>
++ <td>logarithmic</td>
++ </tr>
++ <tr>
++ <td><tt>a_eq.emplace<ins>_value</ins>(args)</tt></td>
++ <td><tt>iterator</tt></td>
++ <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...
++ and returns the iterator pointing to the newly inserted element.</td>
++ <td>logarithmic</td>
++ </tr>
++ <tr>
++ <td><tt>a.emplace<del>_hint</del>(p,args)</tt></td>
++ <td><tt>iterator</tt></td>
++ <td>equivalent to
++ <tt>a.emplace<ins>_value</ins>(std::forward&lt;Args&gt;(args)...)</tt>.
++ Return value is an iterator pointing to the element with the key
++ equivalent to the newly inserted element. The const_iterator p is a hint
++ pointing to where the search should start. Implementations are permitted
++ to ignore the hint.</td> <td>logarithmic in general, but amortized
++ constant if the element is inserted right after p</td>
++ </tr>
++ <tr>
++ <td colspan="4">... </td>
++ </tr>
++ </table>
++
++</blockquote>
++<p> In 23.2.5 [unord.req], change: </p>
++<blockquote>
++ <table border="1">
++ <caption>Table 98 &mdash; Unordered associative container requirements (in
++ addition to container)</caption>
++ <tr>
++ <th>expression</th>
++ <th>Return type</th>
++ <th>Assertion/note pre-/post-condition</th>
++ <th>Post-condition</th>
++ </tr>
++ <tr>
++ <td colspan="4">...</td>
++ </tr>
++ <tr>
++ <td><tt>a_uniq.emplace<ins>_value</ins>(args)</tt></td>
++ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
++ <td>inserts a <tt>T</tt> object <tt>t</tt> constructed with <tt>std::forward&lt;Args&gt;(args)...</tt> if
++ and only if there is no element in the container with key equivalent to
++ the key of <tt>t</tt>. The bool component of the returned pair is true if and only
++ if the insertion takes place, and the iterator component of the pair points
++ to the element with key equivalent to the key of t.</td>
++ <td>Average case O(1), worst case O(a_uniq.size()).</td>
++ </tr>
++ <tr>
++ <td><tt>a_eq.emplace<ins>_value</ins>(args)</tt></td>
++ <td><tt>iterator</tt></td>
++ <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...
++ and returns the iterator pointing to the newly inserted element.</td>
++ <td>Average case O(1), worst case O(a_eq.size()).</td>
++ </tr>
++ <tr>
++ <td><tt>a.emplace<del>_hint</del>(p,args)</tt></td>
++ <td><tt>iterator</tt></td>
++ <td>equivalent to
++ <tt>a.emplace<ins>_value</ins>(std::forward&lt;Args&gt;(args)...)</tt>.
++ Return value is an iterator pointing to the element with the key
++ equivalent to the newly inserted element. The const_iterator p is a hint
++ pointing to where the search should start. Implementations are permitted
++ to ignore the hint.</td> <td>Average case O(1), worst case
++ O(a.size()).</td>
++ </tr>
++ <tr>
++ <td colspan="4">... </td>
++ </tr>
++ </table>
++</blockquote>
+
+-<li>
+ <p>
+-Change 23.5.3.1 [stack.defn] as indicated:
++In 23.4.4 [map], 23.4.6 [set], 23.5.4 [unord.map], 23.5.6 [unord.set], change:
+ </p>
++<blockquote>
++ <p><i>// modifiers:</i><br/>
++ <tt>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace<ins>_value</ins>(Args&amp;&amp;...
++ args);<br/>
++ template &lt;class... Args&gt; iterator emplace<del>_hint</del>(const_iterator
++ position, Args&amp;&amp;... args);</tt></p>
++</blockquote>
+
+-<blockquote><pre>void swap(stack&amp;<del>&amp;</del> s) { c.swap(s.c); }
++<p>
++In 23.4.5 [multimap], 23.4.7 [multiset], 23.5.5 [unord.multimap], 23.5.7 [unord.multiset], change:
++</p>
++<blockquote>
++ <p><i>// modifiers:<br/></i><tt>template &lt;class... Args&gt; iterator emplace<ins>_value</ins>(Args&amp;&amp;...
++ args);<br/>
++ template &lt;class... Args&gt; iterator emplace<del>_hint</del>(const_iterator position,
++ Args&amp;&amp;... args);<br/>
++ </tt> </p>
++</blockquote>
+
+-[..]
+
+-template &lt;class T, class Allocator&gt;
+-void swap(stack&lt;T,Allocator&gt;&amp; x, stack&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(stack&lt;T,Allocator&gt;&amp;&amp; x, stack&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(stack&lt;T,Allocator&gt;&amp; x, stack&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+
+-</li>
+
+-<li>
++<hr>
++<h3><a name="1308"></a>1308. Concerns about <tt>initializer_list</tt> overloads of <tt>min</tt>,
++<tt>max</tt>, and <tt>minmax</tt></h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2010-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Change 23.5.3.5 [stack.special] as indicated:
++In San Francisco, June 2008,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2722.pdf">N2722</a>
++was adopted, replacing the variadic templates <tt>min</tt>, <tt>max</tt>, and
++<tt>minmax</tt> by overloads that have an <tt>initializer_list&lt;T&gt;</tt>
++parameter. The paper showed benchmark results wherein <tt>initializer_list</tt>
++versions of <tt>min</tt> appeared to outperform the corresponding variadic
++template. Unfortunately, in October 2009 a very serious error was detected in
++the benchmark. (<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=25210">c++std-lib-25210</a>).
++In fact, an <tt>initializer_list&lt;T&gt;</tt> version of <tt>min</tt> often
++appears to perform <i>worse</i> than the corresponding variadic template,
++especially when <tt>T</tt> has an expensive copy constructor
++(<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=25253">c++std-lib-25253</a>,
++<a href="http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix">http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix</a>).
+ </p>
+-
+-<blockquote><pre>template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y);
+-<del>template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp;&amp; x, stack&lt;T, Container&gt;&amp; y);
+-template &lt;class T, class Container&gt;
+-void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+ <p>
+-Change 23.4.1 [vector]/2 as indicated:
++IMO, the biggest problem of the <tt>initializer_list</tt> overloads is that they
++pass and return <tt>T</tt> objects <i>by value</i>. Which has the following
++consequences:
+ </p>
+
+-<blockquote><pre>void swap(vector&lt;T,Allocator&gt;&amp;<del>&amp;</del>);
+-void clear();
+-
+-[..]
+-
+-// specialized algorithms:
+-template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
++<ol>
++<li>
++They require that <tt>T</tt> is <tt>CopyConstructible</tt>. IMO that is too much of a
++constraint for a generic, general purpose function like
++<tt>std::min&lt;T&gt;</tt>.
++</li>
++<li>
++They potentially throw an exception, even if <tt>T</tt>'s less-than-operator
++throws nothing. (And of course, less-than typically throws nothing.)
++</li>
++<li>
++They are inconsistent with C++03 <tt>std::min</tt> and <tt>std::max</tt>.
++Consider the subtle difference between <tt>const T&amp; c1 = min(a,b);</tt> and
++<tt>const T&amp; c2 = min({a,b});</tt>
++(<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=25265">c++std-lib-25265</a>)
++</li>
++<li>
++They do not conveniently support use cases that need to have a reference to the
++minimum or maximum object <i>itself</i>, rather than just a copy.
+ </li>
+-
+ <li>
+-<p>
+-Change 23.4.1.2 [vector.capacity] before p. 8 as indicated:
+-</p>
+-
+-<blockquote><pre>void swap(vector&lt;T,Allocator&gt;&amp;<del>&amp;</del> x);
+-</pre></blockquote>
+-
++They potentially perform badly: possibly <i>O(n)</i>, when the arguments
++themselves have a size of <i>n</i>.
+ </li>
++</ol>
+
+-<li>
+ <p>
+-Change 23.4.1.5 [vector.special] as indicated:
++In the future, this problem might be solvable by using an
++<tt>initializer_list</tt> of <i>const references</i>, instead:
+ </p>
+-
+-<blockquote><pre>template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-<del>template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
+-template &lt;class T, class Allocator&gt;
+-void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++const T&amp; min(initializer_list&lt;const T&amp;&gt;);
++const T&amp; max(initializer_list&lt;const T&amp;&gt;);
++pair&lt;const T&amp;, const T&amp;&gt; minmax(initializer_list&lt;const T&amp;&gt;);
+ </pre></blockquote>
+
+-</li>
+-
+-<li>
+ <p>
+-Change 23.4.2 [vector.bool]/1 as indicated:
++It is unlikely that C++0x will support <tt>initializer_list&lt;const T&amp;&gt;</tt>,
++but technically it seems possible to add such a language
++feature after C++0x
++(<a href="http://accu.org/cgi-bin/wg21/message?wg=core&amp;msg=15428">c++std-core-15428</a>).
+ </p>
+-
+-<blockquote><pre>iterator erase(const_iterator first, const_iterator last);
+-void swap(vector&lt;bool,Allocator&gt;&amp;<del>&amp;</del>);
+-static void swap(reference x, reference y);
+-</pre></blockquote>
+-
+-</li>
+-
+-<li>
+ <p>
+-Change 23.6 [associative]/1, header <tt>&lt;map&gt;</tt> synopsis as indicated:
++Variadic templates of <tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt>, as
++proposed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2551.pdf">N2551</a>
++(Sylvain Pion), do have some other advantages over <tt>initializer_list</tt>
++overloads:
+ </p>
+-
+-<blockquote><pre>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-
+-[..]
+-
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
++<ol>
++<li>
++It is likely that those variadic templates can be declared <tt>constexpr</tt>,
++now that
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3006.html#991">
++CWG issue #991</a> is in drafting status.
+ </li>
+-
+ <li>
++They provide complete compile-time protection against accidentally passing zero
++arguments.
++</li>
++</ol>
++
+ <p>
+-Change 23.6 [associative]/1, header <tt>&lt;set&gt;</tt> synopsis as indicated:
++Unfortunately, the variadic templates of <tt>min</tt>, <tt>max</tt>, and
++<tt>minmax</tt> may still need further improvement, before having them in the
++Standard Library. Especially the optional <tt>Compare</tt> parameter appears to
++be a concern. So for this moment I recommend to keep both versions out of C++0x,
++and postpone further discussion until after C++0x.
+ </p>
+
+-<blockquote><pre>template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,Compare,Allocator&gt;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,T,Compare,Allocator&amp;&amp; x, set&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,T,Compare,Allocator&amp; x, set&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++<p><i>[
++2010 Pittsburgh: Discussed and the LWG still prefers the initializer list
++solution of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2772.pdf">N2772</a>.
++]</i></p>
+
+-[..]
+
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,T,Compare,Allocator&amp;&amp; x, multiset&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,T,Compare,Allocator&amp; x, multiset&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
++<p><b>Rationale:</b></p><p>
++We prefer the solution of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2772.pdf">N2772</a>
++which will be reapplied.
++</p>
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Change 23.6.1 [map]/2 as indicated:
++Remove both variadic templates and <tt>initializer_list</tt> overloads of
++<tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt> from the synopsis in
++25.1 [algorithms.general] and from 25.4.7 [alg.min.max].
+ </p>
+
+-<blockquote><pre>iterator erase(const_iterator first, const_iterator last);
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;<del>&amp;</del>);
+-void clear();
++<blockquote>
++<p><i>[
++Note: This proposed resolution will resolve LWG <a href="lwg-closed.html#915">915</a> as NAD.
++]</i></p>
+
+-[..]
++</blockquote>
+
+-// specialized algorithms:
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+
+-</li>
+
+-<li>
++
++
++<hr>
++<h3><a name="1313"></a>1313. Seed sequence's param function not useful for pure output iterator</h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Change 23.6.1.5 [map.special] as indicated:
++The Seed sequence requirements (26.5.1.2 [rand.req.seedseq]) require the
++existence of a member function
+ </p>
+
+-<blockquote><pre>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x, map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++template&lt;typename OutputIterator&gt;
++void param(OutputIterator ob);
+ </pre></blockquote>
+
+-</li>
+-
+-<li>
+ <p>
+-Change 23.6.2 [multimap]/2 as indicated:
++The fact that this function returns <tt>void</tt> instead of the value of
++<tt>ob</tt> after accepting the sequence data leads to the same problem as in
++issue <a href="lwg-defects.html#865">865</a> - In case of pure output iterators there is no way to
++serialize further data into that data sink.
+ </p>
+
+-<blockquote><pre>iterator erase(const_iterator first, const_iterator last);
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;<del>&amp;</del>);
+-void clear();
++<p><i>[
++2010-02-07 Howard adds:
++]</i></p>
+
+-[..]
+
+-// specialized algorithms:
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
++<blockquote><p>
++At the time this issue was opened, the suggested changes are with respect to an
++anticipated draft which does not yet exist.
++</p></blockquote>
+
+-</li>
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
+
+-<li>
+-<p>
+-Change 23.6.2.4 [multimap.special] as indicated:
+-</p>
+
+-<blockquote><pre>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class T, class Compare, class Allocator&gt;
+-void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x, multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
++<blockquote><p>
++No technical counterarguments, but it is simply too late in the process
++to make this change at this point.
++</p></blockquote>
+
+-</li>
+
++<p><b>Proposed resolution:</b></p>
++<ol>
+ <li>
+ <p>
+-Change 23.6.3 [set]/2 and 23.6.3.2 [set.special] as indicated: (twice!)
++In Table 109 &mdash; Seed sequence requirements, expression "<tt>r.param(ob)</tt>"
++change the<br/>
++Return type entry:
+ </p>
+
+-<blockquote><pre>// specialized algorithms:
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,Compare,Allocator&gt;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,Compare,Allocator&amp;&amp; x, set&lt;Key,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(set&lt;Key,Compare,Allocator&amp; x, set&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++<del>void</del><ins>OutputIterator</ins>
+ </pre></blockquote>
+-
+ </li>
+
+ <li>
+ <p>
+-Change 23.6.4 [multiset]/2 as indicated:
++In 26.5.7.1 [rand.util.seedseq], class seed_seq synopsis change
+ </p>
+
+-<blockquote><pre>iterator erase(const_iterator first, const_iterator last);
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;<del>&amp;</del>);
+-void clear();
+-
+-[..]
+-
+-// specialized algorithms:
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&amp;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
++<blockquote><pre>
++template&lt;class OutputIterator&gt;
++<del>void</del><ins>OutputIterator</ins> param(OutputIterator dest) const;
+ </pre></blockquote>
+-
+ </li>
+
+-<li>
+-<p>
+-Change 23.6.4.2 [multiset.special] as indicated:
+-</p>
+-
+-<blockquote><pre>template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
+-<del>template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp; y);
+-template &lt;class Key, class Compare, class Allocator&gt;
+-void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x, multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; y);</del>
+-</pre></blockquote>
+-
+-</li>
+ </ol>
+
+
+
+
+
++
+ <hr>
+-<h3><a name="1233"></a>1233. Missing <tt>unique_ptr</tt> signatures in synopsis</h3>
+-<p><b>Section:</b> 20.9 [memory] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#memory">issues</a> in [memory].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1314"></a>1314. <tt>NULL</tt> and <tt>nullptr</tt></h3>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>. Some <tt>unique_ptr</tt> signatures are missing
+-from the synopsis in 20.9 [memory].
++Currently, the 18.2 [support.types]/3 allows <tt>NULL</tt> to be any
++null pointer constant. The footnote marks that 0 or 0L might be appropriate.
++However, this definition also allows the implementation to define <tt>NULL</tt>
++to be <tt>nullptr</tt>. This may lead to overload and conversion issues more
++serious than with the C++98 version:
+ </p>
+
+-<p><i>[
+-2009-11-04 Howard adds:
+-]</i></p>
+-
++<blockquote><pre>
++void f(void*);
++void f(int);
+
+-<blockquote>
+-Moved to Tentatively NAD Editorial. The editor has adopted the fix.
+-</blockquote>
++void g()
++{
++ // calls f(int) if NULL is integral
++ // calls f(void*) if NULL is nullptr
++ f(NULL);
++}
++</pre></blockquote>
+
++<p>
++Possible resolutions:
++</p>
++<ul>
++<li>
++Forbid <tt>NULL</tt> from being <tt>nullptr</tt>
++</li>
++<li>
++Require <tt>NULL</tt> to be <tt>nullptr</tt>
++</li>
++<li>
++Leave it as is
++</li>
++</ul>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Add in 20.9 [memory], Header <tt>&lt;memory&gt;</tt> synopsis
+-missing declarations as shown below:
++Making <tt>NULL</tt> <tt>nullptr</tt> would improve code correctness, and
++breaking backwards compatibility shouldn't be a huge concern as <tt>NULL</tt>
++shouldn't be used except as a null pointer constant anyways.
+ </p>
+
+-<blockquote><pre>// 20.8.11 Class unique_ptr:
+-template &lt;class X&gt; class default_delete;
+-<ins>template&lt;class T&gt; struct default_delete&lt;T[]&gt;;</ins>
+-template &lt;class X, class D = default_delete&lt;T&gt;&gt; class unique_ptr;
+-<ins>template&lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;</ins>
++<p><i>[
++2010-02-10 Chris provided wording.
++]</i></p>
+
+-<ins>template&lt;class T, class D&gt; void swap(unique_ptr&lt;T, D&gt;&amp; x, unique_ptr&lt;T, D&gt;&amp; y);</ins>
+
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-<ins>template&lt;class T1, class D1, class T2, class D2&gt;
+-bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);</ins>
+-</pre></blockquote>
++<p><i>[
++2010 Pittsburgh: Moved to NAD, rationale added below.
++]</i></p>
+
+
+
+
++<p><b>Rationale:</b></p>
++<p>
++The LWG discussed the proposed resolution and several other options. There was
++no concensus to make this or any other changes.
++</p>
++
+
+-<hr>
+-<h3><a name="1235"></a>1235. Issue with C++0x random number proposal</h3>
+-<p><b>Section:</b> X [rand.concept.dist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Matthias Troyer <b>Opened:</b> 2009-10-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
++<p><b>Proposed resolution:</b></p>
+ <p>
+-There exist optimized, vectorized vendor libraries for the creation of
+-random number generators, such as Intel's MKL [1] and AMD's ACML [2]. In
+-timing tests we have seen a performance gain of a factor of up to 80
+-(eighty) compared to a pure C++ implementation (in Boost.Random) when
+-using these generator to generate a sequence of normally distributed
+-random numbers. In codes dominated by the generation of random numbers
+-(we have application codes where random number generation is more than
+-50% of the CPU time) this factor 80 is very significant.
++18.2 [support.types]
+ </p>
+
++<blockquote>
+ <p>
+-To make use of these vectorized generators, we use a C++ class modeling
+-the <tt>RandomNumberEngine</tt> concept and forwarding the generation of random
+-numbers to those optimized generators. For example:
++3 The macro <tt>NULL</tt> <ins>is defined to be <tt>nullptr</tt>.</ins> <del>is
++an implementation-defined C++ null pointer constant in this International
++Standard (4.10).<sup>196</sup></del>
+ </p>
+
+-<blockquote><pre>namespace mkl {
+- class mt19937 {.... };
+-}
+-</pre></blockquote>
++<p><del>
++196) Possible definitions include <tt>0</tt> and <tt>0L</tt>, but not
++<tt>(void*)0</tt>.
++</del></p>
++</blockquote>
+
+ <p>
+-For the generation of random variates we also want to dispatch to
+-optimized vectorized functions in the MKL or ACML libraries. See this
+-example:
++20.7.13 [c.malloc]
+ </p>
+
+-<blockquote><pre>mkl::mt19937 eng;
+-std::normal_distribution&lt;double&gt; dist;
++<blockquote><p>
++7 The contents are the same as the Standard C library header
++<tt>&lt;string.h&gt;</tt>, with the change to <tt>memchr()</tt> specified in
++21.6 <ins>and the macro <tt>NULL</tt> defined to be <tt>nullptr</tt></ins>.
++</p></blockquote>
+
+-double n = dist(eng);
+-</pre></blockquote>
+
+ <p>
+-Since the variate generation is done through the <tt>operator()</tt> of the
+-distribution there is no customization point to dispatch to Intel's or
+-AMD's optimized functions to generate normally distributed numbers based
+-on the <tt>mt19937</tt> generator. Hence, the performance gain of 80 cannot be
+-achieved.
++20.12.8 [date.time]
+ </p>
+
++<blockquote><p>
++2 The contents are the same as the Standard C library header
++<tt>&lt;time.h&gt;</tt><del>.</del><sup>232</sup> <ins>except the macro
++<tt>NULL</tt>, which is defined to be <tt>nullptr</tt>.</ins> The functions
++<tt>asctime</tt>, <tt>ctime</tt>, <tt>gmtime</tt>, and <tt>localtime</tt> are
++not required to avoid data races (17.6.4.8).
++</p></blockquote>
++
++
+ <p>
+-Contrast this with TR1:
++22.6 [c.locales]
+ </p>
+
+-<blockquote><pre>mkl::mt19937 eng;
+-std::tr1::normal_distribution&lt;double&gt; dist;
+-std::tr1::variate_generator&lt;mkl::mt19937,std::tr1::normal_distribution&lt;double&gt; &gt; rng(eng,dist);
+-double n = rng();
+-</pre></blockquote>
++<blockquote><p>
++2 The contents are the same as the Standard C library header
++<tt>&lt;locale.h&gt;</tt> <ins>except the macro <tt>NULL</tt>, which is defined
++to be <tt>nullptr</tt></ins>.
++</p></blockquote>
+
+ <p>
+-This - admittedly much uglier from an aestethic point of view - design
+-allowed optimization by specializing the <tt>variate_generator</tt> template for
+-<tt>mkl::mt19937</tt>:
++C.5.2.4 [diff.null]
+ </p>
+
+-<blockquote><pre>namespace std { namespace tr1 {
++<blockquote><p>
++1 The macro <tt>NULL</tt>, defined in any of <tt>&lt;clocale&gt;</tt>,
++<tt>&lt;cstddef&gt;</tt>, <tt>&lt;cstdio&gt;</tt>, <tt>&lt;cstdlib&gt;</tt>,
++<tt>&lt;cstring&gt;</tt>, <tt>&lt;ctime&gt;</tt>, or <tt>&lt;cwchar&gt;</tt>, is
++<ins>nullptr</ins> <del>an implementation-defined C++ null pointer constant in
++this International Standard (18.2).</del>
++</p></blockquote>
++
++
+
+-template&lt;&gt;
+-class variate_generator&lt;mkl::mt19937,std::tr1::normal_distribution&lt;double&gt; &gt; { .... };
+
+-} }
+-</pre></blockquote>
+
++
++<hr>
++<h3><a name="1315"></a>1315. return type of <tt>async</tt></h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-A similar customization point is missing in the C++0x design and
+-prevents the optimized vectorized version to be used.
++Both overloads of <tt>async</tt> return <tt>future&lt;typename
++F::result_type&gt;</tt> which requires that <tt>F</tt> has a nested type. This
++prevents <tt>async</tt> being used with function pointers and makes the example
++in 30.6.8 [futures.async] invalid. I believe this is unintentional.
+ </p>
+
+ <p>
+-Suggested resolution:
++The proposed resolution also addresses editorial issues with the
++<tt>launch_policy</tt> function parameter.
+ </p>
+
+ <p>
+-Add a customization point to the distribution concept. Instead of the
+-<tt>variate_generator</tt> template this can be done through a call to a
+-free function <tt>generate_variate</tt> found by ADL instead of
+-<tt>operator()</tt> of the distribution:
++For the first overload it is not sufficient to return <tt>future&lt;typename
++result_of&lt;F(ArgTypes...)&gt;::type&gt;</tt>. Calling <tt>async(launch::xxx,
++foo, bar)</tt> performs argument deduction on both <tt>async</tt> overloads,
++which for the first overload attempts to instantiate <tt>result_of&lt;launch(F,
++ArgTypes...)&gt;</tt>, which is invalid. SFINAE must be used to prevent that.
+ </p>
+
+-<blockquote><pre>template &lt;RandomNumberDistribution, class RandomNumberEngine&gt;
+-typename RandomNumberDistribution ::result_type
+-generate_variate(RandomNumberDistribution const&amp; dist, RandomNumberEngine&amp; eng);
+-</pre></blockquote>
++<p><i>[
++2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
+
+-<p>
+-This function can be overloaded for optimized enginges like
+-<tt>mkl::mt19937</tt>.
+-</p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2010-02-12 Daniel opens:
+ ]</i></p>
+
+
+ <blockquote>
+-NAD Future. No time to add this feature for C++0X.
++<p>
++[..] if <tt>decay&lt;F&gt;::type</tt> is of type <tt>std::launch</tt>.
++</p>
++<p>
++or
++</p>
++<p>
++[..] if <tt>remove_cv&lt;remove_reference&lt;F&gt;::type&gt;::type</tt> is of
++type <tt>std::launch</tt>.
++</p>
++
++<p>
++The latter is the more specific form, but the former is equivalent to
++the latter for all cases that can occur here. I suggest to use the
++former for simplicity, but expect that implementations can effectively
++use the latter.
++
++</p>
+ </blockquote>
+
++<p><i>[
++2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
+
+
++<blockquote><p>
++Moved to NAD Editorial. Rationale added below.
++</p></blockquote>
+
+
+
+-<hr>
+-<h3><a name="1236"></a>1236. reserved identifiers in programs not using the library</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-10-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
++<p><b>Rationale:</b></p>
+ <p>
+-I wasn't sure whether to consider this a library or a language issue,
+-because the issue is I think it's incorrectly categorized as being part
+-of the library, so I thought I'd send a message to both of you and let
+-you sort it out.
++Solved by N3058.
+ </p>
+
+-<p>
+-Most reserved identifiers are treated as unilaterally available to the
+-implementation, such as to implement language extensions, or provide
+-macros documenting its functionality. However, the requirements for
+-reserved identifers are in 17.6.3.3 [reserved.names], which are a
+-subsection of 17.6.3 [constraints]. 17.6.3.1 [constraints.overview] appears only to apply to "C++ programs
+-that use the facilities of the C++ standard library", meaning that, in
+-theory, all implementations are erroneous in having any non-standard
+-identifiers predefined for programs that do not, at some point, include
+-a standard library header.
+-</p>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Furthermore, it's unclear whether the use of certain identifiers is UB
+-or results in an ill-formed program. In particular, 17.6.3.3.1 [macro.names] uses a "shall not", where 17.6.3.3.2 [global.names] says that names are "reserved to the
+-implementation". 17.6.3.3 [reserved.names] seems only to cover the
+-instance of a name being described as "reserved", so are implementations
+-required to diagnose a program that performs, as an example, "<tt>#undef
+-get</tt>"?
++In 30.6.1 [futures.overview] paragraph 1:
+ </p>
+
+-<p><i>[
+-2009 Santa Cruz:
+-]</i></p>
++<blockquote><pre>
++template &lt;class F, class... Args&gt;
++ <del>future&lt;typename F::result_type&gt;</del>
++ <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
++ async(F&amp;&amp; f, Args&amp;&amp;... args);
++template &lt;class F, class... Args&gt;
++ <del>future&lt;typename F::result_type&gt;</del>
++ <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
++ async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
++</pre></blockquote>
+
++<p>
++In 30.6.8 [futures.async] before paragraph 1
++</p>
+
++<blockquote><pre>
++template &lt;class F, class... Args&gt;
++ <del>future&lt;typename F::result_type&gt;</del>
++ <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
++ async(F&amp;&amp; f, Args&amp;&amp;... args);
++template &lt;class F, class... Args&gt;
++ <del>future&lt;typename F::result_type&gt;</del>
++ <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
++ async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
++</pre>
+ <blockquote>
+-Move to NAD. There may in theory be multiple interpretations possible,
+-but there's no evidence that this causes any genuine problems or
+-uncertainty about what implementations are allowed to do. We do not
+-believe this rises to the level of a defect.
++<p>...</p>
++<p><ins>
++<i>Remarks:</i> The first signature shall not participate in overload resolution
++if <tt>decay&lt;F&gt;::type</tt> is <tt>std::launch</tt>.
++</ins></p>
++</blockquote>
+ </blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-
+-
+
+
+
+ <hr>
+-<h3><a name="1238"></a>1238. defining algorithms taking iterator for range</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1318"></a>1318. N2982 removes previous allocator capabilities</h3>
++<p><b>Section:</b> 20.7.8.1 [allocator.traits.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2010-02-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1375">1375</a></p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses US-87</b></p>
+ <p>
+-The library has many algorithms that take a source range represented by
+-a pair of iterators, and the start of some second sequence given by a
+-single iterator. Internally, these algorithms will produce undefined
+-behaviour if the second 'range' is not as large as the input range, but
+-none of the algorithms spell this out in Requires clauses, and there is
+-no catch-all wording to cover this in clause 17 or the front matter of
+-25.
+-</p>
+-
+-<p>
+-There was an attempt to provide such wording in paper
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf">n2944</a>
+-but this
+-seems incidental to the focus of the paper, and getting the wording of
+-this issue right seems substantially more difficult than the simple
+-approach taken in that paper. Such wording will be removed from an
+-updated paper, and hopefully tracked via the LWG issues list instead.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
++says that containers should have a nested typedef that defines their
++<tt>reference_type</tt> as <tt>value_type&amp;</tt>; the previous
++standard deferred to the allocator to define its
++<tt>reference_type</tt>, and containers simply passed the allocator's
++typedef on. This change is a mistake. Allocators should define both a
++<tt>pointer</tt> type and a <tt>reference</tt> type. That's essential
++for their original purpose, which was to make different memory models
++transparent. If an allocator defines a <tt>pointer</tt> type that isn't
++compatible with a normal pointer it also has to define a corresponding
++<tt>reference</tt> type. For example (and please forgive a Windows-ism),
++if an allocator's pointer is <tt>T __far*</tt>, then it's
++<tt>reference</tt> has to be <tt>T __far&amp;</tt>. Otherwise everything
++crashes (under the hood, references are pointers and have to have the
++same memory access mechanics). Extensions such as this for more general
++memory models were explicitly encouraged by C++03, and the allocator's
++<tt>pointer</tt> and <tt>reference</tt> typedefs were the hooks for such
++extensions. Removing the allocator's <tt>reference</tt> and
++<tt>const_reference</tt> typedefs makes those extensions unimplementable
++and breaks existing implementations that rely on those hooks.
+ </p>
+
+-<p>
+-It seems there are several classes of problems here and finding wording
+-to solve all in one paragraph could be too much. I suspect we need
+-several overlapping requirements that should cover the desired range of
+-behaviours.
+-</p>
++<p><i>[
++2010-02-25 Alisdair adds:
++]</i></p>
+
+-<p>
+-Motivating examples:
+-</p>
+
++<blockquote>
+ <p>
+-A good initial example is the <tt>swap_ranges</tt> algorithm. Here there is a
+-clear requirement that <tt>first2</tt> refers to the start of a valid range at
+-least as long as the range <tt>[first1, last1)</tt>. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf">n2944</a> tries to solve this
+-by positing a hypothetical <tt>last2</tt> iterator that is implied by the
+-signature, and requires <tt>distance(first2,last2) &lt; distance(first1,last1)</tt>.
+- This mostly works, although I am uncomfortable assuming that <tt>last2</tt> is
+-clearly defined and well known without any description of how to obtain
+-it (and I have no idea how to write that).
++<tt>vector&lt;bool&gt;::reference</tt> is a nested class, and not a typedef. It
++should be removed from the list of containers when this change is made.
+ </p>
+
+ <p>
+-A second motivating example might be the <tt>copy</tt> algorithm. Specifically,
+-let us image a call like:
++In general, I am uncomfortable placing this reference requirement on each
++container, as I would prefer to require:
+ </p>
+
+-<blockquote><pre>copy(istream_iterator&lt;int&gt;(is),istream_iterator(),ostream_iterator&lt;int&gt;(os));
++<blockquote><pre>
++is_same&lt;Container::reference, Container::iterator::reference&gt;
+ </pre></blockquote>
+
+ <p>
+-In this case, our input iterators are literally simple <tt>InputIterators</tt>,
+-and the destination is a simple <tt>OutputIterator</tt>. In neither case am I
+-happy referring to <tt>std::distance</tt>, in fact it is not possible for the
+-<tt>ostream_iterator</tt> at all as it does not meet the requirements. However,
+-any wording we provide must cover both cases. Perhaps we might deduce
+-<tt>last2 == ostream_iterator&lt;int&gt;{}</tt>, but that might not always be valid for
+-user-defined iterator types. I can well imagine an 'infinite range'
+-that writes to <tt>/dev/null</tt> and has no meaningful <tt>last2</tt>.
+-</p>
+-
+-<p>
+-The motivating example in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2944.pdf">n2944</a> is <tt>std::equal</tt>, and that seems to fall somewhere between the
+-two.
++This distinction is important, if we intend to support proxy iterators. The
++iterator paper in the pre-Pittsburgh mailing
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3046.html">N3046</a>)
++does <em>not</em> make this proposal, but organises clause 24 in such a way this
++will be much easier to specify.
+ </p>
+
+ <p>
+-Outlying examples might be <tt>partition_copy</tt> that takes two output
+-iterators, and the <tt>_n</tt> algorithms where a range is specified by a
+-specific number of iterations, rather than traditional iterator pair.
+-We should also <em>not</em> accidentally apply inappropriate constraints to
+-<tt>std::rotate</tt> which takes a third iterator that is not intended to be a
+-separate range at all.
++The changes to clause 20 remain important for all the reasons Pete highlights.
+ </p>
+-
+-<p>
+-I suspect we want some wording similar to:
+-</p>
+-
+-<blockquote>
+-For algorithms that operate on ranges where the end iterator of the
+-second range is not specified, the second range shall contain at least
+-as many elements as the first.
+ </blockquote>
+
+-<p>
+-I don't think this quite captures the intent yet though. I am not sure
+-if 'range' is the right term here rather than sequence. More awkwardly,
+-I am not convinced we can describe an Output sequence such as produce by
+-an <tt>ostream_iterator</tt> as "containing elements", at least not as a
+-precondition to the call before they have been written.
+-</p>
++<p><i>[
++2010 Batavia
++]</i></p>
+
+-<p>
+-Another idea was to describe require that the trailing iterator support
+-at least distance(input range) applications of <tt>operator++</tt> and may be
+-written through the same number of times if a mutable/output iterator.
+-</p>
+
+ <p>
+-We might also consider handling the case of an output range vs. an input
+-range in separate paragraphs, if that simplifies how we describe some of
+-these constraints.
++Removed <tt>vector</tt> from list of templates that should be adjusted as of meeting outcome.
+ </p>
+
+ <p><i>[
+-2009-11-03 Howard adds:
++2010 post-Batavia
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
+-</blockquote>
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Does not have sufficient support at this time. May wish to reconsider for a
+-future standard.
++Replaced <tt>vector&lt;bool&gt;</tt> reference by <tt>vector</tt> reference because of misinterpreting meeting typo.
++Additional corrected numbering in P/R to N3225 wording.
+ </p>
+
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
++<p><i>[
++2010-12-06 Daniel reopens
++]</i></p>
+
+
+-<hr>
+-<h3><a name="1239"></a>1239. Defect report</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-10-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+ <p>
+-Table 43 defines a number of traits that yield true for arrays of class
+-types with the trait's property, but not arrays of other types with that
+-property. For example, <tt>has_trivial_default_constructor</tt>:
++Unfortunately, the current P/R is defective for several reasons:
+ </p>
+-
++<ol>
++<li> Table 43 &mdash; Descriptive variable definitions still contains three
++references to <tt>T&amp;</tt>, namely in:
+ <blockquote>
+-<tt>T</tt> is a trivial type (3.9) or a class type with a trivial default
+-constructor (12.1) or an array of such a class type.
+-</blockquote>
++<table border="1">
++<tr>
++<td>
++<tt>t</tt>
++</td>
++<td>a value of type <tt>const T&amp;</tt></td>
++</tr>
++<tr>
++<td>
++<tt>r</tt>
++</td>
++<td>a value of type <tt>T&amp;</tt> obtained by the expression <tt>*p</tt></td>
++</tr>
++<tr>
++<td>
++<tt>s</tt>
++</td>
++<td>a value of type <tt>const T&amp;</tt> obtained by the expression <tt>*q</tt>
++or by conversion from a value <tt>r</tt></td>
++</tr>
++</table>
++</blockquote>
++Especially the second and third items are misses in the 1318 P/R,
++e.g. in N2723 or in C++03 these were referring
++to <tt>X::reference</tt> and <tt>X::const_reference</tt>, resp.
++None of them is referenced anywhere in the allocator requirements
++table: <tt>r</tt> and <tt>s</tt> where historically needed to
++define the expressions <tt>a.address(r)</tt> and <tt>a.address(s)</tt> which are gone now,
++and <tt>t</tt> was needed to define the expression <tt>a.construct(p, t)</tt> which has been
++replaced by <tt>a.construct(p,args)</tt>.
++<p/>
++The easiest fix seems to be to remove all three rows from Table 43.
++</li>
++<li>
++Further-on, the current P/R suggests to replace the the current
++definitions of the adaptor classes
++<blockquote><pre>
++stack
++priority_queue
++queue
++</pre></blockquote>
++similar to the other container types, i.e. to define <tt>reference</tt> and
++<tt>const_reference</tt> now as
++<blockquote><pre>
++typedef typename allocator_traits&lt;Allocator&gt;::reference reference;
++typedef typename allocator_traits&lt;Allocator&gt;::const_reference const_reference;
++</pre></blockquote>
++This would not only be an ill-formed definition (because there is no name
++<tt>Allocator</tt> in scope), but it would also introduce a breakage compared to C++03,
++where these definitions where already referring to the definition of the wrapped
++containers. So, the adaptor class templates should be removed from the current list.
++</li>
++<li>
++Then the current P/R wording leads to one further unexpected and unwanted change due to
++the general formular used: <tt>match_result::reference</tt> is currently defined as
++<blockquote><pre>
++typedef const_reference reference;
++</pre></blockquote>
++because it is an <em>immutable</em> container (And we had this definition
++already in N2723). The application of the rule would change this silently.
++</li>
++<li>
++Finally the suggested wording for the <tt>unordered_</tt> containers is incomplete.
++The reason is a current inconsistency between these containers and the rest: While
++normally the definition of the pointer types is
++<blockquote><pre>
++typedef typename allocator_traits&lt;Allocator&gt;::pointer pointer;
++typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
++</pre></blockquote>
++for the unordered containers they are
++<blockquote><pre>
++typedef typename allocator_type::pointer pointer;
++typedef typename allocator_type::const_pointer const_pointer;
++</pre></blockquote>
++These definitions are <em>not</em> equivalent, because allocators are no longer
++required to define typedefs <tt>pointer</tt> and <tt>const_pointer</tt>, the
++<tt>allocator_traits</tt> were invented as a further indirection to cope
++with that. I.e. for the unordered containers we need to bring both the definition
++of references <em>and</em> pointers in sync.
++</li>
++</ol>
+
+ <p><i>[
+-2009-10 post-Santa Cruz:
++2011-02-23 Daniel updates the proposed wording with support from Pablo
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-An array of a trivial type is a trivial type.
+-</p>
+-<p>
+-Mark as Tentatively NAD Editorial. The wording is OK as is,
+-since an array of a trivial type is a trivial type, but the wording as
+-proposed might be clearer.
+-</p>
+-</blockquote>
+-
+-
++<p>The update attempts to fix the backward-compatibility problem that we have
++introduced by ignoring the C++03 member function overloads <tt>address</tt>
++of allocator types in C++0x completely. The resolution attempts to fix that
++by adding these functions as optional members of allocators that are considered
++first before falling back to <tt>pointer_traits::pointer_to</tt>. This still
++allows us to remove the unused symbol <tt>t</tt> from the table, but we adapt
++the symbols <tt>r</tt> and <tt>s</tt> to purely refer to the typenames
++<tt>reference</tt> and <tt>const_reference</tt>.</p>
+
+-<p><b>Rationale:</b></p>
+-<p>
+-The wording is OK as is, since an array of a trivial type is a trivial type.
+-Project editor may wish to accept the suggested wording as editorial.
+-</p>
++<p><i>[2011-03-06 Daniel adapts numbering to N3242]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change all the traits in question following this pattern:
+-</p>
++<p><i>[2011-03-11 Daniel removes <tt>noexcept</tt> specifiers from <tt>address</tt> functions]</i></p>
+
+-<blockquote>
+-<tt>T</tt> is a trivial type (3.9) or a class type with a trivial default
+- constructor (12.1)<ins>,</ins> or an array of such a <del>class</del> type.
+-</blockquote>
+
+-<p>
+-i.e., add a comma and delete a "class."
+-</p>
++<p><i>[2011-03-12 Further wording improvements by Daniel and Pablo]</i></p>
+
+
++<p><i>[2011-03-22 Madrid]</i></p>
+
+
++<p>Closed as NAD, no consensus to make a change</p>
++
+
+-<hr>
+-<h3><a name="1242"></a>1242. Enable SCARY iterators</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2009-10-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-See
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2980.pdf">N2980</a>.
+-</p>
+
++<p><b>Rationale:</b></p><p>No consensus to make a change</p>
+
+ <p><b>Proposed resolution:</b></p>
+
+@@ -45518,105 +35910,170 @@ See
+
+
+ <hr>
+-<h3><a name="1243"></a>1243. Missing <tt>operator+= (initializer_list&lt;T&gt;)</tt> for <tt>valarray</tt></h3>
+-<p><b>Section:</b> 26.6.2.6 [valarray.cassign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cassign">issues</a> in [valarray.cassign].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1330"></a>1330. Move container requirements into requirements tables</h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-03-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP 64</b></p>
++<p>
++Abstract:
++</p>
++<p>
++In general, it seems that in a couple of places container behavior is
++not described in requirement tables although it is a general behavior.
++</p>
+
+ <p>
+-During the additions of <tt>initializer_list</tt> overloads
+-<tt>basic_string</tt> added
++History:
++</p>
++
++<p>
++Issue <a href="lwg-defects.html#676">676</a> added move semantics to unordered containers.
++For the added insert functions the Editor requested to put their
++semantic description into a requirements table rather than describing
++them for each container individually. The text however was taken from
++the associative containers, where we also have the semantics for each
++container described. Also, <a href="lwg-defects.html#1034">1034</a> is to some extend
++requesting a clarification of the requirement tables and it turned out
++that in other places we have the same problem (e.g. we have no general
++requirement for type pointer and const_pointer although each container
++has them with issue <a href="lwg-defects.html#1306">1306</a>).
+ </p>
+
+-<blockquote><pre>basic_string&amp; operator+=(initializer_list&lt;charT&gt;);
++<p>
++From my personal list of functions in requirement tables
++and containers, the following types/functions are missing in
++requirement tables:
++</p>
++
++<ul>
++<li>
++<tt>pointer</tt>, <tt>const_pointer</tt> in Table 91 (container requirements)
++</li>
++<li>
++<p>
++all copy constructors, copy constructors with allocator,
++ assignment operators, and insert operators
++ with move semantics for associative and unordered containers
++</p>
++<blockquote><pre>
++ContType c1(c2&amp;&amp;)
++ContType c1(c2&amp;&amp;,alloc)
++c1 = c2&amp;&amp;
++c.insert(val&amp;&amp;)
++c.insert(pos,val&amp;&amp;)
+ </pre></blockquote>
++</li>
++</ul>
+
+ <p>
+-but
++As a special case, we lack the following requirements for all sequence
++containers BUT array (so special wording or a new container category is
++required):
+ </p>
+
+-<blockquote><pre>valarray&lt;T&gt;&amp; operator+= (initializer_list&lt;T&gt;);
++<ul>
++<li>
++<p>
++constructor with only a size argument
++</p>
++<blockquote><pre>
++ContType c(num)
+ </pre></blockquote>
++</li>
++<li>
++<p>
++copy constructor with allocator and move semantics
++</p>
++<blockquote><pre>
++ContType c1(c2&amp;&amp;,alloc)
++</pre></blockquote>
++</li>
++<li>
++<p>
++all constructors that insert multiple elements with additional allocator
++</p>
++<blockquote><pre>
++ContType c(num, val,alloc)
++ContType c(beg, end,alloc)
++ContType c(initlist,alloc)
++</pre></blockquote>
++</li>
++<li>
++<p>
++all resize functiuons:
++</p>
++<blockquote><pre>
++c.resize(num)
++c.resize(num,val)
++</pre></blockquote>
++</li>
++</ul>
+
+ <p>
+-was not defined.
++Note that we also might have to add additional requirements on other
++places for sequence containers because having an allocator requires
++additional statements for the treatment of the allocators. E.g. swap for
++containers with allocators is not specified in any requirement table.
++</p>
++
++<p>
++And finally, if we have the requirements in the requirements tables, we
++can remove the corresponding descriptions for the individual container.
++However, note that sequence container requirements have NO complexity
++column, so that we still need container specific descriptions for the
++functions listed there.
+ </p>
+
+ <p><i>[
+-Daniel adds on opening:
++2010 Batavia
+ ]</i></p>
+
+-
+-<blockquote>
+-Recommend NAD. The <tt>operator+=</tt> overload of <tt>basic_string</tt>
+-behaves as-if calling <tt>append</tt>, which is completely different in
+-meaning as the existing <tt>operator+=</tt> overloads in
+-<tt>valarray</tt> which just sum the value or values to the existing
+-elements. The suggestion to add a corresponding append function to
+-<tt>valarray</tt> was not considered as appropriate and the request was
+-withdrawn (c++std-lib-24968).
+-</blockquote>
++<p>
++While there is consensus that further cleaning up the container requirement
++tables would be a good thing, there is no feeling that this <em>must</em>
++be done in time for 0x. The issue remains open, but Deferred.
++</p>
+
+ <p><i>[
+-2009-10 Santa Cruz:
++2011 Bloomington
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as NAD. Request has been withdrawn by NB.
+-</blockquote>
++<p>
++Closes as NAD. There are a number of deficiencies in the way the container
++requirements tables are presented, and the LWG welcomes further papers that
++will help clear up this presentation.
++</p>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add to 26.6.2.6 [valarray.cassign]:
+-</p>
+
+-<blockquote><pre>valarray&lt;T&gt;&amp; operator+= (initializer_list&lt;T&gt;);
+-</pre></blockquote>
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1244"></a>1244. wait_*() in *future for synchronous functions</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1331"></a>1331. incorporate move special member functions into library</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2010-03-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-With the addition of <tt>async()</tt>, a <tt>future</tt> might be
+-associated with a function that is not running in a different thread but
+-is stored to by run synchronously on the <tt>get()</tt> call. It's not
+-clear what the <tt>wait()</tt> functions should do in this case.
+-</p>
+-
+-<p>
+-Suggested resolution:
++Review the library portion of the spec and incorporate the newly added
++core feature Move Special Member Functions (N3044).
+ </p>
+
+-<p>
+-Throw an exception.
++<p><b>Rationale:</b></p><p>
++2010 Batavia: This has now been done to a large extent.
+ </p>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
+-</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -45626,2819 +36083,2488 @@ Solved by
+
+
+ <hr>
+-<h3><a name="1246"></a>1246. <tt>vector::resize()</tt> missing efficiency guarantee</h3>
+-<p><b>Section:</b> 23.4.1.2 [vector.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> David Abrahams <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1348"></a>1348. Exception safety of unspecified types</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-64</b></p>
+ <p>
+-If <tt>v</tt> is a <tt>vector</tt>, I think repeated calls to
+-<tt>v.resize( v.size() + 1 )</tt> should be amortized O(1), but it's not
+-clear that's true from the text of the standard:
+-</p>
+-
+-<blockquote><pre>void resize(size_type sz);
+-</pre>
+-<blockquote>
+-<i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent to <tt>erase(begin() + sz, end());</tt>. If
+-<tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> default constructed elements to the
+-sequence.
+-</blockquote>
+-</blockquote>
+-
+-<p>
+-Seems to me if we used <tt>push_back</tt> instead of appends, we might be giving
+-the guarantee I'd like. Thoughts?
++There are a number of unspecified types used throughout
++the library, such as the container iterators. Many of these
++unspecified types have restrictions or expectations on
++their behaviour in terms of exceptions. Are they permitted
++or required to use exception specifications, more
++specifically the new <tt>noexcept</tt> specification? For example,
++if <tt>vector&lt;T>::iterator</tt> is implemented as a native pointer,
++all its operations will have an (effective) <tt>noexcept</tt>
++specification. If the implementation uses a class type to
++implement this iterator, is it permitted or required to
++support that same guarantee?
+ </p>
+
+ <p><i>[
+-2009-11-10 Howard adds:
++Resolution proposed by ballot comment
+ ]</i></p>
+
++<p>
++Clearly state the requirements for exception
++specifications on all unspecified library types. For
++example, all container iterator operations should
++be conditionally <tt>noexcept</tt>, with the condition
++matching the same operation applied to the
++allocator's <tt>pointer_type</tt>, a certain subset of which
++are already required not to throw.
++</p>
+
+-<blockquote>
+-Moved to Tentatively NAD after 5 positive votes on c++std-lib. Rationale added
+-below.
+-</blockquote>
+-
++<p><i>[2011-03-24 Madrid meeting]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In 23.4.1.2 [vector.capacity]/10, change
++<p>Discussion:</p>
++<p>Alisdair: Probably an NAD Future at least but could be NAD.
++<p/>
++Daniel K: Approach is not consistent with what we've decided with <tt>noexcept</tt>.
++<p/>
++Alisdair: Any objection to marking 1348 as NAD?
++<p/>
++No objections.
+ </p>
+
+-<blockquote><pre>void resize(size_type sz);
+-</pre>
+-<blockquote>
+-<i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent to <tt>erase(begin() + sz, end());</tt>. If
+-<tt>size() &lt; sz</tt>, <del>appends <tt>sz - size()</tt> default constructed elements to the
+-sequence</del>
+-<ins>equivalent to <tt>sz - size()</tt> consecutive evaluations of <tt>push_back(T())</tt></ins>.
+-</blockquote>
+-</blockquote>
+-
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-The description in terms of <tt>push_back</tt> led some to believe that
+-one could expect the exact same growth pattern from both <tt>resize</tt> and
+-<tt>push_back</tt> (e.g.) which could lead to sub-optimal implementations.
+-Additionally, 23.4.1 [vector], p1 includes a statement that this container
+-"supports (amortized) constant time insert and erase operations at the end;",
+-therefore addressing the concern of this issue.
+-</p>
++<p><b>Rationale:</b></p><p>Standard is correct as written</p>
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1248"></a>1248. Equality comparison for unordered containers</h3>
+-<p><b>Section:</b> 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2009-10-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord">issues</a> in [unord].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1350"></a>1350. Implicit contructors accidentally made some library types move-only</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1421">1421</a></p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CH-15</b></p>
+ <p>
+-See
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>.
++Due to the new rules about implicit copy and move
++constructors some library facilities are now move-only.
+ </p>
+
+ <p><i>[
+-2010-01-22 Alisdair Opens.
+-]</i></p>
+-
+-
+-<p><i>[
+-2010-01-24 Alisdair provides wording.
+-]</i></p>
+-
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++Resolution proposed by ballot comment
+ ]</i></p>
+
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf">N3068</a>.
++Make them copyable again.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Apply paper
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>.
+-</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1251"></a>1251. move constructing <tt>basic_stringbuf</tt></h3>
+-<p><b>Section:</b> 27.8.1.1 [stringbuf.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-29 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.cons">issues</a> in [stringbuf.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1351"></a>1351. Replace dynamic exception specifications with <tt>noexcept</tt></h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1344">1344</a></p>
+ <p><b>Discussion:</b></p>
+-<p>
+-I just came across issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a> -- Global permission to move, which
+-seems to address the concern raised by the example in c++std-lib-25030.
+-</p>
+-<p>
+-IIUC, the example violates the permission to assume that arguments
+-bound to rvalue references are unnamed temporaries granted to
+-implementations by the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a> - Global permission
+-to move.
+-</p>
+-
+-<p>
+-I.e., the <tt>ostringstream(ostringstream &amp;&amp;rhs)</tt> ctor can leave the <tt>rhs</tt>
+-pointers pointing to the newly constructed object's buffer just as
+-long as the dtor doesn't change or invalidate the buffer. The caller
+-may not make any assumptions about rhs after the move beyond it being
+-safe to destroy or reassign.
+-</p>
+
++<p><b>Addresses CH-16</b></p>
+ <p>
+-So unless I misunderstood something, I still think the <tt>basic_stringbuf</tt>
+-move ctor is overspecified. Specifically, I think the third sentence
+-in the Effects clause and the last 6 bullets in the Postconditions
+-clause can, and IMO should, be stricken.
++Dynamic exception specifications are deprecated.
++Deprecated features shouldn't be used in the Standard.
+ </p>
+
+ <p><i>[
+-2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
++Resolution proposed by ballot comment
+ ]</i></p>
+
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-The sense of 1251 appears to be that the <tt>basic_stringbuf</tt> move
+-constructor offers more guarantees than the minimum. This is true, and quite
+-correct. The additional words guarantee that the internal buffer has genuinely
+-transferred from one object to another, and further operations on the original
+-will not affect the buffer of the newly created object. This is a very
+-important guarantee, much as we see that a moved-from <tt>unique_ptr</tt> is
+-guaranteed to be empty.
++Replace dynamic exception specifications with <tt>noexcept</tt>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Strike from 27.8.1.1 [stringbuf.cons]:
+-</p>
+-
+-<blockquote><pre>basic_stringbuf(basic_stringbuf&amp;&amp; rhs);
+-</pre>
+-<blockquote>
+-<p>
+-<i>Effects:</i> Move constructs from the rvalue <tt>rhs</tt>. It is
+-implementation-defined whether the sequence pointers in <tt>*this</tt>
+-(<tt>eback()</tt>, <tt>gptr()</tt>, <tt>egptr()</tt>, <tt>pbase()</tt>,
+-<tt>pptr()</tt>, <tt>epptr()</tt>) obtain the values which <tt>rhs</tt>
+-had. <del>Whether they do or not, <tt>*this</tt> and <tt>rhs</tt> reference
+-separate buffers (if any at all) after the construction.</del> The openmode,
+-locale and any other state of <tt>rhs</tt> is also copied.
+-</p>
+-
+-<p>
+-<i>Postconditions:</i> Let <tt>rhs_p</tt> refer to the state of
+-<tt>rhs</tt> just prior to this construction and let <tt>rhs_a</tt>
+-referto the state of <tt>rhs</tt> just after this construction.
+-</p>
+-<ul>
+-<li>
+-<tt>str() == rhs_p.str()</tt>
+-</li>
+-<li>
+-<tt>gptr() - eback() == rhs_p.gptr() - rhs_p.eback()</tt>
+-</li>
+-<li>
+-<tt>egptr() - eback() == rhs_p.egptr() - rhs_p.eback()</tt>
+-</li>
+-<li>
+-<tt>pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()</tt>
+-</li>
+-<li>
+-<tt>epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()</tt>
+-</li>
+-<li><del>
+-if <tt>(eback()) eback() != rhs_a.eback()</tt>
+-</del></li>
+-<li><del>
+-if <tt>(gptr()) gptr() != rhs_a.gptr()</tt>
+-</del></li>
+-<li><del>
+-if <tt>(egptr()) egptr() != rhs_a.egptr()</tt>
+-</del></li>
+-<li><del>
+-if <tt>(pbase()) pbase() != rhs_a.pbase()</tt>
+-</del></li>
+-<li><del>
+-if <tt>(pptr()) pptr() != rhs_a.pptr()</tt>
+-</del></li>
+-<li><del>
+-if <tt>(epptr()) epptr() != rhs_a.epptr()</tt>
+-</del></li>
+-</ul>
+-</blockquote>
+-</blockquote>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="1259"></a>1259. Should initializer-list constructors move elements?</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-11-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1352"></a>1352. Apply <tt>noexcept</tt> where library specification says "Throws: Nothing"</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1346">1346</a></p>
+ <p><b>Discussion:</b></p>
++
++<p><b>Addresses CH-17</b></p>
+ <p>
+-According to 23.2.3 [sequence.reqmts], <tt>X(il)</tt> is
+-equivalent to <tt>X(il.begin(), il.end())</tt>. Should it instead be
+-equivalent to <tt>X(move_iterator(il.begin()),
+-move_iterator(il.end()))</tt> so that needless copies are not made? This
+-doesn't seem ideal either - it may make more sense to provide two
+-overloads for the constructor, one for move and one for copy.
++The introduction of <tt>noexcept</tt> makes "Throws: Nothing" clauses looking strange.
+ </p>
+
+ <p><i>[
+-2009-11-10 Howard adds:
++Resolution proposed by ballot comment
+ ]</i></p>
+
+-
+-<blockquote>
+-I've moved this issue to Tentatively NAD after 5 positive votes on c++std-lib,
+-and added a rationale below.
+-</blockquote>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
++Consider replacing "Throws: Nothing." clause by
++the respective noexcept specification.
+ </p>
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-There is no consensus at this time within EWG or CWG to make the
+-required language changes. Therefore this is not something that the LWG
+-can even consider. Should such language changes be made for a future
+-standard, no doubt there would need to be an accompanying library impact
+-survey.
+-</p>
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1263"></a>1263. missing <tt>swap</tt> overloads for <tt>regex</tt></h3>
+-<p><b>Section:</b> 28.4 [re.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-11-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1358"></a>1358. Add <tt>&lt;chrono&gt;</tt> and <tt>&lt;ratio&gt;</tt> to
++freestanding implementations</h3>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses: UK 314</b></p>
+-
++<p><b>Addresses GB-55</b></p>
+ <p>
+-In Message c++std-lib-25529, Alisdair writes:
++The <tt>&lt;thread&gt;</tt> header uses <tt>duration</tt> types, found in the
++<tt>&lt;chrono&gt;</tt> header, and which rely on the <tt>ratio</tt> types
++declared in the <tt>&lt;ratio></tt> header.
+ </p>
+
+-<blockquote>
++<p><i>[
++Extracts from lengthy Rapperswil discussion:
++]</i></p>
++
+ <p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3009.html#UK314">UK comment 314</a>
+-requests rvalue swap overloads in a couple of places they
+-were missed.
++There is a concern that this issue is a misunderstanding of the actual
++requirements of a free-standing implementation to support the <tt>&lt;thread></tt>
++header. In general, a free-standanding implementation will provide an <em>empty</em>
++header, specifically so that a user can test for the absence of the
++<tt>_ _ STDCPP_THREADS _ _</tt> macro. This idiom as used as there is no portable
++way to test for the lack of a header.
+ </p>
+-
+ <p>
+-We have in general reverted to the single swap signature taking lvalue
+-references, which could be seen as the alternative solution to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3009.html#UK314">UK 314</a>,
+-bringing consistency to the standard &lt;g&gt;
++At this point, it was suggested the NB comment is trying to solve the wrong problem,
++and that <tt>_ _ STDCPP_THREADS _ _</tt> should be a pre-defined macro in clause 16
++that can be tested before including <tt>&lt;thread&gt;</tt>. That would remove the
++need to add additional headers to the free-standanding requirements.
+ </p>
+-
+ <p>
+-Either way, I no longer expect to see any work to resolve this comment -
+-the work is complete and it should be either marked Rejected, or
+-Accepted with Modifications (namely, removing all other rvalue swaps!)
++It is worth noting that Japan requested <tt>&lt;ratio&gt;</tt> as a free-standing header
++in their CD1 comments. No-one seemed keen to require clocks of a free-standing
++implementation though.
+ </p>
+-</blockquote>
++
++<p>Detlef volunteers to look at a way to redraft 17.6.1.3 p3.</p>
+
+ <p><i>[
+-Moved to Tentatively NAD after 5 positive votes on c++std-lib.
++Original resolution proposed by NB comment:
+ ]</i></p>
+
+
++<blockquote>
++<p>
++Add the <tt>&lt;chrono&gt;</tt> and <tt>&lt;ratio&gt;</tt> headers to the
++freestanding requirements.
++</p>
++<p>
++It might be necessary to address scaled-down
++expectations of clock support in a freestanding
++environment, much like <tt>&lt;thread&gt;</tt>.
++</p>
++</blockquote>
+
+-<p><b>Proposed resolution:</b></p>
++<p><i>[2011-02-25: Alberto drafts wording]</i></p>
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-We have in general reverted to the single swap signature taking
+-lvalue references, which could be seen as the alternative solution to
+-UK 314, bringing consistency to the standard.
+-</p>
++<p><i>[2011-03-06: Daniel observes:]</i></p>
+
+
++<p>Accepting the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3256.html">n3256</a>
++would solve this issue.</p>
+
++<p><i>[2011-03-24 Madrid meeting]</i></p>
+
+
+-<hr>
+-<h3><a name="1265"></a>1265. <tt>longjmp</tt> and destructors</h3>
+-<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2009-11-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-18.10 [support.runtime]/4 says that <tt>longjmp</tt> is undefined if
+-unwinding by the mechanism used by catch and throw would invoke any nontrivial
+-destructors. However, the text as written is rather vague, in particular when
+-dealing with <tt>catch(...)</tt>:
+-</p>
++<p>Freestanding no longer requires <tt>&lt;thread&gt;</tt> header</p>
+
+-<blockquote><pre>void foo() {
+- jump_buf buf;
+- non_trivial_dtor n1; // 1
+- if (!setjmp(buf)) {
+- non_trivial_dtor n2; // 2
+- try {
+- longjmp(buf, 1);
+- } catch (...) {
+- }
+- }
+-}
+-</pre></blockquote>
+
+-<p>
+-My interpretation of the meaning of 18.10 [support.runtime]/4 is that
+-declaration 2, but not 1, would cause the <tt>longjmp</tt> to be undefined
+-behavior. However, it's not entirely clear from the text. Arguably, replacing
+-the <tt>setjmp</tt> and <tt>longjmp</tt> with <tt>catch</tt> would still cause
+-the destructor for <tt>n1</tt> to be called after the unwinding, which would
+-lead to undefined behavior. This is clearly not an intended consequence of the
+-wording. However, it is probably still UB, as <tt>n1</tt> now has
+-"indeterminate" value, and running its destructor on <tt>foo</tt>'s exit will
+-cause Bad Things.
+-</p>
++<p><b>Rationale:</b></p><p>We are not adding new headers to freestanding at this point.</p>
+
+-<p>
+-Declarations 2 has a more interesting issue. The <tt>catch(...)</tt> muddles up
+-the definition that uses <tt>throw</tt> and <tt>catch</tt> - if
+-<tt>longjmp()</tt> were indeed a <tt>throw</tt>, control would never return to
+-the <tt>setjmp</tt>. As such, <tt>n2</tt>'s destructor wouldn't be called
+-(except by the argument for <tt>n1</tt>, which is that the destructor would be
+-called later as the frame was left in the normal control flow).
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-I suggest that paragraph 4 of 18.10 [support.runtime] should be replaced
+-with the following, or something that reads better but has the same effect:
+-</p>
++<ol>
++<li><p>Add a new entry in Table 14 &mdash; C++ library headers:</p>
+
+ <blockquote>
+-The function signature <tt>longjmp(jmp_buf jbuf, int val)</tt> has more
+-restricted behavior in this International Standard. A call to <tt>longjmp</tt>
+-has undefined behavior if any non-trivial destructors would be called were the
+-<tt>longjmp</tt> call replaced with a throw-expression whose nearest matching
+-handler were a (possibly imaginary) function-try-block on the function
+-containing the corresponding <tt>setjmp</tt> call.
+-</blockquote>
++<table border="1">
++<caption>Table 14 &mdash; C++ library headers</caption>
++<tr>
++<td style="text-align:center;">&hellip;</td>
++</tr>
++<tr>
++<td><tt>&lt;iterator&gt;</tt></td>
++</tr>
++<tr>
++<td><ins><tt>&lt;library_support&gt;</tt></ins></td>
++</tr>
++<tr>
++<td><tt>&lt;limits&gt;</tt></td>
++</tr>
++<tr>
++<td style="text-align:center;">&hellip;</td>
++</tr>
++</table>
++</blockquote>
++</li>
+
+-<p><i>[
+-2009-11-17 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
+-]</i></p>
++<li><p>Remove the last row 30.3 [thread.threads] <tt>&lt;threads&gt;</tt>
++from Table 16 &mdash; C++ headers for freestanding implementations and insert
++a new one instead (To the editor: For the actual target Clause please see the comment
++in bullet 5 of this proposed resolution):</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 16 &mdash; C++ headers for freestanding implementations</caption>
+
++<tr>
++<th>Subclause</th>
++<th>Header(s)</th>
++</tr>
+
++<tr>
++<td colspan="2" style="text-align:center;">&hellip;</td>
++</tr>
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 18.10 [support.runtime]/4:
+-</p>
++<tr>
++<td><del>30.3 [thread.threads] Threads</del></td>
++<td><del><tt>&lt;thread&gt;</tt></del></td>
++</tr>
++
++<tr>
++<td><ins>?? Library support</ins></td>
++<td><ins><tt>&lt;library_support&gt;</tt></ins></td>
++</tr>
++
++</table>
+
+-<blockquote>
+-The function signature <tt>longjmp(jmp_buf jbuf, int val)</tt> has more
+-restricted behavior in this International Standard. <del>A
+-<tt>setjmp</tt>/<tt>longjmp</tt> call pair has undefined behavior if replacing
+-the <tt>setjmp</tt> and <tt>longjmp</tt> by <tt>catch</tt> and <tt>throw</tt>
+-would invoke any non-trivial destructors for any automatic objects.</del>
+-<ins>A call to <tt>longjmp</tt> has undefined behavior if any non-trivial
+-destructors would be called were the <tt>longjmp</tt> call replaced with a
+-throw-expression whose nearest matching handler were a (possibly imaginary)
+-function-try-block on the function containing the corresponding <tt>setjmp</tt>
+-call.</ins>
+ </blockquote>
++ </li>
++
++ <li><p>Modify paragraph 17.6.1.3 [compliance] p. 3:</p>
++ <blockquote><p>
++ 3 The supplied version of the header <tt>&lt;cstdlib&gt;</tt> shall declare at least the functions
++ <tt>abort</tt>, <tt>atexit</tt>, <tt>at_quick_exit</tt>, <tt>exit</tt>, and <tt>quick_exit</tt>
++ (18.5). <del>The supplied version of the header <tt>&lt;thread&gt;</tt> shall meet the
++same requirements as for a hosted implementation or including it shall have no effect</del>. The
++other headers listed in this table shall meet the same requirements as for a hosted
++implementation. <ins>A program can detect the presence of standard headers not listed in Table
++16 using the facilities provided by the <tt>&lt;library_support&gt;</tt> header.</ins>
++</p></blockquote>
++</li>
++
++<li><p>Remove the following line from the header <tt>&lt;thread&gt;</tt> synopsis in
++30.3 [thread.threads] p. 1:</p>
++<blockquote><pre>
++namespace std {
++ <del>#define __STDCPP_THREADS__ __cplusplus</del>
++
++ class thread;
++ [...]
++}
++</pre></blockquote>
++</li>
+
++<li><p>Add a new section in Clause 18 or 20 (or any other suitable place at
++the editor's discretion):</p>
+
+-<p><b>Rationale:</b></p>
+-<p>
+-In the given example, it is clear that it is only <tt>n2</tt> and not
+-<tt>n1</tt> that is destroyed by the <tt>longjmp</tt>.
+-</p>
+-<p>
+-At this late stage in the standards process, we are focusing on issues that
+-impact users or implementers. Trying to rewrite complex wording just for the
+-sake of improved clarity is likely to do more harm than good.
+-</p>
++<blockquote>
++<p><ins>?? Library support [library.support]</ins></p>
++<blockquote><p>
++<ins>The header <tt>&lt;library_support&gt;</tt> defines an implementation-defined set
++of macros to allow a program detect the presence of standard headers in freestanding
++implementations. [<i>Note</i>: Hosted implementations shall provide all
++standard headers, thus shall provide all macros. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>For each standard header listed in Tables 14 (C++ library headers) and 15 (C++ headers for C library facilities)
++that is provided by the implementation, <tt>&lt;library_support&gt;</tt> shall define a macro with name
++<code>_ _HAS_<i>XXX</i>_HEADER_ _</code> where <code><i>XXX</i></code> is replaced by the uppercase version of the
++name of the header. Each such macro shall expand to the value <code>_ _cplusplus</code>.
++[<i>Example</i>:</ins></p>
++<blockquote><pre>
++<ins>#include &lt;library_support&gt;
++
++#ifdef _ _HAS_THREADS_HEADER_ _
++ #include &lt;threads&gt;
++ // code that exploit the presence of threads
++#else
++ // fallback code that doesn't rely on threads
++#endif</ins>
++</pre></blockquote>
++<p><ins>&mdash; <i>end example</i>]</ins></p>
++</blockquote>
++<blockquote><p>
++<ins>No other standard header shall define macros with a name beginning with <code>_ _HAS_</code>
++and ending with <code>_HEADER_ _</code>.</ins>
++</p></blockquote>
++
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1266"></a>1266. <tt>shared_future::get</tt> and deferred async functions</h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1359"></a>1359. Add <tt>&lt;tuple&gt;</tt> and <tt>&lt;utility&gt;</tt> to freestanding implementations</h3>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-56</b></p>
++<p>
++The <tt>&lt;utility&gt;</tt> header provides support for several
++important C++ idioms with <tt>move</tt>, <tt>forward</tt> and <tt>swap</tt>.
++Likewise, <tt>declval</tt> will be frequently used like a type trait.
++In order to complete cycles introduced by <tt>std::pair</tt>, the
++<tt>&lt;tuple&gt;</tt> header should also be made available. This is a
++similarly primitive set of functionality, with no dependency
++of a hosted environment, but does go beyond the minimal
++set of functionality otherwise suggested by the
++freestanding libraries.
++</p>
+ <p>
+-If a <tt>shared_future</tt> is constructed with the result of an <tt>async</tt> call with a
+-deferred function, and two or more copies of that <tt>shared_future</tt> are created,
+-with multiple threads calling <tt>get()</tt>, it is not clear which thread runs the
+-deferred function. 30.6.7 [futures.shared_future]p22 from
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>
+-says (minus editor's note):
++Alternatively, split the <tt>move</tt>/<tt>forward</tt>/<tt>swap</tt>/<tt>declval</tt>
++functions out of <tt>&lt;utility&gt;</tt> and into a new primitive header,
++requiring only that of freestanding implementation.
+ </p>
+
+-<blockquote>
+-<i>Effects:</i> if the associated state contains a deferred function, executes
+-the deferred function. Otherwise, blocks until the associated state is ready.
+-</blockquote>
++<p><i>[
++Summary of Rapperswil discusions
++]</i></p>
++
++<p>
++The preference of the meeting was to extract the rvalue-reference related utilities
++and swap into a freestanding header, but there was no clear preference for a name.
++Howard suggested simply dropping them into <tt>&lt;type_traits&gt;</tt> as both
++these utilities and type traits are used pretty much everywhere in the library
++implementation, it is the most convenient place to keep them (from an implementer's
++perspective).
++</p>
+
+ <p>
+-In the absence of wording to the contrary, this implies that every thread that
+-calls <tt>wait()</tt> will execute the deferred function.
++Poll: Two-way: New header for forward, move, swap, move_with_noexcept and declval vs.
++calling out forward, move, swap, move_with_noexcept and declval as freestanding explicitly?
++
++SF new header: 4 WF new header: 3 WF call out as freestanding: 1 SF call out as freestanding: 2
++
++Alisdair: Willing to write up both solutions, give us some time to think on it.
++
++Action: Need an issue and proposed wording for GB 56 - Alisdair to draft both options as in the last poll.
+ </p>
+
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++Resolution proposed by ballot comment
+ ]</i></p>
+
++<blockquote>
++<p>
++Add <tt>&lt;utility&gt;</tt> and <tt>&lt;tuple&gt;</tt> to table 15, headers
++required for a free-standing implementation.
++</p>
++</blockquote>
+
++<p><i>[
++2010-Batavia:
++]</i></p>
+
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++Closed as NAD, reversing the decision at Rapperswil.
+ </p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Replace 30.6.7 [futures.shared_future]p22 with the following:
++The consensus was that
++any freestanding implementation is going to feel compelled to offer the important
++features of <tt>&lt;utility></tt> even if we do not make them a freestanding
++requirement; breaking out additional small headers may have additional costs at
++compile time, and while the critical <tt>move</tt>-related functions could migrate
++to <tt>&lt;type_traits></tt>, the header name is far from appealing; adding the
++whole of <tt>&lt;utility></tt> starts to drag in dependencies on <tt>&lt;tuple></tt>
++and <tt>&lt;memory></tt>, so we prefer to place the burden of slicing or supporting
++this whole header on free-standing vendors.
+ </p>
+
+-<blockquote>
+-<p>
+-<i>Effects:</i> If the associated state
+-<del>contains a deferred function, executes the deferred function. Otherwise,
+-blocks until the associated state is ready.</del>
+-<ins>was created by a <tt>promise</tt> or <tt>packaged_task</tt> object, block
+-until the associated state is ready. If the associated state is associated with
+-a thread created for an <tt>async</tt> call (30.6.9 [futures.async]), as
+-if <tt>associated-thread.join()</tt>.
+-</ins></p>
+
+-<p><ins>
+-If the associated state contains a deferred function, calls to <tt>wait()</tt>
+-on all <tt>shared_future</tt> objects that share the same associated state are
+-serialized. The first call to <tt>wait()</tt> that shares a given associated
+-state executes the deferred function and stores the return value or exception in
+-the associated state.
+-</ins></p>
+
+-<p><ins>
+-<i>Synchronization:</i> if the associated state was created by a
+-<tt>promise</tt> object, the completion of <tt>set_value()</tt> or
+-<tt>set_exception()</tt> to that <tt>promise</tt> happens before (1.10 [intro.multithread]) <tt>wait()</tt> returns. If the associated state
+-was created by a <tt>packaged_task</tt> object, the completion of the associated
+-task happens before <tt>wait()</tt> returns. If the associated state is
+-associated with a thread created for an <tt>async</tt> call (30.6.9 [futures.async]), the completion of the associated thread happens-before
+-<tt>wait()</tt> returns.
+-</ins></p>
++<p><b>Proposed resolution:</b></p>
+
+-<p><ins>
+-If the associated state contained a deferred function, the invocation of the
+-deferred function happens-before any call to <tt>wait()</tt> on a
+-<tt>future</tt> that shares that state returns.
+-</ins></p>
+-</blockquote>
+
++<p><b>Rationale:</b></p><p>No consensus for a change at this time.</p>
+
+
+
+
+ <hr>
+-<h3><a name="1269"></a>1269. Associated state doesn't account for async</h3>
+-<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.state">active issues</a> in [futures.state].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.state">issues</a> in [futures.state].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1361"></a>1361. Does use of <tt>std::size_t</tt> in a header imply that typedef name is available to users?</h3>
++<p><b>Section:</b> 17.6.2 [using] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-58</b></p>
++<p>
++It is not clear whether a library header specified in terms
++of a typedef name makes that same typedef name
++available for use, or if it simply requires that the specified
++type is an alias of the same type, and so the typedef name
++cannot be used without including the specific header that
++defines it. For example, is the following code required to
++be accepted:
++</p>
++<blockquote><pre>
++#include &lt;vector&gt;
++std::size_t x = 0;
++</pre></blockquote>
+ <p>
+-The current description of the associated state in 30.6.4 [futures.state]
+-does not allow for futures created by an <tt>async</tt> call. The description
+-therefore needs to be extended to cover that.
++Most often, this question concerns the typedefs defined in
++header <tt>&lt;cstddef&gt;</tt>
+ </p>
+
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++Resolution proposed by ballot comment:
+ ]</i></p>
+
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++Add a paragraph under 17.6.2 [using] clarifying whether
++or not headers specified in terms of <tt>std::size_t</tt> can
++be used to access the typedef <tt>size_t</tt>, or whether
++the header <tt>&lt;cstddef&gt;</tt> must be included to reliably
++use this name.
+ </p>
++<p><i>[Batavia: NAD - see rationale below]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add a new sentence to 30.6.4 [futures.state] p2:
+-</p>
+-
+-<blockquote>
+-2 This <i>associated state</i> consists of some state information and some
+-(possibly not yet evaluated) <i>result</i>, which can be a (possibly
+-<tt>void</tt>) value or an exception. <ins>If the associated state was created
+-by a call to <tt>async</tt> (30.6.9 [futures.async]) then it may also
+-contain a deferred function or an associated <tt>thread</tt>.</ins>
+-</blockquote>
+
+-<p>
+-Add an extra bullet to 30.6.4 [futures.state] p3:
+-</p>
+
+-<blockquote>
+-<p>
+-The result of an associated state can be set by calling:
+-</p>
+-<ul>
+-<li>
+-<tt>promise::set_value</tt>,
+-</li>
+-<li>
+-<tt>promise::set_exception</tt>, <del>or</del>
+-</li>
+-<li>
+-packaged_task::operator()<del>.</del><ins>, or</ins>
+-</li>
+-<li>
+-<ins>a call to <tt>async</tt> (30.6.9 [futures.async]).</ins>
+-</li>
+-</ul>
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
++<p><b>Rationale:</b></p><p>The standard is correct as written.</p>
+
+
+
+
+ <hr>
+-<h3><a name="1272"></a>1272. confusing declarations of <tt>promise::set_value</tt></h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1369"></a>1369. <tt>rethrow_exception</tt> may introduce data races</h3>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-74</b></p>
+ <p>
+-The definitions of <tt>promise::set_value</tt> need tidying up, the
+-synopsis says:
++One idea for the <tt>exception_ptr</tt> type was that a reference-counted
++implementation could simply 'reactivate' the same
++exception object in the context of a call to
++<tt>rethrow_exception</tt>. Such an implementation would allow
++the same exception object to be active in multiple threads
++(such as when multiple threads join on a <tt>shared_future</tt>)
++and introduce potential data races in any exception
++handler that catches exceptions by reference - notably
++existing library code written before this capability was
++added. <tt>rethrow_exception</tt> should <em>always</em> make a copy
++of the target exception object.
+ </p>
+
+-<blockquote><pre>// setting the result
+-void set_value(const R&amp; r);
+-void set_value(<i>see below</i>);
+-</pre></blockquote>
++<p><i>[Resolution suggested by NB comment]</i></p>
+
+-<p>
+-Why is the first one there? It implies it is always present for all
+-specialisations of promise, which is not true.
+-</p>
+
+ <p>
+-The definition says:
++Add the following to 18.8.5, [propogation]
+ </p>
++<blockquote><p><ins>
++<i>Throws</i>: a copy of the exception object to which <tt>p</tt> refers.
++</ins></p></blockquote>
+
+-<blockquote><pre>void set_value(const R&amp; r);
+-void promise::set_value(R&amp;&amp; r);
+-void promise&lt;R&amp;&gt;::set_value(R&amp; r);
+-void promise&lt;void&gt;::set_value();
+-</pre></blockquote>
++<p><i>[2011-03-15: Anthony drafts wording]</i></p>
+
+-<p>
+-The lack of qualification on the first one again implies it's present
+-for all specialisations, again not true.
+-</p>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
++<p><i>[2011-03-23 Madrid meeting]</i></p>
+
+
++<p>No consensus for a change</p>
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
+-</p>
+
++<p><b>Rationale:</b></p><p>It would break too many existing implementations</p>
+
+ <p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Alter 15.1 [except.throw] p. 5 as follows:</p>
++
++<blockquote><p>
++5 When the thrown object is a class object, the copy/move constructor and the destructor shall be accessible,
++even if the copy/move operation is elided (12.8 [class.copy]). <ins>The copy constructor shall be
++accessible, and is odr-used (3.2 [basic.def.odr]), even if the copy operation is elided,
++or a move constructor used to construct the exception object.</ins>
++</p></blockquote>
++</li>
++
++<li><p>Alter 18.8.5 [propagation] p. 7 as follows:</p>
++
++<blockquote><pre>
++exception_ptr current_exception() noexcept;
++</pre><blockquote>
+ <p>
+-Change the synopsis in 30.6.5 [futures.promise]:
++7 <i>Returns</i>: An <tt>exception_ptr</tt> object that refers to <del>the currently handled exception
++(15.3 [except.handle]) or</del> a copy of the currently handled exception, or a null <tt>exception_ptr</tt>
++object if no exception is being handled. The referenced object shall remain valid at least as long as there
++is an <tt>exception_ptr</tt> object that refers to it. If the function needs to allocate memory and the
++attempt fails, it returns an <tt>exception_ptr</tt> object that refers to an instance of <tt>bad_alloc</tt>.
++It is unspecified whether the return values of two successive calls to <tt>current_exception</tt> refer to
++the same exception object. [ <i>Note</i>: That is, it is unspecified whether <tt>current_exception</tt>
++creates a new copy each time it is called. &mdash; <i>end note</i> ] If the attempt to copy the current
++exception object throws an exception,<ins> or is otherwise not possible,</ins> the function returns an
++<tt>exception_ptr</tt> object that refers to the thrown exception <ins>if any</ins> or, <del>if this is not possible,</del>
++to an instance of <tt>bad_exception</tt>. [ <i>Note</i>: The copy constructor of the thrown exception
++may also fail, so the implementation is allowed to substitute a <tt>bad_exception</tt> object to avoid
++infinite recursion. &mdash; <i>end note</i> ]
+ </p>
++</blockquote></blockquote>
++</li>
+
+-<blockquote><pre>// setting the result
+-<del>void set_value(const R&amp; r);</del>
+-void set_value(<i>see below</i>);
+-</pre></blockquote>
++<li><p>Alter 18.8.5 [propagation] p. 9 and add a new paragraph after p. 9 as follows:</p>
+
++<blockquote><pre>
++[[noreturn]] void rethrow_exception(exception_ptr p);
++</pre><blockquote>
+ <p>
+-And the definition be changed by qualifying the first signature:
++8 <i>Requires</i>: <tt>p</tt> shall not be a null pointer.
++<p/>
++9 <i>Throws</i>: <ins>a copy of</ins> the exception object to which <tt>p</tt> refers<ins>, or any exception
++thrown by the attempt to copy the exception object to which <tt>p</tt> refers</ins>.
++<p/>
++<ins>? <i>Synchronization</i>: Calls to <tt>rethrow_exception</tt> on <tt>exception_ptr</tt> objects
++that refer to the same exception object shall appear to occur in a single total order. The completion
++of each call shall synchronize with (1.10 [intro.multithread]) the next call in that total order.</ins>
+ </p>
++</blockquote></blockquote>
++</li>
++</ol>
+
+-<blockquote><pre>void <ins>promise::</ins>set_value(const R&amp; r);
+-void promise::set_value(R&amp;&amp; r);
+-void promise&lt;R&amp;&gt;::set_value(R&amp; r);
+-void promise&lt;void&gt;::set_value();
+-</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1273"></a>1273. <tt>future::valid</tt> should be callable on an invalid future</h3>
+-<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1371"></a>1371. Standard exceptions require stronger no-throw guarantees</h3>
++<p><b>Section:</b> 19 [diagnostics] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-75</b></p>
+ <p>
+-30.6.6 [futures.unique_future]/3 says:
+-</p>
+-
+-<blockquote>
+-The effect of calling any member function other than the destructor or
+-the move-assignment operator on a <tt>future</tt> object for which <tt>valid() ==
+-false</tt> is undefined.
+-</blockquote>
+-
+-<p>
+-This means calling <tt>future::valid()</tt> is undefined unless it will
+-return <tt>true</tt>, so you can only use it if you know the answer!
++None of the exception types defined in clause 19 are
++allowed to throw an exception on copy or move
++operations, but there is no clear specification that the
++operations have an exception specification to prove it.
++Note that the implicitly declared constructors, taking the
++exception specification from their base class (ultimately
++<tt>std::exception</tt>) will implicitly generate a <tt>noexcept</tt>
++exception specification if all of their data members
++similarly declare <tt>noexcept</tt> operations. As the
++representation is unspecified, we cannot assume nonthrowing
++operations unless we explicitly state this as a
++constraint on the implementation.
+ </p>
+
+ <p><i>[
+-2009-12-08 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++Resolution proposed by ballot comment:
+ ]</i></p>
+
++<p>
++Add a global guarantee that all exception types
++defined in clause 19 that rely on implicitly declared
++operations have a non-throwing exception
++specification on those operations.
++</p>
+
+ <p><i>[
+-2010 Pittsburgh:
++2010 Batavia:
+ ]</i></p>
+
+-
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by N3058.
++This is addressed by the current words in 18.8.1 [exception], p2
+ </p>
++<blockquote><p>
++Each standard library class <tt>T</tt> that derives from class <tt>exception</tt>
++shall have a publicly accessible copy constructor and a publicly accessible copy
++assignment operator that do not exit with an exception.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Change 30.6.6 [futures.unique_future]/3:
+-</p>
+-
+-<blockquote>
+-The effect of calling any member function other than the
+-destructor<ins>,</ins> or the move-assignment operator<ins>, or
+-<tt>valid</tt>,</ins> on a <tt>future</tt> object for which <tt>valid()
+-== false</tt> is undefined.
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1274"></a>1274. <tt>atomic_future</tt> constructor</h3>
+-<p><b>Section:</b> 30.6.8 [futures.atomic_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1373"></a>1373. Customizable traits should have their own headers</h3>
++<p><b>Section:</b> 20.2 [utility] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB-79</b></p>
+ <p>
+-In 30.6.8 [futures.atomic_future] this constructor:
+-</p>
+-
+-<blockquote><pre>atomic_future(future&lt;R&gt;&amp;&amp;);
+-</pre></blockquote>
+-
+-<p>
+-is declared in the synopsis, but not defined. Instead
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">n2997</a>
+-defines:
++The library provides several traits mechanisms intended a
++customization points for users. Typically, they are
++declared in headers that are growing quite large. This is
++not a problem for standard library vendors, who can
++manage their internal file structure to avoid large
++dependencies, but can be a problem for end users who
++have no option but to include these large headers.
+ </p>
+
+-<blockquote><pre>atomic_future(const future&lt;R&gt;&amp;&amp; rhs);
+-</pre></blockquote>
++<p><i>[
++2010 Rapperswil
++]</i></p>
+
+ <p>
+-and
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">n3000</a>
+-defines
++There was no enthusiasm for touching <tt>char_traits</tt> or <tt>regex_traits</tt>.
++Consensus to move <tt>iterator_traits</tt>, <tt>allocator_traits</tt>
++and <tt>pointer_traits</tt> to their own respective headers once wording supplied.
+ </p>
+
+-<blockquote><pre>atomic_future(atomic_future&lt;R&gt;&amp;&amp; rhs);
+-</pre></blockquote>
++<p><i>[
++2010 Rapperswil
++]</i></p>
+
+ <p>
+-both of which are wrong. The constructor definition should be changed
+-to match the synopsis.
++After some discussion, consensus is that moving these features into separate
++headers does not buy much in practice, as the larger headers will inevitably
++be included anyway. Resolve as NAD.
+ </p>
+
+ <p><i>[
+-2009-12-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++Resolution proposed in ballot comment
+ ]</i></p>
+
++<p>
++Move the following traits classes into their own
++headers, and require the existing header to
++<tt>#include</tt> the traits header to support backwards
++compatibility:
++</p>
++<blockquote><pre>
++iterator_traits (plus the iterator tag-types)
++allocator_traits
++pointer_traits
++char_traits
++regex_traits
++</pre></blockquote>
+
+ <p><i>[
+-2010 Pittsburgh:
++2010 Batavia:
+ ]</i></p>
+
+-
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by N3058.
++Closed as NAD with the rationale below.
+ </p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Adjust the signature above 30.6.8 [futures.atomic_future]/6 like so:
++
++<p><b>Rationale:</b></p><p>
++This suggest is not a defect, as the likely benefit is small, if any,
++compared to the cost of not just implementating the feature, but also
++explaining/teaching it.
+ </p>
+
+-<blockquote><pre>atomic_future(<del>atomic_</del>future<ins>&lt;R&gt;</ins>&amp;&amp; rhs);
+-</pre></blockquote>
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1275"></a>1275. creating and setting futures</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1374"></a>1374. Clarify moved-from objects are &quot;toxic&quot;</h3>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses US-85</b></p>
+ <p>
+-30.6.6 [futures.unique_future]/1 should be updated to mention
+-<tt>async</tt>.
+-</p>
+-
+-<p>
+-30.6.7 [futures.shared_future]/1 should also be updated for
+-<tt>async</tt>. That paragraph also says
++20.2.1 Table 34 "MoveConstructible requirements" says
++"Note: rv remains a valid object. Its state is unspecified".
++Some components give stronger guarantees. For
++example, moved-from <tt>shared_ptr</tt>s are guaranteed <tt>empty</tt>
++(20.9.11.2.1/25).
++In general, what the standard really should say (preferably
++as a global blanket statement) is that moved-from objects
++can be destroyed and can be the destination of an
++assignment. Anything else is radioactive. For example,
++containers can be "emptier than empty". This needs to be
++explicit and required generally.
+ </p>
+-
+-<blockquote>
+-... Its value or exception can be set by use of a
+-<tt>shared_future</tt>, <tt>promise</tt> (30.6.5 [futures.promise]), or <tt>packaged_task</tt> (30.6.10 [futures.task]) object that shares the same associated state.
+-</blockquote>
+-
+ <p>
+-How can the value be set by a <tt>shared_future</tt>?
++Note: The last time that one of us mentioned "emptier
++than empty" (i.e. containers missing sentinel nodes, etc.)
++the objection was that containers can store sentinel nodes
++inside themselves in order to avoid dynamically allocating
++them. This is unacceptable because
+ </p>
+-
+ <p>
+-30.6.8 [futures.atomic_future]/1 says
++(a) it forces existing implementations (i.e. Dinkumware's, Microsoft's,
++IBM's, etc.) to change for no good reason (i.e. permitting more
++operations on moved-from objects), and
+ </p>
+-
+-<blockquote>
+-An <tt>atomic_future</tt> object can only be created by use of a
+-<tt>promise</tt> (30.6.5 [futures.promise]) or
+-<tt>packaged_task</tt> (30.6.10 [futures.task]) object.
+-</blockquote>
+-
+ <p>
+-which is wrong, it's created from a <tt>std::future</tt>, which could
+-have been default-cosntructed. That paragraph should be closer to the
+-text of 30.6.7 [futures.shared_future]/1, and should also mention
+-<tt>async</tt>.
++(b) it invalidates end-iterators when swapping containers. (The Working
++Paper currently permits end-iterator invalidation, which we
++consider to be wrong, but that's a separate argument. In
++any event, <em>mandating</em> end-iterator invalidation is very
++different from permitting it.)
+ </p>
+
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++Resolution proposed in ballot comment
+ ]</i></p>
+
+-
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++State as a general requirement that moved-from
++objects can be destroyed and can be the
++destination of an assignment. Any other use is
++undefined behavior.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3241.html">N3241</a></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1281"></a>1281. CopyConstruction and Assignment between ratios having the same normalized form</h3>
+-<p><b>Section:</b> 20.6.1 [ratio.ratio] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Vicente Juan Botet Escribá <b>Opened:</b> 2009-12-07 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1375"></a>1375. <tt>reference_type</tt> should not have been removed from the
++allocator requirements</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1318">1318</a></p>
+ <p><b>Discussion:</b></p>
+-<p>
+-CopyConstruction and Assignment between <tt>ratio</tt>s having the same
+-normalized form. Current
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>
+-do not allows to copy-construct or assign <tt>ratio</tt> instances of
+-<tt>ratio</tt> classes having the same normalized form.
+-</p>
+
++<p><b>Addresses US-87</b></p>
+ <p>
+-Two <tt>ratio</tt> classes <tt>ratio&lt;N1,D1&gt;</tt> and
+-<tt>ratio&lt;N2,D2&gt;</tt> have the same normalized form if
++<tt>reference_type</tt> should not have been removed from the
++allocator requirements. Even if it is always the same as
++<tt>value_type&amp;</tt>, it is an important customization point for
++extensions and future features.
+ </p>
+
+-<blockquote><pre>ratio&lt;N1, D1&gt;::num == ratio&lt;N2, D2&gt;::num &amp;&amp;
+-ratio&lt;N1, D1&gt;::den == ratio&lt;N2, D2&gt;::den
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-This simple example
++In [allocator.requirements] Table 42 - Allocotor Requirements,
++Add a row (after <tt>value_type</tt>) with columns:
+ </p>
++<blockquote><p>
++Expression: <ins><tt>X::reference_type</tt></ins><BR/>
++Return type: <ins><tt>T&amp;</tt></ins><BR/>
++Assertion/note...: (empty)<BR/>
++Default: <ins><tt>T&amp;</tt></ins><BR/>
++</p></blockquote>
++<p>
++[allocator.traits]:
++</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class Alloc&gt; struct allocator_traits {
++ typedef Alloc allocator_type;
++
++ typedef typename Alloc::value_type value_type;
+
+-<blockquote><pre>ratio&lt;1,3&gt; r1;
+-ratio&lt;3,9&gt; r2;
+-r1 = r2; // (1)
++ typedef <i>see below</i> pointer;
++ typedef <i>see below</i> const_pointer;
++ typedef <i>see below</i> void_pointer;
++ typedef <i>see below</i> const_void_pointer;
++ <ins>typedef value_type&amp; reference_type;</ins>
+ </pre></blockquote>
+-
+ <p>
+-fails to compile in (1). Other example
++Add <tt>reference_type</tt> to
++allocator_traits template, defaulted to
++value_type&amp;.
+ </p>
+
+-<blockquote><pre>ratio&lt;1,3&gt; r1;
+-ratio_subtract&lt;ratio&lt;2,3&gt;, ratio&lt;1,3&gt;&gt;::type r2;
+-r1 = r2;
+-</pre></blockquote>
+
+-<p>
+-The nested type of <tt>ratio_subtract&lt;ratio&lt;2,3&gt;,
+-ratio&lt;1,3&gt;&gt;</tt> could be <tt>ratio&lt;3,9&gt;</tt> so the compilation
+-could fail. It could also be <tt>ratio&lt;1,3&gt;</tt> and the compilation
+-succeeds.
+-</p>
+
+-<p>
+-In 20.6.2 [ratio.arithmetic] 3 and similar clauses
+-</p>
+
+-<blockquote>
+-3 The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
+-T2&gt;</tt> where <tt>T1</tt> has the value <tt>R1::num * R2::den - R2::num *
+-R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>.
+-</blockquote>
+
++<hr>
++<h3><a name="1376"></a>1376. Allocator interface is not backward compatible</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-88</b></p>
+ <p>
+-the meaning of synonym let think that the result shall be a normalized
+-<tt>ratio</tt> equivalent to <tt>ratio&lt;T1, T2&gt;</tt>, but there is not an
+-explicit definition of what synonym means in this context.
++Allocator interface is not backward compatible.
+ </p>
+
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
+ <p>
+-Additionally we should add a typedef for accessing the normalized
+-<tt>ratio</tt>, and change 20.6.2 [ratio.arithmetic] to return only this
+-<em>normalized</em> result.
++See Appendix 1 - Additional Details
+ </p>
+
+ <p><i>[
+-2010 Pittsburgh:
++2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-There is no consensus to add the converting copy constructor or converting copy
+-assignment operator. However there was consensus to add the typedef.
+-</p>
++<blockquote><p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3165.pdf">n3165</a> provides an alternative resolution.
++</p></blockquote>
+
+-<p>
+-Proposed wording modified. Original proposed wording preserved here. Moved to
+-Review.
+-</p>
++<p><i>[
++2910 Batavia:
++]</i></p>
+
+-<blockquote class="note">
+ <p>
+-Make <tt>ratio</tt> default constructible, copy-constructible and assignable
+-from any <tt>ratio</tt> which has the same reduced form.
++Closed as NAD - withdrawn by the submitter.
+ </p>
+
+-<p>
+-Add to 20.6.1 [ratio.ratio] synopsis
++
++<p><b>Proposed resolution:</b></p><p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3165.pdf">n3165</a>
+ </p>
+
+-<blockquote><pre>template &lt;intmax_t N, intmax_t D = 1&gt;
+-class ratio {
+-public:
+- static constexpr intmax_t num;
+- static constexpr intmax_t den;
++<p><b>Rationale:</b></p><p>Withdrawn by the submitter.</p>
+
+- <ins>typedef ratio&lt;num, den&gt; type;</ins>
+
+- <ins>ratio() = default;
+- template &lt;intmax_t N2, intmax_t D2&gt;
+- ratio(const ratio&lt;N2, D2&gt;&amp;);
+- template &lt;intmax_t N2, intmax_t D2&gt;
+- ratio&amp; operator=(const ratio&lt;N2, D2&gt;&amp;);</ins>
+-};
+-</pre></blockquote>
+
+-<p>
+-Add to 20.6.1 [ratio.ratio]:
+-</p>
+
+-<blockquote>
++<hr>
++<h3><a name="1395"></a>1395. Inconsistent reference links should be unified</h3>
++<p><b>Section:</b> 20.10.6 [meta.rel] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP-32</b></p>
+ <p>
+-Two ratio classes <tt>ratio&lt;N1,D1&gt;</tt> and <tt>ratio&lt;N2,D2&gt;</tt>
+-have the same reduced form if <tt>ratio&lt;N1,D1&gt;::type</tt> is the same
+-type as <tt>ratio&lt;N2,D2&gt;::type</tt>
++Representations of reference link are not unified.
++Most reference links to clause (table) number, say X, are
++in the form "Clause X" ("Table X") capitalized, and
++subsection Y.Y.Y is referenced with its number only in the
++form "Y.Y.Y". Whether they are parenthesized or not
++depends on the context.
++However there are some notations "(Z)" consisting of only
++a number Z in parentheses to confer Clause or Table
++number Z.
+ </p>
+
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new section: [ratio.cons]
++Change "(10)" to "(Clause 10)".
+ </p>
+
+-<blockquote>
+-<p><b>
+-Construction and assignment [ratio.cons]
+-</b></p>
+
+-<pre>template &lt;intmax_t N2, intmax_t D2&gt;
+- ratio(const ratio&lt;N2, D2&gt;&amp; r);
+-</pre>
+
+-<blockquote>
+-<p>
+-<i>Effects:</i> Constructs a <tt>ratio</tt> object.
+-</p>
+-<p>
+-<i>Remarks:</i> This constructor shall not participate in overload resolution
+-unless <tt>r</tt> has the same reduced form as <tt>*this</tt>.
+-</p>
+-</blockquote>
+
+-<pre>template &lt;intmax_t N2, intmax_t D2&gt;
+- ratio&amp; operator=(const ratio&lt;N2, D2&gt;&amp; r);
+-</pre>
+
+-<blockquote>
+-<p>
+-<i>Effects:</i> None.
+-</p>
+-<p>
+-<i>Returns:</i> <tt>*this</tt>.
+-</p>
++<hr>
++<h3><a name="1398"></a>1398. Users should be able to specialize functors without depending on whole <tt>&lt;functional&gt;</tt> header</h3>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-96</b></p>
+ <p>
+-<i>Remarks:</i> This operator shall not participate in overload resolution
+-unless <tt>r</tt> has the same reduced form as <tt>*this</tt>.
++The function templates <tt>hash</tt>, <tt>less</tt> and <tt>equal_to</tt>
++are important customization points for user-defined types to
++be supported by several standard containers. These are
++accessed through the <tt>&lt;functional&gt;</tt> header which has
++grown significantly larger in C++0x, exposing many more
++facilities than a user is likely to need through there own
++header, simply to declare the necessary specialization.
++There should be a smaller header available for users to
++make the necessary customization.
+ </p>
+-</blockquote>
+-
+-</blockquote>
+
+-<p>
+-Change 20.6.2 [ratio.arithmetic]
+-</p>
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
+
+-<blockquote>
+ <p>
+-Implementations may use other algorithms to compute these values. If overflow
+-occurs, a diagnostic shall be issued.
++Provide a tiny forwarding header for important
++functor types in the <tt>&lt;functional&gt;</tt> header that a
++user may want to specialize. This should contain
++the template declaration for <tt>equal_to</tt>, <tt>hash</tt> and
++<tt>less</tt>.
+ </p>
+
+-<pre>template &lt;class R1, class R2&gt; struct ratio_add {
+- typedef <i>see below</i> type;
+-};
+-</pre>
+-
+-<blockquote>
+-The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
+-T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
+-R2::den + R2::num * R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den *
+-R2::den</tt>.
+-</blockquote>
+-
+-<pre>template &lt;class R1, class R2&gt; struct ratio_subtract {
+- typedef <i>see below</i> type;
+-};
+-</pre>
+-
+-<blockquote>
+-The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
+-T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
+-R2::den - R2::num * R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den *
+-R2::den</tt>.
+-</blockquote>
+-
+-<pre>template &lt;class R1, class R2&gt; struct ratio_multiply {
+- typedef <i>see below</i> type;
+-};
+-</pre>
+-
+-<blockquote>
+-The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
+-T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
+-R2::num</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>.
+-</blockquote>
+-
+-<pre>template &lt;class R1, class R2&gt; struct ratio_divide {
+- typedef <i>see below</i> type;
+-};
+-</pre>
+-
+-<blockquote>
+-The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
+-T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
+-R2::den</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::num</tt>.
+-</blockquote>
+-
+-</blockquote>
++<p><i>[
++Rapperswill summary
++]</i></p>
+
+-</blockquote>
++<p>Alisdair: Would recommend NAD unless someone takes the issue. </p>
+
+-</blockquote>
++<p>Daniel: Volunteers to write a paper for this. </p>
+
+ <p><i>[
+-2010-03-27 Howard adds:
++2010-11-07 Daniel provides a paper available on the Batavia document list
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-Daniel brought to my attention the recent addition of the typedef <tt>type</tt>
+-to the FCD
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>:
+-</p>
+-
+-<blockquote><pre>typedef ratio type;
+-</pre></blockquote>
+-
+-<p>
+-This issue was discussed in Pittsburgh, and the decision there was to accept the
+-typedef as proposed and move to Review. Unfortunately the issue was accidently
+-applied to the FCD, and incorrectly. The FCD version of the typedef refers to
+-<tt>ratio&lt;N, D&gt;</tt>, but the typedef is intended to refer to
+-<tt>ratio&lt;num, den&gt;</tt> which in general is not the same type.
+-</p>
++<p><i>[
++2010 Batavia:
++]</i></p>
+
+ <p>
+-I've updated the wording to diff against
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>.
++Closed as NAD - the consensus was that forwarding headers such as
++<tt>&lt;iosfwd&gt;</tt> do not bring the expected benefits, and are
++not widely used (to the surprise of some active users in the room!).
++Without real experience reporting a benefit, there is no further interest
++in pursuing this issue as an extension - hence NAD rather than NAD Future.
+ </p>
+
+-</blockquote>
+-
+-<p><i>[Batavia: NAD Editorial - see rationale below]</i></p>
+-
+
+
+-
+-<p><b>Rationale:</b></p>Already fixed in working draft
++<p><b>Rationale:</b></p><p>No consensus to make a change</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 20.6.1 [ratio.ratio] synopsis
++See paper &quot;Forwarding <tt>&lt;functional&gt;</tt> functor templates&quot;
++on the Batavia LWG document list
+ </p>
+
+-<blockquote><pre>template &lt;intmax_t N, intmax_t D = 1&gt;
+-class ratio {
+-public:
+- static constexpr intmax_t num;
+- static constexpr intmax_t den;
+-
+- typedef ratio<ins>&lt;num, den&gt;</ins> type;
+-};
+-</pre></blockquote>
+-
+-
+
+
+
+
+ <hr>
+-<h3><a name="1282"></a>1282. A proposal to add std::split algorithm</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Igor Semenov <b>Opened:</b> 2009-12-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1411"></a>1411. Add a compile-time flag to detect <tt>monotonic_clock</tt></h3>
++<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1410">1410</a></p>
+ <p><b>Discussion:</b></p>
+-<ol type="I">
+
+-<li>
+-<p>
+-Motivation and Scope
+-</p>
++<p><b>Addresses DE-20</b></p>
+ <p>
+-Splitting strings into parts by some set of delimiters is an often task, but
+-there is no simple and generalized solution in C++ Standard. Usually C++
+-developers use <tt>std::basic_stringstream&lt;&gt;</tt> to split string into
+-parts, but there are several inconvenient restrictions:
++The library component <tt>monotonic_clock</tt> is conditionally
++supported, but no compile-time flag exists that allows
++user-code to query its existence. Further-on there exist no
++portable means to simulate such a query. (To do so, user
++code would be required to add types to namespace
++<tt>std::chrono</tt>.)
+ </p>
+
+-<ul>
+-<li>
+-we cannot explicitly assign the set of delimiters;
+-</li>
+-<li>
+-this approach is suitable only for strings, but not for other types of
+-containers;
+-</li>
+-<li>
+-we have (possible) performance leak due to string instantiation.
+-</li>
+-</ul>
+-</li>
+
+-<li>
+-<p>
+-Impact on the Standard
+-</p>
++<p><b>Proposed resolution:</b></p>
+ <p>
+-This algorithm doesn't interfere with any of current standard algorithms.
++Provide a compile-time flag (preferably a macro)
++that can be used to query the existence of
++<tt>monotonic_clock</tt>.
+ </p>
+-</li>
+
+-<li>
+-<p>
+-Design Decisions
+-</p>
+-<p>
+-This algorithm is implemented in terms of input/output iterators. Also, there is
+-one additional wrapper for <tt>const CharType *</tt> specified delimiters.
+-</p>
+-</li>
+
+-<li>
+-<p>
+-Example implementation
+-</p>
+-<pre>template&lt; class It, class DelimIt, class OutIt &gt;
+-void split( It begin, It end, DelimIt d_begin, DelimIt d_end, OutIt out )
+-{
+- while ( begin != end )
+- {
+- It it = std::find_first_of( begin, end, d_begin, d_end );
+- *out++ = std::make_pair( begin, it );
+- begin = std::find_first_of( it, end, d_begin, d_end,
+- std::not2( std::equal_to&lt; typename It::value_type &gt;() ) );
+- }
+-}
+
+-template&lt; class It, class CharType, class OutIt &gt;
+-void split( It begin, It end, const CharType * delim, OutIt out )
+-{
+- split( begin, end, delim, delim + std::strlen( delim ), out );
+-}
+-</pre>
+-</li>
+
+-<li>
++
++<hr>
++<h3><a name="1413"></a>1413. Specify whether <tt>high_resolution_clock</tt> is a distinct type or a typedef</h3>
++<p><b>Section:</b> 20.12.7.3 [time.clock.hires] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-112</b></p>
+ <p>
+-Usage
++What it means for <tt>high_resolution_clock</tt> to be a synonym
++is undefined. If it may or may not be a typedef, then
++certain classes of programs become unportable.
+ </p>
+-<pre>std::string ss( "word1 word2 word3" );
+-std::vector&lt; std::pair&lt; std::string::const_iterator, std::string::const_iterator &gt; &gt; v;
+-split( ss.begin(), ss.end(), " ", std::back_inserter( v ) );
+-
+-for ( int i = 0; i &lt; v.size(); ++i )
+-{
+- std::cout &lt;&lt; std::string( v[ i ].first, v[ i ].second ) &lt;&lt; std::endl;
+-}
+-// word1
+-// word2
+-// word3
+-</pre>
+-</li>
+-
+-</ol>
+
+ <p><i>[
+-2010-01-22 Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
+-Rationale added below.
++Resolution proposed in ballot comment
+ ]</i></p>
+
+-
+-
+-<p><b>Rationale:</b></p>
+-<p>
+-The LWG is not considering completely new features for standardization at this
+-time. We would like to revisit this good suggestion for a future TR and/or
+-standard.
+-</p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Add to the synopsis in 25.1 [algorithms.general]:
+-</p>
+-
+-<blockquote><pre>template&lt; class ForwardIterator1, class ForwardIterator2, class OutputIterator &gt;
+- void split( ForwardIterator1 first, ForwardIterator1 last,
+- ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
+- OutputIterator result );
+-
+-template&lt; class ForwardIterator1, class CharType, class OutputIterator &gt;
+- void split( ForwardIterator1 first, ForwardIterator1 last,
+- const CharType * delimiters, OutputIterator result );
+-</pre></blockquote>
+-
+ <p>
+-Add a new section [alg.split]:
++Require that it be a distinct class type.
+ </p>
+
+-<blockquote><pre>template&lt; class ForwardIterator1, class ForwardIterator2, class OutputIterator &gt;
+- void split( ForwardIterator1 first, ForwardIterator1 last,
+- ForwardIterator2 delimiter_first, ForwardIterator2 delimiter_last,
+- OutputIterator result );
+-</pre>
++<p><i>[
++2010 Batavia
++]</i></p>
+
+-<blockquote>
+-<p>
+-1. <i>Effects:</i> splits the range <tt>[first, last)</tt> into parts, using any
+-element of <tt>[delimiter_first, delimiter_last)</tt> as a delimiter. Results
+-are pushed to output iterator in the form of <tt>std::pair&lt;ForwardIterator1,
+-ForwardIterator1&gt;</tt>. Each of these pairs specifies a maximal subrange of
+-<tt>[first, last)</tt> which does not contain a delimiter.
+-</p>
+ <p>
+-2. <i>Returns:</i> nothing.
++This is not a defect. Threre are a number of places in the standard where
++we allow implentations to choose their preferred technique, the most obvious
++example being the <tt>iterator</tt>/<tt>const_iterator</tt> types of <tt>set</tt>.
+ </p>
+ <p>
+-3. <i>Complexity:</i> Exactly <tt>last - first</tt> assignments.
++Typically, this means it is not portable to declare function overloads that differ
++only in their use of these types.
+ </p>
+-</blockquote>
+
+-<pre>template&lt; class ForwardIterator1, class CharType, class OutputIterator &gt;
+- void split( ForwardIterator1 first, ForwardIterator1 last,
+- const CharType * delimiters, OutputIterator result );
+-</pre>
+
+-<blockquote>
+-<p>
+-1. <i>Effects:</i> split the range <tt>[first, last)</tt> into parts, using any
+-element of <tt>delimiters</tt> (interpreted as zero-terminated string) as a
+-delimiter. Results are pushed to output iterator in the form of
+-<tt>std::pair&lt;ForwardIterator1, ForwardIterator1&gt;</tt>. Each of these
+-pairs specifies a maximal subrange of <tt>[first, last)</tt> which does not
+-contain a delimiter.
+-</p>
+-<p>
+-2. <i>Returns:</i> nothing.
+-</p>
+-<p>
+-3. <i>Complexity:</i> Exactly <tt>last - first</tt> assignments.
+-</p>
+-</blockquote>
+
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1289"></a>1289. Generic casting requirements for smart pointers</h3>
+-<p><b>Section:</b> 20.3 [utility] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Ion Gaztañaga <b>Opened:</b> 2009-12-14 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility">issues</a> in [utility].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="1415"></a>1415. Iterator stability bans the short-string optimization</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In section 20.2.5 [allocator.requirements], Table 40 — Allocator requirements,
+-the following expression is required for allocator pointers:
++Requirements on iterators swapping allegiance would
++disallow the small-string optimization.
+ </p>
++<p><i>[
++Resolved in Rapperswil by paper N3108.
++]</i></p>
+
+-<blockquote>
+-<table border="1">
+-<caption>Table 40 — Allocator requirements</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
+-<th>Default</th>
+-</tr>
+-<tr>
+-<td><tt>static_cast&lt;X::pointer&gt;(w)</tt></td>
+-<td><tt>X::pointer</tt></td>
+-<td><tt>static_cast&lt;X::pointer&gt;(w) == p</tt></td>
+-<td>&nbsp;</td>
+-</tr>
+-</tbody></table>
+-</blockquote>
+
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-To achieve this expression, a smart pointer writer must introduce an explicit
+-conversion operator from <tt>smart_ptr&lt;void&gt;</tt> to
+-<tt>smart_ptr&lt;T&gt;</tt> so that
+-<tt>static_cast&lt;pointer&gt;(void_ptr)</tt> is a valid expression.
+-Unfortunately this explicit conversion weakens the safety of a smart pointer
+-since the following expression (invalid for raw pointers) would become valid:
++Add an exclusion for <tt>basic_string</tt> to the sentence
++beginning &#8220;Every iterator referring to an
++element...&#8221;. Add a sentence to 21.4.6.8/2 saying
++that iterators and references to string elements
++remain valid, but it is not specified whether they
++refer to the same string or the other string.
+ </p>
+
+-<blockquote><pre>smart_ptr&lt;void&gt; smart_v = ...;
+-smart_ptr&lt;T&gt; smart_t(smart_v);
+-</pre></blockquote>
+
+-<p>
+-On the other hand, <tt>shared_ptr</tt> also defines its own casting functions in
+-20.9.10.2.10 [util.smartptr.shared.cast], and although it's unlikely that a
+-programmer will use <tt>shared_ptr</tt> as <tt>allocator::pointer</tt>, having
+-two different ways to do the same cast operation does not seem reasonable. A
+-possible solution would be to replace <tt>static_cast&lt;X::pointer&gt;(w)</tt>
+-expression with a user customizable (via ADL)
+-<tt>static_pointer_cast&lt;value_type&gt;(w)</tt>, and establish the
+-<tt>xxx_pointer_cast</tt> functions introduced by <tt>shared_ptr</tt> as the
+-recommended generic casting utilities of the standard.
+-</p>
+
+-<p>
+-Unfortunately, we've experienced problems in Boost when trying to establish
+-<tt>xxx_pointer_cast</tt> as customization points for generic libraries (<a href="http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html">http://objectmix.com/c/40424-adl-lookup-explicit-template-parameters.html</a>)
+-because these casting functions are called with explicit template parameters and
+-the standard says in 14.8.1 [temp.arg.explicit] p.8 "Explicit template
+-argument specification":
+-</p>
+
+-<blockquote>
+-8 ...But when a function template with explicit template arguments is used, the
+-call does not have the correct syntactic form unless there is a function
+-template with that name visible at the point of the call. If no such name is
+-visible, the call is not syntactically well-formed and argument-dependent lookup
+-does not apply.
+-</blockquote>
+
++<hr>
++<h3><a name="1419"></a>1419. <tt>forward_list::erase_after</tt> should return an iterator</h3>
++<p><b>Section:</b> 23.3.4 [forwardlist] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-117</b></p>
+ <p>
+-So we can do this:
++<tt>forward_list::erase_after</tt> should return an iterator.
+ </p>
++<p><i>[
++Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
++]</i></p>
+
+-<blockquote><pre>template&lt;class BasePtr&gt;
+-void generic_ptr_swap(BasePtr p)
+-{
+- //ADL customization point
+- swap(p, p);
+- //...
+-}
+-</pre></blockquote>
+
+-<p>
+-but not the following:
+-</p>
+
+-<blockquote><pre>template&lt;class BasePtr&gt;
+-void generic_ptr_algo(BasePtr p)
+-{
+- typedef std::pointer_traits&lt;BasePtr&gt;::template
+- rebind&lt;Derived&gt; DerivedPtr;
+- DerivedPtr dp = static_pointer_cast&lt;Derived&gt;(p);
+-}
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-The solution to make <tt>static_pointer_cast</tt> a customization point is to
+-add a generic declaration (no definition) of <tt>static_pointer_cast</tt> in a
+-namespace (like <tt>std</tt>) and apply "<tt>using
+-std::static_pointer_cast</tt>" declaration to activate ADL:
++See Appendix 1 - Additional Details
+ </p>
+
+-<blockquote><pre>namespace std{
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-static_pointer_cast(T&amp;&amp;) = delete;
+-
+-}
+
+-template&lt;class BasePtr&gt;
+-void generic_ptr_algo(BasePtr p)
+-{
+- typedef std::pointer_traits&lt;BasePtr&gt;::template
+- rebind&lt;Derived&gt; DerivedPtr;
+
+- //ADL applies because static_pointer_cast is made
+- // visible according to [temp.arg.explicit]/8
+- using std::static_pointer_cast;
+
+- DerivedPtr dp = static_pointer_cast&lt;Derived&gt;(p);
++<hr>
++<h3><a name="1433"></a>1433. <tt>random_shuffle</tt> and <tt>shuffle</tt> should have consistent signatures</h3>
++<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1432">1432</a></p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-119</b></p>
++<p>
++The functions <tt>random_shuffle</tt> and <tt>shuffle</tt> both take
++arguments providing a source of randomness, but one
++take its argument by rvalue reference, and the other
++requires an lvalue reference. The technical merits of which
++form of argument passing should be settled for this
++specific case, and a single preferred form used
++consistently.
++</p>
+
+- //...
+-}
+-</pre></blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-A complete solution will need also the definition of
+-<tt>static_pointer_cast</tt> for raw pointers, and this definition has been
+-present in Boost (<a href="http://www.boost.org/boost/pointer_cast.hpp">http://www.boost.org/boost/
+-pointer_cast.hpp</a>) for years.
++[DEPENDS ON WHETHER RVALUE OR
++LVALUE REFERENCE IS THE PREFERRED
++FORM]
+ </p>
+
+-<p><i>[
+-2010-03-26 Daniel made editorial adjustments to the proposed wording.
+-]</i></p>
+
+
++
++
++<hr>
++<h3><a name="1434"></a>1434. For <tt>min/max</tt> functions replace variadic arguments by <tt>initializer_list</tt> argument</h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-122</b></p>
++<p>
++It was the LWG's intent in Pittsburgh that N2772 be applied to the WP.
++</p>
+ <p><i>[
+-Moved to NAD Future at 2010-11 Batavia
++Resolved in Rapperswil by paper N3106.
+ ]</i></p>
+
+-<blockquote>
+-This is a new feature rather than a defect.
+-It can be added later: "this is such a hairy area that people will put up with changes"
+-</blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Add to section 20.3 [utility] Utility components, Header
+-<tt>&lt;utility&gt;</tt> synopsis:
+-</p>
++<p>Apply N2772 to the WP.</p>
+
+-<blockquote><pre>// 20.3.X, generic pointer cast functions
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-static_pointer_cast(T&amp;&amp;) = delete;
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-dynamic_pointer_cast(T&amp;&amp;) = delete;
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-const_pointer_cast(T&amp;&amp;) = delete;
+
+-//Overloads for raw pointers
+-template&lt;typename U, typename T&gt;
+-auto static_pointer_cast(T* t) -&gt; decltype(static_cast&lt;U*&gt;(t));
+-
+-template&lt;typename U, typename T&gt;
+-auto dynamic_pointer_cast(T* t) -&gt; decltype(dynamic_cast&lt;U*&gt;(t));
++<hr>
++<h3><a name="1442"></a>1442. "happens-before" should be "synchronizes-with"</h3>
++<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread">issues</a> in [thread].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1443">1443</a></p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CA-9, GB-122</b></p>
+
+-template&lt;typename U, typename T&gt;
+-auto const_pointer_cast(T* t) -&gt; decltype(const_cast&lt;U*&gt;(t));
+-</pre></blockquote>
++<p><i>[CA-9:]</i></p>
+
+ <p>
+-Add to section 20.3 [utility] Utility components, a new subclause
+-20.3.X Pointer cast utilities [pointer.cast]:
++Imposed happens-before edges should be in
++synchronizes-with<br/>
++Each use of the words "happens-before" should be
++replaced with the words "synchronizes-with" in the
++following sentences:<br/>
++27.2.3p2<br/>
++30.3.1.2p6<br/>
++30.3.1.5p7<br/>
++30.6.4p7<br/>
++30.6.9p5<br/>
++30.6.10.1p23<br/>
++Rationale: Happens-before is defined in 1.10p11 in a way
++that (deliberately) does not make it explicitly transitively
++closed. Adding edges to happens-before directly, as in
++27.2.3p2 etc., does not provide transitivity with
++sequenced-before or any other existing happens-before
++edge. This lack of transitivity seems to be unintentional.
+ </p>
+
+-<blockquote>
+-<p>
+-20.3.X Pointer cast utilities [pointer.cast]
+-</p>
++<p><i>[GB-122]</i></p>
+
+-<p>
+-1 The library defines generic pointer casting function templates so that template code
+-can explicitly make these names visible and activate argument-dependent lookup
+-for pointer cast calls.
+-</p>
+
+-<pre>//Generic declarations
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-static_pointer_cast(T&amp;&amp;) = delete;
++<p>At various points in the standard new edges are added to
++happens-before, for example 27.2.3:2 adds happens-before edges between
++writes and reads from a stream:</p>
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-dynamic_pointer_cast(T&amp;&amp;) = delete;
++<p>If one thread makes a library call a that writes a value to a
++stream and, as a result, another thread reads this value from the
++stream through a library call b such that this does not result in a
++data race, then a happens before b.</p>
+
+-template&lt;typename U, typename T&gt;
+-<i>unspecified</i>
+-const_pointer_cast(T&amp;&amp;) = delete;
+-</pre>
++<p>Happens-before is defined in 1.10:11 in a deliberate way that makes it
++not explicitly transitively closed. Adding edges to happens-before
++directly, as in 27.2.3:2, does not provide transitivity with
++sequenced-before or any other existing happens-before edge. This lack
++of transitivity seems to be unintentional. In order to achieve
++transitivity we suggest each edge be added to
++inter-thread-happens-before as a synchronises-with edge (as per
++conversation with Hans Boehm). In the standard, each use of the words
++"happens-before" should be replaced with the words "synchronizes-with"
++in the following sentences:</p>
+
+-<p>
+-2 The library also defines overloads of these functions for raw pointers.
+-</p>
++<p>27.2.3:2,
++30.3.1.2:6,
++30.3.1.5:7,
++30.6.4:7,
++30.6.9:5,
++30.6.10.1:23</p>
+
+-<pre>//Overloads for raw pointers
+-template&lt;typename U, typename T&gt;
+-auto static_pointer_cast(T* t) -&gt; decltype(static_cast&lt;U*&gt;(t));
+-</pre>
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-<i>Returns:</i> <tt>static_cast&lt;U*&gt;(t)</tt>
+-</blockquote>
++<p><i>[Beman provided specific wording for the proposed resolution.]</i></p>
+
+-<pre>template&lt;typename U, typename T&gt;
+-auto dynamic_pointer_cast(T* t) -&gt; decltype(dynamic_cast&lt;U*&gt;(t));
+-</pre>
+
+-<blockquote>
+-<i>Returns:</i> <tt>dynamic_cast&lt;U*&gt;(t)</tt>
+-</blockquote>
++<p>Change 27.2.3 Thread Safety [iostreams.threadsafety] paragraph 2:</p>
+
+-<pre>template&lt;typename U, typename T&gt;
+-auto const_pointer_cast(T* t) -&gt; decltype(const_cast&lt;U*&gt;(t));
+-</pre>
++<p>If one thread makes a library call <tt>a</tt> that writes a value to a stream
++and, as a result, another thread reads this value from the stream through a library
++call <tt>b</tt> such that this does not result in a data race, then <tt>a</tt>
++<del>happens before</del> <ins>synchronizes with</ins> <tt>b</tt>.</p>
+
+-<blockquote>
+-<i>Returns:</i> <tt>const_cast&lt;U*&gt;(t)</tt>
+-</blockquote>
++<p>Change 30.3.1.2 thread constructors [thread.thread.constr] paragraph 6:</p>
+
+-<p>
+-[<i>Example:</i>
+-</p>
++<p><i>Synchronization:</i> The invocation of the constructor <del>happens
++before</del> <ins>synchronizes with</ins> the invocation of the copy of <tt>f</tt>.</p>
+
+-<blockquote><pre>#include &lt;utility&gt; //static_pointer_cast
+-#include &lt;memory&gt; //pointer_traits
++<p>Change 30.3.1.5 thread members [thread.thread.member] paragraph 7:</p>
+
+-class Base{};
+-class Derived : public Base{};
++<p><i>Synchronization:</i> The completion of the thread represented by <tt>*this</tt>
++<del>happens before</del> <ins>synchronizes with</ins> (1.10) <tt>join()</tt>
++<del>returns</del> <ins>returning</ins>. [ Note: Operations on <tt>*this</tt>
++are not synchronized. --end note ]</p>
+
+-template&lt;class BasePtr&gt;
+-void generic_pointer_code(BasePtr b)
+-{
+- typedef std::pointer_traits&lt;BasePtr&gt;::template
+- rebind&lt;Derived&gt; DerivedPtr;
++<p>Change 30.6.4 Associated asynchronous state [futures.state] paragraph 7:</p>
+
+- using std::static_pointer_cast;
+- //ADL applies now that static_pointer_cast is visible
+- DerivedPtr d = static_pointer_cast&lt;Derived&gt;(b);
+-}
+-</pre></blockquote>
++<p>Calls to functions that successfully set the stored result of an associated
++asynchronous state synchronize with (1.10) calls to functions successfully detecting
++the ready state resulting from that setting. The storage of the result (whether normal
++or exceptional) into the associated asynchronous state <del>happens before</del>
++<ins>synchronizes with</ins> (1.10) that state <del>is</del> <ins>being</ins> set to ready.</p>
+
+-<p>
+-— <i>end example</i>]
+-</p>
++<p>Change 30.6.9 Function template async [futures.async] paragraph 5:</p>
+
+-</blockquote>
++<p><i>Synchronization:</i> the invocation of <tt>async</tt> <del>happens before</del>
++<ins>synchronizes with</ins> (1.10) the invocation of <tt>f</tt>. [ <i>Note</i>: this
++statement applies even when the corresponding future object is moved to another thread. &mdash; <i>end
++note</i> ] If the invocation is not deferred, a call to a waiting function on an asynchronous return object
++that shares the associated asynchronous state created by this async call shall block until the associated
++thread has completed. If the invocation is not deferred, the <tt>join()</tt> on the created thread
++<del>happens before</del> <ins>synchronizes with</ins> (1.10) the first function that successfully
++detects the ready status of the associated asynchronous state returns or before the function that
++gives up the last reference to the associated asynchronous state returns, whichever happens first.
++If the invocation is deferred, the completion of the invocation of the deferred function <del>happens
++before</del> <ins>synchronizes with</ins> the calls to the waiting functions return.</p>
+
+-<p>
+-Replace in section 20.2.5 [allocator.requirements] Table 40 — Allocator
+-requirements, the following table entries for allocator pointers:
+-</p>
++<p>Change 30.6.10.1 packaged_task member functions [futures.task.members] paragraph 23:</p>
+
+-<blockquote>
+-<table border="1">
+-<caption>Table 40 — Allocator requirements</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
+-<th>Default</th>
+-</tr>
++<p><i>Synchronization:</i> a successful call to <tt>operator()</tt> synchronizes with (1.10) a call
++to any member function of a <tt>future</tt>, <tt>shared_future</tt>, or <tt>atomic_future</tt> object
++that shares the associated asynchronous state of <tt>*this</tt>. The completion of the invocation
++of the stored task and the storage of the result (whether normal or exceptional) into the associated
++asynchronous state <del>happens before</del> <ins>synchronizes with</ins> (1.10) the state <del>is</del>
++<ins>being</ins> set to ready. [ Note: <tt>operator()</tt> synchronizes and serializes with other
++functions through the associated asynchronous state. —end note ]</p>
+
+-<tr>
+-<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::pointer</del><ins>T</ins>&gt;(w)</tt></td>
+-<td><tt>X::pointer</tt></td>
+-<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::pointer</del><ins>T</ins>&gt;(w) == p</tt></td>
+-<td>&nbsp;</td>
+-</tr>
+
+-<tr>
+-<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::const_pointer</del><ins>const T</ins>&gt;(w)</tt></td>
+-<td><tt>X::const_pointer</tt></td>
+-<td><tt>static<ins>_pointer</ins>_cast&lt;<del>X::const_pointer</del><ins>const T</ins>&gt;(z) == q</tt></td>
+-<td>&nbsp;</td>
+-</tr>
+
+-</tbody></table>
+-</blockquote>
+
+
+
++<hr>
++<h3><a name="1443"></a>1443. Imposed happens-before edges are not made transitive</h3>
++<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread">issues</a> in [thread].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1442">1442</a></p>
++<p><b>Discussion:</b></p>
+
+
++<p><b>Addresses GB-122</b></p>
+
+-<hr>
+-<h3><a name="1291"></a>1291. exceptions thrown during <tt>promise::set_value</tt></h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-In 30.6.5 [futures.promise]
+-</p>
++<p>At various points in the standard new edges are added to
++happens-before, for example 27.2.3:2 adds happens-before edges between
++writes and reads from a stream:</p>
+
+-<p>
+-Does <tt>promise&lt;R&gt;::set_value</tt> return normally if the copy/move
+-constructor of <tt>R</tt> throws?
+-</p>
++<p>If one thread makes a library call a that writes a value to a
++stream and, as a result, another thread reads this value from the
++stream through a library call b such that this does not result in a
++data race, then a happens before b.</p>
+
+-<p>
+-The exception could be caught and set using
+-<tt>promise&lt;R&gt;::set_exception</tt>, or it could be allowed to leave the
+-<tt>set_value</tt> call, but it's not clear which is intended. I suggest the
+-exception should not be caught.
+-</p>
++<p>Happens-before is defined in 1.10:11 in a deliberate way that makes it
++not explicitly transitively closed. Adding edges to happens-before
++directly, as in 27.2.3:2, does not provide transitivity with
++sequenced-before or any other existing happens-before edge. This lack
++of transitivity seems to be unintentional. In order to achieve
++transitivity we suggest each edge be added to
++inter-thread-happens-before as a synchronises-with edge (as per
++conversation with Hans Boehm). In the standard, each use of the words
++"happens-before" should be replaced with the words "synchronizes-with"
++in the following sentences:</p>
+
++<p>27.2.3:2,
++30.3.1.2:6,
++30.3.1.5:7,
++30.6.4:7,
++30.6.9:5,
++30.6.10.1:23</p>
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-N.B. This doesn't apply to <tt>promise&lt;R&amp;&gt;::set_value</tt> or
+-<tt>promise&lt;void&gt;::set_value</tt> because they don't construct a new
+-object.
++Request the concurrency working group to
++determine if changes are needed
+ </p>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+
+
+
+
+-<p><b>Rationale:</b></p>
++<hr>
++<h3><a name="1444"></a>1444. <tt>OFF_T</tt> is not defined</h3>
++<p><b>Section:</b> 27.5.4.2 [fpos.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos.operations">issues</a> in [fpos.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1414">1414</a></p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses GB-123</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++Several rows in table 124 specify a Return type of
++'OFF_T', which does not appear to be a type defined in
++this standard.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 30.6.5 [futures.promise]/18:
++Resolve outstanding references to the removed type 'OFF_T'.
+ </p>
+
+-<blockquote>
+-18 <i>Throws:</i> <tt>future_error</tt> if its associated state is already
+-ready<ins> or, for the first version an exception thrown by the copy constructor
+-of <tt>R</tt>, or for the second version an exception thrown by the move
+-constructor of <tt>R</tt></ins>.
+-</blockquote>
+-
+
+
+
+
+ <hr>
+-<h3><a name="1296"></a>1296. <tt>map</tt> and <tt>multimap value_compare</tt> overspecified</h3>
+-<p><b>Section:</b> 23.6.1 [map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map">issues</a> in [map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1446"></a>1446. Move and swap for I/O streams</h3>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>
+-The container class templates <tt>map</tt> and <tt>multimap</tt> both contain a
+-nested type called <tt>value_compare</tt>, that is used to compare the
+-<tt>value_type pair</tt> elements, an adaptor of the user-supplied comparison
+-function-like object.
+-</p>
++<p><b>Addresses US-138</b></p>
+
+ <p>
+-I believe these types are over-specified, as we require a distinct type for each
+-template, even though the allocator plays no part in the comparator, and
+-<tt>map</tt> and <tt>multimap value_compare</tt> classes could easily be shared.
+- The benefits are similar to the SCARY iterator proposal (although on a much
+-smaller scale!) but unlike SCARY, this is not a QoI issue today but actively
+-prohibited.
++For istreams and ostreams, the move-constructor does
++not move-construct, the move-assignment operator does
++not move-assign, and the swap function does not swap
++because these operations do not manage the <tt>rdbuf()</tt>
++pointer. Useful applications of these operations are
++prevented both by their incorrect semantics and because
++they are protected.
+ </p>
+
+-<p>
+-If the <tt>value_compare</tt> classes were marked 'exposition only', a vendor
+-would be free to experiment with implementations that do not produce so many
+-template instantiations with negligible impact on conforming programs. (There
+-is a minor risk that programs could no longer portably overload functions taking
+-<tt>value_compare</tt> types. This scenario is extremely unlikely outside
+-conformance suites.)
+-</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+ <p>
+-(Note that there are no similar problems for unordered maps, nor any of the set
+-variants)
++In short: reverse the resolution of issue 900, then
++change the semantics to move and swap the
++<tt>rdbuf()</tt> pointer. Add a new protected constructor
++that takes an rvalue reference to a stream and a
++pointer to a streambuf, a new protected <tt>assign()</tt>
++operator that takes the same arguments, and a
++new protected <tt>partial_swap()</tt> function that doesn't
++swap <tt>rdbuf()</tt>.
++See Appendix 1 - Additional Details
+ </p>
+
+ <p><i>[
+-2010-01-31 Moved to Tentatively NAD after 5 positive votes on c++std-lib.
+-Rationale added below.
++2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-The <tt>value_compare</tt> specification is an unfortunate bit from the past
+-that we have to live with. Fortunately vendors can work around the problems
+-mentioned in this issue.
+-</p>
+-
+-
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3179.pdf">n3179</a> would solve this issue.
++</p></blockquote>
+
++<p><i>[
++2010-11 Batavia
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-p2 23.6.1 [map]:
+-Above the declaration of class <tt>value_compare</tt> in the map synopsis, add:
++Closed as NAD.
+ </p>
+-
+-<blockquote><pre>template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
+- class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
+-class map {
+-public:
+- // types:
+- ...
+- <ins>// exposition only.</ins>
+- class value_compare
+- : public binary_function&lt;value_type,value_type,bool&gt; {
+- ...
+-</pre></blockquote>
+-
++<blockquote><p>
++The Library Working Group reviewed <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3179.pdf">n3179</a> and
++concluded that this change alone was not sufficient, as it would require changes to some of the derived stream types in the library.
++The preference is to not make such a broad fix, and retain the current semantics. This is closed as NAD rather than NAD future as it
++will be difficult to rename the new functions introduced in the C++0x revision of the standard at a later date.
++</p></blockquote>
+
+
+-<p>
+-p2 23.6.2 [multimap]:
+-Above the declaration of class <tt>value_compare</tt> in the map synopsis, add:
+-</p>
+
+-<blockquote><pre>template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
+- class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
+-class multimap {
+-public:
+- // types:
+- ...
+- <ins>// exposition only.</ins>
+- class value_compare
+- : public binary_function&lt;value_type,value_type,bool&gt; {
+- ...
+-</pre></blockquote>
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1300"></a>1300. circular definition of <tt>promise::swap</tt></h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-26 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1451"></a>1451. <tt>regex</tt> should support allocators</h3>
++<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex">issues</a> in [re.regex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-active.html#1396">1396</a></p>
+ <p><b>Discussion:</b></p>
++
++<p><b>Addresses US-141</b></p>
++
+ <p>
+-30.6.5 [futures.promise]/12 defines the effects of
+-<tt>promise::swap(promise&amp;)</tt> as
++<tt>std::basic_regex</tt> should have an allocator for all the
++reasons that a <tt>std::string</tt> does. For example, I can use
++<tt>boost::interprocess</tt> to put a <tt>string</tt> or <tt>vector</tt>
++in shared memory, but not a regex.
+ </p>
+
+-<blockquote><pre>void swap(promise&amp; other);
+-</pre>
+-<blockquote>
+-12 <i>Effects:</i> <tt>swap(*this, other)</tt>
+-</blockquote>
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-and 30.6.5 [futures.promise]/25 defines <tt>swap(promise&lt;R&amp;&gt;,
+-promise&lt;R&gt;&amp;)</tt> as
++Add allocators to regexes; see paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">N3171</a>
++in the pre-Batavia mailing.
+ </p>
+
+-<blockquote><pre>template &lt;class R&gt;
+- void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
+-</pre>
+-<blockquote>
+-25 <i>Effects:</i> <tt>x.swap(y)</tt>.
+-</blockquote>
+-</blockquote>
+
+-<p><i>[
+-2010-01-13 Daniel added "Throws: Nothing."
+-]</i></p>
+
+
++
++<hr>
++<h3><a name="1452"></a>1452. "target sequence" is not defined</h3>
++<p><b>Section:</b> 28.10.4 [re.results.acc] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.acc">issues</a> in [re.results.acc].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-125</b></p>
++
++<p>The term "target sequence" is not defined (28.10.4 [re.results.acc] p. 2).</p>
++
+ <p><i>[
+-2010-01-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++Resolution proposed by ballot comment:
+ ]</i></p>
+
++<p>
++Replace "target sequence" with "string being searched/matched"
++</p>
+
+ <p><i>[
+-2010 Pittsburgh:
++2010-11-01 Daniel comments:
+ ]</i></p>
+
++<p>
++The proposed resolution looks incomplete to me, there are more normative
++usages of the term <em>target sequence</em> in clause 28, e.g.
++28.12.2 [re.tokiter] p. 7.
++</p>
+
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
++<p><i>[2011-03-22 Madrid meeting: Moved to NAD]</i></p>
+
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by N3058.
+-</p>
+
++<p><b>Rationale:</b></p><p>Standard is correct as written</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 30.6.5 [futures.promise] paragraph 12
+-</p>
+-
+-<blockquote><pre>void swap(promise&amp; other);
+-</pre>
+-<blockquote>
+-<p>
+-12 <i>Effects:</i> <del><tt>swap(*this, other)</tt></del> <ins>Exchanges the
+-associated
+-states of <tt>*this</tt> and <tt>other</tt>.</ins>
++Wording changes are against N3126. They are intended not to conflict with the wording changes
++suggested by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a>.
+ </p>
+ <p>
+-13 ...
++Change 28.10.4 [re.results.acc] p. 2 as indicated:
+ </p>
+-<p><ins>
+-<i>Throws:</i> Nothing.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-
++<blockquote><pre>
++difference_type position(size_type sub = 0) const;
++</pre><blockquote><p>
++2 <em>Returns</em>: The distance from the start of the <del>target sequence</del><ins>string being matched</ins> to <tt>(*this)[sub].first</tt>.
++</p></blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1301"></a>1301. <tt>clear()</tt> and assignment</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-01 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1454"></a>1454. Ensure C compatibility for atomics</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1455">1455</a></p>
+ <p><b>Discussion:</b></p>
+-<p>
+-I propose that <tt>clear()</tt> be defined to be equivalent to
+-<tt>erase(begin(),end())</tt> except not using copy or move of elements.
+-</p>
+-
+-<blockquote>
+-<p>
+-To: C++ libraries mailing list<br>
+-Message c++std-lib-26465
+-</p>
+
++<p><b>Addresses GB-128</b></p>
+ <p>
+-and specifiying as post: <tt>size()==0</tt> might also not be appropriate
+-because forward-Lists provide no <tt>size()</tt>, this it should be:
+-post: <tt>empty()==true</tt>
++WG14 has made some late changes to their specification
++of atomics, and care should be taken to ensure that we
++retain a common subset of language/library syntax to
++declare headers that are portable to both languages.
++Ideally, such headers would not require users to define
++their own macros, especially not macros that map to
++keywords (which remains undefined behaviour)
+ </p>
+
+-<p>
+-Bjarne Stroustrup schrieb/wrote:
+-</p>
+
+-<blockquote>
+-<p>
+-To: C++ libraries mailing list<br>
+-Message c++std-lib-26458
+-</p>
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
+
+ <p>
+-in table 94 we define <tt>clear()</tt> as:
++Depends on result of the review of WG14 work,
++which is expected to be out to ballot during the
++time wg21 is resolving its own ballot comments.
++Liaison may also want to file comments in WG14
++to ensure compatibity from both sides.
+ </p>
+
+-<blockquote><pre>a.clear() void erase(begin(), end())
+-post: size() == 0
+-</pre></blockquote>
+
+-<p>
+-Now <tt>erase</tt> requires assignment (<tt>MoveAssignable</tt>) which makes
+-sense if we have to move an element, but why should that be required from
+-<tt>clear()</tt> where all elements are destroyed?
+-</p>
+-</blockquote>
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
+
+-<p><i>[
+-2010-01-23 Alisdiar provides wording.
+-]</i></p>
+
+
+-<p><i>[
+-2010-01-30 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-]</i></p>
+
+
++<hr>
++<h3><a name="1456"></a>1456. Missing fixed-size <tt>atomic_</tt> typedefs</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-129</b></p>
++<p>
++Table 143 lists the typedefs for various atomic types
++corresponding to the various standard integer typedefs,
++such as <tt>atomic_int_least8_t</tt> for <tt>int_least8_t</tt>, and
++<tt>atomic_uint_fast64_t</tt> for <tt>uint_fast64_t</tt>. However, there are
++no atomic typedefs corresponding to the fixed-size
++standard typedefs <tt>int8_t</tt>, <tt>int16_t</tt>, and so forth.
++</p>
+ <p><i>[
+-2010-01-30 Daniel opens:
++2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
+-<p>
+-First, I read the newly proposed spec for <tt>clear()</tt> that it does in
+-general <em>not</em> invalidate a previous past-the-end iterator value, but
+-<tt>deque</tt> says in 23.3.2.3 [deque.modifiers] for the semantics of
+-<tt>erase</tt> that erasures at the end will invalidate the past-the-end
+-iterator. With removal of a direct binding between <tt>clear()</tt> and
+-<tt>erase()</tt> there seem to be some fixes necessary. One way to fix that
+-would be to mention in Table 94 that this "may also invalidate the past-the-end
+-iterator" and then to mention for all specific containers where this does not
+-happen, the exception, [1] e.g. in <tt>std::vector</tt>. <tt>std::vector</tt>
+-has no own specification of <tt>clear()</tt> and one aspect of the closed issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a> was to realize just that (indirectly via <tt>erase</tt>). IMO
+-we should now add an extra specification for <tt>clear()</tt>. Btw.:
+-<tt>std::vector::erase</tt> reads to me that it would invalidate previous
+-past-the-end values (and that seems correct in general).
+-</p>
+-<p>
+-Before I will provide explicit wording, I would like to
+-discuss these points.
+-</p>
+-
+-<p>
+-[1] <tt>std::list</tt> does fortunately specify that clear does not invalidate
+-the past-the-end iterator.
+-</p>
+-</blockquote>
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue.
++</p></blockquote>
+
+ <p><i>[
+-2010-02-08 Moved to Tentatively NAD Editorial after 5 positive votes on c++std-lib.
+-Rationale added below.
++2011-02-15 Anthony corrects numbering/naming for N3225, Howard suggests improvement for the position
++of '(optional)', Daniel reorders rows in harmony to remaining entries and suggests specific optionality
++comments:
+ ]</i></p>
+
+
++<p><i>[2011-02-16 Reflector discussion]</i></p>
+
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved as proposed by LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>.
++Moved to Tentatively Ready after 5 votes.
+ </p>
+
++<p><i>[2011-03-16: Hans reopenes and comments]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+-
+-<p>
+-Change 23.2.1 [container.requirements.general]/10:
+-</p>
+
+-<blockquote>
+-<p>
+-Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.2.3, and 23.3.6.4) all
+-container types defined in this Clause meet the following additional
+-requirements:
++<p>WG14 briefly discussed LWG 1456. It turns out that they had previously made a conscious decision not to make a
++similar change. If C++ would deviate, this would introduce a C divergence.
++<p/>
++We should reopen the issue and, in my opinion, probably resolve it as NAD instead. This is in a part of the standard
++that is there mostly for C compatibility, so introducing divergence here seems to make no sense.
+ </p>
+
+-<ul>
+-<li>
+-..
+-</li>
++<p><i>[2011-03-24 Madrid]</i></p>
+
+-<li>
+-no <tt>erase()</tt>, <ins><tt>clear()</tt>,</ins> <tt>pop_back()</tt> or
+-<tt>pop_front()</tt> function throws an exception.
+-</li>
++<p><b>Rationale:</b></p><p>
++WG14 does not require these typedefs, and we see no reason to be gratuitously different.
++</p>
+
+-<li>
+-...
+-</li>
+-</ul>
+
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Replace the following words from Table 94 — Sequence container
+-requirements (in addition to container) in 23.2.3 [sequence.reqmts]:
++Add the following entries to table 143:
+ </p>
+-
+ <blockquote>
+ <table border="1">
+-<caption>Table 94 — Sequence container requirements (in addition to
+-container)</caption>
+-<tbody><tr>
+-<th>Expression</th>
+-<th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<caption>Table 146 &mdash; <tt>atomic</tt> <tt>&lt;inttypes.h&gt;</tt> typedefs</caption>
++<tr>
++<th>Atomic typedef</th>
++<th><tt>&lt;inttypes.h&gt;</tt> type</th>
+ </tr>
+-
+ <tr>
+-<td><tt>a.clear()</tt></td>
+-<td><tt>void</tt></td>
+-<td><del><tt>erase(begin(), end())</tt></del><br>
+-<ins>Destroys all elements in the container a. Invalidates all references,
+-pointers, and iterators referring to the elements of <tt>a</tt> and may
+-invalidate the past-the-end iterator.</ins><br>
+-post: <tt><del>size() == 0</del> <ins>a.empty() == true</ins></tt>. </td>
++<td><tt>...</tt></td>
++<td><tt>...</tt></td>
+ </tr>
+-</tbody></table>
+-</blockquote>
++<tr>
++<td><tt>atomic_intmax_t</tt></td>
++<td><tt>intmax_t</tt></td>
++</tr>
++<tr>
++<td><tt>atomic_uintmax_t</tt></td>
++<td><tt>uintmax_t</tt></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_int8_t&nbsp;</tt>// <em>iff <tt>int8_t</tt> is provided</em></ins></td>
++<td><ins><tt>int8_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_uint8_t&nbsp;</tt>// <em>iff <tt>uint8_t</tt> is provided</em></ins></td>
++<td><ins><tt>uint8_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_int16_t&nbsp;</tt>// <em>iff <tt>int16_t</tt> is provided</em></ins></td>
++<td><ins><tt>int16_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_uint16_t&nbsp;</tt>// <em>iff <tt>uint16_t</tt> is provided</em></ins></td>
++<td><ins><tt>uint16_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_int32_t&nbsp;</tt>// <em>iff <tt>int32_t</tt> is provided</em></ins></td>
++<td><ins><tt>int32_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_uint32_t&nbsp;</tt>// <em>iff <tt>uint32_t</tt> is provided</em></ins></td>
++<td><ins><tt>uint32_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_int64_t&nbsp;</tt>// <em>iff <tt>int64_t</tt> is provided</em></ins></td>
++<td><ins><tt>int64_t</tt></ins></td>
++</tr>
++<tr>
++<td><ins><tt>atomic_uint64_t&nbsp;</tt>// <em>iff <tt>uint64_t</tt> is provided</em></ins></td>
++<td><ins><tt>uint64_t</tt></ins></td>
++</tr>
++</table>
++</blockquote>
++
++
++
+
++
++<hr>
++<h3><a name="1458"></a>1458. Overlapping evaluations are allowed</h3>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-active.html#1459">1459</a></p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses GB-131</b></p>
++
++<p>
++29.4 [atomics.lockfree] p.8 states:
++</p>
++<blockquote><p>
++An atomic store shall only store a value that has been computed
++from constants and program input values by a finite sequence of
++program evaluations, such that each evaluation observes the values
++of variables as computed by the last prior assignment in the
++sequence.
++</p></blockquote>
+ <p>
+-Add a new paragraph after 23.3.3.4 [forwardlist.modifiers]/23:
++... but 1.9 [intro.execution] p.13 states:
++</p>
++<blockquote><p>
++If A is not sequenced before B and B is not sequenced before A,
++then A and B are unsequenced. [ <em>Note</em>: The execution of unsequenced
++evaluations can overlap. &mdash; <em>end note</em> ]
++</p></blockquote>
++<p>
++Overlapping executions can make it impossible to construct the sequence
++described in 29.4 [atomics.lockfree] p.8. We are not sure of the intention here and do not
++offer a suggestion for change, but note that 29.4 [atomics.lockfree] p.8 is the condition
++that prevents out-of-thin-air reads.
+ </p>
+
+-<blockquote><pre>void clear();
+-</pre>
+
+-<blockquote>
++<p><b>Proposed resolution:</b></p>
+ <p>
+-23 <i>Effects:</i> Erases all elements in the range <tt>[begin(),end())</tt>.
++Request the concurrency working group to
++determine if changes are needed. Consider
++changing the use of "sequence" in 29.4 [atomics.lockfree]
+ </p>
+-<p><ins>
+-<i>Remarks:</i> Does not invalidate past-the-end iterators.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+-
+
+
+
+
+
+ <hr>
+-<h3><a name="1302"></a>1302. different <tt>emplace</tt> semantics for sequence and associated containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1461"></a>1461. Rename all <tt>ATOMIC_*</tt> macros as <tt>STD_ATOMIC_*</tt></h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CA-1</b></p>
+ <p>
+-According to the new naming scheme introduced with
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680</a>
++All <tt>ATOMIC_</tt>... macros should be prefixed with <tt>STD_</tt> as
++in <tt>STD_ATOMIC_</tt>... to indicate they are <tt>STD</tt> macros as
++other standard macros. The rationale that they all seem too long seems weak.
+ </p>
+
+-<blockquote><pre>vector&lt;T&gt; v;
+-v.emplace(v.begin(),x,y,z)
+-</pre></blockquote>
++<p><i>[2011-03-06: Daniel adapts suggested wording to N3242 and comments]</i></p>
+
+-<p>
+-now has a different semantics than
+-</p>
+
+-<blockquote><pre>set&lt;T&gt; s;
+-s.emplace(s.begin(),x,y,z);
+-</pre></blockquote>
++<p>I suggest to declare this issue as NAD. Reason for this suggestion is, that
++C1x is currently going to suggest exactly the same macros as additions to
++header <tt>&lt;stdatomic.h&gt;</tt>, therefore C++0x should not define a
++whole new set. I'm making this suggestion with the understanding that
++C1x is intending to keep in sync in this regard. For example, the most
++<a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1548.pdf">recent
++draft of C1x</a> does contain the macro <tt>ATOMIC_ADDRESS_LOCK_FREE</tt>
++which has recently been removed from the C++ working draft.</p>
+
+-<p>
+-While the version for <tt>vector</tt>s takes the first argument as position and
+-the remaining for construction, the version for <tt>set</tt>s takes all
+-arguments for construction.
+-</p>
++<p><i>[2011-03-24]</i></p>
+
+-<p>
+-IMO, this is a serious design mistake for a couple of reasons:
++<p><b>Rationale:</b></p><p>
++C is not going to change the name of these macros, and it is
++important they have the same name for compatibility
+ </p>
+
+-<ul>
+-<li>
+-<p>
+-First, in principle, all STL member functions should have the same behavior with
+-the same member function to avoid confusion and allow to write proper generic
+-code.
+-</p>
+-<p>
+-In fact, when I write the following simple function template:
+-</p>
+-<blockquote><pre>template &lt;typename T&gt;
+-void doEmplace (T&amp; cont)
+-{
+- cont.emplace(cont.begin(),"nico","josuttis",42);
+-}
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Change sub-clause 29.2 [atomics.syn] as indicated:</p>
++<blockquote><pre>
++[..]
++// <em>[atomics.lockfree], lock-free property</em>
++#define <ins>STD_</ins>ATOMIC_CHAR_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_CHAR16_T_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_CHAR32_T_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_WCHAR_T_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_SHORT_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_INT_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_LONG_LOCK_FREE <em>unspecified</em>
++#define <ins>STD_</ins>ATOMIC_LLONG_LOCK_FREE <em>unspecified</em>
++
++// <em>[atomics.types.operations.req], operations on atomic types</em>
++#define <ins>STD_</ins>ATOMIC_VAR_INIT(value) <em>see below</em>
++[..]
+ </pre></blockquote>
+-<p>
+-the semantics depends on the type of the container.
+-</p>
+ </li>
+ <li>
++<p>Change 29.4 [atomics.lockfree] p. 1 as indicated:</p>
++<blockquote><pre>
++#define <ins>STD_</ins>ATOMIC_CHAR_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_CHAR16_T_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_CHAR32_T_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_WCHAR_T_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_SHORT_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_INT_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_LONG_LOCK_FREE <em>implementation-defined</em>
++#define <ins>STD_</ins>ATOMIC_LLONG_LOCK_FREE <em>implementation-defined</em>
++</pre><blockquote>
+ <p>
+-In addition, I also guess using the name <tt>emplace_hint()</tt> instead of
+-<tt>emplace()</tt> for associative containers is a design mistake. According to
+-my knowledge, it was a design goal of the original STL to provide ONE
+-<tt>insert</tt> function, which works for ALL containers. This was
+-<tt>insert(pos,val)</tt>.
+-</p>
+-<p>
+-The trick to declare <tt>pos</tt> as a hint, allowed that we could implement a
+-generic <tt>insert</tt> for all containers. Now, with the new <tt>emplace</tt>
+-naming scheme, this trick is gone for the new kind of insertion.
+-</p>
++1 The <tt><ins>STD_</ins>ATOMIC_..._LOCK_FREE</tt> macros indicate the lock-free property of the corresponding atomic types, [..]
++</p></blockquote></blockquote>
+ </li>
+-</ul>
+-
+-<p>
+-I consider this to be a serious design penalty because once this
+-is specified we can't fix that without breaking backward compatibility.
+-</p>
+-
+-<p>
+-However, we have two choices for a fix:
+-</p>
+-
+-<ul>
+ <li>
+-rename <tt>emplace_hint(pos,val)</tt> for associative containers back to
+-<tt>emplace(pos,val)</tt>. However to avoid the overloading problems, we also
+-have to rename the existing <tt>emplace(val)</tt> functions to something else (I
+-don't have a good name here at hand).
++<p>Change 29.6.5 [atomics.types.operations.req] p. 6 as indicated:</p>
++<blockquote><pre>
++#define <ins>STD_</ins>ATOMIC_VAR_INIT(value) <em>see below</em>
++</pre><blockquote><p>
++5 <em>Remarks</em>: The macro expands to a token sequence suitable for constant initialization
++an atomic variable of static storage duration of a type that is initialization-compatible
++with <i>value</i>. [ <i>Note</i>: This operation may need to initialize locks. &mdash; <i>end note</i> ]
++Concurrent access to the variable being initialized, even via an atomic operation, constitutes
++a data race. [ <em>Example:</em>
++</p><blockquote><pre>
++atomic&lt;int&gt; v = <ins>STD_</ins>ATOMIC_VAR_INIT(5);
++</pre></blockquote>
++<p>&mdash; <em>end example</em> ]</p>
++</blockquote></blockquote>
+ </li>
+ <li>
+-Keep <tt>emplace(val)</tt> for associative containers as it is, but rename
+-<tt>emplace(pos,val)</tt> for sequence containers and
+-<tt>emplace_hint(pos,val)</tt> to something like <tt>emplace_at(pos,val)</tt>,
+-declaring that <tt>pos</tt> is a hint for associative containers.
++<p>Change 29.7 [atomics.flag] p. 1+4 as indicated:</p>
++<blockquote><pre>
++namespace std {
++ [..]
++ #define <ins>STD_</ins>ATOMIC_FLAG_INIT <em>see below</em>
++}
++</pre><blockquote><p>
++[..]
++4 The macro <tt><ins>STD_</ins>ATOMIC_FLAG_INIT</tt> shall be defined in such a way that it can be used to initialize an object of
++type <tt>atomic_flag</tt> to the clear state. For a static-duration object, that initialization shall be static. It is
++unspecified whether an unitialized <tt>atomic_flag</tt> object has an initial state of set or clear. [ <em>Example:</em>
++</p><blockquote><pre>
++atomic_flag guard = <ins>STD_</ins>ATOMIC_FLAG_INIT;
++</pre></blockquote>
++<p>&mdash; <em>end example</em> ]</p>
++</blockquote></blockquote>
+ </li>
+-</ul>
+-
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD, rationale added below.
+-]</i></p>
++</ol>
+
+
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-There was no consensus to make this change.
+-</p>
+
++<hr>
++<h3><a name="1463"></a>1463. Inconsistent value assignment for <tt>atomic_bool</tt></h3>
++<p><b>Section:</b> X [atomics.types.integral] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1462">1462</a></p>
++<p><b>Discussion:</b></p>
+
+-<p><b>Proposed resolution:</b></p>
+-<p> In 23.2.5 [unord.req], change: </p>
+-<blockquote>
+- <table border="1">
+- <caption>Table 96 — Associative container requirements (in addition to
+- container)</caption>
+- <tbody><tr>
+- <th>expression</th>
+- <th>Return type</th>
+- <th>Assertion/note pre-/post-condition</th>
+- <th>Post-condition</th>
+- </tr>
+- <tr>
+- <td colspan="4">...</td>
+- </tr>
+- <tr>
+- <td><tt>a_uniq.emplace<ins>_value</ins>(args)</tt></td>
+- <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+- <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...<br>
+- if and only if there is no element in the container with key equivalent
+- to the key of t.<br>
+- The bool component of the returned pair is true if and only if the insertion
+- takes place, and the iterator component of the pair points to the element
+- with key equivalent to the key of t.</td>
+- <td>logarithmic</td>
+- </tr>
+- <tr>
+- <td><tt>a_eq.emplace<ins>_value</ins>(args)</tt></td>
+- <td><tt>iterator</tt></td>
+- <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...
+- and returns the iterator pointing to the newly inserted element.</td>
+- <td>logarithmic</td>
+- </tr>
+- <tr>
+- <td><tt>a.emplace<del>_hint</del>(p,args)</tt></td>
+- <td><tt>iterator</tt></td>
+- <td>equivalent to
+- <tt>a.emplace<ins>_value</ins>(std::forward&lt;Args&gt;(args)...)</tt>.
+- Return value is an iterator pointing to the element with the key
+- equivalent to the newly inserted element. The const_iterator p is a hint
+- pointing to where the search should start. Implementations are permitted
+- to ignore the hint.</td> <td>logarithmic in general, but amortized
+- constant if the element is inserted right after p</td>
+- </tr>
+- <tr>
+- <td colspan="4">... </td>
+- </tr>
+- </tbody></table>
+-
+-</blockquote>
+-<p> In 23.2.5 [unord.req], change: </p>
+-<blockquote>
+- <table border="1">
+- <caption>Table 98 — Unordered associative container requirements (in
+- addition to container)</caption>
+- <tbody><tr>
+- <th>expression</th>
+- <th>Return type</th>
+- <th>Assertion/note pre-/post-condition</th>
+- <th>Post-condition</th>
+- </tr>
+- <tr>
+- <td colspan="4">...</td>
+- </tr>
+- <tr>
+- <td><tt>a_uniq.emplace<ins>_value</ins>(args)</tt></td>
+- <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+- <td>inserts a <tt>T</tt> object <tt>t</tt> constructed with <tt>std::forward&lt;Args&gt;(args)...</tt> if
+- and only if there is no element in the container with key equivalent to
+- the key of <tt>t</tt>. The bool component of the returned pair is true if and only
+- if the insertion takes place, and the iterator component of the pair points
+- to the element with key equivalent to the key of t.</td>
+- <td>Average case O(1), worst case O(a_uniq.size()).</td>
+- </tr>
+- <tr>
+- <td><tt>a_eq.emplace<ins>_value</ins>(args)</tt></td>
+- <td><tt>iterator</tt></td>
+- <td>inserts a T object t constructed with std::forward&lt;Args&gt;(args)...
+- and returns the iterator pointing to the newly inserted element.</td>
+- <td>Average case O(1), worst case O(a_eq.size()).</td>
+- </tr>
+- <tr>
+- <td><tt>a.emplace<del>_hint</del>(p,args)</tt></td>
+- <td><tt>iterator</tt></td>
+- <td>equivalent to
+- <tt>a.emplace<ins>_value</ins>(std::forward&lt;Args&gt;(args)...)</tt>.
+- Return value is an iterator pointing to the element with the key
+- equivalent to the newly inserted element. The const_iterator p is a hint
+- pointing to where the search should start. Implementations are permitted
+- to ignore the hint.</td> <td>Average case O(1), worst case
+- O(a.size()).</td>
+- </tr>
+- <tr>
+- <td colspan="4">... </td>
+- </tr>
+- </tbody></table>
+-</blockquote>
++<p><b>Addresses US-157</b></p>
+
+ <p>
+-In 23.6.1 [map], 23.6.3 [set], 23.7.1 [unord.map], 23.7.3 [unord.set], change:
++<tt>atomic_bool</tt> has a <tt>volatile</tt> assignment operator but not a
++non-<tt>volatile</tt> operator. The other integral types have both.
+ </p>
+-<blockquote>
+- <p><i>// modifiers:</i><br>
+- <tt>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace<ins>_value</ins>(Args&amp;&amp;...
+- args);<br>
+- template &lt;class... Args&gt; iterator emplace<del>_hint</del>(const_iterator
+- position, Args&amp;&amp;... args);</tt></p>
+-</blockquote>
+
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-In 23.6.2 [multimap], 23.6.4 [multiset], 23.7.2 [unord.multimap], 23.7.4 [unord.multiset], change:
++Add a non-volatile assignment operator to <tt>atomic_bool</tt>.
+ </p>
+-<blockquote>
+- <p><i>// modifiers:<br></i><tt>template &lt;class... Args&gt; iterator emplace<ins>_value</ins>(Args&amp;&amp;...
+- args);<br>
+- template &lt;class... Args&gt; iterator emplace<del>_hint</del>(const_iterator position,
+- Args&amp;&amp;... args);<br>
+- </tt> </p>
+-</blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1304"></a>1304. missing preconditions for <tt>shared_future</tt></h3>
+-<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1470"></a>1470. &quot;Same-ness&quot; curiosities</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1474">1474</a></p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses US-165</b></p>
+
+ <p>
+-The revised futures package in the current working paper simplified the
+-<tt>is_ready/has_exception/has_value</tt> set of APIs, replacing them with a
+-single 'valid' method. This method is used in many places to signal pre- and
+-post- conditions, but that edit is not complete. Each method on a
+-<tt>shared_future</tt> that requires an associated state should have a
+-pre-condition that <tt>valid() == true</tt>.
++According to 29.6 [atomics.types.operations] p. 23:
+ </p>
++<blockquote><p>
++&#8220;is the same that same as that of&#8221; is not grammatical (and is not clear)
++</p></blockquote>
+
+-<p><i>[
+-2010-01-28 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-]</i></p>
+
+
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
+
+
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+
+
+
+-<p><b>Rationale:</b></p>
++<hr>
++<h3><a name="1471"></a>1471. Default constructor of atomics needs specification</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-168</b></p>
++
+ <p>
+-Solved by N3058.
++29.6 [atomics.types.operations] around p. 4: The definition of the default constructor needs exposition.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Insert the following extra paragraphs:
++Insert a new general prototype description following the current 29.6 [atomics.types.operations] p. 3 as indicated:
+ </p>
++<blockquote><p>
++3 [<em>Note</em>: Many operations are volatile-qualified. The “volatile as device register” semantics have not changed
++in the standard. This qualification means that volatility is preserved when applying these operations to
++volatile objects. It does not mean that operations on non-volatile objects become volatile. Thus, volatile
++qualified operations on non-volatile objects may be merged under some conditions. -- <em>end note</em>]
++</p></blockquote>
++<blockquote><pre>
++<ins>A::A() = default;</ins>
++</pre><blockquote><p>
++<ins>? <em>Effects</em>: Leaves the atomic object in an uninitialized state.
++[<em>Note</em>: These semantics ensure compatiblity with <tt>C</tt>. -- <em>end note</em>]</ins>
++</p></blockquote></blockquote>
++<blockquote><pre>
++constexpr A::A(C desired);
++[..]
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1472"></a>1472. Incorrect semantics of <tt>atomic_init</tt></h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-171</b></p>
+
+ <p>
+-In 30.6.7 [futures.shared_future]
++As of 29.6 [atomics.types.operations] p. 7:
++<p/>
++The <tt>atomic_init</tt> definition "Non-atomically assigns the
++value" is not quite correct, as the <tt>atomic_init</tt> purpose is
++initialization.
+ </p>
+
+-<blockquote><pre>shared_future();
+-</pre>
+-<blockquote>
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-4 <i>Effects:</i> constructs ...
++Change 29.6 [atomics.types.operations] p. 7 as indicated:
+ </p>
++<blockquote><pre>
++void atomic_init(volatile A *object, C desired);
++void atomic_init(A *object, C desired);
++</pre><blockquote><p>
++7 <em>Effects</em>: <del>Non-atomically assigns the value desired to <tt>*object</tt></del><ins>Initializes <tt>*object</tt> with value
++<tt>desired</tt></ins>. Concurrent access from another thread, even via an atomic operation, constitutes a data race.
++<ins>[<em>Note</em>: This function should only be applied to objects that have been default constructed. These semantics ensure
++compatibility with <tt>C</tt>. &mdash; <em>end note</em>]</ins>
++</p></blockquote></blockquote>
+
+-<p><ins>
+-<i>Postcondition:</i> <tt>valid() == false</tt>.
+-</ins></p>
+
+-<p><ins>
+-<i>Throws:</i> nothing.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+
+-<blockquote><pre>void wait() const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++
++<hr>
++<h3><a name="1473"></a>1473. Incomplete memory order specifications</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-172</b></p>
+
+ <p>
+-22 <i>Effects:</i> if the associated ...
++As of 29.6 [atomics.types.operations] p. 9, 13, 17, 20:
++<p/>
++The order specifications are incomplete because the non-<tt>_explicit</tt>
++functions do not have such parameters.
++<p/>
++Add a new sentence: "If the program does not specify an order, it shall be
++<tt>memory_order_seq_cst</tt>." Or perhaps: "The non-_explicit
++non-member functions shall affect memory as though they were _explicit with
++<tt>memory_order_seq_cst</tt>."
+ </p>
+-</blockquote>
+-</blockquote>
+-
+-<blockquote><pre>template &lt;class Rep, class Period&gt;
+- bool wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++<p><i>[
++2010 Batavia
++]</i></p>
+
+ <p>
+-23 <i>Effects:</i> if the associated ...
++The Concurrency subgroup reviewed this, and deemed it NAD according to
++29.6 [atomics.types.operations] paragraph 2, bullet 4.
+ </p>
+-</blockquote>
+-</blockquote>
+
+-<blockquote><pre>template &lt;class Clock, class Duration&gt;
+- bool wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
+-</pre>
+-<blockquote>
++<p><b>Rationale:</b></p><p>The working paper is correct as written.</p>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
+
+-<p>
+-25 <i>Effects:</i> blocks until ...
+-</p>
+-</blockquote>
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>Change 29.6 [atomics.types.operations] p. 9 as indicated:
++<blockquote><pre>
++void atomic_store(volatile A* object, C desired);
++void atomic_store(A* object, C desired);
++void atomic_store_explicit(volatile A *object, C desired, memory_order order);
++void atomic_store_explicit(A* object, C desired, memory_order order);
++void A::store(C desired, memory_order order = memory_order_seq_cst) volatile;
++void A::store(C desired, memory_order order = memory_order_seq_cst);
++</pre><blockquote><p>
++8 <em>Requires</em>: The order argument shall not be <tt>memory_order_consume</tt>, <tt>memory_order_acquire</tt>, nor
++<tt>memory_order_acq_rel</tt>.
++<p/>
++9 <em>Effects</em>: Atomically replaces the value pointed to by <tt>object</tt> or by this with the value of <tt>desired</tt>.
++Memory is affected according to the value of <tt>order</tt>. <ins>If the program does not specify an order, it shall be
++<tt>memory_order_seq_cst</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++<li>Change 29.6 [atomics.types.operations] p. 13 as indicated:
++<blockquote><pre>
++C atomic_load(const volatile A* object);
++C atomic_load(const A* object);
++C atomic_load_explicit(const volatile A* object, memory_order);
++C atomic_load_explicit(const A* object, memory_order);
++C A::load(memory_order order = memory_order_seq_cst) const volatile;
++C A::load(memory_order order = memory_order_seq_cst) const;
++</pre><blockquote><p>
++12 <em>Requires</em>: The order argument shall not be <tt>memory_order_release</tt> nor <tt>memory_order_acq_rel</tt>.
++<p/>
++13 <em>Effects</em>: Memory is affected according to the value of <tt>order</tt>. <ins>If the program does not specify an order, it shall be
++<tt>memory_order_seq_cst</tt>.</ins>
++<p/>
++14 <em>Returns</em>: Atomically returns the value pointed to by <tt>object</tt> or by <tt>this</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++<li>Change 29.6 [atomics.types.operations] p. 17 as indicated:
++<blockquote><pre>
++C atomic_exchange(volatile A* object, C desired);
++C atomic_exchange(A* object, C desired);
++C atomic_exchange_explicit(volatile A* object, C desired, memory_order);
++C atomic_exchange_explicit(A* object, C desired, memory_order);
++C A::exchange(C desired, memory_order order = memory_order_seq_cst) volatile;
++C A::exchange(C desired, memory_order order = memory_order_seq_cst);
++</pre><blockquote><p>
++17 <em>Effects</em>: Atomically replaces the value pointed to by <tt>object</tt> or by <tt>this</tt> with <tt>desired</tt>. Memory
++is affected according to the value of <tt>order</tt>. These operations are atomic read-modify-write operations
++(1.10). <ins>If the program does not specify an order, it shall be <tt>memory_order_seq_cst</tt>.</ins>
++<p/>
++18 <em>Returns</em>: Atomically returns the value pointed to by <tt>object</tt> or by <tt>this</tt> immediately before the effects.
++</p>
++</blockquote></blockquote>
++</li>
++<li>Change 29.6 [atomics.types.operations] p. 20 as indicated:
++<blockquote><pre>
++bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
++bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
++bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
++bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
++bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired,
++ memory_order success, memory_order failure);
++bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired,
++ memory_order success, memory_order failure);
++bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired,
++ memory_order success, memory_order failure);
++bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired,
++ memory_order success, memory_order failure);
++bool A::compare_exchange_weak(C &amp; expected, C desired,
++ memory_order success, memory_order failure) volatile;
++bool A::compare_exchange_weak(C &amp; expected, C desired,
++ memory_order success, memory_order failure);
++bool A::compare_exchange_strong(C &amp; expected, C desired,
++ memory_order success, memory_order failure) volatile;
++bool A::compare_exchange_strong(C &amp; expected, C desired,
++ memory_order success, memory_order failure);
++bool A::compare_exchange_weak(C &amp; expected, C desired,
++ memory_order order = memory_order_seq_cst) volatile;
++bool A::compare_exchange_weak(C &amp; expected, C desired,
++ memory_order order = memory_order_seq_cst);
++bool A::compare_exchange_strong(C &amp; expected, C desired,
++ memory_order order = memory_order_seq_cst) volatile;
++bool A::compare_exchange_strong(C &amp; expected, C desired,
++ memory_order order = memory_order_seq_cst);
++</pre><blockquote><p>
++19 <em>Requires</em>: The <tt>failure</tt> argument shall not be <tt>memory_order_release</tt> nor <tt>memory_order_acq_rel</tt>.
++The <tt>failure</tt> argument shall be no stronger than the success argument.
++<p/>
++20 <em>Effects</em>: Atomically, compares the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> for equality
++with that in <tt>expected</tt>, and if true, replaces the contents of the memory pointed to by <tt>object</tt> or by
++<tt>this</tt> with that in <tt>desired</tt>, and if false, updates the contents of the memory in expected with the
++contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt>. Further, if the comparison is true, memory
++is affected according to the value of <tt>success</tt>, and if the comparison is false, memory is affected
++according to the value of <tt>failure</tt>. When only one <tt>memory_order</tt> argument is supplied, the value of
++<tt>success</tt> is <tt>order</tt>, and the value of <tt>failure</tt> is <tt>order</tt> except that a value of
++<tt>memory_order_acq_rel</tt> shall be replaced by the value <tt>memory_order_acquire</tt> and a value of
++<tt>memory_order_release</tt> shall be replaced by the value <tt>memory_order_relaxed</tt>. <ins>If
++the program does not specify an order, it shall be <tt>memory_order_seq_cst</tt>.</ins> If the operation returns <tt>true</tt>,
++these operations are atomic read-modify-write operations (1.10). Otherwise, these operations are atomic load operations.
++<p/>
++[..]
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1305"></a>1305. preconditions for <tt>atomic_future</tt></h3>
+-<p><b>Section:</b> 30.6.8 [futures.atomic_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1475"></a>1475. weak compare-and-exchange confusion II</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1474">1474</a></p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CH-23</b></p>
+
+ <p>
+-The revised futures package in the current working paper simplified the
+-<tt>is_ready/has_exception/has_value</tt> set of APIs, replacing them with a
+-single 'valid' method. This method is used in many places to signal pre- and
+-post- conditions, but that edit is not complete.
+-</p>
+-
+-<p>
+-Atomic future retains the extended earlier API, and provides defined,
+-synchronized behaviour for all calls. However, some preconditions and throws
+-clauses are missing, which can easily be built around the new <tt>valid()</tt>
+-api. Note that for consistency, I suggest <tt>is_ready/has_exception/has_value
+-throw</tt> an exception if <tt>valid()</tt> is not <tt>true</tt>, rather than
+-return <tt>false</tt>. I think this is implied by the existing pre-condition on
+-<tt>is_ready</tt>.
++29.6 [atomics.types.operations] p. 23: The first sentence has non-English syntax.
+ </p>
+
+ <p><i>[
+-2010-01-23 See discussion starting with Message c++std-lib-26666.
++Resolution proposed in ballot comment:
+ ]</i></p>
+
+
++<p>
++Change to "The weak compare-and-exchange
++operations may fail spuriously, that is, return false
++while leaving the contents of memory pointed to
++by expected unchanged."
++</p>
++
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++Daniel translates NB comment in a proposed resolution
+ ]</i></p>
+
+
++<p>Change 29.6 [atomics.types.operations] p. 23 as indicated:</p>
+
++<blockquote><p>
++23 <em>Remark</em>: <del>The weak compare-and-exchange operations may fail spuriously, that is, return false while
++leaving the contents of memory pointed to by <tt>expected</tt> before the operation is the same that same
++as that of the <tt>object</tt> and the same as that of <tt>expected</tt> after the operation</del><ins>The weak
++compare-and-exchange operations may fail spuriously, that is, return false while leaving the contents of memory
++pointed to by <tt>expected</tt> unchanged.</ins>. [ <em>Note</em>: This spurious failure enables implementation of
++compare-and-exchange on a broader class of machines, e.g., loadlocked store-conditional machines. A consequence of
++spurious failure is that nearly all uses of weak compare-and-exchange will be in a loop.
++<p/>
++When a compare-and-exchange is in a loop, the weak version will yield better performance on some
++platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
++strong one is preferable. &mdash; <em>end note</em> ]
++</p></blockquote>
+
+-<p><b>Rationale:</b></p>
+-<p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
+-</p>
++<p><i>[
++See <a href="lwg-defects.html#1474">1474</a> for the proposed resolution
++]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-Insert the following extra paragraphs:
+-</p>
+
+-<p>
+-In 30.6.8 [futures.atomic_future]
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote><pre>bool is_ready() const;
+-</pre>
+-<blockquote>
+-<p>
+-17 <i><del>Precondition</del> <ins>Requires</ins>:</i> <tt>valid() == true</tt>.
+-</p>
+
+-<p>
+-18 <i>Returns:</i> <tt>true</tt> only if the associated state is ready.
+-</p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
+
+-</blockquote>
+-</blockquote>
+
+-<blockquote><pre>bool has_exception() const;
+-</pre>
+-<blockquote>
++<hr>
++<h3><a name="1476"></a>1476. Meaningless specification of spurious failure</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1474">1474</a></p>
++<p><b>Discussion:</b></p>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++<p><b>Addresses US-177</b></p>
+
+ <p>
+-19 <i>Returns:</i> <tt>true</tt> only if the associated state is ready and
+-contains an exception.
++The first sentence of this paragraph doesn't make sense.
+ </p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
++<p><i>[
++Resolution proposed in ballot comment
++]</i></p>
+
+-</blockquote>
+-</blockquote>
++<p>
++Figure out what it's supposed to say, and say it.
++</p>
+
+-<blockquote><pre>bool has_value() const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-20 <i>Returns:</i> <tt>true</tt> only if the associated state is ready and
+-contains a value.
+-</p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
+
+-</blockquote>
+-</blockquote>
+
+-<blockquote><pre>void wait() const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++<hr>
++<h3><a name="1477"></a>1477. weak compare-and-exchange confusion III</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Dup">Dup</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Dup">Dup</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-defects.html#1474">1474</a></p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-135</b></p>
+
+ <p>
+-22 <i>Effects:</i> blocks until ...
++The first sentence of 29.6 [atomics.types.operations] p.23 was changed by n2992 but
++now makes no sense: "that is, return <tt>false</tt> while leaving
++the contents of memory pointed to by <tt>expected</tt> before the
++operation is the same that same as that of the <tt>object</tt> and
++the same as that of <tt>expected</tt> after the operation."
++There's a minor editorial difference between n2992 ("is
++that same as that" vs "is the same that same as that") but
++neither version makes sense.
++Also, the remark talks about "<tt>object</tt>" which should
++probably be "<tt>object</tt> or <tt>this</tt>" to cover the member functions
++which have no object parameter.
+ </p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
++<p><i>[
++Resolution proposed in ballot comment:
++]</i></p>
+
+-</blockquote>
+-</blockquote>
++<p>
++Fix the Remark to say whatever was intended.
++</p>
+
+-<blockquote><pre>template &lt;class Rep, class Period&gt;
+- bool wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
+
+-<p>
+-23 <i>Effects:</i> blocks until ...
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-24 <i>Returns:</i> <tt>true</tt> only if ...
+-</p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
+
+-</blockquote>
+-</blockquote>
+
+-<blockquote><pre>template &lt;class Clock, class Duration&gt;
+- bool wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
+-</pre>
+-<blockquote>
+
+-<p><ins>
+-<i>Requires:</i> <tt>valid() == true</tt>.
+-</ins></p>
++<hr>
++<h3><a name="1483"></a>1483. <tt>__STDCPP_THREADS spelling</tt></h3>
++<p><b>Section:</b> 30.3 [thread.threads] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses DE-23</b></p>
+
+ <p>
+-25 <i>Effects:</i> blocks until ...
++Predefined macros usually start and end with two
++underscores, see 16.8 and FDIS 29124 = WG21 N3060
++clause 7. <tt>__STDCPP_THREADS</tt> should blend in.
+ </p>
+
+-<p>
+-26 <i>Returns:</i> <tt>true</tt> only if ...
+-</p>
++<p><i>[
++Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
++]</i></p>
+
+-<p><ins>
+-<i>Throws:</i> <tt>future_error</tt> with an error condition of
+-<tt>no_state</tt> if the precondition is not met.
+-</ins></p>
+
+-</blockquote>
+-</blockquote>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the macro name to <tt>__STDCPP_THREADS__</tt>.
++</p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1308"></a>1308. Concerns about <tt>initializer_list</tt> overloads of <tt>min</tt>,
+-<tt>max</tt>, and <tt>minmax</tt></h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2010-02-02 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1485"></a>1485. Unclear <tt>thread::id</tt> specification</h3>
++<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses US-184</b></p>
+ <p>
+-In San Francisco, June 2008, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2722.pdf">N2722</a>
+-was adopted, replacing the variadic templates <tt>min</tt>, <tt>max</tt>, and
+-<tt>minmax</tt> by overloads that have an <tt>initializer_list&lt;T&gt;</tt>
+-parameter. The paper showed benchmark results wherein <tt>initializer_list</tt>
+-versions of <tt>min</tt> appeared to outperform the corresponding variadic
+-template. Unfortunately, in October 2009 a very serious error was detected in
+-the benchmark. (<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&msg=25210">c++std-lib-25210</a>).
+-In fact, an <tt>initializer_list&lt;T&gt;</tt> version of <tt>min</tt> often
+-appears to perform <i>worse</i> than the corresponding variadic template,
+-especially when <tt>T</tt> has an expensive copy constructor (<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&msg=25253">c++std-lib-25253</a>,
+-<a href="http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix">http://www.xs4all.nl/~nd/dekkerware/issues/n2772_fix</a>).
+-</p>
+-<p>
+-IMO, the biggest problem of the <tt>initializer_list</tt> overloads is that they
+-pass and return <tt>T</tt> objects <i>by value</i>. Which has the following
+-consequences:
++It is unclear when a <tt>thread::id</tt> ceases to be meaningful.
++The sentence "The library may reuse the value of a
++<tt>thread::id</tt> of a terminated thread that can no longer be
++joined." implies that some terminated threads can be
++joined. It says nothing about detached threads.
+ </p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Require a unique <tt>thread::id</tt> for every thread that is
++(1) detached and not terminated or (2) has an associated <tt>std::thread</tt>
++object.
++</p></blockquote>
++
++<p><i>[
++2010-11-22 Howard Hinnant observes
++]</i></p>
+
+-<ol>
+-<li>
+-They require that <tt>T</tt> is CopyConstructible. IMO that is too much of a
+-constraint for a generic, general purpose function like
+-<tt>std::min&lt;T&gt;</tt>.
+-</li>
+-<li>
+-They potentially throw an exception, even if <tt>T</tt>'s less-than-operator
+-throws nothing. (And of course, less-than typically throws nothing.)
+-</li>
+-<li>
+-They are inconsistent with C++03 std::<tt>min</tt> and std::<tt>max</tt>.
+-Consider the subtle difference between <tt>const T&amp; c1 = min(a,b);</tt> and
+-<tt>const T&amp; c2 = min({a,b});</tt> (<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&msg=25265">c++std-lib-25265</a>)
+-</li>
+-<li>
+-They do not conveniently support use cases that need to have a reference to the
+-minimum or maximum object <i>itself</i>, rather than just a copy.
+-</li>
+-<li>
+-They potentially perform badly: possibly <i>O(n)</i>, when the arguments
+-themselves have a size of <i>n</i>.
+-</li>
+-</ol>
+
+ <p>
+-In the future, this problem might be solvable by using an
+-<tt>initializer_list</tt> of <i>const references</i>, instead:
++A thread can either be running or terminated. Additionally a thread can be joined, detached, or neither.
++These combine into the five possible states shown in this table:
+ </p>
+-<blockquote><pre>const T&amp; min(initializer_list&lt;const T&amp;&gt;);
+-const T&amp; max(initializer_list&lt;const T&amp;&gt;);
+-pair&lt;const T&amp;, const T&amp;&gt; minmax(initializer_list&lt;const T&amp;&gt;);
+-</pre></blockquote>
+
++<table border="1">
++<tr>
++<th></th><th>Running</th><th>Terminated</th>
++</tr>
++<tr>
++<th>Neither joined nor detached</th><td>shall not reuse id</td><td>shall not reuse id</td>
++</tr>
++<tr>
++<th>detached</th><td>shall not reuse id</td><td>may reuse id</td>
++</tr>
++<tr>
++<th>joined</th><td>impossible state</td><td>may reuse id</td>
++</tr>
++</table>
+ <p>
+-It is unlikely that C++0x will support <tt>initializer_list&lt;const
+-T&amp;&gt;</tt>, but technically it seems possible to add such a language
+-feature after C++0x (<a href="http://accu.org/cgi-bin/wg21/message?wg=core&msg=15428">c++std-core-15428</a>).
++Only if a thread is neither joined nor detached can it be joined. Or said differently, if a
++thread has already been joined or detached, then it can not be joined. The sentence:
+ </p>
++<blockquote><p>
++The library may reuse the value of a <tt>thread::id</tt> of a terminated thread that can no longer be joined.
++</p></blockquote>
+ <p>
+-Variadic templates of <tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt>, as
+-proposed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2551.pdf">N2551</a>
+-(Sylvain Pion), do have some other advantages over <tt>initializer_list</tt>
+-overloads:
++precisely defines the two states shown in the above table where a thread::id may be reused.
+ </p>
+-<ol>
+-<li>
+-It is likely that those variadic templates can be declared <tt>constexpr</tt>,
+-now that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3006.html#991">
+-CWG issue #991</a> is in drafting status.
+-</li>
+-<li>
+-They provide complete compile-time protection against accidentally passing zero
+-arguments.
+-</li>
+-</ol>
+-
+ <p>
+-Unfortunately, the variadic templates of <tt>min</tt>, <tt>max</tt>, and
+-<tt>minmax</tt> may still need further improvement, before having them in the
+-Standard Library. Especially the optional <tt>Compare</tt> parameter appears to
+-be a concern. So for this moment I recommend to keep both versions out of C++0x,
+-and postpone further discussion until after C++0x.
++The following program illustrates all of the possibilities:
+ </p>
++<blockquote><pre>
++#include &lt;mutex>
++#include &lt;thread>
++#include &lt;iostream>
++#include &lt;chrono>
+
+-<p><i>[
+-2010 Pittsburgh: Discussed and the LWG still prefers the initializer list
+-solution of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2772.pdf">N2772</a>.
+-]</i></p>
++std::mutex mut;
+
++void f()
++{
++ std::lock_guard&lt;std::mutex&gt; _(mut);
++ std::cout &lt;&lt; "f id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; " terminating\n";
++}
+
++void g()
++{
++ std::lock_guard&lt;std::mutex&gt; _(mut);
++ std::cout &lt;&lt; "g id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; " terminating\n";
++}
+
++int main()
++{
++ std::cout &lt;&lt; "main id = " &lt;&lt; std::this_thread::get_id() &lt;&lt; "\n";
++ std::thread t1(f);
++ std::thread(g).detach();
++ std::this_thread::sleep_for(std::chrono::seconds(1));
++ std::cout &lt;&lt; "g's thread::id can be reused here because g has terminated and is detached.\n";
++ std::cout &lt;&lt; "f's thread::id can't be reused here because f has terminated but is still joinable.\n";
++ std::cout &lt;&lt; "f id = " &lt;&lt; t1.get_id() &lt;&lt; "\n";
++ t1.join();
++ std::cout &lt;&lt; "f's thread::id can be reused here because f has terminated and is joined.\n";
++ std::cout &lt;&lt; "f id = " &lt;&lt; t1.get_id() &lt;&lt; "\n";
++}
+
+-<p><b>Rationale:</b></p>
+-We prefer the solution of
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2772.pdf">N2772</a>
+-which will be reapplied.
++main id = 0x7fff71197ca0
++f id = 0x100381000 terminating
++g id = 0x100581000 terminating
++g's thread::id can be reused here because g has terminated and is detached.
++f's thread::id can't be reused here because f has terminated but is still joinable.
++f id = 0x100381000
++f's thread::id can be reused here because f has terminated and is joined.
++f id = 0x0
++</pre></blockquote>
+
++<p><i>[2011-02-11 Reflector discussion]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Remove both variadic templates and <tt>initializer_list</tt> overloads of
+-<tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt> from the synopsis in
+-25.1 [algorithms.general] and from 25.4.7 [alg.min.max].
++Moved to Tentatively NAD after 5 votes.
+ </p>
+
+-<blockquote>
+-<p><i>[
+-Note: This proposed resolution will resolve LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a> as NAD.
+-]</i></p>
+
+-</blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1311"></a>1311. multi-pass property of Forward Iterator underspecified</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1486"></a>1486. Value of <tt>this_thread::get_id()</tt> underspecified for detached thread</h3>
++<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CH-24</b></p>
+ <p>
+-The following example demonstrates code that would meet the guarantees of a
+-Forward Iterator, but only permits a single traversal of the underlying
+-sequence:
++What would be the value <tt>this_thread::get_id()</tt> when called from a detached thread?
+ </p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+-<blockquote><pre>template&lt; typename ForwardIterator&gt;
+-struct bad_iterator {
+- shared_ptr&lt;ForwardIterator&gt; impl;
++<p>
++Add some text to clarify that <tt>get_id()</tt> still returns the same value even after detaching.
++</p>
+
+- bad_iterator( ForwardIterator iter ) {
+- : impl{new ForwardIterator{iter} }
+- {
+- }
++<p><i>[
++2010-11-22 Howard Hinnant observes
++]</i></p>
+
+- auto operator*() const -&gt; decltype(*ForwardIterator{}) {
+- return **impl;
+- }
+
+- auto operator-&gt;() const -&gt; ForwardIterator {
+- return *impl;
+- }
++<p>
++30.3.2 [thread.thread.this]/1 contains the following sentence describing <tt>this_thread::get_id()</tt>:
++</p>
+
+- auto operator==(bad_iterator const &amp; rhs) {
+- return impl == rhs.impl;
+- }
++<blockquote><p>
++... No other thread of execution shall have this id and this thread of execution shall always have this id.
++</p></blockquote>
+
+- auto operator++() {
+- ++(*imp);
+- }
+- // other operations as necessary...
+-};
+-</pre></blockquote>
++<p>I don't object to adding "even if detached" to this sentence, but it seems unnecessary to me. "Always" means always.</p>
+
+-<p>
+-Here, we use <tt>shared_ptr</tt> to wrap a forward iterator, so all iterators
+-constructed from the same original iterator share the same 'value', and
+-incrementing any one copy increments all others.
+-</p>
++<p><i>[2011-02-11 Reflector discussion]</i></p>
+
+ <p>
+-There is a missing guarantee, expressed by the following code sequence
++Moved to Tentatively NAD after 5 votes.
+ </p>
+
+-<blockquote><pre>FwdIter x = seq.begin(); // obtain forward iterator from a sequence
+-FwdIter y = x; // copy the iterator
+-assert(x == y); // iterators must be the same
+-++x; // increment *just one* iterator
+-assert(x != y); // iterators *must now be different*
+-++y; // increment the other iterator
+-assert(x == y); // now the iterators must be the same again
+-</pre></blockquote>
+
+-<p>
+-That inequality in the middle is an essential guarantee. Note that this list is
+-simplified, as each assertion should also note that they refer to exactly the
+-same element <tt>(&amp;*x == &amp;*y)</tt> but I am not complicating the issue
+-with tests to support proxy iterators, or value types overloading unary
+-<tt>operator+</tt>.
+-</p>
+
+-<p>
+-I have not yet found a perverse example that can meet this additional
+-constraint, and not meet the multi-pass expectations of a Forward Iterator
+-without also violating other Forward Iterator requirements.
+-</p>
++<p><b>Proposed resolution:</b></p>
+
+-<p>
+-Note that I do not yet have standard-ready wording to resolve the problem, as
+-saying this neatly and succinctly in 'standardese' is more difficult.
+-</p>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+-]</i></p>
+
+
+
++<hr>
++<h3><a name="1489"></a>1489. <tt>unlock</tt> functions and unlock mutex requirements are inconsistent</h3>
++<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-26</b></p>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++Specifications of <tt>unlock</tt> member functions and <tt>unlock</tt>
++mutex requirements are inconsistent wrt to exceptions and
++pre- and postconditions.
+ </p>
+
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++<tt>unlock</tt> should specifiy the precondition that the
++current thread "owns the lock", this will make calls
++without holding the locks "undefined behavior".
++<tt>unlock</tt> in [mutex.requirements] should either be
++<tt>noexcept(true)</tt> or be allowed to throw
++<tt>system_error</tt> like <tt>unique_lock::unlock</tt>, or the latter
++should be <tt>nothrow(true)</tt> and have the precondition
++<tt>owns == true</tt>.
++Furthermore <tt>unique_lock</tt>'s postcondition is wrong
++in the case of a recursive mutex where <tt>owns</tt>
++might stay true, when it is not the last <tt>unlock</tt>
++needed to be called.
++</p></blockquote>
++
++
+
+ <p><b>Proposed resolution:</b></p>
+
+@@ -48447,786 +38573,1024 @@ Solved by
+
+
+ <hr>
+-<h3><a name="1313"></a>1313. Seed sequence's param function not useful for pure output iterator</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1495"></a>1495. Condition variable <tt>wait_for</tt> return value insufficient</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>
+-The Seed sequence requirements (26.5.1.2 [rand.req.seedseq]) require the
+-existence of a member function
+-</p>
+-
+-<blockquote><pre>template&lt;typename OutputIterator&gt;
+-void param(OutputIterator ob);
+-</pre></blockquote>
++<p><b>Addresses US-191</b></p>
+
+ <p>
+-The fact that this function returns <tt>void</tt> instead of the value of
+-<tt>ob</tt> after accepting the sequence data leads to the same problem as in
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a> - In case of pure output iterators there is no way to
+-serialize further data into that data sink.
++The condition variable <tt>wait_for</tt> returning <tt>cv_status</tt> is insufficient.
+ </p>
+
+ <p><i>[
+-2010-02-07 Howard adds:
++Resolution proposed by ballot comment:
+ ]</i></p>
+
++<blockquote><p>
++Return a duration of timeout remaining instead.
++See Appendix 1 of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> - Additional Details, p. 211
++</p></blockquote>
+
+-<blockquote>
+-At the time this issue was opened, the suggested changes are with respect to an
+-anticipated draft which does not yet exist.
+-</blockquote>
+
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
+
+-<blockquote>
+-No technical counterarguments, but it is simply too late in the process
+-to make this change at this point.
+-</blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>
+-<p>
+-In Table 109 — Seed sequence requirements, expression "<tt>r.param(ob)</tt>"
+-change the<br>
+-Return type entry:
+-</p>
+
+-<blockquote><pre><del>void</del><ins>OutputIterator</ins>
+-</pre></blockquote>
+-</li>
+
+-<li>
++<hr>
++<h3><a name="1496"></a>1496. <tt>condition_variable</tt> not implementable</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-28</b></p>
++
+ <p>
+-In 26.5.7.1 [rand.util.seedseq], class seed_seq synopsis change
++Requiring <tt>wait_until</tt> makes it impossible to implement
++<tt>condition_variable</tt> correctly using respective objects
++provided by the operating system (i.e. implementing the
++native_handle() function) on many platforms (e.g. POSIX,
++Windows, MacOS X) or using the same object as for the
++condition variable proposed for C.
+ </p>
+
+-<blockquote><pre>template&lt;class OutputIterator&gt;
+-<del>void</del><ins>OutputIterator</ins> param(OutputIterator dest) const;
+-</pre></blockquote>
+-</li>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+-</ol>
++<blockquote><p>
++Remove the <tt>wait_until</tt> functions or make them at least conditionally supported.
++</p></blockquote>
+
+
++<p><b>Proposed resolution:</b></p>
++
+
+
+
+
+ <hr>
+-<h3><a name="1314"></a>1314. <tt>NULL</tt> and <tt>nullptr</tt></h3>
+-<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.types">issues</a> in [support.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="1500"></a>1500. Consider removal of <tt>native_handle()</tt></h3>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CH-32</b></p>
++
+ <p>
+-Currently, the 18.2 [support.types]/3 allows <tt>NULL</tt> to be any
+-null pointer constant. The footnote marks that 0 or 0L might be appropriate.
+-However, this definition also allows the implementation to define <tt>NULL</tt>
+-to be <tt>nullptr</tt>. This may lead to overload and conversion issues more
+-serious than with the C++98 version:
++Given that the lock type can be something the underlying
++doesn't know 'native_handle()' is probably
++unimplementable on essentially all platforms.
+ </p>
+
+-<blockquote><pre>void f(void*);
+-void f(int);
++<p><i>[
++Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
++]</i></p>
+
+-void g()
+-{
+- // calls f(int) if NULL is integral
+- // calls f(void*) if NULL is nullptr
+- f(NULL);
+-}
+-</pre></blockquote>
+
++
++
++<p><b>Proposed resolution:</b></p>
+ <p>
+-Possible resolutions:
++Consider the removal of 'native_handle()'.
+ </p>
+-<ul>
+-<li>
+-Forbid <tt>NULL</tt> from being <tt>nullptr</tt>
+-</li>
+-<li>
+-Require <tt>NULL</tt> to be <tt>nullptr</tt>
+-</li>
+-<li>
+-Leave it as is
+-</li>
+-</ul>
+
++
++
++
++
++<hr>
++<h3><a name="1503"></a>1503. "associated asynchronous state" must go</h3>
++<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.state">issues</a> in [futures.state].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-35</b></p>
+ <p>
+-Making <tt>NULL</tt> <tt>nullptr</tt> would improve code correctness, and
+-breaking backwards compatibility shouldn't be a huge concern as <tt>NULL</tt>
+-shouldn't be used except as a null pointer constant anyways.
++The term "associated asynchronous state" is long, ugly and misleading terminology. When
++introduced we agreed upon that we should come up with a better name. Here it is:
++"liaison state". Since the state is hidden and provides synchronization of a
++<tt>future</tt> with its corresponding <tt>promise</tt>, we believe "liaison state" is
++a much better and shorter name (liaison ~ (typically hidden) relationship)
+ </p>
+-
+ <p><i>[
+-2010-02-10 Chris provided wording.
++Resolution proposed by ballot comment:
+ ]</i></p>
+
++<blockquote><p>
++Change all occurrences of "associated
++asynchronous state" to "liaison state".
++</p></blockquote>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD, rationale added below.
+-]</i></p>
+
++<p><b>Proposed resolution:</b></p>
++<p>The project editor may supply a more appopriate term, or use "liaison state",
++at his own discretion.</p>
+
+
+
+-<p><b>Rationale:</b></p>
+-<p>
+-The LWG discussed the proposed resolution and several other options. There was
+-no concensus to make this or any other changes.
+-</p>
+
+
+-<p><b>Proposed resolution:</b></p>
++<hr>
++<h3><a name="1506"></a>1506. <tt>set_exception</tt> with a null pointer</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-198</b></p>
+ <p>
+-18.2 [support.types]
++<tt>promise::set_exception</tt> can be called with a null pointer,
++but none of the descriptions of the <tt>get()</tt> functions for the
++three types of futures say what happens for this case.
+ </p>
++<p><i>[
++Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
++]</i></p>
++
+
+-<blockquote>
+-<p>
+-3 The macro <tt>NULL</tt> <ins>is defined to be <tt>nullptr</tt>.</ins> <del>is
+-an implementation-defined C++ null pointer constant in this International
+-Standard (4.10).<sup>196</sup></del>
+-</p>
+
+-<p><del>
+-196) Possible definitions include <tt>0</tt> and <tt>0L</tt>, but not
+-<tt>(void*)0</tt>.
+-</del></p>
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-20.9.13 [c.malloc]
++Add the following sentence to the end of
++30.6.5/22: The behavior of a program that calls
++<tt>set_exception</tt> with a null pointer is undefined.
+ </p>
+
+-<blockquote>
+-7 The contents are the same as the Standard C library header
+-<tt>&lt;string.h&gt;</tt>, with the change to <tt>memchr()</tt> specified in
+-21.6 <ins>and the macro <tt>NULL</tt> defined to be <tt>nullptr</tt></ins>.
+-</blockquote>
+-
+
+-<p>
+-20.12 [date.time]
+-</p>
+
+-<blockquote>
+-2 The contents are the same as the Standard C library header
+-<tt>&lt;time.h&gt;</tt><del>.</del><sup>232</sup> <ins>except the macro
+-<tt>NULL</tt>, which is defined to be <tt>nullptr</tt>.</ins> The functions
+-<tt>asctime</tt>, <tt>ctime</tt>, <tt>gmtime</tt>, and <tt>localtime</tt> are
+-not required to avoid data races (17.6.4.8).
+-</blockquote>
+
+
++<hr>
++<h3><a name="1509"></a>1509. No restriction on calling <tt>future::get</tt> more than once</h3>
++<p><b>Section:</b> X [futures.atomic_future] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-202</b></p>
+ <p>
+-22.6 [c.locales]
++The note in this paragraph says "unlike <tt>future</tt>, calling <tt>get</tt>
++more than once on the same <tt>atomic_future</tt> object is well
++defined and produces the result again." There is nothing
++in <tt>future</tt> that says anything negative about calling <tt>get</tt>
++more than once.
+ </p>
+
+-<blockquote>
+-2 The contents are the same as the Standard C library header
+-<tt>&lt;locale.h&gt;</tt> <ins>except the macro <tt>NULL</tt>, which is defined
+-to be <tt>nullptr</tt></ins>.
+-</blockquote>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+ <p>
+-C.2.2.4 [diff.null]
++Remove this note, or add words to the
++requirements for future that reflect what this note
++says.
+ </p>
+
+-<blockquote>
+-1 The macro <tt>NULL</tt>, defined in any of <tt>&lt;clocale&gt;</tt>,
+-<tt>&lt;cstddef&gt;</tt>, <tt>&lt;cstdio&gt;</tt>, <tt>&lt;cstdlib&gt;</tt>,
+-<tt>&lt;cstring&gt;</tt>, <tt>&lt;ctime&gt;</tt>, or <tt>&lt;cwchar&gt;</tt>, is
+-<ins>nullptr</ins> <del>an implementation-defined C++ null pointer constant in
+-this International Standard (18.2).</del>
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1315"></a>1315. return type of <tt>async</tt></h3>
+-<p><b>Section:</b> 30.6.9 [futures.async] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-02-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.async">issues</a> in [futures.async].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="1510"></a>1510. Should be undefined behaviour to call <tt>atomic_future</tt> operations unless <tt>valid()</tt></h3>
++<p><b>Section:</b> X [futures.atomic_future] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses US-203</b></p>
+ <p>
+-Both overloads of <tt>async</tt> return <tt>future&lt;typename
+-F::result_type&gt;</tt> which requires that <tt>F</tt> has a nested type. This
+-prevents <tt>async</tt> being used with function pointers and makes the example
+-in 30.6.9 [futures.async] invalid. I believe this is unintentional.
++Both <tt>future</tt> and <tt>shared_future</tt> specify that calling most
++member functions on an object for which <tt>valid() == false</tt>
++produces undefined behavior. There is no such statement
++for <tt>atomic_future</tt>.
+ </p>
+
+-<p>
+-The proposed resolution also addresses editorial issues with the
+-<tt>launch_policy</tt> function parameter.
+-</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+ <p>
+-For the first overload it is not sufficient to return <tt>future&lt;typename
+-result_of&lt;F(ArgTypes...)&gt;::type&gt;</tt>. Calling <tt>async(launch::xxx,
+-foo, bar)</tt> performs argument deduction on both <tt>async</tt> overloads,
+-which for the first overload attempts to instantiate <tt>result_of&lt;launch(F,
+-ArgTypes...)&gt;</tt>, which is invalid. SFINAE must be used to prevent that.
++Add a new paragraph after X [futures.atomic_future]/2 with the same words as
++30.6.7 [futures.shared_future]/3.
+ </p>
+
+ <p><i>[
+-2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++2010-11-02 Daniel translates proposed changes into specific deltas and comments:
+ ]</i></p>
+
+
+-<p><i>[
+-2010-02-12 Daniel opens:
+-]</i></p>
++<blockquote><p>
++While applying the wording, I notice that 30.6.7 [futures.shared_future]/3 does
++speak of the move-assignment operator, and <em>not</em> of the copy-assignment operator.
++<tt>atomic_future</tt> obviously needs this to be true for the copy-assignment operator,
++but I strongly assume that <tt>shared_future</tt> needs to mention both special member
++assignment operators in this paragraph. To keep this consistent, the following P/R also
++provides wording to fix the corresponding location for <tt>shared_future</tt>.
++</p></blockquote>
+
+
+-<blockquote>
+-<p>
+-[..] if <tt>decay&lt;F&gt;::type</tt> is of type <tt>std::launch</tt>.
+-</p>
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>Change 30.6.7 [futures.shared_future]/3 as indicated:
++<blockquote><p>
++3 The effect of calling any member function other than the destructor<ins>, the
++copy-assignment operator</ins>, the move-assignment operator, or <tt>valid()</tt>
++on a <tt>shared_future</tt> object for which <tt>valid() == false</tt> is undefined.
++</p></blockquote>
++</li>
++<li>Following X [futures.atomic_future]/2, add a new paragraph:
++<blockquote><p>
++<ins>? The effect of calling any member function other than the destructor, the copy-assignment operator, or <tt>valid()</tt>
++on a <tt>atomic_future</tt> object for which <tt>valid() == false</tt> is undefined.</ins>
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1511"></a>1511. Synchronize the move-constructor for <tt>atomic_future</tt></h3>
++<p><b>Section:</b> X [futures.atomic_future] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-204</b></p>
+ <p>
+-or
++According to the definition of <tt>atomic_future</tt>, all members
++of <tt>atomic_future</tt> are synchronizing except constructors.
++However, it would probably be appropriate for a move
++constructor to be synchronizing on the source object. If
++not, the postconditions on paragraphs 7-8, might not be
++satisfied. This may be applicable if a collection of futures
++are being doled out to a set of threads that process their
++value.
+ </p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
+ <p>
+-[..] if <tt>remove_cv&lt;remove_reference&lt;F&gt;::type&gt;::type</tt> is of
+-type <tt>std::launch</tt>.
++Make the move constructor for atomic future lock
++the source
+ </p>
+
+-<p>
+-The latter is the more specific form, but the former is equivalent to
+-the latter for all cases that can occur here. I suggest to use the
+-former for simplicity, but expect that implementations can effectively
+-use the latter.
+
+-</p>
+-</blockquote>
+
+-<p><i>[
+-2010-02-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-]</i></p>
++<p><b>Proposed resolution:</b></p>
+
+
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+
+
+-<blockquote>
+-Moved to NAD Editorial. Rationale added below.
+-</blockquote>
+
++<hr>
++<h3><a name="1512"></a>1512. Conflict in specification: block or join?</h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-205</b></p>
++<p>
++30.6.8 [futures.async] p. 3: The third sentence says
++"If the invocation is not deferred, a call to a waiting function
++on an asynchronous return object that shares the associated asynchronous state
++created by this <tt>async</tt> call shall block until the associated
++thread has completed." The next sentence says "If the
++invocation is not deferred, the <tt>join()</tt> on the created
++thread..." Blocking until a thread completes is not
++necessarily a join.
++</p>
+
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
+
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by N3058.
++Decide whether the requirement is to block until
++finished or to call join, and rewrite to match.
+ </p>
+
+
++
+ <p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2006"></a>2006. <tt>emplace</tt> broken for associative containers</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2010-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The current definition of <tt>emplace(args)</tt> for associative containers as
++described in Table 99 is:
++</p>
++<blockquote>
++<p>
++<i>Requires</i>: <tt>T</tt> shall be constructible from <tt>args</tt>.
++<p/>
++<i>Effects</i>: Inserts a <tt>T</tt> object <tt>t</tt> constructed with
++<tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element
++in the container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt>
++component of the returned <tt>pair</tt> is <tt>true</tt> if and only if the
++insertion takes place, and the iterator component of the <tt>pair</tt>
++points to the element with key equivalent to the key of <tt>t</tt>.
++</p>
++</blockquote>
+ <p>
+-In 30.6.1 [futures.overview] paragraph 1:
++There is similar language in Table 100 for unordered associative containers.
++<p/>
++The first issue is editorial: <tt>T</tt> should be <tt>value_type</tt> throughout
++both tables.
++<p/>
++The major issue is that, if the container is <tt>map</tt>, <tt>multimap</tt>,
++<tt>unordered_map</tt>, or <tt>unordered_multimap</tt>, then the only way to
++construct an object of <tt>value_type</tt> is to supply exactly two arguments
++for <tt>Key</tt> and <tt>Value</tt>, a <tt>pair&lt;Key,Value&gt;</tt>, or a
++<tt>piecewise_construct_t</tt> followed by two <tt>tuple</tt>s. The original
++<tt>emplace()</tt> proposal would have allowed you to specify a <tt>Key</tt>
++value followed by any number of constructor arguments for <tt>Value</tt>.
++When we removed the variadic constructor to <tt>pair</tt>, this ability went
++away. I don't think that was deliberate.
++<p/>
++Fixing this is non-trivial, I think. I think that <tt>emplace()</tt> for <tt>map</tt>
++and <tt>multimap</tt> need several overloads: one for each overloaded constructor in
++<tt>pair&lt;Key,Value&gt;</tt>, and one for the <tt>emplace(Key, valueargs...)</tt> case.
++And it probably needs some SFINAE meta-programming to ensure that the last case
++doesn't override any of the other ones. Alternatively, one could say that
++there are exactly two cases: <tt>emplace(args)</tt> where <tt>pair&lt;Key,Value&gt;</tt>
++is constructible from <tt>args</tt>, and <tt>emplace(args)</tt> where <tt>Key</tt> is
++constructible form the first <tt>arg</tt> and <tt>Value</tt> is constructible from the
++rest.
++<p/>
++Alternatively, the status quo is to use <tt>piecewise_construct_t</tt> if you want to
++construct an object.
+ </p>
+
+-<blockquote><pre>template &lt;class F, class... Args&gt;
+- <del>future&lt;typename F::result_type&gt;</del>
+- <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
+- async(F&amp;&amp; f, Args&amp;&amp;... args);
+-template &lt;class F, class... Args&gt;
+- <del>future&lt;typename F::result_type&gt;</del>
+- <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
+- async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
+-</pre></blockquote>
++<p><i>[
++2010 Batavia:
++]</i></p>
++
+
+ <p>
+-In 30.6.9 [futures.async] before paragraph 1
++N3178 was looked at in session and moved to NAD.
+ </p>
+
+-<blockquote><pre>template &lt;class F, class... Args&gt;
+- <del>future&lt;typename F::result_type&gt;</del>
+- <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
+- async(F&amp;&amp; f, Args&amp;&amp;... args);
+-template &lt;class F, class... Args&gt;
+- <del>future&lt;typename F::result_type&gt;</del>
+- <ins>future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;</ins>
+- async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
+-</pre>
+-<blockquote>
+-<p>...</p>
+-<p><ins>
+-<i>Remarks:</i> The first signature shall not participate in overload resolution
+-if <tt>decay&lt;F&gt;::type</tt> is <tt>std::launch</tt>.
+-</ins></p>
+-</blockquote>
+-</blockquote>
+
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1317"></a>1317. make_hash</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Nicolai M. Josuttis <b>Opened:</b> 2010-02-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2026"></a>2026. <tt>hash</tt> should be <tt>std</tt> qualified for unordered container</h3>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Currently, the library lacks a convenient way to provide a hash function that
+-can be used with the provided unordered containers to allow the usage of non
+-trivial element types.
+-</p>
+-
+-<p>
+-While we can easily declare an
++Tom Plum pointed out to me that there's an apparent inconsistency in the <tt>std::</tt> qualification of template names in the unordered containers:
+ </p>
+
+-<blockquote><pre>std::unordered_set&lt;int&gt;
++<blockquote><pre>
++ template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
++ class unordered_map;
+ </pre></blockquote>
+
+ <p>
+-or
++Is there a reason that hash is not qualified with <tt>std::</tt>? TR1 also
++does not use <tt>std::</tt> here.
+ </p>
+
+-<blockquote><pre>std::unordered_set&lt;std::string&gt;
+-</pre></blockquote>
++<p><i>[
++2011-02-07 Chris Jefferson adds:
++]</i></p>
+
+ <p>
+-we have no easy way to declare an <tt>unordered_set</tt> for a user defined
+-type. IMO, this is a big obstacle to use unordered containers in practice. Note
+-that in Java, the wide usage of <tt>HashMap</tt> is based on the fact that there
+-is always a default hash function provided.
++I assumed (I might be wrong) it is because <tt>hash</tt> is designed to be a
++customisation point, like <tt>swap</tt>.
+ </p>
+
+-<p>
+-Of course, a default hash function implies the risk to provide poor hash
+-functions. But often even poor hash functions are good enough.
++<p><i>[
++2011-02-07 Howard Hinnant adds:
++]</i></p>
++
++<p>I think this is incorrect. We mean <tt>std::hash</tt>, though clients
++are free to specialize <tt>std::hash</tt> on user-defined types. With the
++possible exception of <tt>begin</tt>/<tt>end</tt> (which I'm not sure if
++we've settled that), <tt>swap</tt> is the only intended customization point (look up a function by ADL) in the <tt>std::</tt> lib.
+ </p>
+
++<p><i>[
++2011-02-24 Chris Jefferson adds:
++]</i></p>
++
++<p>I recommend NAD, due to 17.6.1.1 [contents] p3:</p>
++<blockquote><p>
++Whenever a name <tt>x</tt> defined in the standard library is mentioned, the name <tt>x</tt> is assumed to be fully qualified
++as <tt>::std::x</tt>, unless explicitly described otherwise. For example, if the Effects section for library function <tt>F</tt>
++is described as calling library function <tt>G</tt>, the function <tt>::std::G</tt> is meant.
++</p></blockquote>
++
++<p><i>[2011-02-25 Reflector discussion]</i></p>
++
+ <p>
+-While I really would like to see a default hash function, I don't propose it
+-here because this would probably introduce a discussion that's too big for this
+-state of C++0x.
+-</p>
++Moved to Tentatively NAD after 5 votes.
++</p>
++
+
++<p><b>Proposed resolution:</b></p>
+ <p>
+-However, I strongly suggest at least to provide a convenience variadic template
+-function <tt>make_hash&lt;&gt;()</tt> to allow an easy definition of a (possibly
+-poor) hash function.
+ </p>
+
+-<p>
+-As a consequence for a user-defined type such as
++
++
++
++
++<hr>
++<h3><a name="2036"></a>2036. <tt>istream &gt;&gt; char</tt> and <tt>eofbit</tt></h3>
++<p><b>Section:</b> 27.7.2.1 [istream] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream">issues</a> in [istream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The question is: When a single character is extracted from an <tt>istream</tt> using <tt>operator&gt;&gt;</tt>,
++does <tt>eofbit</tt> get set if this is the last character extracted from the stream? The current standard is at
++best ambiguous on the subject. 27.7.2.1 [istream]/p3 describes all extraction operations with:</p>
++
++<blockquote><p>
++3 If <tt>rdbuf()-&gt;sbumpc()</tt> or <tt>rdbuf()-&gt;sgetc()</tt> returns <tt>traits::eof()</tt>, then the input
++function, except as explicitly noted otherwise, completes its actions and does <tt>setstate(eofbit)</tt>, which may
++throw <tt>ios_base::failure</tt> (27.5.5.4 [iostate.flags]), before returning.
++</p></blockquote>
++
++<p>And 27.7.2.2.3 [istream::extractors]/p12 in describing <tt>operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp; in, charT&amp; c);</tt>
++offers no further clarification:
+ </p>
+
+-<blockquote><pre>class Customer {
+- friend class CustomerHash;
+- private:
+- string firstname;
+- string lastname;
+- long no;
+- ...
+- };
+-</pre></blockquote>
++<blockquote><p>
++12 <i>Effects</i>: Behaves like a formatted input member (as described in [istream.formatted.reqmts]) of <tt>in</tt>.
++After a <tt>sentry</tt> object is constructed a character is extracted from <tt>in</tt>, if one is available, and
++stored in <tt>c</tt>. Otherwise, the function calls <tt>in.setstate(failbit)</tt>.
++</p></blockquote>
+
+-<p>
+-would allow to specify:
++<p>I coded it one way in libc++, and g++ coded it another way. Chris Jefferson noted that some boost code was
++sensitive to the difference and fails for libc++. Therefore I believe that it is very important that we specify
++this extraction operator in enough detail that both vendors and clients know what behavior is required and expected.
+ </p>
+
+-<blockquote><pre>class CustomerHash : public std::unary_function&lt;Customer, std::size_t&gt;
++<p>Here is a brief code example demonstrating the issue:</p>
++
++<blockquote><pre>
++#include &lt;sstream&gt;
++#include &lt;cassert&gt;
++
++int main()
+ {
+- public:
+- std::size_t operator() (const Customer&amp; c) const {
+- return make_hash(c.firstname,c.lastname,c.no);
+- }
++ std::istringstream ss("1");
++ char t;
++ ss &gt;&gt; t;
++ assert(!ss.eof());
+ };
+ </pre></blockquote>
+
+-<p>
+-instead of:
+-</p>
++<p>For every type capable of reading this istringstream but <tt>char</tt>, <tt>ss.eof()</tt> will be true after the
++extraction (<tt>bool</tt>, <tt>int</tt>, <tt>double</tt>, etc.). So for consistency's sake we might want to have
++<tt>char</tt> behave the same way as other built-in types.</p>
++
++<p>However Jean-Marc Bourguet offers this counter example code using an interactive stream. He argues that
++setting <tt>eof</tt> inhibits reading the next line:</p>
+
+-<blockquote><pre>class CustomerHash : public std::unary_function&lt;Customer, std::size_t&gt;
++<blockquote><pre>
++#include &lt;iostream&gt;
++
++int main()
+ {
+- public:
+- std::size_t operator() (const Customer&amp; c) const {
+- return std::hash&lt;std::string&gt;()(c.firstname) +
+- std::hash&lt;std::string&gt;()(c.lastname) +
+- std::hash&lt;long&gt;()(c.no);
++ char c;
++ std::cin &gt;&gt; std::noskipws;
++ std::cout &lt;&lt; "First line: ";
++ while (std::cin &gt;&gt; c) {
++ if (c == '\n') {
++ std::cout &lt;&lt; "Next line: ";
+ }
+-};
++ }
++}
+ </pre></blockquote>
+
+-<p>
+-Note that, in principle, we can either specify that
+-</p>
++<p>As these two code examples demonstrate, whether or not <tt>eofbit</tt> gets set is an observable difference and it
++is impacting real-world code. I feel it is critical that we clearly and unambiguously choose one behavior or the other.
++I am proposing wording for both behaviors and ask the LWG to choose one (and only one!).</p>
+
+-<blockquote>
+-<tt>make_hash</tt> returns the sum of a call of
+-<tt>std::hash&lt;T&gt;()(x)</tt> for each argument <tt>x</tt> of type
+-<tt>T</tt>
+-</blockquote>
++<p>Wording for setting <tt>eof</tt> bit:</p>
+
+-<p>
+-or we can specify that
+-</p>
++<p>Modify 27.7.2.2.3 [istream::extractors]/p12 as follows:</p>
+
+-<blockquote>
+-<tt>make_hash</tt> provides a hash value for each argument, for which a
+-<tt>std::hash()</tt> function is provided
+-</blockquote>
++<blockquote><p>
++12 <i>Effects</i>: Behaves like a formatted input member (as described in [istream.formatted.reqmts]) of <tt>in</tt>.
++After a <tt>sentry</tt> object is constructed a character is extracted from <tt>in</tt>, if one is available, and
++stored in <tt>c</tt>. <del>Otherwise, the function calls <tt>in.setstate(failbit)</tt>.</del> <ins>If a character is
++extracted and it is the last character in the pending sequence, the function calls <tt>in.setstate(eofbit)</tt>.
++If a character is not extracted the function calls <tt>in.setstate(failbit | eofbit)</tt>.</ins>
++</p></blockquote>
+
+-<p>
+-with the possible note that the hash value may be poor or only a good hash value
+-if the ranges of all passed arguments is equally distributed.
+-</p>
++<p>Wording for not setting <tt>eof</tt> bit:</p>
+
+-<p>
+-For my convenience, I propose wording that describes
+-the concrete implementation.
+-</p>
++<blockquote><p>
++12 <i>Effects</i>: Behaves like a formatted input member (as described in [istream.formatted.reqmts]) of <tt>in</tt>.
++After a <tt>sentry</tt> object is constructed a character is extracted from <tt>in</tt><del>, if one is available,
++and stored in <tt>c</tt>. Otherwise, the function calls <tt>in.setstate(failbit)</tt>.</del> <ins>with
++<tt>in.rdbuf()-&gt;sbumpc()</tt>. If <tt>traits::eof()</tt> is returned, the function calls
++<tt>in.setstate(failbit | eofbit)</tt>. Otherwise the return value is converted to type <tt>charT</tt> and stored
++in <tt>c</tt>.</ins>
++</p></blockquote>
+
+-<p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial, rationale added below.
+-]</i></p>
++<p><i>[2011-02-27: Jean-Marc Bourguet comments]</i></p>
+
+
++<p>Just for completeness: it [the counter example] doesn't inhibit to read the next line, it inhibits the prompt
++to be put at the appropriate time.</p>
+
++<p>More information to take into account when deciding:</p>
+
+-<p><b>Rationale:</b></p>
+-<p>
+-There is no consensus to make this change at this time.
+-</p>
++<ul>
++<li><p>if I'm reading correctly the section to get boolean values when <tt>boolalpha</tt> is set, there we mandate
++that <tt>eof</tt> isn't set if trying to read past the end of the pending sequence wasn't needed to determine the result.
++</p></li>
+
++<li><p>
++see also the behaviour of <tt>getline</tt> (which isn't a formatted input function but won't set <tt>eof</tt>
++if it occurs just after the delimiter)
++</p></li>
+
+-<p><b>Proposed resolution:</b></p>
+-<p>
+-In Function objects 20.8 [function.objects]
+-in paragraph 2 at the end of the Header <tt>&lt;functional&gt;</tt> synopsis
+-insert:
+-</p>
++<li><p>
++if I'm reading the C standard correctly <tt>scanf("%c")</tt> wouldn't set <tt>feof</tt> either in that situation.
++</p></li>
++</ul>
+
+-<blockquote><pre>// convenience functions
+-template &lt;class T&gt;
+- size_t make_hash (const T&amp;);
+-template &lt;class T, class... Types&gt;
+- size_t make_hash (const T&amp;, const Types&amp;...);
+-</pre></blockquote>
++<p><i>[2011-02-28: Martin Sebor comments]</i></p>
+
+-<p>
+-In Class template hash 20.8.15 [unord.hash]
+-add:
+-</p>
+
+-<blockquote>
++<p>[Responds to bullet 1 of Jean-Marc's list]</p>
++
+ <p>
+-<b>20.7.16.1 Hash creation functions [hash.creation]</b>
++Yes, this matches the stdcxx test suite for <tt>num_get</tt> and <tt>time_get</tt>
++but not <tt>money_get</tt> when the currency symbol is last. I don't see
++where in the locale.money.get.virtuals section we specify whether
++<tt>eofbit</tt> is or isn't set and when.
++<p/>
++IMO, if we try to fix the <tt>char</tt> extractor to be consistent we
++should also fix all the others extractors and manipulators that
++aren't consistent (including <tt>std::get_money</tt> and <tt>std::get_time</tt>).
+ </p>
+
+-<pre>template &lt;class T&gt;
+- size_t make_hash (const T&amp; val);
+-</pre>
++<p><i>[2011-03-24 Madrid meeting]</i></p>
+
+-<blockquote>
+-<i>Returns:</i> <tt>hash&lt;T&gt;()(val);</tt>
+-</blockquote>
+
+-<pre>template &lt;class T, class... Types&gt;
+- size_t make_hash (const T&amp; val, const Types&amp;... args);
+-</pre>
++<p>Dietmar convinced Howard, that the standard does already say the right words</p>
+
+-<blockquote>
+-<i>Returns:</i> <tt>hash&lt;T&gt;()(val) + std::make_hash(args...)</tt>
+-</blockquote>
+
+-</blockquote>
+
++<p><b>Rationale:</b></p><p>Reading the last character does not set eofbit and the standard says so already</p>
++
++<p><b>Proposed resolution:</b></p>
++<p></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1329"></a>1329. Data races on <code>vector&lt;bool&gt;</code></h3>
+-<p><b>Section:</b> 23.2.2 [container.requirements.dataraces] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Jeffrey Yaskin <b>Opened:</b> 2010-03-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2043"></a>2043. <tt>std{in,out,err}</tt> should be usable as field names</h3>
++<p><b>Section:</b> 27.9.2 [c.files] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2011-03-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.files">issues</a> in [c.files].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The common implementation of <tt>vector&lt;bool&gt;</tt> is as an
+-unsynchronized bitfield. The addition of 23.2.2 [container.requirements.dataraces]/2 would require either a
+-change in representation or a change in access synchronization, both of
+-which are undesireable with respect to compatibility and performance.
++People often define structs and classes with fields named <tt>stdin</tt>,
++<tt>stdout</tt>, or <tt>stderr</tt>. According to 27.9.2 [c.files],
++though, these are macros.
++<p/>
++glibc defines them to themselves, allowing their non-portable use as
++field names, while the Mac OS X libc defines them to either <tt>__stdoutp</tt>
++or <tt>(&amp;__sF[1])</tt>, etc depending on <tt>__DARWIN_UNIX03</tt>. It's possible to
++allow their use while, as far as I can see, only requiring minor
++changes to various libc's, so C++1x should allow it.
+ </p>
+
+ <p><i>[
+-2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
++2011 Bloomington
+ ]</i></p>
+
+
+-
+-
+-<p><b>Rationale:</b></p>
+ <p>
+-Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3069.html">N3069</a>.
++Closed as NAD. This is an extension request that has been an issue for over 20 years.
++Supporting the extension would place a burden on the underlying C library that we may
++not be in a position to influence.
+ </p>
+
+
++
+ <p><b>Proposed resolution:</b></p>
+-<p>
+-Container data races 23.2.2 [container.requirements.dataraces]
+-</p>
+
+-<p>
+-Paragraph 1 is unchanged as follows:
+-</p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>In 27.9.2 [c.files] add "stderr", "stdin", and "stdout" to a new Values section in Table
++134 &mdash; Header <tt>&lt;cstdio&gt;</tt> synopsis:</p>
+
+ <blockquote>
+-1 For purposes of avoiding data races (17.6.4.8), implementations shall
+-consider the following functions to be <code>const</code>:
+-<code>begin</code>, <code>end</code>, <code>rbegin</code>,
+-<code>rend</code>, <code>front</code>, <code>back</code>,
+-<code>data</code>, <code>find</code>, <code>lower_bound</code>,
+-<code>upper_bound</code>, <code>equal_range</code>, and, except in
+-associative containers, <code>operator[]</code>.
+-</blockquote>
++<table border="1">
++<caption>134 &mdash; Header <tt>&lt;cstdio&gt;</tt> synopsis</caption>
+
+-<p>
+-Edit paragraph 2 as follows:
+-</p>
++<tr>
++<th colspan="6" style="text-align:center;">Type Name(s)</th>
++</tr>
+
+-<blockquote>
+-2 Notwithstanding (17.6.4.8), implementations are required to avoid data
+-races when the contents of the contained object in different elements in
+-the same sequence<ins>, excepting <code>vector&lt;bool&gt;</code>,</ins>
+-are modified concurrently.
+-</blockquote>
++<tr>
++<th colspan="6" style="text-align:left;">Macros:</th>
++</tr>
+
+-<p>
+-Edit paragraph 3 as follows:
+-</p>
++<tr>
++<td><tt>BUFSIZ</tt></td>
++<td><tt>FOPEN_MAX</tt></td>
++<td><tt>SEEK_CUR</tt></td>
++<td><tt>TMP_MAX</tt></td>
++<td><tt>_IONBF</tt></td>
++<td><tt>stdout</tt></td>
++</tr>
+
+-<blockquote>
+-3 [<i>Note:</i>
+-For a <code>vector&lt;int&gt; x</code> with a size greater than one,
+-<code>x[1] = 5</code> and <code>*x.begin() = 10</code>
+-can be executed concurrently without a data race,
+-but <code>x[0] = 5</code> and <code>*x.begin() = 10</code>
+-executed concurrently may result in a data race.
+-<ins>As an exception to the general rule,
+-for a <code>vector&lt;bool&gt; y</code>,
+-<code>y[i] = true</code> may race with <code>y[j] = true</code>.</ins>
+-—<i>end note</i>]
+-</blockquote>
++<tr>
++<td><tt>EOF</tt></td>
++<td><tt>L_tmpnam</tt></td>
++<td><tt>SEEK_END</tt></td>
++<td><tt>_IOFBF</tt></td>
++<td><tt>stderr</tt></td>
++<td>&nbsp;</td>
++</tr>
+
++<tr>
++<td><tt>FILENAME_MAX</tt></td>
++<td><tt>NULL &lt;cstdio&gt;</tt></td>
++<td><tt>SEEK_SET</tt></td>
++<td><tt>_IOLBF</tt></td>
++<td><tt>stdin</tt></td>
++<td>&nbsp;</td>
++</tr>
+
++<tr>
++<th style="text-align:left;">Types:</th>
++<td><tt>FILE</tt></td>
++<td><tt>fpos_t</tt></td>
++<td><tt>size_t &lt;cstdio&gt;</tt></td>
++<td>&nbsp;</td>
++<td>&nbsp;</td>
++</tr>
+
++<tr>
++<th colspan="6" style="text-align:left;">Functions:</th>
++</tr>
+
++<tr>
++<td colspan="6" style="text-align:center;">&hellip;</td>
++</tr>
+
++<tr>
++<th colspan="6" style="text-align:left;"><ins>Values:</ins></th>
++</tr>
+
+-<hr>
+-<h3><a name="1331"></a>1331. incorporate move special member functions into library</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2010-03-10 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>
+-Review the library portion of the spec and incorporate the newly added
+-core feature Move Special Member Functions (N3044).
+-</p>
++<tr>
++<td><ins><tt>stderr</tt></ins></td>
++<td><ins><tt>stdin</tt></ins></td>
++<td><ins><tt>stdout</tt></ins></td>
++<td>&nbsp;</td>
++<td>&nbsp;</td>
++<td>&nbsp;</td>
++</tr>
+
+-<p><b>Rationale:</b></p>
+-2010 Batavia: This has now been done to a large extent.
++</table>
++</blockquote>
++
++</li>
+
++<li><p>Add a new paragraph after paragraph 2 as indicated:</p>
+
++<blockquote><p>
++2 Calls to the function <tt>tmpnam</tt> with an argument of <tt>NULL</tt> may
++introduce a data race (17.6.5.9) with other calls to <tt>tmpnam</tt> with an
++argument of <tt>NULL</tt>.<br/>
++See also: ISO C 7.9, Amendment 1 4.6.2.
++<p/>
++<ins>? The macros <tt>stderr</tt>, <tt>stdin</tt>, and <tt>stdout</tt> shall
++expand to <tt>stderr</tt>, <tt>stdin</tt>, and <tt>stdout</tt>, respectively.
++[<i>Note:</i> This allows uses of <tt>#ifdef</tt> to detect their presence,
++while allowing code in other scopes to use them as identifiers. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++</li>
+
++<li><p>In C.5 [diff.library] add "stderr", "stdin", and "stdout" to
++Table 150 &mdash; Standard values:</p>
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote>
++<table border="1">
++<caption>Table 150 &mdash; Standard values</caption>
+
++<tr>
++<td><tt>CHAR_BIT</tt></td>
++<td><tt>FLT_DIG</tt></td>
++<td><tt>INT_MIN</tt></td>
++<td><tt>MB_LEN_MAX</tt></td>
++</tr>
+
++<tr>
++<td colspan="4" style="text-align:center;">&hellip;</td>
++</tr>
+
++<tr>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td><tt>SHRT_MIN</tt></td>
++</tr>
+
++<tr>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td><ins><tt>stderr</tt></ins></td>
++</tr>
+
+-<hr>
+-<h3><a name="1350"></a>1350. [FCD] Implicit contructors accidentally made some library types move-only</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-25</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1421">1421</a></p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CH-15</b></p>
+-<p>
+-Due to the new rules about implicit copy and move
+-constructors some library facilities are now move-only.
+-</p>
++<tr>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td><ins><tt>stdin</tt></ins></td>
++</tr>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<tr>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td><ins><tt>stdout</tt></ins></td>
++</tr>
+
+-<p>
+-Make them copyable again.
+-</p>
++<tr>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td>&hellip;</td>
++<td><tt>UCHAR_MAX</tt></td>
++</tr>
+
++<tr>
++<td colspan="4" style="text-align:center;">&hellip;</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++</ol>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1351"></a>1351. [FCD] Replace dynamic exception specifications with <tt>noexcept</tt></h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-25</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a></p>
++<h3><a name="2046"></a>2046. <tt>shared_future(future&lt;R&gt;&amp;&amp;)</tt> should be allowed to throw</h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Peter Sommerlad <b>Opened:</b> 2011-04-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses CH-16</b></p>
+ <p>
+-Dynamic exception specifications are deprecated.
+-Deprecated features shouldn't be used in the Standard.
++Requiring the constructor <tt>shared_future(future&lt;R&gt;&amp;&amp; rhs)</tt> not to throw
++is a pessimisation of the case where a future is returned from a call to
++<tt>async(function,launch::deferred)</tt> and possible other cases.
++<p/>
++Such a future not dealing with multiple threads only needs to keep (a copy of) the function
++to be called it later. However, creating a <tt>shared_future</tt> from that future will require more
++infrastructure, like space for the value of type <tt>R</tt>, an <tt>exception_ptr</tt>, and a synchronized
++reference counter for the <tt>shared_future</tt>'s instances.
++<p/>
++Enforcing the constructor <tt>shared_future(future&lt;R&gt;&amp;&amp; rhs)</tt> not to throw,
++implies that any implementation of <tt>future</tt> will need to pre-allocate space for <tt>shared_future</tt>'s
++infrastructure, that also requires an operating system resource for synchronization, regardless
++if is ever needed.
++<p/>
++All this came up when discussing D&#47;N3267 and Concurrency Working Group decided that the constructor
++<tt>shared_future(future&lt;R&gt;&amp;&amp; rhs)</tt> should be allowed to throw.
+ </p>
+
+ <p><i>[
+-Resolution proposed by ballot comment
++2011 Bloomington
+ ]</i></p>
+
++
+ <p>
+-Replace dynamic exception specifications with <tt>noexcept</tt>.
++Closed as NAD. Rationale to follow by email...
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+
++<p>Apply the proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3269.htm">n3269</a></p>
++
++
+
+
+
+
+ <hr>
+-<h3><a name="1352"></a>1352. [FCD] Apply <tt>noexcept</tt> where library specification says "Throws: Nothing"</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-25</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a></p>
++<h3><a name="2060"></a>2060. <tt>unique_ptr&lt;T[]&gt;(nullptr_t)</tt> missing <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.8.1.3 [unique.ptr.runtime] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Howard Hinnant, Paolo Carlini <b>Opened:</b> 2011-05-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.runtime">issues</a> in [unique.ptr.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses CH-17</b></p>
+ <p>
+-The introduction of <tt>noexcept</tt> makes "Throws: Nothing" clauses looking strange.
+-</p>
++The synopsis in 20.8.1.2 [unique.ptr.single] specifies:
++</p><blockquote><pre>
++constexpr unique_ptr(nullptr_t) noexcept
++</pre></blockquote><p>
++which looks correct to me. However the corresponding constructor in 20.8.1.3 [unique.ptr.runtime] is missing <tt>noexcept</tt>:
++</p><blockquote><pre>
++constexpr unique_ptr(nullptr_t) : unique_ptr() { }
++</pre></blockquote>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<p><i>[Bloomington, 2011]</i></p>
+
+ <p>
+-Consider replacing "Throws: Nothing." clause by
+-the respective noexcept specification.
++Closed as NAD Editorial.
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the synopsis in 20.8.1.3 [unique.ptr.runtime]:</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt; {
++ public:
++ typedef see below pointer;
++ typedef T element_type;
++ typedef D deleter_type;
++
++ // 20.7.1.3.1, constructors
++ constexpr unique_ptr() noexcept;
++ [&hellip;]
++ constexpr unique_ptr(nullptr_t) <ins>noexcept</ins> : unique_ptr() { }
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1359"></a>1359. [FCD] Add <tt>&lt;tuple&gt;</tt> and <tt>&lt;utility&gt;</tt> to freestanding implementations</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="2068"></a>2068. <tt>std::pair</tt> not C++03-compatible with defaulted copy c'tor</h3>
++<p><b>Section:</b> 20.3.2 [pairs.pair] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-06-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-56</b></p>
+ <p>
+-The <tt>&lt;utility&gt;</tt> header provides support for several
+-important C++ idioms with <tt>move</tt>, <tt>forward</tt> and <tt>swap</tt>.
+-Likewise, <tt>declval</tt> will be frequently used like a type trait.
+-In order to complete cycles introduced by <tt>std::pair</tt>, the
+-<tt>&lt;tuple&gt;</tt> header should also be made available. This is a
+-similarly primitive set of functionality, with no dependency
+-of a hosted environment, but does go beyond the minimal
+-set of functionality otherwise suggested by the
+-freestanding libraries.
++The specification of the copy semantics of the C++03 version of <tt>std::pair</tt>
++is defined by the class synopsis in [lib.pairs]:
+ </p>
++<blockquote><pre>
++template &lt;class T1, class T2&gt;
++struct pair {
++ typedef T1 first_type;
++ typedef T2 second_type;
++
++ T1 first;
++ T2 second;
++ pair();
++ pair(const T1&amp; x, const T2&amp; y);
++ template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt; &amp;p);
++};
++</pre></blockquote>
+ <p>
+-Alternatively, split the <tt>move</tt>/<tt>forward</tt>/<tt>swap</tt>/<tt>declval</tt>
+-functions out of <tt>&lt;utility&gt;</tt> and into a new primitive header,
+-requiring only that of freestanding implementation.
++The effect of this specification is, that the copy constructor is compiler-declared
++with the proper form depending on the contained member types. In particular, the
++instantiation of <tt>pair</tt> is well-formed with an element type that has a
++copy constructor with non-const first parameter type like specialzations of <tt>auto_ptr</tt>
++or any user-defined type like the following one:
+ </p>
+-
+-<p><i>[
+-Summary of Rapperswil discusions
+-]</i></p>
+-
++<blockquote><pre>
++struct A {
++ A(A&amp;){}
++};
++</pre></blockquote>
+ <p>
+-The preference of the meeting was to extract the rvalue-reference related utilities and swap into a freestanding header, but there was no clear preference for a name. Howard suggested simply dropping them into <tt>&lt;type_traits&gt;</tt> as both these utilities and type traits are used pretty much everywhere in the library implementation, it is the most convenient place to keep them (from an implementer's perspective).
++In contrast to container types which require <tt>CopyConstructible</tt> value types, the C++03 <tt>pair</tt>
++does support these, albeit unusual, element types.
++<p/>
++The FDIS version of the <tt>std::pair</tt> specification does specify the same semantics by
++defaulting the copy and move constructor in 20.3.2 [pairs.pair]:
+ </p>
+-
++<blockquote><pre>
++template &lt;class T1, class T2&gt;
++struct pair {
++ typedef T1 first_type;
++ typedef T2 second_type;
++
++ T1 first;
++ T2 second;
++ <span style="color:#C80000">pair(const pair&amp;) = default;</span>
++ <span style="color:#C80000">pair(pair&amp;&amp;) = default;</span>
++ pair();
++ [&hellip;]
++};
++</pre></blockquote>
++<p>
++But according to the current core rules this makes the instantiation of e.g. <tt>std::pair&lt;A, int&gt;</tt>
++ill-formed, because of the <tt>const</tt> mismatch of the compiler-declared form of the copy constructor
++with that of the defaulted declaration.
++<p/>
++Unfortunately there seems to be no simple library solution for this problem. If the defaulted declarations
++were removed, both copy c'tor and move c'tor would be <b>deleted</b>, because there exist user-declared
++copy assignment and move assignment operators in the FDIS. But these operations need to be user-defined
++to realize the wanted semantics of these operations for element types that are reference types. If core
++rules would not be changed to fix that, I see the following options:
++</p>
++<ol>
++<li>Intentionally decide to break the support for element types with non-const copy c'tors in <tt>pair</tt>.</li>
++<li>User-declare both copy and move ctor to at least support the instantiation of the <tt>pair</tt> specializations,
++but this would still not allow to copy them by the copy constructor.</li>
++<li>User-declare both the const and non-const copy ctors, the move ctor, and additionally the non-const copy assignment
++operator to support the instantiation of the <tt>pair</tt> specializations and of these members. This would
++support all element types as it did in C++03, but all copy&#47;move members would be non-trivial.</li>
++<li>Intentionally decide to give up support for element types that are references for <tt>pair</tt>, but
++still keep the allocator support with the effect of removing all declarations of the special
++copy&#47;move members. User code that needs to use <tt>tuple</tt> instead. But this would be a rather
++drastic step requiring further corrections of the draft, e.g. a change of the signature of the algorithm
++<tt>minmax</tt> (not the overload with the <tt>initializer_list</tt>) with a different return type.</li>
++</ol>
++<p>
++This problem does <b>not</b> extend as backward-compatibility problem to <tt>tuple</tt>, because the TR1
++specification did explicitly declare copy constructor and copy assignment operator via the &quot;normal&quot;
++form:
++</p>
++<blockquote><pre>
++tuple(const tuple&amp;);
++tuple&amp; operator=(const tuple&amp;);
++</pre></blockquote>
+ <p>
+-Poll: Two-way: New header for forward, move, swap, move_with_noexcept and declval vs. calling out forward, move, swap, move_with_noexcept and declval as freestanding explicitly?
+-
+-SF new header: 4 WF new header: 3 WF call out as freestanding: 1 SF call out as freestanding: 2
+-
+-Alisdair: Willing to write up both solutions, give us some time to think on it.
+-
+-Action: Need an issue and proposed wording for GB 56 - Alisdair to draft both options as in the last poll.
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<p><i>[Bloomington, 2011]</i></p>
+
+-<blockquote>
+ <p>
+-Add <tt>&lt;utility&gt;</tt> and <tt>&lt;tuple&gt;</tt> to table 15, headers
+-required for a free-standing implementation.
++Closed as NAD.
+ </p>
+-</blockquote>
+-
+-<p><i>[
+-2010-Batavia:
+-]</i></p>
+
+ <p>
+-Closed as NAD, reversing the decision at Rapperswil.
++This is an unfortunate change of behavior between C++03 and C++11, but is consistent with <tt>tuple</tt>. There is no desire to go to lengths supporting types like <tt>auto_ptr</tt> now that rvalue references are in the language.
+ </p>
++
+ <p>
+-The consensus was that
+-any freestanding implementation is going to feel compelled to offer the important
+-features of <tt>&lt;utility&gt;</tt> even if we do not make them a freestanding
+-requirement; breaking out additional small headers may have additional costs at
+-compile time, and while the critical <tt>move</tt>-related functions could migrate
+-to <tt>&lt;type_traits&gt;</tt>, the header name is far from appealing; adding the
+-whole of <tt>&lt;utility&gt;</tt> starts to drag in dependencies on <tt>&lt;tuple&gt;</tt>
+-and <tt>&lt;memory&gt;</tt>, so we prefer to place the burden of slicing or supporting
+-this whole header on free-standing vendors.
++There may be an issue for Core/EWG to look at, so that some simple <tt>=default</tt> syntax could be used that would do the right thing. If such a facility became availabile, LWG might revisit this issue.
+ </p>
+
+
+@@ -49234,128 +39598,148 @@ this whole header on free-standing vendors.
+ <p><b>Proposed resolution:</b></p>
+
+
+-<p><b>Rationale:</b></p>No consensus for a change at this time.
+-
+-
+
+
+
+ <hr>
+-<h3><a name="1361"></a>1361. [FCD] Does use of <tt>std::size_t</tt> in a header imply that typedef name is available to users?</h3>
+-<p><b>Section:</b> 17.6.2 [using] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="2073"></a>2073. Library exceptions that take string arguments</h3>
++<p><b>Section:</b> 19.2 [std.exceptions], 19.5.6 [syserr.syserr], 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Eelis van der Weegen <b>Opened:</b> 2011-08-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#std.exceptions">issues</a> in [std.exceptions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-58</b></p>
+-<p>
+-It is not clear whether a library header specified in terms
+-of a typedef name makes that same typedef name
+-available for use, or if it simply requires that the specified
+-type is an alias of the same type, and so the typedef name
+-cannot be used without including the specific header that
+-defines it. For example, is the following code required to
+-be accepted:
+-</p>
+-<blockquote><pre>#include &lt;vector&gt;
+-std::size_t x = 0;
+-</pre></blockquote>
++
+ <p>
+-Most often, this question concerns the typedefs defined in
+-header <tt>&lt;cstddef&gt;</tt>
++This is an extension issue for LWG to add constructor overloads that take a
++<tt>string</tt> by an rvalue reference in order to move the string into the
++exception.
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++
++<p><i>[2012, Kona]</i></p>
+
+ <p>
+-Add a paragraph under 17.6.2 [using] clarifying whether
+-or not headers specified in terms of <tt>std::size_t</tt> can
+-be used to access the typedef <tt>size_t</tt>, or whether
+-the header <tt>&lt;cstddef&gt;</tt> must be included to reliably
+-use this name.
++Move to NAD.
++</p>
++<p>
++This was discussed during C++11 standardization, and deemed (at the time) to be a conforming
++extension that vendors are free to add, but there seemed no need to call it out in the standard.
++Since then it has been noted that the rvalue-reference overloads do not give you the move-semantic
++guarantee the proposer is thought to be looking for, as in order to meet the requirements that
++copy constructors do not throw (for standard exceptions) the exceptions that store strings must
++actually store a reference-counted immutable string, rather than an <tt>std::string</tt> internally.
++Therefore, an rvalue-reference overload is going to have to allocate memory in exactly the same
++way as copying from a <tt>const string&amp;</tt> argument.
+ </p>
+-<p><i>[Batavia: NAD - see rationale below]</i></p>
+-
+
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p><b>Rationale:</b></p>The standard is correct as written.
+
+
+
+
+ <hr>
+-<h3><a name="1373"></a>1373. [FCD] Customizable traits should have their own headers</h3>
+-<p><b>Section:</b> 20.3 [utility] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility">issues</a> in [utility].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="2079"></a>2079. Required <tt>pow()</tt> overloads</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2011-08-29 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-79</b></p>
++
+ <p>
+-The library provides several traits mechanisms intended a
+-customization points for users. Typically, they are
+-declared in headers that are growing quite large. This is
+-not a problem for standard library vendors, who can
+-manage their internal file structure to avoid large
+-dependencies, but can be a problem for end users who
+-have no option but to include these large headers.
++LWG issue <a href="lwg-defects.html#550">550</a> removed the functions:
+ </p>
+-
+-<p><i>[
+-2010 Rapperswil
+-]</i></p>
+-
++<blockquote><pre>
++float pow(float, int);
++double pow(double, int);
++long double pow(long double, int);
++</pre></blockquote>
+ <p>
+-There was no enthusiasm for touching <tt>char_traits</tt> or <tt>regex_traits</tt>.
+-Consensus to move <tt>iterator_traits</tt>, <tt>allocator_traits</tt>
+-and <tt>pointer_traits</tt> to their own respective headers once wording supplied.
++from header <tt>&lt;cmath&gt;</tt>. This change does not seem to be mentioned in Annex C, C.2.14.
++<p/>
++Howard:
+ </p>
+-
+-<p><i>[
+-2010 Rapperswil
+-]</i></p>
+-
++<blockquote><p>
++N3290 26.8 [c.math]&#47;p11 says:
++</p><blockquote>
+ <p>
+-After some discussion, consensus is that moving these features into separate
+-headers does not buy much in practice, as the larger headers will inevitably
+-be included anyway. Resolve as NAD.
++Moreover, there shall be additional overloads sufficient to ensure:
+ </p>
+-
+-<p><i>[
+-Resolution proposed in ballot comment
+-]</i></p>
+-
++<ol>
++<li>If any argument corresponding to a <tt>double</tt> parameter has type <tt>long double</tt>,
++then all arguments corresponding to <tt>double</tt> parameters are effectively cast to
++<tt>long double</tt>.
++</li>
++<li>Otherwise, if any argument corresponding to a <tt>double</tt> parameter has type <tt>double</tt>
++or an integer type, then all arguments corresponding to <tt>double</tt> parameters are effectively
++cast to <tt>double</tt>.
++</li>
++<li>Otherwise, all arguments corresponding to <tt>double</tt> parameters are effectively cast to
++<tt>float</tt>.
++</li>
++</ol>
++</blockquote>
+ <p>
+-Move the following traits classes into their own
+-headers, and require the existing header to
+-<tt>#include</tt> the traits header to support backwards
+-compatibility:
++From C99 7.12.7.4 we have:
+ </p>
+-<blockquote><pre>iterator_traits (plus the iterator tag-types)
+-allocator_traits
+-pointer_traits
+-char_traits
+-regex_traits
++<blockquote><pre>
++double pow(double, double);
+ </pre></blockquote>
+-
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
++<p>
++26.8 [c.math]&#47;p11&#47;b2 says that if the client calls <tt>pow(2.0f, 2)</tt>, then the
++<tt>int</tt> for second argument causes the following effective call to be made:
++</p>
++<blockquote><pre>
++pow(static_cast&lt;double&gt;(2.0f), static_cast&lt;double&gt;(2)) -&gt; double
++</pre></blockquote>
++<p>
++The first sentence of p11 implies that this is done by supplying the following additional overload:
++</p>
++<blockquote><pre>
++double pow(float, int);
++</pre></blockquote>
++<p>
++If the client calls <tt>pow(2.0, 2)</tt>, then the same reasoning (b2 again) implies the following
++additional overload:
++</p>
++<blockquote><pre>
++double pow(double, int);
++</pre></blockquote>
++<p>
++If the client calls <tt>pow(2.0l, 2)</tt>, then b1 implies the following additional overload:
++</p>
++<blockquote><pre>
++long double pow(long double, int);
++</pre></blockquote>
++<p>
++In all, p11 implies hundreds (perhaps thousands?) of extra overloads. All but one of which is a superset
++of the overloads required by C++98&#47;03 (that one being <tt>pow(float, int)</tt> which had its return
++type changed from <tt>float</tt> to <tt>double</tt>).
++<p/>
++In practice, at least some vendors implement p11 by using templated overloads as opposed to ordinary overloads.
++</p></blockquote>
+
+ <p>
+-Closed as NAD with the rationale below.
++Steve Clamage:
+ </p>
++<blockquote><p>
++Thanks. I didn't see that those extra overloads were actually implied by p11, despite the first sentence.
++Without examples, the point is a bit subtle (at least for me).
++</p></blockquote>
+
++<p><i>[2015-05-05 Lenexa: Move to NAD]</i></p>
+
++<p>Billy: I believe this is NAD.</p>
++<p>STL: Oh, Steve himself agrees.</p>
++<p>Wakely: The issue marked as NAD will be sufficient.</p>
++<p>STL: Yes, we should get rid of this.</p>
++<p>Billy: I don't see any minutes from Issaquah.</p>
++<p>Marshall: Since Steve agrees, does anyone object to marking as NAD?</p>
++<p>Nope.</p>
+
+-<p><b>Rationale:</b></p>
+-This suggest is not a defect, as the likely benefit is small, if any,
+-compared to the cost of not just implementating the feature, but also
+-explaining/teaching it.
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -49365,649 +39749,1058 @@ explaining/teaching it.
+
+
+ <hr>
+-<h3><a name="1375"></a>1375. [FCD] <tt>reference_type</tt> should not have been removed from the
+-allocator requirements</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a></p>
++<h3><a name="2082"></a>2082. Misleading complexity requirements in <tt>&lt;algorithm&gt;</tt></h3>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2011-09-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses US-87</b></p>
+ <p>
+-<tt>reference_type</tt> should not have been removed from the
+-allocator requirements. Even if it is always the same as
+-<tt>value_type&amp;</tt>, it is an important customization point for
+-extensions and future features.
++The <tt>partition_point()</tt> algorithm is specified with:
++</p>
++<blockquote><p>
++<i>Complexity</i>: <i>O(log(last - first))</i> applications of <tt>pred</tt>.
++</p></blockquote>
++<p>
++While this is correct, it gives the impression that this is a logarithmic algorithm.
++But unless random access iterators are used it is not logarithmic because for advancing
++the iterator we have last-first steps, which means that the complexity becomes linear here.
++<p/>
++Shouldn't we clarify the complexity here to something like:
++</p>
++<blockquote><p>
++<i>Complexity</i>: logarithmic for random-access iterators and linear otherwise
++ (in any case <i>O(log(last - first)</i>) applications of <tt>pred</tt>).
++</p></blockquote>
++<p>
++Or should we even require <i>O(log(last - first)</i> for random-access iterators only because
++for other iterators just iterating over all elements, while calling <tt>pred</tt> for each element,
++might often be faster.
++</p>
++
++<p>
++Daniel Kr&uuml;gler:
++</p>
++<blockquote><p>
++I agree that especially this description is a bit misleading. I'm not
++convinced that this is a real defect, because the whole bunch of
++templates within <tt>&lt;algorithm&gt;</tt> document the complexity solely of
++<em>applications*</em> of predicates, assignment, or swaps, but never the
++complexity of traversal operations (e.g. increment or iterator
++equality tests). This means, the standard is consistent for this
++function template, even though it could say a bit more.
++<p/>
++I would like to see a wording improvement, but I would rather think that
++the complexity of the predicate should be mentioned first (as in other
++algorithms) and that a non-normative note could be added for
++specifically this algorithm to point out that this does not imply
++a logarithmic traversal complexity. The note could give more details,
++by explicity pointing out the linear traversal complexity for
++non-random-Access iterators.
++</p></blockquote>
++<p>
++Howard Hinnant:
+ </p>
++<blockquote><p>
++If we are going to make such improvements, they should be made across the
++board in <tt>&lt;algorithm&gt;</tt>, not to just <tt>partition_point</tt>.
++For example all 4 algorithms in 25.4.3 [alg.binary.search] have the
++same issue, and have since C++98.
++<p/>
++<tt>stable_partition</tt> and <tt>inplace_merge</tt> should be inspected as well.
++<p/>
++Perhaps a new paragraph in 25.1 [algorithms.general], similar to
++p12 would be a better place to address this issue.
++</p></blockquote>
+
++<p><i>[2012, Kona]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-In [allocator.requirements] Table 42 - Allocotor Requirements,
+-Add a row (after <tt>value_type</tt>) with columns:
++Move to NAD.
+ </p>
+-<blockquote>
+-Expression: <ins><tt>X::reference_type</tt></ins><br>
+-Return type: <ins><tt>T&amp;</tt></ins><br>
+-Assertion/note...: (empty)<br>
+-Default: <ins><tt>T&amp;</tt></ins><br>
+-</blockquote>
+ <p>
+-[allocator.traits]:
+-</p>
+-<blockquote><pre>namespace std {
+- template &lt;class Alloc&gt; struct allocator_traits {
+- typedef Alloc allocator_type;
+-
+- typedef typename Alloc::value_type value_type;
++There was some concern that the issue, if it were to be addressed, is much larger than
++the couple of algorithms called out here, and applies across the whole library. There
++is no interest in looking at this or similar issues without a paper addressing the whole
++library. In fairness to anyone considering writing such a paper, it should be noted
++that there was not much interest in such a paper in the group, although no strong opposition
++either.
++</p>
+
+- typedef <i>see below</i> pointer;
+- typedef <i>see below</i> const_pointer;
+- typedef <i>see below</i> void_pointer;
+- typedef <i>see below</i> const_void_pointer;
+- <ins>typedef value_type&amp; reference_type;</ins>
+-</pre></blockquote>
+
+-Add <tt>reference_type</tt> to
+-allocator_traits template, defaulted to
+-value_type&amp;.
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1376"></a>1376. [FCD] Allocator interface is not backward compatible</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="2084"></a>2084. <tt>basic_string</tt> use of <tt>charT*</tt></h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-09-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-88</b></p>
++
+ <p>
+-Allocator interface is not backward compatible.
++For C++11 we gave all of the containers, including basic_string new generalized pointer types:
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<blockquote><pre>
++typedef typename allocator_traits&lt;Allocator&gt;::pointer pointer:
++typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
++</pre></blockquote>
+
+ <p>
+-See Appendix 1 - Additional Details
++However, the constructors, assignment, and member functions still traffic exclusively in terms
++of <tt>const charT*</tt>, for example:
+ </p>
+
+-<p><i>[
+-2010-10-24 Daniel adds:
+-]</i></p>
+-
+-
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3165.pdf">n3165</a> provides an alternative resolution.
+-</blockquote>
+-
+-<p><i>[
+-2910 Batavia:
+-]</i></p>
++<blockquote><pre>
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++</pre></blockquote>
+
+ <p>
+-Closed as NAD - withdrawn by the submitter.
++Was this an oversight? Did we mean instead:
+ </p>
+
++<blockquote><pre>
++basic_string(const_pointer s, const Allocator&amp; a = Allocator());
++</pre></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3165.pdf">n3165</a>
+-
+-
+-<p><b>Rationale:</b></p>Withdrawn by the submitter.
+-
+-
++<p><b>Rationale:</b></p><p>
++It's intentional. <tt>char_traits</tt> assumes that all elements of
++a string can be accessed indirect on plain pointers. So <tt>basic_string</tt>
++doesn't support allocators with fancy pointers or references. And we meant
++to do that.
++<p/>
++Let's take the constructor example you called out:
++</p>
+
++<blockquote><pre>
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++</pre></blockquote>
+
+-<hr>
+-<h3><a name="1395"></a>1395. [FCD] Ballot Comment JP-32</h3>
+-<p><b>Section:</b> 20.7.6 [meta.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses JP-32</b></p>
+-<p>
+-Representations of reference link are not unified.
+-Most reference links to clause (table) number, say X, are
+-in the form "Clause X" ("Table X") capitalized, and
+-subsection Y.Y.Y is referenced with its number only in the
+-form "Y.Y.Y". Whether they are parenthesized or not
+-depends on the context.
+-However there are some notations "(Z)" consisting of only
+-a number Z in parentheses to confer Clause or Table
+-number Z.
++<p>
++This constructor allows us to create a <tt>basic_string</tt> object from a string literal.
++If we were to change the pointer type, that would no longer be possible.
++<p/>
++There is no issue here, as the implementation of the constructor must make a
++copy of the string pointed-to by the pointer 's' rather than adopt ownership of
++that buffer. It is that internal copy that must make use of the <tt>allocator::pointer</tt> type.
++<p/>
++Now what about the return value of '<tt>c_str()</tt>', should that return an <tt>allocator::pointer</tt>?
++<p/>
++Again, the answer (I believe) is 'no' because this is the function that allows us
++to pass the string's contents to a legacy&#47;OS 'C' API. It is deliberately returning
++a raw pointer for a reason.
++<p/>
++There was an issue where <tt>vector::data</tt> was changed to return an <tt>allocator::pointer</tt>
++to the internal buffer, and this was changed back exactly because this was intended
++to support passing to external APIs.
++<p/>
++Do we have a use-case where the pointer type of internal data structures of our
++containers (notably <tt>basic_string</tt> and <tt>vector</tt>) need to be exposed through a public API?
++All my current use-cases for <tt>allocator::pointer</tt> are specific to the implementation
++of containers themselves.
+ </p>
+
+
++
+ <p><b>Proposed resolution:</b></p>
+-Change "(10)" to "(Clause 10)".
+
+
+
+
+
+ <hr>
+-<h3><a name="1398"></a>1398. [FCD] Users should be able to specialize functors without depending on whole <tt>&lt;functional&gt;</tt> header</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
++<h3><a name="2090"></a>2090. Minor Overconstraint in Mutex Types</h3>
++<p><b>Section:</b> 30.4.1.2 [thread.mutex.requirements.mutex] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements.mutex">issues</a> in [thread.mutex.requirements.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-96</b></p>
++
+ <p>
+-The function templates <tt>hash</tt>, <tt>less</tt> and <tt>equal_to</tt>
+-are important customization points for user-defined types to
+-be supported by several standard containers. These are
+-accessed through the <tt>&lt;functional&gt;</tt> header which has
+-grown significantly larger in C++0x, exposing many more
+-facilities than a user is likely to need through there own
+-header, simply to declare the necessary specialization.
+-There should be a smaller header available for users to
+-make the necessary customization.
++30.4.1.2 [thread.mutex.requirements.mutex]&#47;6, fourth bullet requires the
++return type of <tt>m.lock()</tt> to be <tt>void</tt>.
++<p/>
++This is over-constrained. The true requirement is that the standard library
++ignores any value that the function returns. Yes, allowing non-void return
++types means that users can't store a pointer to this member function. No,
++that's not the least bit important.
++<p/>
++[See also the discussion following c++std-lib-31318]
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<p><i>[2012, Kona]</i></p>
+
+ <p>
+-Provide a tiny forwarding header for important
+-functor types in the <tt>&lt;functional&gt;</tt> header that a
+-user may want to specialize. This should contain
+-the template declaration for <tt>equal_to</tt>, <tt>hash</tt> and
+-<tt>less</tt>.
++This does not specify a concept; it specifies requirements on the concrete mutex types.
+ </p>
+
+-<p><i>[
+-Rapperswill summary
+-]</i></p>
+
+-<p>Alisdair: Would recommend NAD unless someone takes the issue. </p>
+
+-<p>Daniel: Volunteers to write a paper for this. </p>
++<p><b>Proposed resolution:</b></p>
+
+-<p><i>[
+-2010-11-07 Daniel provides a paper available on the Batavia document list
+-]</i></p>
+
+
+-<p><i>[
+-2010 Batavia:
+-]</i></p>
++
++
++<hr>
++<h3><a name="2107"></a>2107. Some iterator category should guarantee the lifetime of references</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2011-11-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+
+ <p>
+-Closed as NAD - the consensus was that forwarding headers such as
+-<tt>&lt;iosfwd&gt;</tt> do not bring the expected benefits, and are
+-not widely used (to the surprise of some active users in the room!).
+-Without real experience reporting a benefit, there is no further interest
+-in pursuing this issue as an extension - hence NAD rather than NAD Future.
++Many iterators guarantee that references and pointers returned from
++their methods will outlive the iterator itself. Other useful iterators
++can't guarantee this, leading to the rule in 24.2 [iterator.requirements]
++p9 that "Destruction of an iterator may invalidate pointers and references
++previously obtained from that iterator."
++<p/>
++Some algorithms can take advantage of long-lived references by
++returning them, while they can adapt to short-lived references by
++returning by value instead. However, there doesn't seem to be a way in
++the standard to distinguish between these two types of iterators.
++<p/>
++The <tt>ForwardIterator</tt> requirements come close by saying "If <tt>a</tt> and <tt>b</tt> are
++both dereferenceable, then <tt>a == b</tt> if and only if <tt>*a</tt> and <tt>*b</tt> are bound
++to the same object." (24.2.5 [forward.iterators] p6) However, there are some
++subtle ways to satisfy this rule and still return a short-lived reference, meaning
++algorithms can't be guaranteed that <tt>forward_iterator_tag</tt> will imply
++long-lived references.
++<p/>
++On the other hand, defect <a href="lwg-defects.html#198">198</a>, which added the invalidation wording
++to iterator.requirements.general, refers to iterators with short-lived references
++being used as arguments to reverse_iterator, which requires <tt>BidirectionalIterator</tt>s.
++If <tt>ForwardIterator</tt> required long-lived references, this would be impossible.
++<p/>
++Either <tt>ForwardIterator</tt> should be clarified to require long-lived
++references, or a new category should be added that does.
++<p/>
++See also the discussion around c++std-lib-31477.
++<p/>
++Daniel: Related to this issue is that when applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>
++we unintentionally lost some forward iterator requirements from C++03, where we
++had the post-conditions <tt>a == X(a)</tt> of <tt>X(a)</tt>, and <tt>u == a</tt>
++of any copy operation from <tt>a</tt> to <tt>u</tt>. This wording must be restored as well.
+ </p>
+
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to NAD.
++</p>
++<p>
++This issue affects only Input Iterators, as all other categories are required to return
++a native reference, and are not (currently) allowed to return proxies. The issue with
++Input Iterators is known, and has been present since the original standard. Any change
++in this regard would be an extension requiring a more substantial paper than treatment
++as a simple issue.
++</p>
+
+
+-<p><b>Rationale:</b></p>No consensus to make a change
+
+ <p><b>Proposed resolution:</b></p>
+-See paper "Forwarding <tt>&lt;functional&gt;</tt> functor templates"
+-on the Batavia LWG document list
+
+
+
+
+
+ <hr>
+-<h3><a name="1406"></a>1406. [FCD] Support hashing smart-pointers based on <i>owner</i></h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2113"></a>2113. Do library implementers have the freedom to add <tt>final</tt> to non-polymorphic components?</h3>
++<p><b>Section:</b> 17.6.5 [conforming] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#conforming">issues</a> in [conforming].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP-5</b></p>
+-<p>
+-Hash support based on ownership sharing should be
+-supplied for <tt>shared_ptr</tt> and <tt>weak_ptr</tt>.
+-For two <tt>shared_ptr</tt> objects <tt>p</tt> and <tt>q</tt>, two distinct
+-equivalence relations can be defined. One is based on
+-equivalence of pointer values, which is derived from the
+-expression <tt>p.get() == q.get()</tt> (hereafter called <i>address based
+-equivalence relation</i>), the other is based on
+-equivalence of ownership sharing, which is derived from
+-the expression <tt>!p.owner_before(q) &amp;&amp; !q.owner_before(p)</tt>
+-(hereafter called <i>ownership-based equivalence relation</i>).
+-These two equivalence relations are independent in
+-general. For example, a <tt>shared_ptr</tt> object created by the
+-constructor of the signature <tt>shared_ptr(shared_ptr&lt;U&gt;
+-const &amp;, T *)</tt> could reveal a difference between these two
+-relations. Therefore, hash support based on each
+-equivalence relation should be supplied for <tt>shared_ptr</tt>.
+-However, while the standard library provides the hash
+-support for address-based one (20.9.11.6 paragraph 2), it
+-lacks the hash support for ownership-based one. In
+-addition, associative containers work well in combination
+-with the <tt>shared_ptr</tt>'s ownership-based comparison but
+-unordered associative containers don't. This is
+-inconsistent.
+-</p>
++
+ <p>
+-For the case of <tt>weak_ptr</tt>, hash support for the ownership based
+-equivalence relation can be safely defined on
+-<tt>weak_ptr</tt>s, and even on expired ones. The absence of
+-hash support for the ownership-based equivalence
+-relation is fatal, especially for expired <tt>weak_ptr</tt>s. And the
+-absence of such hash support precludes some quite
+-effective use-cases, e.g. erasing the <tt>unordered_map</tt> entry
+-of an expired <tt>weak_ptr</tt> key from a customized deleter
+-supplied to <tt>shared_ptr</tt>s.
++Related to LWG <a href="lwg-defects.html#2112">2112</a> the question has been raised whether a library implementation <em>may</em> declare
++non-polymorphic library components, such as class template <tt>std::vector</tt> or <tt>std::basic_string</tt>,
++as <tt>final</tt> class types.
++<p/>
++This issue is <em>not</em> suggesting to enforce that libraries are required to do that, it is asking
++whether libraries should have the freedom to do so.
++<p/>
++The existing wording in 17.6.5.11 [derivation] does not give a clear permission to do so. In my opinion
++this position should be clarified in either direction.
++<p/>
++Giving implementations this freedom would have both advantages and disadvantages. Several opponents where
++worried about breakage of code of existing user implementations. On the other hand such types where not
++designed to be used as base classes. Allowing implementations to mark these components as <tt>final</tt>
++could allow them to provide compile-modes that are intentionally restrictive to the advantage of user code
++that want to be alterted about that. Any implementation that would be concerned about user complaints would
++not take advantage of this feature anyway.
++<p/>
++If agreement exists that such implementation freedom would be useful, wording like
+ </p>
++<blockquote><p>
++An implementation may declare additional non-virtual member function signatures within a class as <tt>final</tt>.
++</p></blockquote>
+ <p>
+-Hash support for the ownership-based equivalence
+-relation cannot be provided by any user-defined manner
+-because information about ownership sharing is not
+-available to users at all. Therefore, the only way to provide
+-ownership-based hash support is to offer it intrusively by
+-the standard library.
++or
+ </p>
++<blockquote><p>
++An implementation may declare additional class without virtual member function signatures as <tt>final</tt>.
++</p></blockquote>
+ <p>
+-As far as we know, such hash support is implementable.
+-Typical implementation of such hash function could return
+-the hash value of the pointer of the counter object that is
+-internally managed by <tt>shared_ptr</tt> and <tt>weak_ptr</tt>.
++should be added to 17.6.5 [conforming] with corresponding exceptions of these rules (e.g. <tt>iterator</tt>,
++<tt>unary_function</tt>, or <tt>pair</tt>).
++<p/>
++If such freedom should not exist, it seems better to clarify this as well, e.g. by adding around 17.6.5.11 [derivation]:
+ </p>
++<blockquote><p>
++An implementation shall not declare any class or any member function signature as <tt>final</tt>.
++</p></blockquote>
+
+-<p><i>[2010 Rapperswil:]</i></p>
+-
+-<blockquote>
+-<p>No consensus to make this change at this time.</p>
+-</blockquote>
+
++<p><i>[2012, Kona]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following non-static member functions to
+-<tt>shared_ptr</tt> and <tt>weak_ptr</tt> class template;
++Move to NAD.
+ </p>
+ <p>
+-Update [util.smartptr.shared], 20.9.11.2 paragraph 1
++Unless the library uses the keyword <tt>final</tt> in a specification, the user clearly has
++freedom to derive from such a class, and so equally clearly, the library vendor does not have
++freedom to add a <tt>final</tt> overrider or class attribute. Howard observed there may be
++some wiggle-room with 'unspecified types' such as those returned from <tt>bind</tt> expressions,
++or iterators, but we did not see a need to further clarify the issue. Note that, for example,
++a <tt>vector::iterator</tt> may be implemented as a raw pointer, so users cannot generally
++assume the ability to derive from unspecified library types.
+ </p>
+-<pre>namespace std{
+-template&lt;class T&gt; class shared_ptr {
+-public:
+-...
+- <ins>size_t owner_hash() const;</ins>
+-...
+-};
+-}
+-</pre>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2124"></a>2124. Seed sequence over-specified</h3>
++<p><b>Section:</b> 26.5.1.2 [rand.req.seedseq] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2012-01-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.seedseq">issues</a> in [rand.req.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++
+ <p>
+-Update [util.smartptr.weak], 20.9.11.3 paragraph 1
++The seed sequence requirements described in 26.5.1.2 [rand.req.seedseq] appear to be over-specified.
++All seed sequence types are required to have a <tt>result_type</tt> nested type, a specific set of
++constructors, function members <tt>size()</tt> and <tt>param()</tt>, which are never used by the library.
++In fact, the only library components that actively use seed sequences are the random engines and all the
++engines need is the <tt>generate()</tt> member function. In particular, library components never attempts
++to construct seed sequence objects. These extraneous requirements are clearly written to describe the
++library provided type <tt>seed_seq</tt> type; while it's good that seed_seq has all those constructors and
++members, it's not a compelling reason to require a user-provided seed sequence type to implement all of
++them.
++<p/>
++Suppose I want to write my own seed sequence class, this should do fine (and actually works as expected with libc++):
+ </p>
+-<pre>namespace std{
+-template&lt;class T&gt; class weak_ptr {
++<blockquote><pre>
++class my_seed_seq
++{
++ /* internals */
+ public:
+-...
+- <ins>size_t owner_hash() const;</ins>
+-...
++ my_seed_seq(/* my own parameters */);
++
++ template &lt;class It&gt;
++ void generate(It first, It last);
+ };
+-}
+-</pre>
++
++my_seed_seq s(/* params */);
++std::default_random_engine e(s);
++</pre></blockquote>
+ <p>
+-These functions satisfy the following
+-requirements. Let <tt>p</tt> and <tt>q</tt> be objects of either
+-<tt>shared_ptr</tt> or <tt>weak_ptr</tt>, <tt>H</tt> be a hypothetical
+-function object type that satisfies the hash
+-requirements ([hash.requirements], 20.2.4) and <tt>h</tt> be an object of the
+-type <tt>H</tt>. The expression <tt>p.owner_hash()</tt> behaves
+-as if it were equivalent to the expression <tt>h(p)</tt>. In
+-addition, <tt>h(p) == h(q)</tt> must become <tt>true</tt> if <tt>p</tt> and
+-<tt>q</tt> share ownership.
++The only reason to have these extra members would be to provide some support for generic serializability&#47;persistence
++of seed sequence objects. I believe that would be out of the scope of the random library, so I doubt we will ever need
++those requirements in the future.
++<p/>
++I therefore propose to remove all requirements from 26.5.1.2 [rand.req.seedseq] except for the presence of the
++<tt>generate()</tt> function.
+ </p>
+
++<p><i>[2012, Kona]</i></p>
+
++<p>
++Move to Tenatively NAD. (Tentative as issue was not in pre-meeting mailing)
++</p>
++<p>
++The 'overspecification', as such, was a deliberate intent to provide guarantees consumers of the whole
++random number framework may rely upon, especially in generic code. While the standard engines may be
++built without relying on these guarantees, this specification is part of a commitment to a broader
++framework, and Walter indicated future proposals in preparation for parallel generation of random
++numbers that may depend more inimately on these existing requirements.
++</p>
++<p>
++Alisdair noted that the <tt>result_type</tt> typedef was a call-back to how we used to specify
++adaptable functors before TR1 <tt>result_of</tt> and the addition of <tt>std::bind</tt> and is
++probably not something we should be actively promoting in future libraries. However, it is too
++late to remove this requirement from seed sequences unless we are doing further surgery, as
++recommended by this issue.
++</p>
++<p>
++Walter notes that the <tt>result_type</tt> protocol has not been formally deprecated by the
++standard. Alisdair replies that was the intent of deprecating the <tt>bind_1st</tt>/
++<tt>unary_function</tt> set of templates in C++11, although we did not say anything about
++<tt>result_type</tt> in general.
++</p>
+
+
+
+-<hr>
+-<h3><a name="1411"></a>1411. [FCD] Add a compile-time flag to detect <tt>monotonic_clock</tt></h3>
+-<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a></p>
+-<p><b>Discussion:</b></p>
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
+
+-<p><b>Addresses DE-20</b></p>
++<ol>
++<li>
++<p>Edit 26.5.1.2 [rand.req.seedseq] p2 as indicated:</p>
+
+-The library component <tt>monotonic_clock</tt> is conditionally
+-supported, but no compile-time flag exists that allows
+-user-code to query its existence. Further-on there exist no
+-portable means to simulate such a query. (To do so, user
+-code would be required to add types to namespace
+-<tt>std::chrono</tt>.)
++<blockquote><p>
++A class <tt>S</tt> satisfies the requirements of a seed sequence if the expressions shown in Table 115 are valid and
++have the indicated semantics, and if <tt>S</tt> also satisfies all other requirements of this section 26.5.1.2 [rand.req.seedseq].
++In that Table and throughout this section:
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++<del><tt>T</tt> is the type named by <tt>S</tt>'s associated <tt>result_type</tt>;</del>
++</li>
++<li>
++<tt>q</tt> is a value of <tt>S</tt><del> and <tt>r</tt> is a possibly const value of <tt>S</tt></del>; <ins>and</ins>
++</li>
++<li>
++<del><tt>ib</tt> and <tt>ie</tt> are input iterators with an unsigned integer <tt>value_type</tt> of at least 32 bits;</del>
++</li>
++<li><tt>rb</tt> and <tt>re</tt> are mutable random access iterators with an unsigned integer <tt>value_type</tt> of at least 32 bits;</li>
++<li>
++<del><tt>ob</tt> is an output iterator; and</del>
++</li>
++<li>
++<del><tt>il</tt> is a value of <tt>initializer_list&lt;T&gt;</tt>.</del>
++</li>
++</ol>
++</blockquote>
++</li>
+
++<li>
++<p>Ditto, in Table 115, remove all rows except the one describing <tt>q.generate(rb, re)</tt>:</p>
+
+-<p><b>Proposed resolution:</b></p>
+-Provide a compile-time flag (preferably a macro)
+-that can be used to query the existence of
+-<tt>monotonic_clock</tt>.
++<table border="1">
++<caption>Table 115 &mdash; Seed sequence requirements</caption>
++<tr align="center">
++<th>Expression</th>
++<th>Return type</th>
++<th>Pre&#47;Post-condition</th>
++<th>Complexity</th>
++</tr>
+
++<tr>
++<td>
++<del><tt>S::result_type</tt></del>
++</td>
++<td>
++<del><tt>T</tt></del>
++</td>
++<td>
++<del><tt>T</tt> is an unsigned integer<br/>
++type (3.9.1 [basic.fundamental]) of at least 32 bits.</del>
++</td>
++<td>
++<del>compile-time</del>
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>S()</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<del>Creates a seed sequence with<br/>
++the same initial state as all<br/>
++other default-constructed seed<br/>
++sequences of type <tt>S</tt>.</del>
++</td>
++<td>
++<del>constant</del>
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>S(ib,ie)</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<del>Creates a seed sequence having<br/>
++internal state that depends on<br/>
++some or all of the bits of the<br/>
++supplied sequence <tt>[ib, ie)</tt>.</del>
++</td>
++<td>
++<del><tt>&#x1d4aa;(ie - ib)</tt></del>
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>S(il)</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<del>Same as <tt>S(il.begin(),<br/>
++il.end())</tt>.</del>
++</td>
++<td>
++<del>same as<br/>
++<tt>S(il.begin(),<br/>
++il.end())</tt></del>
++</td>
++</tr>
+
+-<hr>
+-<h3><a name="1415"></a>1415. [FCD] iterator stability bans the short-string optimization</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-Requirements on iterators swapping allegiance would
+-disallow the small-string optimization.
++<tr>
++<td>
++<tt>q.generate(rb,re)</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++Does nothing if <tt>rb == re</tt>.<br/>
++Otherwise, fills the supplied<br/>
++sequence <tt>[rb, re)</tt> with 32-bit<br/>
++quantities that depend on the<br/>
++sequence supplied to the<br/>
++constructor and possibly also<br/>
++depend on the history of<br/>
++<tt>generate</tt>'s previous<br/>
++invocations.
++</td>
++<td>
++<tt>&#x1d4aa;(re - rb)</tt>
++</td>
++</tr>
+
+-<p><i>[
+-Resolved in Rapperswil by paper N3108.
+-]</i></p>
++<tr>
++<td>
++<del><tt>r.size()</tt></del>
++</td>
++<td>
++<del><tt>size_t</tt></del>
++</td>
++<td>
++<del>The number of 32-bit units that<br/>
++would be copied by a call to<br/>
++<tt>r.param</tt>.</del>
++</td>
++<td>
++<del>constant</del>
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>r.param(ob)</tt></del>
++</td>
++<td>
++<del><tt>void</tt></del>
++</td>
++<td>
++<del>Copies to the given destination
++a sequence of 32-bit units that<br/>
++can be provided to the<br/>
++constructor of a second object<br/>
++of type <tt>S</tt>, and that would<br/>
++reproduce in that second object<br/>
++a state indistinguishable from<br/>
++the state of the first object.</del>
++</td>
++<td>
++<del><tt>&#x1d4aa;(r.size())</tt></del>
++</td>
++</tr>
+
++</table>
++ </li>
+
++</ol>
+
+-<p><b>Proposed resolution:</b></p>
+-Add an exclusion for <tt>basic_string</tt> to the sentence
+-beginning “Every iterator referring to an
+-element...”. Add a sentence to 21.4.6.8/2 saying
+-that iterators and references to string elements
+-remain valid, but it is not specified whether they
+-refer to the same string or the other string.
+
+
+
+
+
+ <hr>
+-<h3><a name="1419"></a>1419. [FCD] Ballot Comment US-117</h3>
+-<p><b>Section:</b> 23.3.3 [forwardlist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2125"></a>2125. <tt>TimedMutex</tt> specification problem</h3>
++<p><b>Section:</b> 30.4.1.3 [thread.timedmutex.requirements], 30.4.1.3.1 [thread.timedmutex.class] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">Pending NAD Editorial</a>
++ <b>Submitter:</b> Vicente J. Botet Escriba <b>Opened:</b> 2012-01-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.timedmutex.requirements">issues</a> in [thread.timedmutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Pending NAD Editorial">Pending NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-117</b></p>
+
+-forward_list::erase_after should return an iterator.
++<p>
++30.4.1.3.1 [thread.timedmutex.class] says:
++</p>
++<blockquote><p>
++The class <tt>timed_mutex</tt> shall satisfy all of the <tt>TimedMutex</tt> requirements (30.4.1.3 [thread.timedmutex.requirements]).
++It shall be a standardlayout class (Clause 9 [class]).
++</p></blockquote>
++<p>
++Problem here is that 30.4.1.3 [thread.timedmutex.requirements] does not define a requirement set named &quot;<tt>TimedMutex</tt>&quot;,
++it only refers to &quot;<i>timed mutex types</i>&quot;
++</p>
++
++<p><i>[See also issue <a href="lwg-closed.html#2126">2126</a>]</i></p>
+
+-<p><i>[
+-Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+-]</i></p>
+
++<p><i>[2012, Portland: move to Tentatively NAD Editorial]</i></p>
++
++<p>
++We have timed mutex type, but it is labeled timed mutex requirements
++</p>
++<p>
++We can make a suggestion, but will send to the editor as it seems purely editorial.
++There is a typo, and we don't have the timed mutex but 30.4.1.3 [thread.timedmutex.requirements] already
++says timed mutex type, and we need to reuse that term down in the class to fulfil the mutex requirement.
++</p>
++<p><i>[To Editor:]</i></p>
++
++<p>
++Replace this one with timed mutex type.
++</p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-See Appendix 1 - Additional Details
+
+
+
+
+
+ <hr>
+-<h3><a name="1422"></a>1422. [FCD] vector&lt;bool&gt; iterators are not random access</h3>
+-<p><b>Section:</b> 23.4.2 [vector.bool] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2126"></a>2126. Several specification problems in regard to mutex requirements</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements], 30.4.1.2.1 [thread.mutex.class], 30.4.1.2 [thread.mutex.requirements.mutex], 30.4.1.2.2 [thread.mutex.recursive], 30.4.1.3 [thread.timedmutex.requirements], 30.4.1.3.1 [thread.timedmutex.class], 30.4.1.3.2 [thread.timedmutex.recursive] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">Pending NAD Editorial</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-01-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Pending NAD Editorial">Pending NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-118</b></p>
++
+ <p>
+-<tt>vector&lt;bool&gt;</tt> iterators are not random access iterators
+-because their reference type is a special class, and not
+-<tt>bool &amp;</tt>. All standard libary operations taking iterators
+-should treat this iterator as if it was a random access iterator, rather
+-than a simple input iterator.
++ 30.4.1.2.1 [thread.mutex.class]&#47;3 says that the class mutex "shall satisfy all the <tt>Mutex</tt> requirements (30.4.1 [thread.mutex.requirements])".
++ 30.4.1.2.1 [thread.mutex.class] is part of 30.4.1 [thread.mutex.requirements], so at the very least, this
++ requirement is recursive. But worse, there is nothing that says what "the <tt>Mutex</tt> requirements" refers to. For example,
++ the "<tt>Lockable</tt> requirements" section starts with "A type <tt>L</tt> meets the <tt>Lockable</tt> requirements if &hellip;". There is no such
++ statement for "the <tt>Mutex</tt> requirements".
++<p/>
++Organizationally, paragraphs 1-26 in 30.4.1.2 [thread.mutex.requirements.mutex] should probably be in a subclause with a name.
++(This is actually an ISO requirement, to avoid exactly this kind of ambiguous referencing) Then the first sentence of
++30.4.1.2.1 [thread.mutex.class]&#47;3 can become a note: "The class mutex meets the requirements of (whatever)", since that
++subclause already says that the mutex types "shall meet the requirements set out in this section."
++<p/>
++And similarly for 30.4.1.2.2 [thread.mutex.recursive]&#47;2 (<tt>recursive_mutex</tt>).
++<p/>
++30.4.1.3 [thread.timedmutex.requirements], Timed mutex types, also needs the same rearrangement: its introductory
++requirements should be moved into a subclause, and the first sentences of 30.4.1.3.1 [thread.timedmutex.class]&#47;2
++and 30.4.1.3.2 [thread.timedmutex.recursive]&#47;2 should be turned into notes that refer to this new subclause and
++to the new subclause in 30.4.1.2 [thread.mutex.requirements.mutex].
+ </p>
+
+-<p><i>[
+-Resolution proposed in ballot comment
+-]</i></p>
++<p><i>[See also issue <a href="lwg-closed.html#2125">2125</a>]</i></p>
+
+-<p>
+-Either revise the iterator requirements to support proxy iterators
+-(restoring functionality that was lost when the Concept facility was
+-removed) or add an extra paragraph to the <tt>vector&lt;bool&gt;</tt>
+-specification requiring the library to treat <tt>vector&lt;bool&gt;</tt>
+-iterators as-if they were random access iterators, despite having the wrong
+-reference type.
+-</p>
+
+-<p><i>[
+-Rapperswil Review
+-]</i></p>
++<p><i>[2012, Portland: move to Tentatively NAD Editorial]</i></p>
+
+ <p>
+-The consensus at Rapperswil is that it is too late for full support for
+-proxy iterators, but requiring the library to respect <tt>vector&amp;;t;bool&gt;</tt>
+-iterators as-if they were random access would be preferable to flagging
+-this container as deliberately incompatible with standard library algorithms.
++Seems no real ambiguity. May need some reorg of text rather then changing the wording.
++</p>
++<p>
++Is there much that needs to be changed? But Pete's suggestion of putting requirement in separate sub section is good.
++Should be the direction to editor.
+ </p>
+ <p>
+-Alisdair to write the note, which may become normative <i>Remark</i> depending
+-on the preferences of the project editor.
++Suggest this is an editorial change. Happy with Pete's comments.
+ </p>
+
+-<p><i>[
+-Post-Rapperswil Alisdair provides wording
+-]</i></p>
+
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2131"></a>2131. Member function getline taking a string as parameter</h3>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Lo&iuml;c Joly <b>Opened:</b> 2012-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Initial wording is supplied, deliberately using <i>Note</i> in preference to
+-<i>Remark</i> although the author notes his preference for <i>Remark</i>. The
+-issue of whether <tt>iterator_traits&lt;vector&lt;bool&gt;&gt;::iterator_category</tt>
+-is permitted to report <tt>random_access_iterator_tag</tt> or must report
+-<tt>input_iterator_tag</tt> is not addressed.
++I think the following code should be legal:
+ </p>
++<blockquote><pre>
++void f(std::istream&amp; is)
++{
++ std::string s;
++ is.getline(s); // Would be equivalent to std::getline(is, s)
++}
++</pre></blockquote>
++
++<p><i>[2013-04-20, Bristol]</i></p>
+
+-<p><i>[
+-Old Proposed Resolution:
+-]</i></p>
+
+-<blockquote>
+ <p>
+-Insert a new paragraph into 23.4.2 [vector.bool] between p4 and p5:
++Unanimous that this is a new feature request and not a issue.
++<p/>
++Resolution: Tentatively NAD
+ </p>
+-<blockquote>
+-[<i>Note</i> All functions in the library that take a pair of iterators to
+-denote a range shall treat <tt>vector&lt;bool&gt;</tt> iterators as-if they were
+-random access iterators, even though the <tt>reference</tt> type is not a
+-true reference.<i>-- end note</i>]
+-</blockquote>
+-</blockquote>
+
+-<p><i>[
+-2010-11 Batavia:
+-]</i></p>
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change the class template <tt>basic_istream</tt> synopsis, 27.7.2.1 [istream], as indicated</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
++ class basic_istream : virtual public basic_ios&lt;charT,traits&gt; {
++ public:
++ [&hellip;]
++ <i>// 27.7.2.3 Unformatted input:</i>
++ [&hellip;]
++ basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);
++ basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n,
++ char_type delim);
++ <ins>template&lt;class Allocator&gt;
++ basic_istream&lt;charT,traits&gt;&amp; getline(basic_string&lt;charT,traits,Allocator&gt;&amp; str);
++ template&lt;class Allocator&gt;
++ basic_istream&lt;charT,traits&gt;&amp; getline(basic_string&lt;charT,traits,Allocator&gt;&amp; str,
++ char_type delim);</ins>
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Insert the following two new prototype descriptions after 27.7.2.3 [istream.unformatted] paragraph 24:</p>
+
+ <blockquote>
+-Closed as NAD Future, because the current iterator categories cannot correctly describe
+-<tt>vector&lt;bool&gt;::iterator</tt>. But saying that they are Random Access Iterators
+-is also incorrect, because it is not too hard to create a corresponding test that fails.
+-We should deal with the more general proxy iterator problem in the future, and see no
+-benefit to take a partial workaround specific to <tt>vector&lt;bool&gt;</tt> now.
++<pre>
++basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);
++</pre>
++<blockquote><p>
++-24- <i>Returns</i>: <tt>getline(s,n,widen('\n'))</tt>
++</p>
+ </blockquote>
+
++<pre>
++<ins>template&lt;class Allocator&gt;
++basic_istream&lt;charT,traits&gt;&amp; getline(basic_string&lt;charT,traits,Allocator&gt;&amp; str);</ins>
++</pre>
++<blockquote><p>
++<ins>-??- <i>Returns</i>: <tt>std::getline(*this, str)</tt></ins>
++</p>
++</blockquote>
+
++<pre>
++<ins>template&lt;class Allocator&gt;
++basic_istream&lt;charT,traits&gt;&amp; getline(basic_string&lt;charT,traits,Allocator&gt;&amp; str, char_type delim);</ins>
++</pre>
++<blockquote><p>
++<ins>-??- <i>Returns</i>: <tt>std::getline(*this, str, delim)</tt></ins>
++</p>
++</blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-
++</blockquote>
++</li>
++</ol>
+
+-<p><b>Rationale:</b></p>
+-No consensus to make this change at this time.
+
+
+
+
+
+ <hr>
+-<h3><a name="1433"></a>1433. [FCD] Ballot Comment GB-119</h3>
+-<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a></p>
++<h3><a name="2134"></a>2134. Redundant Mutex requirement?</h3>
++<p><b>Section:</b> 30.4.1.2 [thread.mutex.requirements.mutex] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">Pending NAD Editorial</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements.mutex">issues</a> in [thread.mutex.requirements.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Pending NAD Editorial">Pending NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-119</b></p>
+
+-The functions random_shuffle and shuffle both take
+-arguments providing a source of randomness, but one
+-take its argument by rvalue reference, and the other
+-requires an lvalue reference. The technical merits of which
+-form of argument passing should be settled for this
+-specific case, and a single preferred form used
+-consistently.
++<p>
++30.4.1.2 [thread.mutex.requirements.mutex]&#47;11 says that prior unlock operations <em>synchronize with</em> <tt>m.lock()</tt>.
++<p/>
++30.4.1.2 [thread.mutex.requirements.mutex]&#47;19 says that if <tt>m.try_lock()</tt> succeeds, prior unlock operations
++<em>synchronize with</em> the operation.
++<p/>
++30.4.1.2 [thread.mutex.requirements.mutex]&#47;25 says that <tt>m.unlock()</tt> <em>synchronizes with</em> subsequent
++successful lock operations.
++<p/>
++Does the third requirement add anything to the first two? If not, it should probably be a non-normative note.
++</p>
++
++<p><i>[2012, Portland: move to Tentatively NAD Editorial]</i></p>
++
++<p>
++Agree that third note should be non-normative and adds nothing.
++</p>
++<p>
++Seems An Editorial change, but does changing a normative to non-normative wording makes it a non-editorial change?
++</p>
++<p>
++Ask the editor. If not editorial, then we will agree on the fix as removal of the third point,
++then we will put it in ready state for Bristol.
++</p>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+-[DEPENDS ON WHETHER RVALUE OR
+-LVALUE REFERENCE IS THE PREFERRED
+-FORM]
+
+
+
+
+
+ <hr>
+-<h3><a name="1434"></a>1434. [FCD] Ballot Comment US-122</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2167"></a>2167. Copy assignment requirements of Containers</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Dean Michael Berris <b>Opened:</b> 2012-07-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-122</b></p>
+
+-It was the LWG's intent in Pittsburgh that N2772 be
+-applied to the WP.
++<p>
++Table 96 defines the general requirement for copy assignment (row 23, page 704) as:
++</p>
+
+-<p><i>[
+-Resolved in Rapperswil by paper N3106.
+-]</i></p>
++<table border="1">
++<caption>Table 96 &mdash; Container requirements</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td>
++<tt>r = a</tt>
++</td>
++<td>
++<tt>X&amp;</tt>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++post: <tt>r == a.</tt>
++</td>
++<td>
++linear
++</td>
++</tr>
++
++</table>
++
++<p>
++However there is no requirement that <tt>T</tt> is <tt>CopyInsertable</tt> into <tt>X</tt>.
++</p>
++
++<p><i>[2012, Portland: Move to Tentatively NAD]</i></p>
+
++<p>
++Howard notes that this may be a difficult requirement for <tt>std::array</tt>
++</p>
++
++<p>
++We already have this requirement for allocator aware containers, and
++<tt>std::array</tt> already adds the appropriate extra requirement.
++</p>
++
++<p>
++We say the necessary things in the necessary places, but the container requirements
++continue to cause confusion in where we sometimes say things. Consensus is that
++this issue remains NAD though.
++</p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-Apply N2772 to the WP.
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change Table 96 &mdash; "Container requirements" in 23.2.1 [container.requirements.general]:</p>
++
++<table border="1">
++<caption>Table 96 &mdash; Container requirements</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td>
++<tt>r = a</tt>
++</td>
++<td>
++<tt>X&amp;</tt>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++<ins><i>Requires</i>: <tt>T</tt> is <tt>CopyInsertable</tt> into <tt>X</tt>.</ins><br/>
++post: <tt>r == a.</tt>
++</td>
++<td>
++linear
++</td>
++</tr>
+
++</table>
+
++</li>
++</ol>
+
+
+
+-<hr>
+-<h3><a name="1442"></a>1442. [FCD] "happens-before" should be "synchronizes-with"</h3>
+-<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-18</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread">issues</a> in [thread].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a></p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CA-9, GB-122</b></p>
+
+-<p><i>[CA-9:]</i></p>
+
+
+-Imposed happens-before edges should be in
+-synchronizes-with<br>
+-Each use of the words "happens-before" should be
+-replaced with the words "synchronizes-with" in the
+-following sentences:<br>
+-27.2.3p2<br>
+-30.3.1.2p6<br>
+-30.3.1.5p7<br>
+-30.6.4p7<br>
+-30.6.9p5<br>
+-30.6.10.1p23<br>
+-Rationale: Happens-before is defined in 1.10p11 in a way
+-that (deliberately) does not make it explicitly transitively
+-closed. Adding edges to happens-before directly, as in
+-27.2.3p2 etc., does not provide transitivity with
+-sequenced-before or any other existing happens-before
+-edge. This lack of transitivity seems to be unintentional.
+
+-<p><i>[GB-122]</i></p>
++<hr>
++<h3><a name="2171"></a>2171. "swappable" undefined for swapping lvalue and rvalue</h3>
++<p><b>Section:</b> 17.6.3.2 [swappable.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Robert Shearer <b>Opened:</b> 2012-07-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#swappable.requirements">issues</a> in [swappable.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Paragraph 17.6.3.2 [swappable.requirements] p4 states:
++</p>
++<blockquote><p>
++An rvalue or lvalue <tt>t</tt> is <em>swappable</em> if and only if <tt>t</tt> is swappable with any rvalue or lvalue,
++respectively, of type <tt>T</tt>.
++</p></blockquote>
++<p>
++This paragraph seems to establish two disjoint definitions of "swappable" &mdash; one for lvalues and one
++for rvalues &mdash; with neither definition including the case of swapping an rvalue with an lvalue.
++<p/>
++Resolution proposal:
++<p/>
++Delete the word "respectively".
++</p>
+
++<p><i>[
++2012-10 Portland: Close as NAD
++]</i></p>
+
+-<p>At various points in the standard new edges are added to
+-happens-before, for example 27.2.3:2 adds happens-before edges between
+-writes and reads from a stream:</p>
+
+-<p>If one thread makes a library call a that writes a value to a
+-stream and, as a result, another thread reads this value from the
+-stream through a library call b such that this does not result in a
+-data race, then a happens before b.</p>
++<p>
++The current wording does intentionally specify two families of 'swappable' behaviors, for lvalues
++and for rvalues, and not for mixed behavior. The need to support rvalues is for types like
++<tt>vector&lt;bool>::reference</tt>. Likewise, library types like <tt>string</tt> provide a
++<tt>swap</tt> for values, but not a mixed-mode <tt>swap</tt> between lvalues and rvalues, which
++were deliberately removed from C++11 after initally being part of the standard.
++</p>
++
++<p>
++Accepting this resolution would break the library specification, as no current library type would
++meet the new requirements.
++</p>
+
+-<p>Happens-before is defined in 1.10:11 in a deliberate way that makes it
+-not explicitly transitively closed. Adding edges to happens-before
+-directly, as in 27.2.3:2, does not provide transitivity with
+-sequenced-before or any other existing happens-before edge. This lack
+-of transitivity seems to be unintentional. In order to achieve
+-transitivity we suggest each edge be added to
+-inter-thread-happens-before as a synchronises-with edge (as per
+-conversation with Hans Boehm). In the standard, each use of the words
+-"happens-before" should be replaced with the words "synchronizes-with"
+-in the following sentences:</p>
+
+-<p>27.2.3:2,
+-30.3.1.2:6,
+-30.3.1.5:7,
+-30.6.4:7,
+-30.6.9:5,
+-30.6.10.1:23</p>
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
+
+-<p><i>[Beman provided specific wording for the proposed resolution.]</i></p>
++<p>Change 17.6.3.2 [swappable.requirements] p4 as indicated:</p>
+
++<blockquote><p>
++An rvalue or lvalue <tt>t</tt> is <em>swappable</em> if and only if <tt>t</tt> is swappable with any rvalue or
++lvalue <del>, respectively,</del> of type <tt>T</tt>.
++</p></blockquote>
+
+-<p>Change 27.2.3 Thread Safety [iostreams.threadsafety] paragraph 2:</p>
+
+-<p>If one thread makes a library call <tt>a</tt> that writes a value to a stream and, as a result, another thread reads this value from the stream through a library call <tt>b</tt> such that this does not result in a data race, then <tt>a</tt> <del>happens before</del> <ins>synchronizes with</ins> <tt>b</tt>.</p>
+
+-<p>Change 30.3.1.2 thread constructors [thread.thread.constr] paragraph 6:</p>
+
+-<p><i>Synchronization:</i> The invocation of the constructor <del>happens before</del> <ins>synchronizes with</ins> the invocation of the copy of <tt>f</tt>.</p>
+
+-<p>Change 30.3.1.5 thread members [thread.thread.member] paragraph 7:</p>
+
+-<p><i>Synchronization:</i> The completion of the thread represented by <tt>*this</tt> <del>happens before</del> <ins>synchronizes with</ins> (1.10) <tt>join()</tt> <del>returns</del> <ins>returning</ins>. [ Note: Operations on <tt>*this</tt> are not synchronized. --end note ]</p>
++<hr>
++<h3><a name="2204"></a>2204. <tt>reverse_iterator</tt> should not require a second copy of the base iterator</h3>
++<p><b>Section:</b> 24.5.1.3.4 [reverse.iter.op.star] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> David Abrahams <b>Opened:</b> 2012-10-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+
+-<p>Change 30.6.4 Associated asynchronous state [futures.state] paragraph 7:</p>
++<p>
++This note in 24.5.1.3.4 [reverse.iter.op.star]/2:
++</p>
++<blockquote>
++ [ <i>Note</i>: This operation must use an auxiliary member variable rather than a
++ temporary variable to avoid returning a reference that persists beyond the
++ lifetime of its associated iterator. (See 24.2.) &mdash;<i>end note</i> ]
++</blockquote>
++<p>
++is incorrect because such iterator implementations are ruled out by
++24.2.5 [forward.iterators]/6, where it says:
++</p>
++<blockquote>
++ If <tt>a</tt> and <tt>b</tt> are both dereferenceable, then <tt>a == b</tt> if and only if <tt>*a</tt> and
++ <tt>*b</tt> are bound to the same object.
++</blockquote>
+
+-<p>Calls to functions that successfully set the stored result of an associated asynchronous state synchronize
+-with (1.10) calls to functions successfully detecting the ready state resulting from that setting. The storage of the result (whether normal or exceptional) into the associated asynchronous state <del>happens before</del> <ins>synchronizes with</ins> (1.10) that state <del>is</del> <ins>being</ins> set to ready.</p>
++<p><i>[2013-04-20, Bristol]</i></p>
+
+-<p>Change 30.6.9 Function template async [futures.async] paragraph 5:</p>
+
+-<p><i>Synchronization:</i> the invocation of <tt>async</tt> <del>happens before</del> <ins>synchronizes with</ins> (1.10) the invocation of <tt>f</tt>. [ Note: this
+-statement applies even when the corresponding future object is moved to another thread. --end
+-note ] If the invocation is not deferred, a call to a waiting function on an asynchronous return object
+-that shares the associated asynchronous state created by this async call shall block until the associated
+-thread has completed. If the invocation is not deferred, the <tt>join()</tt> on the created thread <del>happens before</del> <ins>synchronizes with</ins>
+-(1.10) the first function that successfully detects the ready status of the associated asynchronous
+-state returns or before the function that gives up the last reference to the associated asynchronous
+-state returns, whichever happens first. If the invocation is deferred, the completion of the invocation
+-of the deferred function <del>happens before</del> <ins>synchronizes with</ins> the calls to the waiting functions return.</p>
++<p>
++Alisdair: sugested to strike the "exposition only" member.
++<p/>
++Daniel: we must check that it wouldn't conflict with a previous solution to another issue.
++<p/>
++Dietmar: This is an issue but the proposing word is not correct. When we have proxies inside the sequence.
++<p/>
++Solution: NAD thanks to a contrieved example by Dietmar.
++</p>
+
+-<p>Change 30.6.10.1 packaged_task member functions [futures.task.members] paragraph 23:</p>
+
+-<p><i>Synchronization:</i> a successful call to <tt>operator()</tt> synchronizes with (1.10) a call to any member function of a <tt>future</tt>, <tt>shared_future</tt>, or <tt>atomic_future</tt> object that shares the associated asynchronous
+-state of <tt>*this</tt>. The completion of the invocation of the stored task and the storage of the result
+-(whether normal or exceptional) into the associated asynchronous state <del>happens before</del> <ins>synchronizes with</ins> (1.10) the
+-state <del>is</del> <ins>being</ins> set to ready. [ Note: <tt>operator()</tt> synchronizes and serializes with other functions through the
+-associated asynchronous state. —end note ]</p>
++<p><b>Proposed resolution:</b></p>
++<p>
++Strike the note, 24.5.1.3.4 [reverse.iter.op.star]/2:
++</p>
++
++<blockquote>
++ <del>[ <i>Note</i>: This operation must use an auxiliary member variable rather than a
++ temporary variable to avoid returning a reference that persists beyond the
++ lifetime of its associated iterator. (See 24.2.) &mdash;<i>end note</i> ]</del>
++</blockquote>
+
+
+
+@@ -50015,820 +40808,1230 @@ associated asynchronous state.
+
+
+ <hr>
+-<h3><a name="1443"></a>1443. [FCD] Imposed happens-before edges are not made transitive</h3>
+-<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-27</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread">issues</a> in [thread].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a></p>
++<h3><a name="2251"></a>2251. C++ library should define <tt>ssize_t</tt></h3>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2013-04-19 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+
++<p>
++The C++ standard library defines <tt>size_t</tt>, a typedef for an implementation defined unsigned integer type
++that can represent the sizes of objects. The POSIX standard augments this with <tt>ssize_t</tt>, a typedef for a
++signed integer type that corresponds to <tt>size_t</tt>.
++<p/>
++The <tt>ssize_t</tt> typedef is useful &mdash; useful enough that the C++ standard even refers to it. (In a
++non-normative footnote in 27.5.2 [stream.types].) Also, lots of OS vendors add it to their headers anyway,
++even though it isn't part of the C or C++ standards, because those vendors are trying to define headers that
++conform to multiple standards at once. We should make users' and implementers' lives easier by adding
++<tt>ssize_t</tt> to 18.2 [support.types].
++</p>
+
+-<p><b>Addresses GB-122</b></p>
++<p><i>[2013-09-29, Suggested wording from Jayson Oldfather]</i></p>
+
+-<p>At various points in the standard new edges are added to
+-happens-before, for example 27.2.3:2 adds happens-before edges between
+-writes and reads from a stream:</p>
++<p>
++I decided to use the phrase to describe <tt>ssize_t</tt> below because of the text describing it in the
++<a href="http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_types.h.html#tag_13_67">POSIX</a> standard.
++In it, it describes <tt>ssize_t</tt> with the value range of <tt>[-1,{SSIZE_MAX}]</tt>.
++<tt>SSIZE_MAX</tt> is specified in the <a href="http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html#tag_13_24">POSIX</a>
++standard as a minimum value of <tt>_POSIX_SSIZE_MAX</tt>. This macro is referenced in the wording below.
++</p>
+
+-<p>If one thread makes a library call a that writes a value to a
+-stream and, as a result, another thread reads this value from the
+-stream through a library call b such that this does not result in a
+-data race, then a happens before b.</p>
++<p><i>[Lenexa 2015-05-05: NAD - no consensus for a change]</i></p>
+
+-<p>Happens-before is defined in 1.10:11 in a deliberate way that makes it
+-not explicitly transitively closed. Adding edges to happens-before
+-directly, as in 27.2.3:2, does not provide transitivity with
+-sequenced-before or any other existing happens-before edge. This lack
+-of transitivity seems to be unintentional. In order to achieve
+-transitivity we suggest each edge be added to
+-inter-thread-happens-before as a synchronises-with edge (as per
+-conversation with Hans Boehm). In the standard, each use of the words
+-"happens-before" should be replaced with the words "synchronizes-with"
+-in the following sentences:</p>
++<p>Billy : ssize_t that was promised to be signed, was based on rsize_t from safe secure C</p>
++<p>NM : ssize_t s ptrdif_t</p>
++<p>Z : ptrdiff_t is full range, ssize_t has only -1 as negative value</p>
++<p>Billy : motivations for ptrdiff_T, ssize_t and rsize_T all fuzzy. - Reads rsize max -</p>
++<p>NM : ptrdiff_T not big enough to rep difference of pointers anymore</p>
++<p>STL : description incorporates posixisms</p>
++<p>Billy : Don't need it</p>
++<p>NM : rather remove it from footnote</p>
++<p>Z : Name has precise meaning</p>
++<p>STL : everyone understands ptrdiff_t is signed counterpart to size_t</p>
++<p>Billy : Not in all implementations anymore</p>
++<p>DK : footnote says something different from ...</p>
++<p>Z/NM : off_t historically tainted</p>
++<p>STL : we have a type trait to make signed version of size_t. we should just use that</p>
++<p>MC : NAD; is feature request</p>
++<p>TP : It's not cstdsef</p>
+
+-<p>27.2.3:2,
+-30.3.1.2:6,
+-30.3.1.5:7,
+-30.6.4:7,
+-30.6.9:5,
+-30.6.10.1:23</p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Request the concurrency working group to
+-determine if changes are needed
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Ammend 18.2 [support.types], Table 30 as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 30 &mdash; Header <tt>&lt;cstddef&gt;</tt> synopsis</caption>
++<tr>
++<th>Type</th>
++<th>Name(s)</th>
++</tr>
++
++<tr>
++<td>
++<b>Macros:</b>
++</td>
++<td>
++<tt>NULL offset_t</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<b>Types:</b>
++</td>
++<td>
++<tt>ptrdiff_t <ins>ssize_t</ins> size_t max_align_t nullptr_t</tt>
++</td>
++</tr>
++</table>
++</blockquote>
++
++<p>Add the following paragraph to describe <tt>ssize_t</tt></p>
++<blockquote><p><ins>
++-?- The type <tt>ssize_t</tt> is an implementation-defined signed integer type that shall contain the minimum range
++<tt>[-1, {SSIZE_MAX}]</tt> where <tt>SSIZE_MAX</tt> is specified at a minimum of <tt>_POSIX_SSIZE_MAX</tt>.</ins>
++</p></blockquote>
++<p>Ammend p7 as follows:</p>
++<blockquote><p>
++-7- [<i>Note:</i> It is recommended that implementations choose types for <tt>ptrdiff_t<ins>, ssize_t,</ins></tt> and <tt>size_t</tt> whose integer conversion ranks &hellip;</p></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1444"></a>1444. [FCD] <tt>OFF_T</tt> is not defined</h3>
+-<p><b>Section:</b> 27.5.3.2 [fpos.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-28</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos.operations">issues</a> in [fpos.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a></p>
++<h3><a name="2270"></a>2270. Inconsistent <tt>to_string</tt> overloads</h3>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Raf Schietekat <b>Opened:</b> 2013-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++For internal consistency, <tt>to_string()</tt> should either list all relevant types (including <tt>bool</tt>, <tt>char</tt>, etc.),
++or only those that are the destination types of integral or floating-point promotion (<tt>float</tt> not being among them).
++<p/>
++A defensible reason for having (or rather keeping) the <tt>float</tt> overloads anyway could be to exactly mirror the adjacent
++sets of <tt>stoX()</tt> function overloads (even without round-trip fidelity for floating-point numbers).
++<p/>
++Unfortunately, that reveals a bigger issue than redundant overloads: the glaring and indefensible omission of an overloaded
++function <tt>stoui()</tt>. Adding that is not as trivial as removing redundant overloads, of course, because it requires
++everybody to take action. Still, it is the preferable remedy for the present situation.
++<p/>
++As far as I can tell from easily accessible information, C++ has already created the precedent with <tt>stoi()</tt>, which
++is not the equivalent of a pair of functions <tt>strtoi()</tt>/<tt>wcstoi()</tt> in C, but it would be if such functions
++existed. The function <tt>atoi()</tt> may look similar, but it does not qualify because it is as different from a
++hypothetical <tt>strtoi()</tt> as <tt>atol()</tt> currently is from <tt>strtol()</tt>, with the latter two both Standard C.
++It is only logical to act on this one-sided precedent by completing the set. Whether or not Standard C leads the way
++(or follows suit) is immaterial, but an invitation could be extended.
++</p>
+
+-<p><b>Addresses GB-123</b></p>
+-
+-Several rows in table 124 specify a Return type of
+-'OFF_T', which does not appear to be a type defined in
+-this standard.
++<p><i>[2013-09 Chicago]</i></p>
+
++<p>
++These overloads were very carefully and experimentally determined to be the minimal set, when all (known) promotion and
++conversion scenarios were considered. Removing superfluous-looking overloads is likely to result in ambiguities.
++</p>
+
+-<p><b>Proposed resolution:</b></p>
+-Resolve outstanding references to the removed
+-type 'OFF_T'.
+
+
++<p><b>Proposed resolution:</b></p>
+
++<p>This wording is relative to N3691.</p>
+
++<ol>
++<li><p>Modify 21.3 [string.classes], header <tt>&lt;string&gt;</tt> synopsis, as indicated:</p>
+
+-<hr>
+-<h3><a name="1446"></a>1446. [FCD] Move and swap for I/O streams</h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-138</b></p>
++<blockquote><pre>
++#include &lt;initializer_list&gt;
+
+-For istreams and ostreams, the move-constructor does
+-not move-construct, the move-assignment operator does
+-not move-assign, and the swap function does not swap
+-because these operations do not manage the <tt>rdbuf()</tt>
+-pointer. Useful applications of these operations are
+-prevented both by their incorrect semantics and because
+-they are protected.
++namespace std {
++ [&hellip;]
++ string to_string(int val);
++ string to_string(unsigned val);
++ string to_string(long val);
++ string to_string(unsigned long val);
++ string to_string(long long val);
++ string to_string(unsigned long long val);
++ <del>string to_string(float val);</del>
++ string to_string(double val);
++ string to_string(long double val);
++ [&hellip;]
++
++ [&hellip;]
++ wstring to_wstring(int val);
++ wstring to_wstring(unsigned val);
++ wstring to_wstring(long val);
++ wstring to_wstring(unsigned long val);
++ wstring to_wstring(long long val);
++ wstring to_wstring(unsigned long long val);
++ <del>wstring to_wstring(float val);</del>
++ wstring to_wstring(double val);
++ wstring to_wstring(long double val);
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<li><p>Modify 21.5 [string.conversions] p7+14 as indicated:</p>
+
++<blockquote>
++<pre>
++string to_string(int val);
++string to_string(unsigned val);
++string to_string(long val);
++string to_string(unsigned long val);
++string to_string(long long val);
++string to_string(unsigned long long val);
++<del>string to_string(float val);</del>
++string to_string(double val);
++string to_string(long double val);
++</pre>
++<blockquote>
+ <p>
+-In short: reverse the resolution of issue 900, then
+-change the semantics to move and swap the
+-<tt>rdbuf()</tt> pointer. Add a new protected constructor
+-that takes an rvalue reference to a stream and a
+-pointer to a streambuf, a new protected <tt>assign()</tt>
+-operator that takes the same arguments, and a
+-new protected <tt>partial_swap()</tt> function that doesn't
+-swap <tt>rdbuf()</tt>.
+-See Appendix 1 - Additional Details
++-7- <i>Returns:</i> Each function returns a <tt>string</tt> object holding the character representation of the value of
++its argument that would be generated by calling <tt>sprintf(buf, fmt, val)</tt> with a format specifier of
++<tt>"%d"</tt>, <tt>"%u"</tt>, <tt>"%ld"</tt>, <tt>"%lu"</tt>, <tt>"%lld"</tt>, <tt>"%llu"</tt>, <del><tt>"%f"</tt>,</del>
++<tt>"%f"</tt>, or <tt>"%Lf"</tt>, respectively, where <tt>buf</tt> designates an internal character buffer of sufficient size.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++wstring to_wstring(int val);
++wstring to_wstring(unsigned val);
++wstring to_wstring(long val);
++wstring to_wstring(unsigned long val);
++wstring to_wstring(long long val);
++wstring to_wstring(unsigned long long val);
++<del>wstring to_wstring(float val);</del>
++wstring to_wstring(double val);
++wstring to_wstring(long double val);
++</pre>
++<blockquote>
++<p>
++-14- <i>Returns:</i> Each function returns a <tt>wstring</tt> object holding the character representation of the value of
++its argument that would be generated by calling <tt>swprintf(buf, buffsz, fmt, val)</tt> with a format specifier of
++<tt>L"%d"</tt>, <tt>L"%u"</tt>, <tt>L"%ld"</tt>, <tt>L"%lu"</tt>, <tt>L"%lld"</tt>, <tt>L"%llu"</tt>, <del><tt>L"%f"</tt>,</del>
++<tt>L"%f"</tt>, or <tt>L"%Lf"</tt>, respectively, where <tt>buf</tt> designates an internal character buffer of sufficient
++size <tt>buffsz</tt>.
+ </p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
+
+-<p><i>[
+-2010-10-24 Daniel adds:
+-]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3179.pdf">n3179</a> would solve this issue.
+-</blockquote>
+
+-<p><i>[
+-2010-11 Batavia
+-]</i></p>
+
++<hr>
++<h3><a name="2279"></a>2279. Carefully state effects of <tt>list::splice</tt> function</h3>
++<p><b>Section:</b> 23.3.5.5 [list.ops], 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Arseny Klimovsky <b>Opened:</b> 2013-08-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Closed as NAD.
++I think that the effects of <tt>list::splice</tt> function should be stated more carefully.
++<p/>
++Function transferring a single element is described now in the following way (23.3.5.5 [list.ops] p7):
+ </p>
++
+ <blockquote>
+-The Library Working Group reviewed <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3179.pdf">n3179</a> and
+-concluded that this change alone was not sufficient, as it would require changes to some of the derived stream types in the library.
+-The preference is to not make such a broad fix, and retain the current semantics. This is closed as NAD rather than NAD future as it
+-will be difficult to rename the new functions introduced in the C++0x revision of the standard at a later date.
++<pre>
++void splice(const_iterator position, list&amp; x, const_iterator i);
++void splice(const_iterator position, list&amp;&amp; x, const_iterator i);
++</pre>
++<blockquote>
++<p>
++<i>Effects:</i> Inserts an element pointed to by <tt>i</tt> from list <tt>x</tt> before position and removes the element from
++<tt>x</tt>. The result is unchanged if <tt>position == i</tt> or <tt>position == ++i</tt>. Pointers and references to <tt>*i</tt>
++continue to refer to this same element but as a member of <tt>*this</tt>. Iterators to <tt>*i</tt> (including <tt>i</tt> itself)
++continue to refer to the same element, but now behave as iterators into <tt>*this</tt>, not into <tt>x</tt>.
++</p>
++</blockquote>
+ </blockquote>
+
++<p>
++But it is incorrect to talk about <tt>operator==</tt> for iterators that are not from the same container (after acceptance of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>, 24.2.5 [forward.iterators] p2).
++So, the text operates with an undefined behaviour.
++</p>
+
++<p>
++One is formally allowed to have list implementation where two iterators from different lists return true to <tt>operator==</tt>.
++For example, this can only happen to non-dereferenceable iterators, and <tt>position</tt> and <tt>++i</tt> can be
++non-dereferenceable. So, literally according to the standard, it is not allowed in this implementation to transfer
++such elements with <tt>splice</tt> function.
++</p>
+
+-<p><b>Proposed resolution:</b></p>
++<p><i>[2013-09 Chicago (late night issues)]</i></p>
+
++<p>
++Moved to NAD.
++</p>
++<p>
++The condition under which the <tt>list</tt> is unchanged is not program code, so there is no undefined behavior to protect against.
++Rather, the precondition that the evaluation can be performed is implicit if determining when the condition applies.
++</p>
+
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
+
+-<hr>
+-<h3><a name="1451"></a>1451. [FCD] <tt>regex</tt> should support allocators</h3>
+-<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex">issues</a> in [re.regex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1396">1396</a></p>
+-<p><b>Discussion:</b></p>
++<ol>
++<li><p>Modify 23.3.4.6 [forwardlist.ops] p6 as indicated:</p>
+
+-<p><b>Addresses US-141</b></p>
++<blockquote>
++<pre>
++void splice_after(const_iterator position, forward_list&amp; x, const_iterator i);
++void splice_after(const_iterator position, forward_list&amp;&amp; x, const_iterator i);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-6- <i>Effects:</i> Inserts the element following <tt>i</tt> into <tt>*this</tt>, following <tt>position</tt>,
++and removes it from <tt>x</tt>. The result is unchanged if <ins><tt>&amp;x == this</tt> and the following
++condition is satisfied:</ins> <tt>position == i</tt> or <tt>position == ++i</tt>. Pointers and references to
++<tt>*++i</tt> continue to refer to the same element but as a member of <tt>*this</tt>. Iterators to <tt>*++i</tt>
++continue to refer to the same element, but now behave as iterators into <tt>*this</tt>, not into <tt>x</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
+
+-std::basic_regex should have an allocator for all the
+-reasons that a std::string does. For example, I can use
+-boost::interprocess to put a string or vector in shared
+-memory, but not a regex.
++<li><p>Modify 23.3.5.5 [list.ops] p7 as indicated:</p>
+
++<blockquote>
++<pre>
++void splice(const_iterator position, list&amp; x, const_iterator i);
++void splice(const_iterator position, list&amp;&amp; x, const_iterator i);
++</pre>
++<blockquote>
++<p>
++-7- <i>Effects:</i> Inserts an element pointed to by <tt>i</tt> from list <tt>x</tt> before position and removes
++the element from <tt>x</tt>. The result is unchanged if <ins><tt>&amp;x == this</tt> and the following
++condition is satisfied:</ins> <tt>position == i</tt> or <tt>position == ++i</tt>. Pointers and references to
++<tt>*i</tt> continue to refer to this same element but as a member of <tt>*this</tt>. Iterators to <tt>*i</tt>
++(including <tt>i</tt> itself) continue to refer to the same element, but now behave as iterators into <tt>*this</tt>,
++not into <tt>x</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
+
+-<p><b>Proposed resolution:</b></p>
+-Add allocators to regexes; see paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3171.pdf">N3171</a>
+-in the pre-Batavia mailing.
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1454"></a>1454. [FCD] Ensure C compatibility for atomics</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a></p>
++<h3><a name="2281"></a>2281. C99 cross-reference typo in [using.linkage]</h3>
++<p><b>Section:</b> 17.6.2.3 [using.linkage] <b>Status:</b> <a href="lwg-active.html#NAD Editorial">NAD Editorial</a>
++ <b>Submitter:</b> Chris Sharpe <b>Opened:</b> 2013-08-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#using.linkage">issues</a> in [using.linkage].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<p><b>Addresses GB-128</b></p>
+ <p>
+-WG14 has made some late changes to their specification
+-of atomics, and care should be taken to ensure that we
+-retain a common subset of language/library syntax to
+-declare headers that are portable to both languages.
+-Ideally, such headers would not require users to define
+-their own macros, especially not macros that map to
+-keywords (which remains undefined behaviour)
++There is a footnote at section 17.6.2.3 [using.linkage]/2 that reads:
++</p>
++<blockquote><p>
++"The only reliable way to declare an object or function signature from the Standard C library is by including
++the header that declares it, notwithstanding the latitude granted in 7.1.7 of the C Standard."
++</p></blockquote>
++<p>
++There is no section 7.1.7 in the C99 Standard (or C11 final draft). I think the relevant section is:
++</p>
++<blockquote><p>
++"Provided that a library function can be declared without reference to any type defined in a header, it is also
++permissible to declare the function and use it without including its associated header."
++</p></blockquote>
++<p>
++at 7.1.4/2 from C99.
+ </p>
+
+-
+-<p><i>[
+-Resolution proposed by ballot comment
+-]</i></p>
++<p><i>[2013-09 Chicago]</i></p>
+
+ <p>
+-Depends on result of the review of WG14 work,
+-which is expected to be out to ballot during the
+-time wg21 is resolving its own ballot comments.
+-Liaison may also want to file comments in WG14
+-to ensure compatibity from both sides.
++Moved to NAD Editorial.
+ </p>
+
+
++
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit footnote 182, 17.6.2.3 [using.linkage] as indicated:</p>
++
++<blockquote>
++<p>
++The only reliable way to declare an object or function signature from the Standard C library is by including the header
++that declares it, notwithstanding the latitude granted in <del>7.1.7</del><ins>7.1.4</ins> of the C Standard.
++</p>
++</blockquote>
++</li>
++
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1458"></a>1458. [FCD] Overlapping evaluations are allowed</h3>
+-<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1459">1459</a></p>
++<h3><a name="2297"></a>2297. [CD] Missing type requirements for <tt>std::exchange</tt></h3>
++<p><b>Section:</b> 20.2.3 [utility.exchange] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2013-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.exchange">issues</a> in [utility.exchange].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses GB 5</b></p>
+
+-<p><b>Addresses GB-131</b></p>
++<p>
++The wording describes example code including the call of a move constructor, but there is no requirement
++stated that <tt>T</tt> be move constructible.
++<p/>
++We would like to add a new Para 1 before existing paragraph:
++</p>
++<blockquote><p>
++<i>Requires:</i> Type <tt>T</tt> shall be <tt>MoveConstructible</tt> (Table 20) and <tt>MoveAssignable</tt> (Table 22).
++</p></blockquote>
+
+-29.4 [atomics.lockfree] p.8 states:
+-<p></p><blockquote>
+-An atomic store shall only store a value that has been computed
+-from constants and program input values by a finite sequence of
+-program evaluations, such that each evaluation observes the values
+-of variables as computed by the last prior assignment in the
+-sequence.
+-</blockquote><p></p>
+ <p>
+-... but 1.9 [intro.execution] p.13 states:
++However the <tt>MoveAssignable</tt> concept currently does not cover cases where the source and destination types may differ.
+ </p>
+-<p></p><blockquote>
+-If A is not sequenced before B and B is not sequenced before A,
+-then A and B are unsequenced. [ <em>Note</em>: The execution of unsequenced
+-evaluations can overlap. — <em>end note</em> ]
+-</blockquote><p></p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
+ <p>
+-Overlapping executions can make it impossible to construct the sequence
+-described in 29.4 [atomics.lockfree] p.8. We are not sure of the intention here and do not
+-offer a suggestion for change, but note that 29.4 [atomics.lockfree] p.8 is the condition
+-that prevents out-of-thin-air reads.
++The requirements are implicit according to 17.5.1.4 [structure.specifications]p4. There is no desire to redundantly
++repeat a set of requirements.
+ </p>
+
+
++
+ <p><b>Proposed resolution:</b></p>
+-Request the concurrency working group to
+-determine if changes are needed. Consider
+-changing the use of "sequence" in 29.4 [atomics.lockfree]
+
+
+
+
+
+ <hr>
+-<h3><a name="1463"></a>1463. [FCD] Inconsistent value assignment for <tt>atomic_bool</tt></h3>
+-<p><b>Section:</b> 29.5.1 [atomics.types.integral] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a></p>
++<h3><a name="2302"></a>2302. Passing null pointer to placement new</h3>
++<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="lwg-active.html#NAD">Pending NAD</a>
++ <b>Submitter:</b> Marc Glisse <b>Opened:</b> 2013-09-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Pending NAD">Pending NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p>
++Based on <a href="http://stackoverflow.com/questions/17571103/passing-null-pointer-to-placement-new">this discussion</a>
++and as discussed in <a href="http://accu.org/cgi-bin/wg21/message?wg=core&amp;msg=23998">c++std-core-23998</a> and
++<a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=34442">c++std-lib-34442</a>, calling placement new currently forces the
++compiler to check if the pointer is null before initializing the object (a non-negligible cost). It seems many people were not
++aware of this and they consider it a user error to pass a null pointer to it.
++<p/>
++Proposed resolution: for <tt>operator new</tt> and <tt>operator new[]</tt>, add:
++</p>
++<blockquote><p>
++<i>Requires:</i> <tt>ptr</tt> shall not be a null pointer.
++</p></blockquote>
+
+-<p><b>Addresses US-157</b></p>
++<p><i>[2014-02-15 post-Issaquah session : move to Tentatively NAD]</i></p>
++
++<p>
++AJM to supply the rationale...
++</p>
+
+-<tt>atomic_bool</tt> has a <tt>volatile</tt> assignment operator but not a
+-non-<tt>volatile</tt> operator. The other integral types have both.
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add a non-volatile assignment operator to <tt>atomic_bool</tt>.
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 18.6.1.3 [new.delete.placement] as indicated:</p>
++
++<blockquote>
++<pre>
++void* operator new(std::size_t size, void* ptr) noexcept;
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires:</i> <tt>ptr</tt> shall not be a null pointer.</ins>
++<p/>
++-2- <i>Returns:</i> <tt>ptr</tt>.
++<p/>
++-3- <i>Remarks:</i> Intentionally performs no other action.
++<p/>
++-4- [<i>Example:</i> This can be useful for constructing an object at a known address:
++</p><blockquote><pre>
++void* place = operator new(sizeof(Something));
++Something* p = new (place) Something();
++</pre></blockquote>
++<p>
++&mdash; <i>end example</i>]
++</p>
++</blockquote>
++</blockquote>
++<blockquote>
++<pre>
++void* operator new[](std::size_t size, void* ptr) noexcept;
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires:</i> <tt>ptr</tt> shall not be a null pointer.</ins>
++<p/>
++-5- <i>Returns:</i> <tt>ptr</tt>.
++<p/>
++-6- <i>Remarks:</i> Intentionally performs no other action.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1470"></a>1470. [FCD] "Same-ness" curiosities</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a></p>
++<h3><a name="2305"></a>2305. [fund.ts] <tt>optional</tt> forwarding construction/assignment</h3>
++<p><b>Section:</b> X [optional.object.ctor] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Cassio Neri <b>Opened:</b> 2013-09-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-165</b></p>
++<p><b>Addresses: fund.ts</b></p>
+
+-According to 29.6 [atomics.types.operations] p. 23:
+-<p></p><blockquote>
+-“is the same that same as that of” is not grammatical (and is not clear)
+-</blockquote><p></p>
++<p>
++Consider:
++</p>
++<blockquote><pre>
++struct foo {
++ foo(std::initializer_list&lt;int&gt;&amp;); // 1
++ foo(const std::initializer_list&lt;int&gt;&amp;); // 2
++ foo(std::initializer_list&lt;int&gt;&amp;&amp;); // 3
++ foo(const std::initializer_list&lt;int&gt;&amp;&amp;); // 4
++};
+
++std::initializer_list&lt;int&gt; il{0, 1, 2};
+
++foo foo_0{1, 2, 3}; // calls 3
++foo foo_1{il}; // calls 1
++foo foo_2((const std::initializer_list&lt;int&gt;&amp;) il); // calls 2
++foo foo_3{(std::initializer_list&lt;int&gt;&amp;&amp;) il}; // calls 3
++foo foo_4((const std::initializer_list&lt;int&gt;&amp;&amp;) il); // calls 4
++</pre></blockquote>
++<p>
++Although the constructors of <tt>foo</tt> are unusual (<tt>initializer_list</tt>s are <i>normally</i> passed by
++value) users of <tt>optional</tt> could naturally expect perfect forwarding of <tt>initializer_list</tt>s. However,
++all lines below end up calling 1.
++</p>
++<blockquote><pre>
++optional&lt;foo&gt; opt0{in_place, {1, 2, 3}};
++optional&lt;foo&gt; opt1{in_place, il};
++optional&lt;foo&gt; opt3{in_place, (const std::initializer_list&lt;int&gt;&amp;) il};
++optional&lt;foo&gt; opt2{in_place, (std::initializer_list&lt;int&gt;&amp;&amp;) il};
++optional&lt;foo&gt; opt4{in_place, (const std::initializer_list&lt;int&gt;&amp;&amp;) il};
+
+-<p><b>Proposed resolution:</b></p>
++opt0.emplace({1, 2, 3});
++opt0.emplace(il);
++opt0.emplace((const std::initializer_list&lt;int&gt;&amp;) il);
++opt0.emplace((std::initializer_list&lt;int&gt;&amp;&amp;) il);
++opt0.emplace((const std::initializer_list&lt;int&gt;&amp;&amp;) il);
++</pre></blockquote>
++<p>
++The constructor
++</p>
++<blockquote><pre>
++template &lt;class... Args&gt; constexpr explicit optional(in_place_t, Args&amp;&amp;... args);
++</pre></blockquote>
++<p>
++can handle all constructor calls above, except the one taking <tt>{1, 2, 3}</tt>. Hence, a simple
++<ins>modification</ins> of
++</p>
++<blockquote><pre>
++template &lt;class U, class... Args&gt;
++constexpr explicit optional(in_place_t, initializer_list&lt;U&gt;<ins>&amp;&amp;</ins> il, Args&amp;&amp;... args);
++</pre></blockquote>
++<p>
++allows perfect forwarding of <tt>std::initializer_list&lt;U&gt;</tt>s to be complete.
++</p>
+
++<p><i>[2014-06-06 pre-Rapperswil]</i></p>
+
++<p>
++This issue has been reopened as fundamentals-ts.
++</p>
+
++<p><i>[2014-06-17, Rapperswil]</i></p>
+
++<p>
++Move to NAD
++</p>
+
+-<hr>
+-<h3><a name="1471"></a>1471. [FCD] Default constructor of atomics needs specification</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-18</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-168</b></p>
+
+-29.6 [atomics.types.operations] around p. 4: The definition of the default constructor needs exposition.
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
+
++<ol>
++<li><p>Change X [optional.object.ctor] as indicated:</p>
+
+-<p><b>Proposed resolution:</b></p>
+-Insert a new general prototype description following the current 29.6 [atomics.types.operations] p. 3 as indicated:
++<blockquote><pre>
++template &lt;class U, class... Args&gt;
++constexpr explicit optional(in_place_t, initializer_list&lt;U&gt;<ins>&amp;&amp;</ins> il, Args&amp;&amp;... args);
++</pre><blockquote>
+ <p>
++-27- <i>Requires</i>: <tt>is_constructible&lt;T, initializer_list&lt;U&gt;&amp;<ins>&amp;</ins>, Args&amp;&amp;...>::value</tt> is <tt>true.</tt>
++<p/>
++-28- <i>Effects</i>: Initializes the contained value as if constructing an object of type <tt>T</tt> with the arguments
++<tt><del>il</del><ins>std::move(il)</ins></tt>, <tt>std::forward&lt;Args&gt;(args)...</tt>.
++<p/>
++[&hellip;]
++<p/>
++<del>-31- <i>Remarks</i>: The function shall not participate in overload resolution unless
++<tt>is_constructible&lt;T, initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...&gt;::value</tt> is <tt>true</tt>.</del>
+ </p>
+-<blockquote>
+-3 [<em>Note</em>: Many operations are volatile-qualified. The “volatile as device register” semantics have not changed
+-in the standard. This qualification means that volatility is preserved when applying these operations to
+-volatile objects. It does not mean that operations on non-volatile objects become volatile. Thus, volatile
+-qualified operations on non-volatile objects may be merged under some conditions. -- <em>end note</em>]
+ </blockquote>
+-<blockquote><pre><ins>A::A() = default;</ins>
++</blockquote>
++</li>
++<li><p>Change X [optional.object.assign] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class U, class... Args&gt;
++void optional&lt;T&gt;::emplace(initializer_list&lt;U&gt;<ins>&amp;&amp;</ins> il, Args&amp;&amp;... args);
+ </pre><blockquote>
+-<ins>? <em>Effects</em>: Leaves the atomic object in an uninitialized state.
+-[<em>Note</em>: These semantics ensure compatiblity with <tt>C</tt>. -- <em>end note</em>]</ins>
+-</blockquote></blockquote>
+-<blockquote><pre>constexpr A::A(C desired);
+-[..]
+-</pre></blockquote>
++<p>
++-27- <i>Requires</i>: <tt>is_constructible&lt;T, initializer_list&lt;U&gt;&amp;<ins>&amp;</ins>, Args&amp;&amp;...>::value</tt> is <tt>true.</tt>
++<p/>
++-28- <i>Effects</i>: Calls <tt>*this = nullopt</tt>. Then initializes the contained value as if constructing an object of
++type <tt>T</tt> with the arguments <tt><del>il</del><ins>std::move(il)</ins></tt>, <tt>std::forward&lt;Args&gt;(args)...</tt>.
++<p/>
++[&hellip;]
++<p/>
++<del>-32- <i>Remarks</i>: This function shall not participate in overload resolution unless
++<tt>is_constructible&lt;T, initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...>::value</tt> is <tt>true.</tt></del>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1472"></a>1472. [FCD] Incorrect semantics of <tt>atomic_init</tt></h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2311"></a>2311. Allocator requirements should be further minimized</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-171</b></p>
+-
+-As of 29.6 [atomics.types.operations] p. 7:
+ <p>
+-The <tt>atomic_init</tt> definition "Non-atomically assigns the
+-value" is not quite correct, as the <tt>atomic_init</tt> purpose is
+-initialization.
+-
++C++11's minimized allocator requirements are great, but they're still requiring more things from users than absolutely necessary.
++</p>
++<ul>
++<li><p>
++They require <tt>X::value_type</tt>, but that can be deduced from <tt>SomeAllocator&lt;T, Args&gt;</tt>.
++</p></li>
++<li><p>
++They require <tt>a1 == a2</tt>, but that could default to <tt>true</tt> as most allocators are stateless.
++</p></li>
++<li><p>
++They require <tt>a1 != a2</tt>, but if we start requiring STL implementations to go through <tt>allocator_traits</tt>
++to provide an <tt>op==</tt> default, we won't need to require <tt>op!=</tt> from users at all. (<tt>std::allocator</tt>,
++of course, would continue to provide <tt>op!=</tt>. Note that this is analogous to <tt>reference</tt>/<tt>const_reference</tt> &mdash;
++<tt>std::allocator</tt> still provides them, but we don't require them from users, and in fact we don't require them to be
++consistent or meaningful if present.)
++</p></li>
++<li><p>
++They require <tt>a == b</tt> and <tt>a != b</tt>. This requirement was not present in C++98/03, it is not necessary
++(<tt>a == b</tt> is always required to be equivalent to rebind-then-compare), and STL implementations don't even need
++to compare allocators of different types directly.
++</p></li>
++</ul>
+
+-</p><p><b>Proposed resolution:</b></p>
+-Change 29.6 [atomics.types.operations] p. 7 as indicated:
+-<blockquote><pre>void atomic_init(volatile A *object, C desired);
+-void atomic_init(A *object, C desired);
+-</pre><blockquote>
+-7 <em>Effects</em>: <del>Non-atomically assigns the value desired to <tt>*object</tt></del><ins>Initializes <tt>*object</tt> with value
+-<tt>desired</tt></ins>. Concurrent access from another thread, even via an atomic operation, constitutes a data race.
+-<ins>[<em>Note</em>: This function should only be applied to objects that have been default constructed. These semantics ensure
+-compatibility with <tt>C</tt>. — <em>end note</em>]</ins>
+-</blockquote></blockquote>
++<p><i>[2014-02-14 Issaquah: Close as NAD]</i></p>
+
++<p>
++Different vendors rely on each of the different elements suggested to be removed.
++</p>
++<p>
++While <tt>value_type</tt> my be deduced as suggested, far too much wording relies on it being available,
++and the standard churn is likely to be much harder than presented here.
++</p>
+
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
+
+-<hr>
+-<h3><a name="1473"></a>1473. [FCD] Incomplete memory order specifications</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD">NAD</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD">NAD</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-172</b></p>
++<ol>
++<li><p>Change in 17.6.3.5 [allocator.requirements], Table 28 &mdash; "Allocator requirements" as indicated:</p>
+
+-As of 29.6 [atomics.types.operations] p. 9, 13, 17, 20:
+-<p>
+-The order specifications are incomplete because the non-<tt>_explicit</tt>
+-functions do not have such parameters.
+-</p><p>
+-Add a new sentence: "If the program does not specify an order, it shall be
+-<tt>memory_order_seq_cst</tt>." Or perhaps: "The non-_explicit
+-non-member functions shall affect memory as though they were _explicit with
+-<tt>memory_order_seq_cst</tt>."
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-</p><p><i>[
+-2010 Batavia
+-]</i></p>
++<tr>
++<td>
++<tt>X::value_type</tt>
++</td>
++<td>
++Identical to <tt>T</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<ins>See Note B, below.</ins>
++</td>
++</tr>
+
+-<p>
+-The Concurrency subgroup reviewed this, and deemed it NAD according to
+-29.6 [atomics.types.operations] paragraph 2, bullet 4.
+-</p>
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-<p><b>Rationale:</b></p>The working paper is correct as written.
++<tr>
++<td>
++<tt>a1 == a2</tt>
++</td>
++<td>
++<tt>bool</tt>
++</td>
++<td>
++returns <tt>true</tt> only if storage<br/>
++allocated from each can be<br/>
++deallocated via the other.<br/>
++<tt>operator==</tt> shall be reflexive,<br/>
++symmetric, and transitive, and<br/>
++shall not exit via an exception.<br/>
++</td>
++<td>
++<ins><tt>true</tt></ins>
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>a1 != a2</tt></del>
++</td>
++<td>
++<del><tt>bool</tt></del>
++</td>
++<td>
++<del>same as <tt>!(a1 == a2)</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
+
++<tr>
++<td>
++<del><tt>a == b</tt></del>
++</td>
++<td>
++<del><tt>bool</tt></del>
++</td>
++<td>
++<del>same as <tt>a ==<br/>
++Y::rebind&lt;T&gt;::other(b)</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>Change 29.6 [atomics.types.operations] p. 9 as indicated:
+-<blockquote><pre>void atomic_store(volatile A* object, C desired);
+-void atomic_store(A* object, C desired);
+-void atomic_store_explicit(volatile A *object, C desired, memory_order order);
+-void atomic_store_explicit(A* object, C desired, memory_order order);
+-void A::store(C desired, memory_order order = memory_order_seq_cst) volatile;
+-void A::store(C desired, memory_order order = memory_order_seq_cst);
+-</pre><blockquote>
+-8 <em>Requires</em>: The order argument shall not be <tt>memory_order_consume</tt>, <tt>memory_order_acquire</tt>, nor
+-<tt>memory_order_acq_rel</tt>.
+-<p>
+-9 <em>Effects</em>: Atomically replaces the value pointed to by <tt>object</tt> or by this with the value of <tt>desired</tt>.
+-Memory is affected according to the value of <tt>order</tt>. <ins>If the program does not specify an order, it shall be
+-<tt>memory_order_seq_cst</tt>.</ins>
+-</p></blockquote></blockquote>
+-</li>
+-<li>Change 29.6 [atomics.types.operations] p. 13 as indicated:
+-<blockquote><pre>C atomic_load(const volatile A* object);
+-C atomic_load(const A* object);
+-C atomic_load_explicit(const volatile A* object, memory_order);
+-C atomic_load_explicit(const A* object, memory_order);
+-C A::load(memory_order order = memory_order_seq_cst) const volatile;
+-C A::load(memory_order order = memory_order_seq_cst) const;
+-</pre><blockquote>
+-12 <em>Requires</em>: The order argument shall not be <tt>memory_order_release</tt> nor <tt>memory_order_acq_rel</tt>.
+-<p>
+-13 <em>Effects</em>: Memory is affected according to the value of <tt>order</tt>. <ins>If the program does not specify an order, it shall be
+-<tt>memory_order_seq_cst</tt>.</ins>
+-</p><p>
+-14 <em>Returns</em>: Atomically returns the value pointed to by <tt>object</tt> or by <tt>this</tt>.
+-</p></blockquote></blockquote>
+-</li>
+-<li>Change 29.6 [atomics.types.operations] p. 17 as indicated:
+-<blockquote><pre>C atomic_exchange(volatile A* object, C desired);
+-C atomic_exchange(A* object, C desired);
+-C atomic_exchange_explicit(volatile A* object, C desired, memory_order);
+-C atomic_exchange_explicit(A* object, C desired, memory_order);
+-C A::exchange(C desired, memory_order order = memory_order_seq_cst) volatile;
+-C A::exchange(C desired, memory_order order = memory_order_seq_cst);
+-</pre><blockquote>
+-17 <em>Effects</em>: Atomically replaces the value pointed to by <tt>object</tt> or by <tt>this</tt> with <tt>desired</tt>. Memory
+-is affected according to the value of <tt>order</tt>. These operations are atomic read-modify-write operations
+-(1.10). <ins>If the program does not specify an order, it shall be <tt>memory_order_seq_cst</tt>.</ins>
+-<p>
+-18 <em>Returns</em>: Atomically returns the value pointed to by <tt>object</tt> or by <tt>this</tt> immediately before the effects.
+-</p></blockquote></blockquote>
+-</li>
+-<li>Change 29.6 [atomics.types.operations] p. 20 as indicated:
+-<blockquote><pre>bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
+-bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
+-bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
+-bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
+-bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired,
+- memory_order success, memory_order failure);
+-bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired,
+- memory_order success, memory_order failure);
+-bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired,
+- memory_order success, memory_order failure);
+-bool atomic_compare_exchange_strong_explicit(A* object, C * expected, C desired,
+- memory_order success, memory_order failure);
+-bool A::compare_exchange_weak(C &amp; expected, C desired,
+- memory_order success, memory_order failure) volatile;
+-bool A::compare_exchange_weak(C &amp; expected, C desired,
+- memory_order success, memory_order failure);
+-bool A::compare_exchange_strong(C &amp; expected, C desired,
+- memory_order success, memory_order failure) volatile;
+-bool A::compare_exchange_strong(C &amp; expected, C desired,
+- memory_order success, memory_order failure);
+-bool A::compare_exchange_weak(C &amp; expected, C desired,
+- memory_order order = memory_order_seq_cst) volatile;
+-bool A::compare_exchange_weak(C &amp; expected, C desired,
+- memory_order order = memory_order_seq_cst);
+-bool A::compare_exchange_strong(C &amp; expected, C desired,
+- memory_order order = memory_order_seq_cst) volatile;
+-bool A::compare_exchange_strong(C &amp; expected, C desired,
+- memory_order order = memory_order_seq_cst);
+-</pre><blockquote>
+-19 <em>Requires</em>: The <tt>failure</tt> argument shall not be <tt>memory_order_release</tt> nor <tt>memory_order_acq_rel</tt>.
+-The <tt>failure</tt> argument shall be no stronger than the success argument.
+-<p>
+-20 <em>Effects</em>: Atomically, compares the contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt> for equality
+-with that in <tt>expected</tt>, and if true, replaces the contents of the memory pointed to by <tt>object</tt> or by
+-<tt>this</tt> with that in <tt>desired</tt>, and if false, updates the contents of the memory in expected with the
+-contents of the memory pointed to by <tt>object</tt> or by <tt>this</tt>. Further, if the comparison is true, memory
+-is affected according to the value of <tt>success</tt>, and if the comparison is false, memory is affected
+-according to the value of <tt>failure</tt>. When only one <tt>memory_order</tt> argument is supplied, the value of
+-<tt>success</tt> is <tt>order</tt>, and the value of <tt>failure</tt> is <tt>order</tt> except that a value of
+-<tt>memory_order_acq_rel</tt> shall be replaced by the value <tt>memory_order_acquire</tt> and a value of
+-<tt>memory_order_release</tt> shall be replaced by the value <tt>memory_order_relaxed</tt>. <ins>If
+-the program does not specify an order, it shall be <tt>memory_order_seq_cst</tt>.</ins> If the operation returns <tt>true</tt>,
+-these operations are atomic read-modify-write operations (1.10). Otherwise, these operations are atomic load operations.
+-</p><p>
+-[..]
+-</p></blockquote></blockquote>
+-</li>
+-</ol>
++<tr>
++<td>
++<del><tt>a != b</tt></del>
++</td>
++<td>
++<del><tt>bool</tt></del>
++</td>
++<td>
++<del>same as <tt>!(a == b)</tt></del>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++<tr>
++<td>
++<tt>X a(b);</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++Shall not exit via an exception.<br/>
++post: <tt>Y(a) == b</tt>, <tt>a == X(b)</tt>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
+
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
++<tr>
++<td>
++<tt>X a(move(b));</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++Shall not exit via an exception.<br/>
++post: <tt>a</tt> equals the prior value of <tt>X(b)</tt>.
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
+
+-<hr>
+-<h3><a name="1475"></a>1475. [FCD] weak compare-and-exchange confusion II</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a></p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CH-23</b></p>
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
+
+-29.6 [atomics.types.operations] p. 23: The first sentence has non-English syntax.
++</table>
++</blockquote>
+
+-<p><i>[
+-Resolution proposed in ballot comment:
+-]</i></p>
++</li>
+
++<li><p>After 17.6.3.5 [allocator.requirements] p3, add a new paragraph:</p>
+
++<blockquote>
+ <p>
+-Change to "The weak compare-and-exchange
+-operations may fail spuriously, that is, return false
+-while leaving the contents of memory pointed to
+-by expected unchanged."
++<ins>Note B: If <tt>Allocator</tt> is a class template instantiation of the form <tt>SomeAllocator&lt;T, Args&gt;</tt>,
++where <tt>Args</tt> is zero or more type arguments, and <tt>Allocator</tt> does not supply a nested type named <tt>value_type</tt>,
++the standard <tt>allocator_traits</tt> template uses <tt>T</tt> in place of <tt>Allocator::value_type</tt> by default.
++For allocator types that are not template instantiations of the above form, no default is provided.</ins>
+ </p>
++</blockquote>
++</li>
+
++<li><p>In the example provided in 17.6.3.5 [allocator.requirements]/5, delete as indicated:</p>
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote>
++<pre>
++template &lt;class Tp&gt;
++struct SimpleAllocator {
++ <del>typedef Tp value_type;</del>
++ SimpleAllocator(ctor args);
++ template &lt;class T&gt; SimpleAllocator(const SimpleAllocator&lt;T&gt;&amp; other);
++ Tp *allocate(std::size_t n);
++ void deallocate(Tp *p, std::size_t n);
++};
+
++<del>template &lt;class T, class U&gt;
++bool operator==(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);
++template &lt;class T, class U&gt;
++bool operator!=(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);</del>
++</pre>
++</blockquote>
+
++</li>
+
++<li><p>Edit 20.7.8 [allocator.traits]p1, class template <tt>allocator_traits</tt> synopsis, as indicated:</p>
+
++<blockquote><pre>
++namespace std {
++ template &lt;class Alloc&gt; struct allocator_traits {
++ typedef Alloc allocator_type;
+
+-<hr>
+-<h3><a name="1476"></a>1476. [FCD] Ballot Comment US-177</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-07</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a></p>
+-<p><b>Discussion:</b></p>
++ typedef <del>typename Alloc::value_type</del><ins><i>see below</i></ins> value_type;
+
+-<p><b>Addresses US-177</b></p>
++ [&hellip;]
+
+-The first sentence of this paragraph doesn't make sense.
++ static Alloc select_on_container_copy_construction(const Alloc&amp; rhs);
+
+-<p><i>[
+-Resolution proposed in ballot comment
+-]</i></p>
++ <ins>static bool equal(const Alloc&amp; a1, const Alloc&amp; a2) noexcept;</ins>
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>At the beginning of 20.7.8.1 [allocator.traits.types], add a new paragraph:</p>
+
++<blockquote><pre>
++<ins>typedef <i>see below</i> value_type;</ins>
++</pre><blockquote>
+ <p>
+-Figure out what it's supposed to say, and say it.
++<ins><i>Type:</i> <tt>Alloc::value_type</tt> if such a type exists; otherwise, <tt>T</tt> if <tt>Alloc</tt> is a class template
++instantiation of the form <tt>Alloc&lt;T, Args&gt;</tt>, where <tt>Args</tt> is zero or more type arguments; otherwise, the program
++is ill-formed.</ins>
+ </p>
++</blockquote></blockquote>
++</li>
+
++<li><p>At the end of 20.7.8.2 [allocator.traits.members], add a new paragraph:</p>
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote><pre>
++<ins>static bool equal(const Alloc&amp; a1, const Alloc&amp; a2) noexcept;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Returns:</i> <tt>a1 == a2</tt> if that expression is well-formed; otherwise, <tt>true</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1477"></a>1477. [FCD] weak compare-and-exchange confusion III</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Dup">Dup</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-31</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Dup">Dup</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a></p>
++<h3><a name="2327"></a>2327. Non-power-of-two URNGs should be forbidden</h3>
++<p><b>Section:</b> 26.5.1.3 [rand.req.urng] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.urng">issues</a> in [rand.req.urng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-135</b></p>
++<p>
++26.5.1.3 [rand.req.urng] allows URNGs with non-power-of-two (NPOT) ranges, like <tt>[0, 1729]</tt>. This is unnecessarily permissive
++(I cannot imagine a realistic source of randomness that would generate such a range) and has real costs for implementers, as
++<tt>uniform_int_distribution</tt> must be prepared to accept such URNGs. The most efficient way to accumulate randomness is to
++concatenate random bits, so NPOT randomness is not just useless, it is actively harmful (to avoid bias, if a URNG generates a
++random number outside of a power-of-two range, the number must be discarded).
++<p/>
++Forbidding NPOT URNGs wouldn't affect users, and would simplify Standard Library implementations. It would be nice to require
++<tt>min()</tt> to be <tt>0</tt>, but this is not necessary; it is simple for implementations to say <tt>g() - G::min()</tt> and
++this will optimize away if <tt>min()</tt> is <tt>0</tt>. (It is vaguely plausible for a URNG to have a nonzero minimum; I can
++imagine something that simply masks off low-order bits without shifting the rest downwards.) What is important is for the entire
++range to have a power-of-two width; <tt>[1729, 1984]</tt> is acceptable as its size is 256.
++</p>
+
+-The first sentence of 29.6 [atomics.types.operations] p.23 was changed by n2992 but
+-now makes no sense: "that is, return <tt>false</tt> while leaving
+-the contents of memory pointed to by <tt>expected</tt> before the
+-operation is the same that same as that of the <tt>object</tt> and
+-the same as that of <tt>expected</tt> after the operation."
+-There's a minor editorial difference between n2992 ("is
+-that same as that" vs "is the same that same as that") but
+-neither version makes sense.
+-Also, the remark talks about "<tt>object</tt>" which should
+-probably be "<tt>object</tt> or <tt>this</tt>" to cover the member functions
+-which have no object parameter.
++<p><i>[2013-10-12: Howard presents a counterexample]</i></p>
+
+-<p><i>[
+-Resolution proposed in ballot comment:
+-]</i></p>
+
+ <p>
+-Fix the Remark to say whatever was intended.
++Consider:
+ </p>
++<blockquote><pre>
++#include &lt;random&gt;
++#include &lt;string&gt;
++#include &lt;iostream&gt;
+
++template &lt;class Int&gt;
++bool is_power_2m1(Int i)
++{
++ return (i &amp; (i + 1)) == 0;
++}
+
++template &lt;class URNG&gt;
++void test(const std::string&amp; urng)
++{
++ using namespace std;
++ typename URNG::result_type rng = URNG::max() - URNG::min();
++ if (!is_power_2m1(rng))
++ {
++ cout &lt;&lt; hex;
++ cout &lt;&lt; urng &lt;&lt; " : min = " &lt;&lt; URNG::min() &lt;&lt; ", max = " &lt;&lt; URNG::max()
++ &lt;&lt; ", max-min = " &lt;&lt; rng &lt;&lt; '\n';
++ }
++};
+
+-<p><b>Proposed resolution:</b></p>
+-
++int main()
++{
++ using namespace std;
++ test&lt;minstd_rand0&gt;("minstd_rand0");
++ test&lt;minstd_rand&gt;("minstd_rand");
++ test&lt;mt19937&gt;("mt19937");
++ test&lt;mt19937_64&gt;("mt19937_64");
++ test&lt;ranlux24_base&gt;("ranlux24_base");
++ test&lt;ranlux48_base&gt;("ranlux48_base");
++ test&lt;ranlux24&gt;("ranlux24");
++ test&lt;ranlux48&gt;("ranlux48");
++ test&lt;knuth_b&gt;("knuth_b");
++}
++</pre></blockquote>
+
++<p>
++Which for me outputs:
++</p>
+
++<blockquote><pre>
++minstd_rand0 : min = 1, max = 7ffffffe, max-min = 7ffffffd
++minstd_rand : min = 1, max = 7ffffffe, max-min = 7ffffffd
++knuth_b : min = 1, max = 7ffffffe, max-min = 7ffffffd
++</pre></blockquote>
+
++<p>
++We do not want to outlaw these three URNG's, and the proposed wording would do that.
++</p>
+
+-<hr>
+-<h3><a name="1483"></a>1483. [FCD] <tt>__STDCPP_THREADS spelling</tt></h3>
+-<p><b>Section:</b> 30.3 [thread.threads] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses DE-23</b></p>
++<p><i>[Issaquah 2014-02-10: Moved to NAD]</i></p>
+
+-Predefined macros usually start and end with two
+-underscores, see 16.8 and FDIS 29124 = WG21 N3060
+-clause 7. __STDCPP_THREADS should blend in.
++<p>
++STL withdraws the issue, non-power-of-2 URNGs are used in the field, it is too late to consider removing them.
++</p>
+
+-<p><i>[
+-Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+-]</i></p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
+
++<ol>
++<li><p>Add a new paragraph at the end of 26.5.1.3 [rand.req.urng] as indicated:</p>
+
+-<p><b>Proposed resolution:</b></p>
+-Change the macro name to
+-__STDCPP_THREADS__.
++<blockquote>
++<p>
++-3- The following relation shall hold: <tt>G::min() &lt; G::max()</tt>.
++<p/>
++<ins>-?- <tt>G::max() - G::min()</tt> shall be 2<sup><tt>n</tt></sup> - 1 for some <tt>n &gt; 0</tt>.</ins>
++</p>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1484"></a>1484. [FCD] Need a way to join a thread with a timeout</h3>
+-<p><b>Section:</b> 30.3.1 [thread.thread.class] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2345"></a>2345. <tt>integer_sequence</tt> should have a self-typedef <tt>::type</tt></h3>
++<p><b>Section:</b> 20.5.2 [intseq.intseq] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-183</b></p>
+-
+-There is no way to join a thread with a timeout.
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+-<blockquote>
+-Add <tt>join_for</tt> and <tt>join_until</tt>. Or decide one should
+-never join a thread with a timeout since <tt>pthread_join</tt> doesn't have a
+-timeout version.
+-</blockquote>
++<p>
++20.10.3 [meta.help] says that <tt>integral_constant&lt;T, v&gt;</tt> provides <tt>::value_type</tt> (for <tt>T</tt>)
++and <tt>::type</tt> (for itself).
++<p/>
++20.5.2 [intseq.intseq] says that <tt>integer_sequence&lt;T, I...&gt;</tt> provides <tt>::value_type</tt> (for <tt>T</tt>),
++but nothing for itself.
++<p/>
++Self-typedefs can be useful when users create chains of derived classes, then want to get the Standard base type.
++This is especially relevant to <tt>integer_sequence</tt>, as variadic templates encourage recursive inheritance.
++</p>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++<p><i>[2014-02-13 Issaquah: Close as NAD]</i></p>
+
+ <p>
+-The concurrency working group deemed this an extension beyond the scope of C++0x.
++AJM: My own implementation used a different alias for types representing parameter packs, and specifically
++did <em>not</em> define <tt>type</tt>. I tried it both ways, and found bugs more quickly when <tt>type</tt> was
++not defined.
+ </p>
+-<p><b>Rationale:</b></p>The LWG does not wish to make a change at this time.
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
+
++<ol>
++<li><p>Edit 20.5.2 [intseq.intseq] as indicated:</p>
+
++<blockquote><pre>
++namespace std {
++ template&lt;class T, T... I&gt;
++ struct integer_sequence {
++ typedef T value_type;
++ <ins>typedef integer_sequence&lt;T, I...&gt; type;</ins>
++ static constexpr size_t size() noexcept { return sizeof...(I); }
++ };
++}
++</pre></blockquote>
++</li>
+
++</ol>
+
+
+-<hr>
+-<h3><a name="1488"></a>1488. [FCD] Improve interoperability between
+-the C++0x and C1x threads APIs</h3>
+-<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-185</b></p>
+-
+-Cooperate with WG14 to improve interoperability between
+-the <tt>C++0x</tt> and <tt>C1x</tt> threads APIs. In particular, <tt>C1x</tt>
+-mutexes should be conveniently usable with a <tt>C++0x</tt>
+-<tt>lock_guard</tt>. Performance overheads for this combination
+-should be considered.
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+
+-<blockquote>
+-Remove <tt>C++0x</tt> <tt>timed_mutex</tt> and
+-<tt>timed_recursive_mutex</tt> if that facilitates
+-development of more compatible APIs.
+-</blockquote>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
+
++<hr>
++<h3><a name="2347"></a>2347. <tt>reverse_iterator::operator[]</tt> calls const version of <tt>current[]</tt></h3>
++<p><b>Section:</b> 24.5.1.3.12 [reverse.iter.opindex] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Timo Bingmann <b>Opened:</b> 2013-11-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iter.opindex">issues</a> in [reverse.iter.opindex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-The concurrency sub-group reviewed the options, and decided that closer harmony should wait until both standards are published.
++Currently <tt>reverse_iterator::operator[]()</tt> returns "<tt>current[-n-1]</tt>" and has
++an "<em>unspecified</em>" return type.
++<p/>
++When <tt>Iterator</tt> is a mutable random access iterator, the expression
++"<tt>current[-n-1]</tt>" calls "<tt>Iterator::operator[] const</tt>", which returns a
++const reference. This const reference cannot be converted back to a
++mutable reference.
++<p/>
++This issue is related to the "<em>unspecified</em>" return value of
++<tt>reverse_iterator::operator[]</tt>, see defect <a href="lwg-defects.html#386">386</a>.
++<p/>
++The -1 is due to "current" pointing one item beyond the
++<tt>reverse_iterator</tt>'s real current value.
++<p/>
++The current libstdc++ implementation reads "<tt>*(current + n)</tt>" for
++<tt>reverse_iterator::operator[]</tt>.
++<p/>
++This copied <tt>current</tt>, advances (backwards) via <tt>operator+</tt> and
++dereferences. It bypasses the issues due to <tt>reverse_iterator::operator[]</tt>
++being const by copying the iterator.
+ </p>
+
+-<p><b>Rationale:</b></p>
+-The LWG does not wish to make any change at this time.
+-
++<p><i>[2014-02-13 Issaquah : close as NAD]</i></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
+
++<ol>
++<li><p>Edit 24.5.1.1 [reverse.iterator], class template <tt>reverse_iterator</tt> synopsis, as indicated:</p>
+
++<blockquote><pre>
++namespace std {
++ template &lt;class Iterator&gt;
++ class reverse_iterator : public
++ iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
++ typename iterator_traits&lt;Iterator&gt;::value_type,
++ typename iterator_traits&lt;Iterator&gt;::difference_type,
++ typename iterator_traits&lt;Iterator&gt;::pointer,
++ typename iterator_traits&lt;Iterator&gt;::reference> {
++ public:
++ [&hellip;]
++ <del><em>unspecified</em></del><ins>reference</ins> operator[](difference_type n) const;
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
+
++<li><p>Edit 24.5.1.3.12 [reverse.iter.opindex] as indicated:</p>
+
++<blockquote><pre>
++<del><em>unspecified</em></del><ins>reference</ins> operator[](
++ typename reverse_iterator&lt;Iterator&gt;::difference_type n) const;
++</pre><blockquote>
++<p>
++-1- <i>Returns:</i> <tt><del>current[-n-1]</del><ins>*(current + n)</ins></tt>.
++</p>
++</blockquote></blockquote>
++</li>
+
+-<hr>
+-<h3><a name="1489"></a>1489. [FCD] <tt>unlock</tt> functions and unlock
+-mutex requirements are inconsistent</h3>
+-<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses CH-26</b></p>
+-
+-Specifications of <tt>unlock</tt> member functions and <tt>unlock</tt>
+-mutex requirements are inconsistent wrt to exceptions and
+-pre- and postconditions.
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+-<blockquote>
+-<tt>unlock</tt> should specifiy the precondition that the
+-current thread "owns the lock", this will make calls
+-without holding the locks "undefined behavior".
+-<tt>unlock</tt> in [mutex.requirements] should either be
+-<tt>noexcept(true)</tt> or be allowed to throw
+-<tt>system_error</tt> like <tt>unique_lock::unlock</tt>, or the latter
+-should be <tt>nothrow(true)</tt> and have the precondition
+-<tt>owns == true</tt>.
+-Furthermore <tt>unique_lock</tt>'s postcondition is wrong
+-in the case of a recursive mutex where <tt>owns</tt>
+-might stay true, when it is not the last <tt>unlock</tt>
+-needed to be called.
+-</blockquote>
+-
+-
++</ol>
+
+-<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1493"></a>1493. [FCD] Add <tt>mutex</tt>, <tt>recursive_mutex</tt>, <tt>is_locked</tt> function</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2351"></a>2351. Does <tt>.seed()</tt> completely reset state of engine?</h3>
++<p><b>Section:</b> 26.5.3 [rand.eng] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2013-12-02 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-189</b></p>
+-
+-<tt>mutex</tt> and <tt>recursive_mutex</tt> should have an <tt>is_locked()</tt>
+-member function. <tt>is_locked</tt> allows a user to test a lock
+-without acquiring it and can be used to implement a lightweight
+-<tt>try_try_lock</tt>.
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
+-<blockquote>
+-Add a member function:
+-<pre>bool is_locked() const;
+-</pre>
+-to <tt>std::mutex</tt> and <tt>std::recursive_mutex</tt>. These
+-functions return true if the current thread would
+-not be able to obtain a mutex. These functions do
+-not synchronize with anything (and, thus, can
+-avoid a memory fence).
+-</blockquote>
++<p>
++With regard to Random number engine class templates 26.5.3 [rand.eng],
++the Standard can be read in two different ways: when the member function
++</p>
++<blockquote><pre>
++.seed(result_type s = default_seed)
++</pre></blockquote>
++<p>
++is invoked, is all associated state (such as carry) reset to the same
++state that would have been created by the constructor
++</p>
++<blockquote><pre>
++explicit <em>engine-type</em>(result_type s = default_seed)
++</pre></blockquote>
++<p>
++or is the exact state unspecified?
++<p/>
++Implementations differ.
++</p>
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++<p><i>[2014-02-13, Issaquah]</i></p>
+
+ <p>
+-The Concurrency subgroup reviewed this issue and deemed it to be an extension to be handled after publishing C++0x.
++Walter Brown says that Table 117 makes this very clear, and that the answer is "Yes"
++<p/>
++Suggested resolution: NAD
+ </p>
+
+-<p><b>Rationale:</b></p>The LWG does not wish to make a change at this time.
++<p><i>[2015-05-05 Lenexa: Move to NAD]</i></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
++Suggested resolution: NAD
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1495"></a>1495. [FCD] Condition variable <tt>wait_for</tt> return insufficient</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2355"></a>2355. <tt>"s"</tt> UDL suffix should be reserved for a compile-time string library type</h3>
++<p><b>Section:</b> 21.7 [basic.string.literals] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Michael Price <b>Opened:</b> 2014-01-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-191</b></p>
+-
+-The condition variable <tt>wait_for</tt> returning <tt>cv_status</tt> is insufficient.
++<p>
++The current draft uses the <tt>"s"</tt> UDL suffix as a UDL for <tt>basic_string&lt;charT&gt;</tt> (21.7 [basic.string.literals]).
++In light of EWG active issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3682.html#66">66</a> (concerning N3599),
++the <tt>"s"</tt> suffix (when applied to character string literals) should be reserved for a compile-time string library type.
++</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><i>[Issaquah 2014-10-12: Move to NAD]</i></p>
+
+-<blockquote>
+-Return a duration of timeout remaining instead.
+-See Appendix 1 of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> - Additional Details, p. 211
+-</blockquote>
+
++<p>We discussed leaving the <tt>s</tt> UDL suffix for <tt>string_view</tt> in Portland, and voted strongly in favor of using it for <tt>std::string</tt>.
++<tt>string</tt> is also an extremely widely used type, and the difference is observable in type deduction cases.
++In addition, a compile-time string is likely to cost significant compile time, which we don't want to make the default with <tt>s</tt>.</p>
++<table>
++ <caption>Mark 2355 as NAD?</caption>
++ <tr><td>SF</td><td>F</td><td>N</td><td>A</td><td>SA</td></tr>
++ <tr><td>8</td> <td>4</td><td>0</td><td>2</td><td>0</td></tr>
++</table>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -50838,28 +42041,34 @@ See Appendix 1 of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/20
+
+
+ <hr>
+-<h3><a name="1496"></a>1496. [FCD] <tt>condition_variable</tt> not implementable</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2373"></a>2373. Make new entities and names in namespace <tt>std</tt> conforming extensions</h3>
++<p><b>Section:</b> 17.6.5 [conforming] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Chandler Carruth <b>Opened:</b> 2014-03-22 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#conforming">issues</a> in [conforming].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-28</b></p>
++<p>
++Technically, right now, it is not a conforming extension to add a new function to namespace <tt>std</tt>. Doing so could cause
++unqualified lookup on the name of that function in the presence of a using directive to find a different function. This seems
++an unreasonable restriction on library vendors providing conforming extensions, as such a using directive seems inherently risky
++in unqualified name lookup.
++</p>
++<p>
++17.6.5.5 [member.functions] implies that adding overloads to a method <em>is</em> a conforming extension, and within some
++limits the same is true for global functions due to 17.6.5.4 [global.functions].
++<p/>
++It would likely be useful to specify that other new entities are valid conforming extensions, or preclude them where they pose
++serious compatibility problems.
++</p>
+
+-Requiring wait_until makes it impossible to implement
+-condition_variable correctly using respective objects
+-provided by the operating system (i.e. implementing the
+-native_handle() function) on many platforms (e.g. POSIX,
+-Windows, MacOS X) or using the same object as for the
+-condition variable proposed for C.
++<p><i>[Lenexa 2015-05-06: Move to NAD]</i></p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p>JY: It's a design question, move to LEWG?</p>
++<p>AM: NAD: extensions led to us being unable to use the names hash_map, leading to unordered_map etc. Will result in collisions between members.</p>
++<p>MC: Agrees, implementations that extend std:: must use __ugly_names for this reason.</p>
++<p>JY: I would not oppose NAD.</p>
++<p>Move to NAD, consensus.</p>
+
+-<blockquote>
+-Remove the <tt>wait_until</tt> functions or make them at least conditionally supported.
+-</blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -50869,36 +42078,120 @@ Remove the <tt>wait_until</tt> functions or make them at least conditionally sup
+
+
+ <hr>
+-<h3><a name="1499"></a>1499. [FCD] Condition variables preclude wakeup optimization</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Future">NAD Future</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Future">NAD Future</a> status.</p>
++<h3><a name="2382"></a>2382. Unclear order of container update versus object destruction on removing an object</h3>
++<p><b>Section:</b> 17.6.5.8 [reentrancy] <b>Status:</b> <a href="lwg-active.html#NAD">Pending NAD</a>
++ <b>Submitter:</b> Peter Kasting <b>Opened:</b> 2014-05-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reentrancy">issues</a> in [reentrancy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Pending NAD">Pending NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-193</b></p>
+-
+-Condition variables preclude a wakeup optimization.
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p>
++The standard does not seem to discuss reentrant access to a container during removal of an element,
++leaving it unclear whether a removed object is destroyed before or after it is removed from the container.
++For example, the behavior of the following code seems to be unspecified:
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;map&gt;
++#include &lt;memory&gt;
++
++struct T;
++typedef std::map&lt;int, std::shared_ptr&lt;T&gt;&gt; TMap;
++
++struct T {
++ T(TMap* t_map, int index) : t_map(t_map), index(index) {}
++ ~T() {
++ std::cout &lt;&lt; "Object " &lt;&lt; index &lt;&lt; " is ";
++ if (t_map->count(index))
++ std::cout &lt;&lt; "destroyed before being removed from the map" &lt;&lt; std::endl;
++ else
++ std::cout &lt;&lt; "removed from the map before being destroyed" &lt;&lt; std::endl;
++ }
+
++ static void AddToMap(TMap* map, int index) {
++ (*map)[index] = std::make_shared&lt;T&gt;(map, index);
++ }
+
+-<blockquote>
+-Change condition_variable to allow such
+-optimization. See Appendix 1 - Additional Details
+-</blockquote>
++ TMap* t_map;
++ int index;
++};
+
+-<p><i>[
+-2010 Batavia
+-]</i></p>
++int main()
++{
++ TMap t_map;
++ T::AddToMap(&amp;t_map, 0);
++ T::AddToMap(&amp;t_map, 1);
++ t_map.erase(1);
++ t_map.erase(0);
++}
++</pre></blockquote>
++<p>
++The output of this program in Visual Studio 2013 is:
++</p>
++<blockquote><pre>
++Object 1 is removed from the map before being destroyed
++Object 0 is destroyed before being removed from the map
++</pre></blockquote>
++<p>
++The core issue here is whether an object removed from a container should be destroyed before or after
++it is removed from the container. The current standard seems to be silent on this issue.
++The above output demonstrates that the behavior is actually inconsistent. (It's difficult to fully
++describe Visual Studio's behavior; for example, changing <tt>main()</tt> in the above example to the following:)
++</p>
++<blockquote><pre>
++int main()
++{
++ TMap t_map;
++ T::AddToMap(&amp;t_map, 0);
++ T::AddToMap(&amp;t_map, 1);
++ T::AddToMap(&amp;t_map, 2);
++ T::AddToMap(&amp;t_map, 3);
++ t_map.erase(3);
++ t_map.clear();
++}
++</pre></blockquote>
++<p>
++(...gives this output:)
++</p>
++<blockquote><pre>
++Object 3 is removed from the map before being destroyed
++Object 2 is destroyed before being removed from the map
++Object 1 is destroyed before being removed from the map
++Object 0 is removed from the map before being destroyed
++</pre></blockquote>
++<p>
++In my opinion, the standard should explicitly describe when objects are destroyed as part of removal from a container.
++To me, it makes the most sense to say that objects should be removed from the container before they are destroyed.
++</p>
++<p><i>[2014-05-07, Jeffrey Yasskin comments]</i></p>
+
+ <p>
+-The Concurrency subgroup reviewed the issue, and deemed it an extension to be handled after C++0x.
++I think there are two main points here beyond this writeup:
++</p>
++<ol>
++<li><p>We can't make recursive use of a standard library container valid
++in all cases.</p></li>
++<li><p>If recursion through especially <tt>erase()</tt> is undefined behavior,
++that's pretty scary for existing large applications with code in
++destructors. Of course, "scary" doesn't mean we have to define the
++behavior.</p></li>
++</ol>
++<p>
++I'll add a third: The language in 17.6.5.8 [reentrancy] nearly makes this
++undefined behavior already. I think any fix is probably going to live
++there, and extend the current "implementation-defined" on recursive
++reentrancy for individual functions to recursive reentrancy on class
++instances. I'm not sure exactly how to word that.
+ </p>
+
+-<p><b>Rationale:</b></p>The LWG does not wish to make the change at this time.
++<p><i>[2014-06 Rapperswil]</i></p>
+
++<p>
++STL: We need more wording about how container methods can be reentrency.
++<p/>
++Jeffrey: The title for this issue is confusing, what we really want is "reentrancy for objects".
++<p/>
++Alisdair: Should we then close 2382 as NAD with a link to the new issue?
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -50908,221 +42201,426 @@ The Concurrency subgroup reviewed the issue, and deemed it an extension to be ha
+
+
+ <hr>
+-<h3><a name="1500"></a>1500. [FCD] Consider removal of <tt>native_handle()</tt></h3>
+-<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-28</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2386"></a>2386. <tt>function::operator=</tt> handles allocators incorrectly</h3>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2014-05-23 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-32</b></p>
+-
+-Given that the lock type can be something the underlying
+-doesn't know 'native_handle()' is probably
+-unimplementable on essentially all platforms.
+-
+-<p><i>[
+-Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+-]</i></p>
+-
+-
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-Consider the removal of 'native_handle()'.
+-
++<p>
++The <i>Effects</i> clauses for the assignment operator for class template <tt>function</tt> are
++written as code that constructs a temporary <tt>function</tt> and then swaps it with <tt>*this</tt>.
++The intention appears to be that assignment should have the strong exception
++guarantee, i.e., <tt>*this</tt> is not modified if an exception is thrown. However, the current
++description is incorrect when <tt>*this</tt> was constructed using an allocator.
++<p/>
++Part of the problem is the under-specification of <tt>swap</tt>, which does not state the
++allocator requirements or allocator postconditions. If <tt>swap</tt> behaves like the rest of the
++standard library, swapping function objects constructed with different allocators
++would be undefined behavior. Alternatively <tt>swap</tt> could exchange the allocators,
++though I would argue against this specification.
++<p/>
++For either specification of <tt>swap</tt>, the current <i>Effects</i> clauses for <tt>operator=</tt> are
++incorrect. If <tt>swap</tt> does not exchange the allocators, then <tt>operator=</tt> would have
++undefined behavior, which is clearly not desired. If <tt>swap</tt> does exchange the allocators,
++then <tt>operator=</tt> would always leave the left-hand side (lhs) of the assignment with a
++default allocator. The latter would be surprising behavior, as the allocator instance is
++normally unchanged for the lifetime of an object (for good reason), and is certainly not
++reset to default arbitrarily.
++<p/>
++The desired behavior is that assignment would leave the allocator of the lhs
++unchanged. The way to achieve this behavior is to construct the temporary <tt>function</tt>
++using the original allocator. Unfortunately, we cannot describe the desired behavior in
++pure code, because there is no way to name the type-erased value of the allocator.
++(N3916 would improve this situation for the Library Fundamentals TS, but even with
++those changes, there is no way to recover the original type of the allocator.) The PR
++below, therefore, uses pseudo-code, inventing a fictitious <tt><i>ALLOCATOR_OF</i>(f)</tt>
++expression that evaluates to the actual allocator type, even if that allocator was type
++erased. I have implemented this PR successfully.
++</p>
+
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
+
++<ol>
++<li><p>Change 20.9.12.2.1 [func.wrap.func.con] as indicated:</p>
+
++<blockquote>
++<p>
++<ins>In the following descriptions, <tt><i>ALLOCATOR_OF</i>(f)</tt> is a copy of the allocator specified in the
++construction of <tt>function</tt> <tt>f</tt>, or <tt>allocator&lt;char&gt;()</tt> if no allocator was specified.</ins>
++</p>
++<pre>
++function&amp; operator=(const function&amp; f);
++</pre>
++<blockquote>
++<p>
++-12- <i>Effects</i>: <tt>function(<ins>allocator_arg, <i>ALLOCATOR_OF</i>(*this),</ins> f).swap(*this);</tt>
++<p/>
++-13- <i>Returns</i>: <tt>*this</tt>
++</p>
++</blockquote>
++<pre>
++function&amp; operator=(function&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++-14- <i>Effects</i>: <del>Replaces the target of <tt>*this</tt> with the target of <tt>f</tt>.</del><ins><tt>function(allocator_arg,
++<i>ALLOCATOR_OF</i>(*this), std::move(f)).swap(*this);</tt></ins>
++<p/>
++-15- <i>Returns</i>: <tt>*this</tt>
++</p>
++</blockquote>
++<pre>
++function&amp; operator=(nullptr_t);
++</pre>
++<blockquote>
++<p>
++-16- <i>Effects</i>: If <tt>*this != nullptr</tt>, destroys the target of <tt>this</tt>.
++<p/>
++-17- <i>Postconditions</i>: <tt>!(*this)</tt>. <ins>The allocator is unchanged.</ins>
++<p/>
++-18- <i>Returns</i>: <tt>*this</tt>
++<p/>
++<ins>-?- <i>Throws</i>: Nothing.</ins>
++</p>
++</blockquote>
++<pre>
++template&lt;class F&gt; function&amp; operator=(F&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++-19- <i>Effects</i>: <tt>function(<ins>allocator_arg, <i>ALLOCATOR_OF</i>(*this),</ins> std::forward&lt;F&gt;(f)).swap(*this);</tt>
++<p/>
++-20- <i>Returns</i>: <tt>*this</tt>
++<p/>
++-21- <i>Remarks</i>: This assignment operator shall not participate in overload resolution unless
++<tt>declval&lt;typename decay&lt;F&gt;::type&amp;&gt;()</tt> is <tt>Callable</tt> (20.9.11.2) for argument types
++<tt>ArgTypes...</tt> and return type <tt>R</tt>.
++</p>
++</blockquote>
++<pre>
++template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt; f);
++</pre>
++<blockquote>
++<p>
++-22- <i>Effects</i>: <tt>function(<ins>allocator_arg, <i>ALLOCATOR_OF</i>(*this),</ins> f).swap(*this);</tt>
++<p/>
++-23- <i>Returns</i>: <tt>*this</tt>
++</p>
++</blockquote>
+
+-<hr>
+-<h3><a name="1506"></a>1506. [FCD] set_exception with a null pointer</h3>
+-<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-198</b></p>
++</blockquote>
++</li>
+
+-promise::set_exception can be called with a null pointer,
+-but none of the descriptions of the get() functions for the
+-three types of futures say what happens for this case.
++</ol>
+
+-<p><i>[
+-Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+-]</i></p>
++</blockquote>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++STL: think this is NAD, don't think this is implementable or even should be.<br/>
++STL: think this issue should be dealt with the same as 2370, don't think this should be done ever.<br/>
++STL: NAD because there is nothing broken here.<br/>
++STL: already fixed <tt>operator= noexcept</tt> so <i>Throws</i> nothing is not needed<br/>
++STL: nothing to salvage here<br/>
++MC: consensus for NAD
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add the following sentence to the end of
+-30.6.5/22: The behavior of a program that calls
+-set_exception with a null pointer is undefined.
++<p>
++There was consensus by the committee that the issue does not constitute as defect.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1509"></a>1509. [FCD] No restriction on calling <tt>future::get</tt> more than once</h3>
+-<p><b>Section:</b> 30.6.8 [futures.atomic_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2388"></a>2388. Handling self-assignment in the proposed library function <tt>std::exchange</tt></h3>
++<p><b>Section:</b> 20.2.3 [utility.exchange] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Nick Calus <b>Opened:</b> 2014-05-09 <b>Last modified:</b> 2015-05-06</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.exchange">issues</a> in [utility.exchange].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-202</b></p>
+ <p>
+-The note in this paragraph says "unlike <tt>future</tt>, calling <tt>get</tt>
+-more than once on the same <tt>atomic_future</tt> object is well
+-defined and produces the result again." There is nothing
+-in <tt>future</tt> that says anything negative about calling <tt>get</tt>
+-more than once.
++In paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html">N3668</a>, the addition of a template function
++<tt>std::exchange</tt> had been proposed. In the rationale provided by the paper, we find the following:
+ </p>
+-
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+-
++<blockquote>
+ <p>
+-Remove this note, or add words to the
+-requirements for future that reflect what this note
+-says.
++I chose the name for symmetry with <tt>atomic_exchange</tt>, since they behave the same except for this function not being atomic.
+ </p>
+-
+-
+-<p><b>Proposed resolution:</b></p>
+-
+-
+-
+-
+-
+-<hr>
+-<h3><a name="1510"></a>1510. [FCD] Should be undefined behaviour to call <tt>atomic_future</tt> operations unless <tt>valid()</tt></h3>
+-<p><b>Section:</b> 30.6.8 [futures.atomic_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p><b>Addresses US-203</b></p>
++</blockquote>
+ <p>
+-Both <tt>future</tt> and <tt>shared_future</tt> specify that calling most
+-member functions on an object for which <tt>valid() == false</tt>
+-produces undefined behavior. There is no such statement
+-for <tt>atomic_future</tt>.
++and:
++</p>
++<blockquote>
++<p>
++Atomic objects provide an <tt>atomic_exchange</tt> function ([atomics.types.operations.req]p18) that <em>assigns a new value to the object
++and returns the old value</em>. This operation is also useful on non-atomic objects, and this paper proposes adding it to the library.
++<p/>
++But the specified semantics of <tt>std::exchange</tt> is defined as follows:
++</p>
++</blockquote>
++<blockquote><pre>
++template &lt;class T, class U=T&gt; T exchange(T&amp; obj, U&amp;&amp; new_val);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: Equivalent to:
++</p>
++<blockquote><pre>
++T old_val = std::move(obj);
++obj = std::forward&lt;U&gt;(new_val);
++return old_val;
++</pre>
++</blockquote>
++</blockquote>
++</blockquote>
++<p>
++When looking at the post-condition of the <tt>std::exchange</tt> function, one would expect the return value to be the old value
++of <tt>obj</tt> and also that <tt>obj</tt> now contains the value of <tt>new_value</tt>.
++This post-condition is violated when <tt>obj</tt> is a reference to the same object as <tt>new_value</tt> and type <tt>T</tt>
++has move semantics.
++<p/>
++Given it's specification, it is clear that <tt>std::exchange</tt> is meant to be used with types that have move semantics.
++Therefore, the post-condition is violated for self-assignments.
++<p/>
++Suppose the following situation:
++<p/>
++You have a vector of objects. The objects implement move semantics and are emptied when moved from.
++You provide a function that allows you to replace an object at a specific index by a new object (provided by reference as
++an argument to your function). When replacing an object, your function calls a member-function <tt>do_something_fancy</tt>
++on the old object.
++</p>
++<blockquote><pre>
++void your_function(int i, X&amp; new_val) {
++ std::exchange(vec[i], new_val).do_something_fancy();
++}
++</pre></blockquote>
++<p>
++Your function gets called with a given index and the corresponding element of said vector. (by coincidence or by purpose, it
++doesn't really matter)
++</p>
++<blockquote><pre>
++your_function(5, vec[5]);
++</pre></blockquote>
++<p>
++This will cause the object at <tt>vec[5]</tt> to be in an empty state.
++If this object would not implement move semantics, assignment performance is potentially worse, but at least it
++is not in an empty (to my business logic, invalid) state.
++<p/>
++So to me, the current reference implementation of <tt>std::exchange</tt> does not have the behavior it is expected to have.
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><i>[2014-12-18 Telecon]</i></p>
+
+ <p>
+-Add a new paragraph after 30.6.8 [futures.atomic_future]/2 with the same words as
+-30.6.7 [futures.shared_future]/3.
++MC: does this resolution solve the problem?
++<p/>
++JW: and is the cost of the extra construction and move acceptable?
++<p/>
++AM: not all moves are cheap
++<p/>
++VV: seems like a design change
++<p/>
++JW: maybe this should be rolled into my unwritten paper on self-swap, so we deal with them consistently
++<p/>
++VV: we should update the issue saying something like that and maybe NAD Future
++<p/>
++MC: instead, add Requires clause saying the arguments are not the same.
++<p/>
++JW: interesting, that can even be checked in a debug mode assertion
++<p/>
++MC: ACTION: send alternative P/R that we can consider
+ </p>
+
+-<p><i>[
+-2010-11-02 Daniel translates proposed changes into specific deltas and comments:
+-]</i></p>
+-
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
+
++<ol>
++<li><p>Change 20.2.3 [utility.exchange] as indicated:</p>
++<blockquote><pre>
++template &lt;class T, class U=T&gt; T exchange(T&amp; obj, U&amp;&amp; new_val);
++</pre>
+ <blockquote>
+-While applying the wording, I notice that 30.6.7 [futures.shared_future]/3 does
+-speak of the move-assignment operator, and <em>not</em> of the copy-assignment operator.
+-<tt>atomic_future</tt> obviously needs this to be true for the copy-assignment operator,
+-but I strongly assume that <tt>shared_future</tt> needs to mention both special member
+-assignment operators in this paragraph. To keep this consistent, the following P/R also
+-provides wording to fix the corresponding location for <tt>shared_future</tt>.
++<p>
++-1- <i>Effects</i>: Equivalent to:
++</p>
++<blockquote><pre>
++<ins>T tmp = std::forward&lt;U&gt;(new_val);</ins>
++T old_val = std::move(obj);
++obj = <del>std::forward&lt;U&gt;(new_val)</del><ins>std::move(tmp)</ins>;
++return old_val;
++</pre>
++</blockquote>
++</blockquote>
++</blockquote>
++</li>
++</ol>
+ </blockquote>
+
++<p>
++<strong>Previous resolution from Marshall [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
+
+-
+-<p><b>Proposed resolution:</b></p>
+ <ol>
+-<li>Change 30.6.7 [futures.shared_future]/3 as indicated:
++<li><p>Change 20.2.3 [utility.exchange] as indicated:</p>
++<blockquote><pre>
++template &lt;class T, class U=T&gt; T exchange(T&amp; obj, U&amp;&amp; new_val);
++</pre>
+ <blockquote>
+-3 The effect of calling any member function other than the destructor<ins>, the
+-copy-assignment operator</ins>, the move-assignment operator, or <tt>valid()</tt>
+-on a <tt>shared_future</tt> object for which <tt>valid() == false</tt> is undefined.
++<p>
++<ins>-?- <i>Requires</i>: <tt>obj</tt> and <tt>new_val</tt> shall not refer to the same object.</ins>
++<p/>
++-1- <i>Effects</i>: Equivalent to:
++</p>
++<blockquote><pre>
++T old_val = std::move(obj);
++obj = std::forward&lt;U&gt;(new_val);
++return old_val;
++</pre>
++</blockquote>
+ </blockquote>
+-</li>
+-<li>Following 30.6.8 [futures.atomic_future]/2, add a new paragraph:
+-<blockquote>
+-<ins>? The effect of calling any member function other than the destructor, the copy-assignment operator, or <tt>valid()</tt>
+-on a <tt>atomic_future</tt> object for which <tt>valid() == false</tt> is undefined.</ins>
+ </blockquote>
+ </li>
+ </ol>
++</blockquote>
++
++<p><i>[2015-03-30, Marshall provides alternative wording]</i></p>
++
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++MC: self <tt>exchange</tt> does not work<br/>
++MC: PR is just to add requires<br/>
++STL: what if the new thing is a subobject, isn't that just as bad, any aliasing<br/>
++STL: don't know that we need to do anything here if we aren't changing the implementation<br/>
++NM: should remove the requires<br/>
++MC: so NAD<br/>
++STL: could add note<br/>
++NM: remove requires<br/>
++DK: requires isn't already there<br/>
++RL: no note?<br/>
++STL: no note, NAD, burden for next person that asks about aliasing<br/>
++DK: what do we do for <tt>swap</tt>?<br/>
++STL: self <tt>swap</tt> has always been noop, <tt>exchange</tt> could do something bad because it clears out<br/>
++MC: alright, NAD it is<br/>
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++The current specification is clear about the implications described by the issue example and is as intended.
+
+
+
+
+
+ <hr>
+-<h3><a name="1511"></a>1511. [FCD] Synchronize the move-constructor for <tt>atomic_future</tt></h3>
+-<p><b>Section:</b> 30.6.8 [futures.atomic_future] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2405"></a>2405. <tt>rotate()</tt>'s return value is incorrect when <tt>middle == first</tt></h3>
++<p><b>Section:</b> 25.3.11 [alg.rotate] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.rotate">issues</a> in [alg.rotate].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-204</b></p>
+ <p>
+-According to the definition of <tt>atomic_future</tt>, all members
+-of <tt>atomic_future</tt> are synchronizing except constructors.
+-However, it would probably be appropriate for a move
+-constructor to be synchronizing on the source object. If
+-not, the postconditions on paragraphs 7-8, might not be
+-satisfied. This may be applicable if a collection of futures
+-are being doled out to a set of threads that process their
+-value.
++When LWG <a href="lwg-defects.html#488">488</a> was resolved, the intention was to return "where the subrange <tt>[first, middle)</tt> starts after
++the rotate is performed". However, this wasn't achieved in one case.
++<p/>
++When <tt>middle == last</tt>, <tt>rotate()</tt> does nothing and returns <tt>first</tt>. This is good.
++<p/>
++When <tt>middle == first</tt>, <tt>rotate()</tt> does nothing and returns <tt>last</tt>. This is bad. In addition to being
++inconsistent with the other do-nothing case, it prevents <tt>rotate()</tt> from providing the useful guarantee that LWG
++<a href="lwg-defects.html#488">488</a> wanted: when <tt>[first, last)</tt> is non-empty, <tt>rotate()</tt>'s return value should always be
++dereferenceable to get the originally-first element.
++<p/>
++Howard Hinnant:
++<p/>
++As the author of LWG <a href="lwg-defects.html#488">488</a> I can assure everyone that the edge cases the proposed resolution specifies were
++not specified by accident. <tt>rotate(i, i, j)</tt> should return <tt>j</tt> and <tt>rotate(i, j, j)</tt> should return <tt>i</tt>.
++Doing otherwise will break working code. These return values were motivated by the uses of <tt>rotate</tt> in the implementation
++of algorithms such as <tt>stable_partition</tt> and <tt>inplace_merge</tt>. The results of these edge cases were not chosen lightly.
++<p/>
++Also a good read:
++<p/>
++<a href="http://www.cs.rpi.edu/~musser/gsd/notes-on-programming-2006-10-13.pdf">notes-on-programming-2006-10-13</a>
++<p/>
++Summary: NAD.
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><i>[2014-06-16 Rapperswill]</i></p>
+
+ <p>
+-Make the move constructor for atomic future lock
+-the source
++Closed as NAD.
+ </p>
+
+
+
++
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 25.3.11 [alg.rotate] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- <i>Returns</i>: <ins>If <tt>middle == first</tt>, returns <tt>first</tt>. Otherwise, returns</ins> <tt>first + (last - middle)</tt>.
++</p>
++</blockquote>
++</li>
++
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1512"></a>1512. [FCD] Conflict in spec: block or join?</h3>
+-<p><b>Section:</b> 30.6.9 [futures.async] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#NAD Editorial">NAD Editorial</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-12</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.async">issues</a> in [futures.async].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
++<h3><a name="2429"></a>2429. <tt>std::basic_ostringstream</tt> is missing an allocator-extended constructor</h3>
++<p><b>Section:</b> 27.8.4 [ostringstream] <b>Status:</b> <a href="lwg-active.html#NAD">NAD</a>
++ <b>Submitter:</b> Markus Kemp <b>Opened:</b> 2014-09-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostringstream">issues</a> in [ostringstream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#NAD">NAD</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-205</b></p>
+ <p>
+-30.6.9 [futures.async] p. 3: The third sentence says
+-"If the invocation is not deferred, a call to a waiting function
+-on an asynchronous return object that shares the associated asynchronous state
+-created by this <tt>async</tt> call shall block until the associated
+-thread has completed." The next sentence says "If the
+-invocation is not deferred, the <tt>join()</tt> on the created
+-thread..." Blocking until a thread completes is not
+-necessarily a join.
++I initially brought this issue up on <a href="http://stackoverflow.com/questions/23955828/how-to-use-basic-ostringstream-with-stateful-custom-allocator-c11">Stack Overflow</a>,
++where I was then told to make a topic about this problem on <a href="https://groups.google.com/a/isocpp.org/d/msg/std-discussion/kAQFOWz47m0/cOXSHa5Iwg4J">std-discussion</a>,
++where I was then in turn asked to report the issue.
++<p/>
++The problem: The <tt>std::basic_ostringstream</tt> class template can be instantiated with an allocator type, but none of the
++constructors provided accept an allocator argument, which means it's impossible to use <tt>std::basic_ostringstream</tt> with
++stateful allocators. The C++ Standard Library Defect Report List seems to already mention a similar issue (<a href="lwg-defects.html#2210">2210</a>).
+ </p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
+
++<p><i>[2014-11 Urbana]</i></p>
++
++<p>Closed as NAD</p>
+ <p>
+-Decide whether the requirement is to block until
+-finished or to call join, and rewrite to match.
++This is not a rejection of the suggestion, but an observation that simply adding an allocator-aware
++constructor is only part of the problem. <tt>stringstream</tt> returns the <tt>string</tt> assembled
++in its buffer by value, as the result of a call to <tt>str</tt>, and typically this will not use the
++same allocator as would be supplied at construction.
++</p>
++<p>
++The appropriate way to make progress on this issue, if motivated, is to submit a paper to LEWG
++addressing the larger design concerns in addition to 'just' adding an (optional) allocator to
++the constructors.
+ </p>
+-
+-
+
+ <p><b>Proposed resolution:</b></p>
+
+@@ -51130,6 +42628,5 @@ finished or to call join, and rewrite to match.
+
+
+
+-
+-
+-</body></html>
+\ No newline at end of file
++</body>
++</html>
+diff --git a/libstdc++-v3/doc/html/ext/lwg-defects.html b/libstdc++-v3/doc/html/ext/lwg-defects.html
+index c1a3c78..1e78c35 100644
+--- a/libstdc++-v3/doc/html/ext/lwg-defects.html
++++ b/libstdc++-v3/doc/html/ext/lwg-defects.html
+@@ -1,6 +1,7 @@
+-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+-<!-- saved from url=(0060)http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html -->
+-<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
++<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
++ "http://www.w3.org/TR/html4/strict.dtd">
++<html>
++<head>
+ <title>C++ Standard Library Defect Report List</title>
+ <style type="text/css">
+ p {text-align:justify}
+@@ -19,13 +20,13 @@
+ </head>
+ <body>
+ <table>
+-<tbody><tr>
++<tr>
+ <td align="left">Doc. no.</td>
+- <td align="left">D3182=10-0172</td>
++ <td align="left">N4485</td>
+ </tr>
+ <tr>
+ <td align="left">Date:</td>
+- <td align="left">2010-11-29</td>
++ <td align="left">2015-05-23</td>
+ </tr>
+ <tr>
+ <td align="left">Project:</td>
+@@ -33,1078 +34,185 @@
+ </tr>
+ <tr>
+ <td align="left">Reply to:</td>
+- <td align="left">Alisdair Meredith &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
++ <td align="left">Marshall Clow &lt;<a href="mailto:lwgchair@gmail.com">lwgchair@gmail.com</a>&gt;</td>
+ </tr>
+-</tbody></table>
+-<h1>C++ Standard Library Defect Report List (Revision D73)</h1>
+-<p>Revised 2010-11-29 at 10:11:56 UTC</p>
+-
+- <p>Reference ISO/IEC IS 14882:2003(E)</p>
++</table>
++<h1>C++ Standard Library Defect Report List (Revision R93)</h1>
++<p><p>Revised 2015-05-23 at 15:05:40 UTC</p>
++</p>
++ <p>Reference ISO/IEC IS 14882:2014(E)</p>
+ <p>Also see:</p>
+ <ul>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-toc.html">Table of Contents</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html">Index by Section</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html">Index by Status</a> for all library issues.</li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">Library Active Issues List</a></li>
+- <li><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html">Library Closed Issues List</a></li>
++ <li><a href="lwg-toc.html">Table of Contents</a> for all library issues.</li>
++ <li><a href="lwg-index.html">Index by Section</a> for all library issues.</li>
++ <li><a href="lwg-status.html">Index by Status</a> for all library issues.</li>
++ <li><a href="lwg-active.html">Library Active Issues List</a></li>
++ <li><a href="lwg-closed.html">Library Closed Issues List</a></li>
+ </ul>
+ <p>This document contains only library issues which have been closed
+ by the Library Working Group (LWG) after being found to be defects
+- in the standard. That is, issues which have a status of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#DR">DR</a>,
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC">TC</a>, or <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#RR">RR</a>. See the
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html">Library Closed Issues List</a> for issues closed as non-defects. See the
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html">Library Active Issues List</a> for active issues and more information. The
+- introductory material in that document also applies to this
+- document.</p>
++ in the standard. That is, issues which have a status of <a href="lwg-active.html#DR">DR</a>,
++ <a href="lwg-active.html#TC1">TC1</a>, <a href="lwg-active.html#C++11">C++11</a>,
++ <a href="lwg-active.html#C++14">C++14</a>, or <a href="lwg-active.html#Resolved">Resolved</a>. See
++ the <a href="lwg-closed.html">Library Closed Issues List</a> for issues closed as non-defects. See
++ the <a href="lwg-active.html">Library Active Issues List</a> for active issues and more information.
++ The introductory material in that document also applies to this document.</p>
+
+ <h2>Revision History</h2>
+ <ul>
+-<li>D73: Batavia meeting preview<ul>
+-<li><b>Summary:</b><ul>
+-<li>80 open issues, down by 126.</li>
+-<li>1459 closed issues, up by 145.</li>
+-<li>1539 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following 11 New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1521">1521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1523">1523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2012">2012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2013">2013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2014">2014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2015">2015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2016">2016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2017">2017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2018">2018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2019">2019</a>.</li>
+-<li>Added the following 5 Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2001">2001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2003">2003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2005">2005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Added the following Resolved issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2002">2002</a>.</li>
+-<li>Added the following Review issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>.</li>
+-<li>Added the following Tentatively NAD issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2006">2006</a>.</li>
+-<li>Added the following 3 Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2000">2000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2004">2004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2007">2007</a>.</li>
+-<li>Added the following WP issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1522">1522</a>.</li>
+-<li>Changed the following 3 issues from New to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>.</li>
+-<li>Changed the following issue from Open to Deferred: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>.</li>
+-<li>Changed the following 14 issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>.</li>
+-<li>Changed the following issue from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>.</li>
+-<li>Changed the following 8 issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issue from WP to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following 11 issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>.</li>
+-<li>Changed the following issue from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issue from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>.</li>
+-<li>Changed the following 6 issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>.</li>
+-<li>Changed the following 2 issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following 2 issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>.</li>
+-<li>Changed the following 3 issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>.</li>
+-<li>Changed the following 6 issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>.</li>
+-<li>Changed the following 42 issues from NAD Editorial to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>.</li>
+-<li>Changed the following 5 issues from New to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>.</li>
+-<li>Changed the following 46 issues from Open to Resolved: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>.</li>
+-<li>Changed the following issue from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>.</li>
+-<li>Changed the following 2 issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>.</li>
+-<li>Changed the following issue from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>.</li>
+-<li>Changed the following 3 issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>.</li>
+-<li>Changed the following issue from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>.</li>
+-<li>Changed the following 24 issues from NAD Editorial to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>.</li>
+-<li>Changed the following issue from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>.</li>
+-<li>Changed the following 10 issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>.</li>
+-<li>Changed the following 2 issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following 33 issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R72:
+-2010-10-18 pre-Batavia mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>206 open issues, up by 141.</li>
+-<li>1314 closed issues, up by 36.</li>
+-<li>1520 issues total, up by 177.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1433">1433</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1444">1444</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1360">1360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1363">1363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1367">1367</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1372">1372</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1381">1381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1384">1384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1386">1386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1387">1387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1388">1388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1394">1394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1399">1399</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1400">1400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1402">1402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1403">1403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1405">1405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1407">1407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1415">1415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1416">1416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1417">1417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1419">1419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1423">1423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1424">1424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1425">1425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1426">1426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1427">1427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1429">1429</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1430">1430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1431">1431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1434">1434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1441">1441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1483">1483</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1500">1500</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1506">1506</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1344">1344</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1345">1345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1346">1346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1347">1347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1348">1348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1349">1349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1350">1350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1353">1353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1354">1354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1355">1355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1356">1356</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1357">1357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1358">1358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1359">1359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1361">1361</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1362">1362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1364">1364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1368">1368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1369">1369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1370">1370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1371">1371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1373">1373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1374">1374</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1375">1375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1376">1376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1377">1377</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1378">1378</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1379">1379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1380">1380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1382">1382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1383">1383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1385">1385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1389">1389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1390">1390</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1391">1391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1392">1392</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1393">1393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1395">1395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1396">1396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1397">1397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1398">1398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1401">1401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1406">1406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1408">1408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1409">1409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1410">1410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1412">1412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1413">1413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1418">1418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1420">1420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1421">1421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1422">1422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1428">1428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1435">1435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1436">1436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1437">1437</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1438">1438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1439">1439</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1440">1440</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1442">1442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1443">1443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1445">1445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1446">1446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1447">1447</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1448">1448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1450">1450</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1451">1451</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1452">1452</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1453">1453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1455">1455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1456">1456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1457">1457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1458">1458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1459">1459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1460">1460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1461">1461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1462">1462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1464">1464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1465">1465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1466">1466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1468">1468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1470">1470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1471">1471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1472">1472</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1473">1473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1474">1474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1475">1475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1476">1476</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1477">1477</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1478">1478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1479">1479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1480">1480</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1481">1481</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1482">1482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1484">1484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1485">1485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1486">1486</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1487">1487</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1488">1488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1489">1489</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1490">1490</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1491">1491</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1492">1492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1493">1493</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1494">1494</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1495">1495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1496">1496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1497">1497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1498">1498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1499">1499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1501">1501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1502">1502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1503">1503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1504">1504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1505">1505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1507">1507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1508">1508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1509">1509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1510">1510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1511">1511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1512">1512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1513">1513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1514">1514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1515">1515</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1404">1404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1414">1414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1432">1432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1449">1449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1516">1516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1517">1517</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1518">1518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1519">1519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1520">1520</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R71:
+-2010-08-25 post-Rapperswil mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>65 open issues, up by 2.</li>
+-<li>1278 closed issues, up by 7.</li>
+-<li>1343 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1335">1335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2008">2008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1337">1337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1338">1338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1339">1339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1340">1340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2009">2009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2010">2010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2011">2011</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R70:
+-2010-03-26 post-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>63 open issues, down by 203.</li>
+-<li>1271 closed issues, up by 219.</li>
+-<li>1334 issues total, up by 16.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1321">1321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1329">1329</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1319">1319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1320">1320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1322">1322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1323">1323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1325">1325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1326">1326</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1328">1328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1330">1330</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1331">1331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1332">1332</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1333">1333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1334">1334</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1327">1327</a>.</li>
+-<li>Changed the following issues from Tentatively Dup to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Concepts to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#446">446</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>.</li>
+-<li>Changed the following issues from Ready to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#427">427</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R69:
+-2010-02-12 pre-Pittsburgh mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>266 open issues, up by 61.</li>
+-<li>1052 closed issues, down by 3.</li>
+-<li>1318 issues total, up by 58.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1266">1266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1269">1269</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1272">1272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1275">1275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1278">1278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1281">1281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1289">1289</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1291">1291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1292">1292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1294">1294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1295">1295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1297">1297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1302">1302</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1305">1305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1307">1307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1308">1308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1310">1310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1311">1311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1313">1313</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1314">1314</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1316">1316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1317">1317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1318">1318</a>.</li>
+-<li>Added the following Tentatively NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1263">1263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1265">1265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1296">1296</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1301">1301</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1282">1282</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1261">1261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1262">1262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1264">1264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1267">1267</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1270">1270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1271">1271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1273">1273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1274">1274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1276">1276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1277">1277</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1280">1280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1284">1284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1285">1285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1286">1286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1293">1293</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298">1298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1299">1299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1300">1300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1303">1303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1304">1304</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1306">1306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1312">1312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1315">1315</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#101">101</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>.</li>
+-<li>Changed the following issues from New to Tentatively Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>.</li>
+-<li>Changed the following issues from NAD to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Ready to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R68:
+-2009-11-06 post-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>205 open issues, down by 77.</li>
+-<li>1055 closed issues, up by 120.</li>
+-<li>1260 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1230">1230</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1229">1229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1236">1236</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1243">1243</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1232">1232</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1235">1235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1242">1242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1248">1248</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1218">1218</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1221">1221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1222">1222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1223">1223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1224">1224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1240">1240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1244">1244</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1246">1246</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1249">1249</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1250">1250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1251">1251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1252">1252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1253">1253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1254">1254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1256">1256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1257">1257</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1259">1259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1260">1260</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1228">1228</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1237">1237</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1247">1247</a>.</li>
+-<li>Added the following Tentatively NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1239">1239</a>.</li>
+-<li>Added the following Tentatively NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1238">1238</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1220">1220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1226">1226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1241">1241</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from NAD Concepts to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>.</li>
+-<li>Changed the following issues from New to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#485">485</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R67:
+-2009-09-25 pre-Santa Cruz mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>282 open issues, up by 32.</li>
+-<li>935 closed issues, down by 1.</li>
+-<li>1217 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1187">1187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1188">1188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1189">1189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1190">1190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1191">1191</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1192">1192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1193">1193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1197">1197</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1200">1200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1201">1201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1202">1202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1203">1203</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1206">1206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1207">1207</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1208">1208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1209">1209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1210">1210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1211">1211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1212">1212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1213">1213</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1214">1214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1215">1215</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1216">1216</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1217">1217</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#296">296</a>.</li>
+-<li>Changed the following issues from WP to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R66:
+-2009-07-31 post-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>250 open issues, down by 128.</li>
+-<li>936 closed issues, up by 171.</li>
+-<li>1186 issues total, up by 43.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1164">1164</a>.</li>
+-<li>Added the following NAD Concepts issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1149">1149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1167">1167</a>.</li>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1168">1168</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1144">1144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1145">1145</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1146">1146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1147">1147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1148">1148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1150">1150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1151">1151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1152">1152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1153">1153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1154">1154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1155">1155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1156">1156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1158">1158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1159">1159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1166">1166</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1169">1169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1170">1170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1171">1171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1172">1172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1174">1174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1175">1175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1179">1179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1180">1180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1181">1181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1183">1183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1184">1184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1185">1185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1186">1186</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1160">1160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1161">1161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1162">1162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1163">1163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1165">1165</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1157">1157</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#290">290</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#343">343</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#394">394</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#398">398</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#417">417</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">418</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#421">421</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#459">459</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#492">492</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>.</li>
+-<li>Changed the following issues from Review to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>.</li>
+-<li>Changed the following issues from New to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Changed the following issues from Open to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>.</li>
+-<li>Changed the following issues from Review to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Concepts: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#423">423</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from CD1 to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>.</li>
+-<li>Changed the following issues from Tentatively NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#419">419</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#430">430</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>.</li>
+-<li>Changed the following issues from NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#473">473</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Tentatively NAD to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R65:
+-2009-06-19 pre-Frankfurt mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>378 open issues, up by 32.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1143 issues total, up by 32.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1115">1115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1118">1118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1119">1119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1122">1122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1123">1123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1124">1124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1125">1125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1126">1126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1127">1127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1128">1128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1129">1129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1130">1130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1131">1131</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1132">1132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1133">1133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1134">1134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1135">1135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1136">1136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1138">1138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1139">1139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1140">1140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1141">1141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1142">1142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1143">1143</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1112">1112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#458">458</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Tentatively NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>.</li>
+-<li>Changed the following issues from Review to Tentatively NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>.</li>
+-<li>Changed the following issues from Open to Tentatively NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R64:
+-2009-05-01 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>346 open issues, up by 19.</li>
+-<li>765 closed issues, up by 0.</li>
+-<li>1111 issues total, up by 19.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1093">1093</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1094">1094</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1095">1095</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1096">1096</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1097">1097</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1098">1098</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1099">1099</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1100">1100</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1101">1101</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1102">1102</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1103">1103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1104">1104</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1105">1105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1106">1106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1107">1107</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1108">1108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1109">1109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1110">1110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1111">1111</a>.</li>
+-<li>Changed the following issues from DR to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#386">386</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#406">406</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#409">409</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#413">413</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#434">434</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#438">438</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#444">444</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#445">445</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#455">455</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#469">469</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>.</li>
+-<li>Changed the following issues from Review to New: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R63:
+-2009-03-20 post-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>327 open issues, up by 96.</li>
+-<li>765 closed issues, up by 14.</li>
+-<li>1092 issues total, up by 110.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1022">1022</a>.</li>
+-<li>Added the following NAD Future issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1025">1025</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#983">983</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#984">984</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#985">985</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#989">989</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#990">990</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#995">995</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#996">996</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#999">999</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1033">1033</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1054">1054</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1056">1056</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1057">1057</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1058">1058</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1059">1059</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1060">1060</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1061">1061</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1062">1062</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1063">1063</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1067">1067</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1068">1068</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1069">1069</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1071">1071</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1072">1072</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1073">1073</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1074">1074</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1076">1076</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1077">1077</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1080">1080</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1090">1090</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1091">1091</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1092">1092</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1007">1007</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1008">1008</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1016">1016</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1017">1017</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1018">1018</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1020">1020</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1026">1026</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1027">1027</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1028">1028</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1029">1029</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1030">1030</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1031">1031</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1032">1032</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1034">1034</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1035">1035</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1036">1036</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1041">1041</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1042">1042</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1046">1046</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1048">1048</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1052">1052</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1053">1053</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1055">1055</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1064">1064</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1075">1075</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1078">1078</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1079">1079</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1081">1081</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1082">1082</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1083">1083</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1084">1084</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1085">1085</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1086">1086</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1087">1087</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1088">1088</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1089">1089</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#986">986</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#991">991</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#992">992</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#993">993</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#994">994</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#997">997</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1002">1002</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1003">1003</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1004">1004</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1005">1005</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1006">1006</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1009">1009</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1010">1010</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1013">1013</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1014">1014</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1015">1015</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1019">1019</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1037">1037</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1038">1038</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1039">1039</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1040">1040</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1043">1043</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1044">1044</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1045">1045</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1047">1047</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1049">1049</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1050">1050</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1065">1065</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1070">1070</a>.</li>
+-<li>Added the following Tentatively Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#988">988</a>.</li>
+-<li>Changed the following issues from New to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Changed the following issues from Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R62:
+-2009-02-06 pre-Summit mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>231 open issues, up by 44.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>982 issues total, up by 44.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#940">940</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#941">941</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#942">942</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#943">943</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#944">944</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#945">945</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#946">946</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#949">949</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#952">952</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#954">954</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#955">955</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#956">956</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#957">957</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#960">960</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#961">961</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#963">963</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#965">965</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#967">967</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#968">968</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#969">969</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#970">970</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#971">971</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#972">972</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#977">977</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#979">979</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#980">980</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#981">981</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#982">982</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R61:
+-2008-12-05 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>187 open issues, up by 20.</li>
+-<li>751 closed issues, up by 0.</li>
+-<li>938 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#919">919</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#920">920</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#921">921</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#922">922</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#923">923</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#924">924</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#925">925</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#926">926</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#927">927</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#928">928</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#930">930</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#931">931</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#933">933</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#934">934</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#935">935</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#936">936</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#937">937</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#938">938</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R60:
+-2008-10-03 post-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>167 open issues, down by 25.</li>
+-<li>751 closed issues, up by 65.</li>
+-<li>918 issues total, up by 40.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following CD1 issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#882">882</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#879">879</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#880">880</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#891">891</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#893">893</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#897">897</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#898">898</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#899">899</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#901">901</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#902">902</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#903">903</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#904">904</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#906">906</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#907">907</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#908">908</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#909">909</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#912">912</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#913">913</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#914">914</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#915">915</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#916">916</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#917">917</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#918">918</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#881">881</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#884">884</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#887">887</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#890">890</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#896">896</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#892">892</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#894">894</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#888">888</a>.</li>
+-<li>Changed the following issues from New to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>.</li>
+-<li>Changed the following issues from Ready to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Changed the following issues from Review to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>.</li>
+-<li>Changed the following issues from WP to CD1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#44">44</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#98">98</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#123">123</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#167">167</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#200">200</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#231">231</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#239">239</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#240">240</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#274">274</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#282">282</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#291">291</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#300">300</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#305">305</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#310">310</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#315">315</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#316">316</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#318">318</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#319">319</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#320">320</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#321">321</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#322">322</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#324">324</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#325">325</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#327">327</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#328">328</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#329">329</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#331">331</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#333">333</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#334">334</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#337">337</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#338">338</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#339">339</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#340">340</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#341">341</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#345">345</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#346">346</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#349">349</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#352">352</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#354">354</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#355">355</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#358">358</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#359">359</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#360">360</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#363">363</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#364">364</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#365">365</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#370">370</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#373">373</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#375">375</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#379">379</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#380">380</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#381">381</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#391">391</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#395">395</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#400">400</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#403">403</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#405">405</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#407">407</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#410">410</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#411">411</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#412">412</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#414">414</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#415">415</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#420">420</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#425">425</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#426">426</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#428">428</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#435">435</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#436">436</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#442">442</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#443">443</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#448">448</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#449">449</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from Open to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#484">484</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-<li>Changed the following issues from TC to TC1: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1">1</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#5">5</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#7">7</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#11">11</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#13">13</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#14">14</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#15">15</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#16">16</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#18">18</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#20">20</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#21">21</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#22">22</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#24">24</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#25">25</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#27">27</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#28">28</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#30">30</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#32">32</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#33">33</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#34">34</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#35">35</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#36">36</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#37">37</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#39">39</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#40">40</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#41">41</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#42">42</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#46">46</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#47">47</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#48">48</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#50">50</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#51">51</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#52">52</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#53">53</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#54">54</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#56">56</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#57">57</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#59">59</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#62">62</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#66">66</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#68">68</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69">69</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#71">71</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#74">74</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#75">75</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#78">78</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#79">79</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#80">80</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#90">90</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#106">106</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#119">119</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#124">124</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#125">125</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#141">141</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#148">148</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#150">150</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#151">151</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#152">152</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#154">154</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#155">155</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#156">156</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#158">158</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#161">161</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#168">168</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#169">169</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#172">172</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#173">173</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#174">174</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#175">175</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#176">176</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#193">193</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R59:
+-2008-08-22 pre-San Francisco mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>192 open issues, up by 9.</li>
+-<li>686 closed issues, up by 0.</li>
+-<li>878 issues total, up by 9.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#871">871</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#872">872</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#873">873</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#874">874</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#875">875</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#876">876</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#878">878</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R58:
+-2008-07-28 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>183 open issues, up by 12.</li>
+-<li>686 closed issues, down by 4.</li>
+-<li>869 issues total, up by 8.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#862">862</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#863">863</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#864">864</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#865">865</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#866">866</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#869">869</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from WP to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R57:
+-2008-06-27 post-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>171 open issues, down by 20.</li>
+-<li>690 closed issues, up by 43.</li>
+-<li>861 issues total, up by 23.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#840">840</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#841">841</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#843">843</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#845">845</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#846">846</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#847">847</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#849">849</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#854">854</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#855">855</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#856">856</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#858">858</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#860">860</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#861">861</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#839">839</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#844">844</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#848">848</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#852">852</a>.</li>
+-<li>Added the following Review issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#851">851</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from Review to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Changed the following issues from Ready to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R56:
+-2008-05-16 pre-Sophia Antipolis mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>191 open issues, up by 24.</li>
+-<li>647 closed issues, up by 1.</li>
+-<li>838 issues total, up by 25.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#814">814</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#815">815</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#818">818</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#819">819</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#820">820</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#824">824</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#825">825</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#826">826</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#827">827</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#829">829</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#830">830</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#831">831</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#833">833</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#834">834</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#835">835</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#836">836</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#837">837</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#838">838</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R55:
+-2008-03-14 post-Bellevue mailing.
+-<ul>
++<li>R93: 2014-05-22 2015 post-Lenexa mailing<ul>
+ <li><b>Summary:</b><ul>
+-<li>167 open issues, down by 39.</li>
+-<li>646 closed issues, up by 65.</li>
+-<li>813 issues total, up by 26.</li>
++<li>256 open issues, down by 36.</li>
++<li>1770 closed issues, up by 48.</li>
++<li>2026 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following Dup issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#795">795</a>.</li>
+-<li>Added the following NAD issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#790">790</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#791">791</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#796">796</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#797">797</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#799">799</a>.</li>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#794">794</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#802">802</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#804">804</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#807">807</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#808">808</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809">809</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#810">810</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#812">812</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#813">813</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#793">793</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#800">800</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a>.</li>
+-<li>Added the following Ready issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#789">789</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#792">792</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#798">798</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from Review to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>.</li>
+-<li>Changed the following issues from Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>.</li>
+-<li>Changed the following issues from Open to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
++<li>Added the following 2 Ready issues: <a href="lwg-active.html#2492">2492</a>, <a href="lwg-active.html#2494">2494</a>.</li>
++<li>Added the following 10 New issues: <a href="lwg-active.html#2493">2493</a>, <a href="lwg-active.html#2495">2495</a>, <a href="lwg-active.html#2496">2496</a>, <a href="lwg-active.html#2497">2497</a>, <a href="lwg-active.html#2498">2498</a>, <a href="lwg-active.html#2499">2499</a>, <a href="lwg-active.html#2500">2500</a>, <a href="lwg-active.html#2501">2501</a>, <a href="lwg-active.html#2502">2502</a>, <a href="lwg-active.html#2503">2503</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-active.html#2111">2111</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 20 issues to Ready (from New): <a href="lwg-active.html#2244">2244</a>, <a href="lwg-active.html#2250">2250</a>, <a href="lwg-active.html#2259">2259</a>, <a href="lwg-active.html#2336">2336</a>, <a href="lwg-active.html#2353">2353</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2489">2489</a>.</li>
++<li>Changed the following 12 issues to Ready (from Open): <a href="lwg-active.html#1169">1169</a>, <a href="lwg-active.html#2072">2072</a>, <a href="lwg-active.html#2101">2101</a>, <a href="lwg-active.html#2119">2119</a>, <a href="lwg-active.html#2127">2127</a>, <a href="lwg-active.html#2133">2133</a>, <a href="lwg-active.html#2156">2156</a>, <a href="lwg-active.html#2181">2181</a>, <a href="lwg-active.html#2218">2218</a>, <a href="lwg-active.html#2219">2219</a>, <a href="lwg-active.html#2447">2447</a>, <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2224">2224</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2296">2296</a>.</li>
++<li>Changed the following issue to Review (from Open): <a href="lwg-active.html#2328">2328</a>.</li>
++<li>Changed the following 11 issues to Open (from New): <a href="lwg-active.html#2262">2262</a>, <a href="lwg-active.html#2289">2289</a>, <a href="lwg-active.html#2338">2338</a>, <a href="lwg-active.html#2348">2348</a>, <a href="lwg-active.html#2349">2349</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2456">2456</a>.</li>
++<li>Changed the following 8 issues to Open (from SG1): <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following issue to LEWG (from New): <a href="lwg-active.html#2372">2372</a>.</li>
++<li>Changed the following issue to EWG (from New): <a href="lwg-active.html#2432">2432</a>.</li>
++<li>Changed the following issue to Deferred (from Open): <a href="lwg-active.html#2202">2202</a>.</li>
++<li>Changed the following 14 issues to WP (from Ready): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following 18 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2059">2059</a>, <a href="lwg-defects.html#2076">2076</a>, <a href="lwg-defects.html#2239">2239</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2415">2415</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-defects.html#2458">2458</a>, <a href="lwg-defects.html#2459">2459</a>, <a href="lwg-defects.html#2463">2463</a>, <a href="lwg-defects.html#2467">2467</a>, <a href="lwg-defects.html#2470">2470</a>, <a href="lwg-defects.html#2482">2482</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-defects.html#2464">2464</a>, <a href="lwg-defects.html#2488">2488</a>.</li>
++<li>Changed the following issue to WP (from Open): <a href="lwg-defects.html#2063">2063</a>.</li>
++<li>Changed the following 2 issues to WP (from SG1): <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2442">2442</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2228">2228</a>.</li>
++<li>Changed the following 3 issues to Resolved (from Open): <a href="lwg-defects.html#1526">1526</a>, <a href="lwg-defects.html#2274">2274</a>, <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Changed the following 5 issues to NAD (from New): <a href="lwg-closed.html#2079">2079</a>, <a href="lwg-closed.html#2251">2251</a>, <a href="lwg-closed.html#2351">2351</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-closed.html#2386">2386</a>.</li>
++<li>Changed the following issue to NAD (from Open): <a href="lwg-closed.html#2388">2388</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R54:
+-2008-02-01 pre-Bellevue mailing.
++<li>R92:
++2015-04-09 pre-Lenexa mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>206 open issues, up by 23.</li>
+-<li>581 closed issues, up by 0.</li>
+-<li>787 issues total, up by 23.</li>
++<li>292 open issues, up by 33.</li>
++<li>1722 closed issues, up by 0.</li>
++<li>2014 issues total, up by 33.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#765">765</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#766">766</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#767">767</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#768">768</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#769">769</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#770">770</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#772">772</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#773">773</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#775">775</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776">776</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#778">778</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#779">779</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#780">780</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#781">781</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#782">782</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#783">783</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#784">784</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#785">785</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#786">786</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#787">787</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>.</li>
+-<li>Changed the following issues from NAD Future to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>.</li>
+-<li>Changed the following issues from NAD Future to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>.</li>
++<li>Added the following 5 Tentatively Ready issues: <a href="lwg-active.html#2459">2459</a>, <a href="lwg-active.html#2463">2463</a>, <a href="lwg-active.html#2467">2467</a>, <a href="lwg-active.html#2470">2470</a>, <a href="lwg-active.html#2482">2482</a>.</li>
++<li>Added the following 27 New issues: <a href="lwg-active.html#2460">2460</a>, <a href="lwg-active.html#2461">2461</a>, <a href="lwg-active.html#2462">2462</a>, <a href="lwg-active.html#2464">2464</a>, <a href="lwg-active.html#2465">2465</a>, <a href="lwg-active.html#2466">2466</a>, <a href="lwg-active.html#2468">2468</a>, <a href="lwg-active.html#2471">2471</a>, <a href="lwg-active.html#2472">2472</a>, <a href="lwg-active.html#2473">2473</a>, <a href="lwg-active.html#2474">2474</a>, <a href="lwg-active.html#2475">2475</a>, <a href="lwg-active.html#2476">2476</a>, <a href="lwg-active.html#2477">2477</a>, <a href="lwg-active.html#2478">2478</a>, <a href="lwg-active.html#2479">2479</a>, <a href="lwg-active.html#2480">2480</a>, <a href="lwg-active.html#2481">2481</a>, <a href="lwg-active.html#2483">2483</a>, <a href="lwg-active.html#2484">2484</a>, <a href="lwg-active.html#2485">2485</a>, <a href="lwg-active.html#2486">2486</a>, <a href="lwg-active.html#2487">2487</a>, <a href="lwg-active.html#2488">2488</a>, <a href="lwg-active.html#2489">2489</a>, <a href="lwg-active.html#2490">2490</a>, <a href="lwg-active.html#2491">2491</a>.</li>
++<li>Added the following Open issue: <a href="lwg-active.html#2469">2469</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Review): <a href="lwg-active.html#2378">2378</a>.</li>
++<li>Changed the following 11 issues to Tentatively Ready (from New): <a href="lwg-active.html#2076">2076</a>, <a href="lwg-active.html#2239">2239</a>, <a href="lwg-active.html#2369">2369</a>, <a href="lwg-active.html#2410">2410</a>, <a href="lwg-active.html#2415">2415</a>, <a href="lwg-active.html#2418">2418</a>, <a href="lwg-active.html#2437">2437</a>, <a href="lwg-active.html#2448">2448</a>, <a href="lwg-active.html#2454">2454</a>, <a href="lwg-active.html#2455">2455</a>, <a href="lwg-active.html#2458">2458</a>.</li>
++<li>Changed the following issue to Tentatively Ready (from Open): <a href="lwg-active.html#2059">2059</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-active.html#2337">2337</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from Open): <a href="lwg-active.html#760">760</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2312">2312</a>, <a href="lwg-active.html#2388">2388</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2447">2447</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-active.html#2451">2451</a>.</li>
++<li>Changed the following issue to EWG (from Open): <a href="lwg-active.html#2089">2089</a>.</li>
++<li>Changed the following issue to Core (from New): <a href="lwg-active.html#2452">2452</a>.</li>
++<li>Changed the following 13 issues to SG1 (from New): <a href="lwg-active.html#2236">2236</a>, <a href="lwg-active.html#2245">2245</a>, <a href="lwg-active.html#2265">2265</a>, <a href="lwg-active.html#2276">2276</a>, <a href="lwg-active.html#2309">2309</a>, <a href="lwg-active.html#2334">2334</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2407">2407</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-active.html#2442">2442</a>, <a href="lwg-active.html#2445">2445</a>.</li>
++<li>Changed the following issue to SG1 (from Open): <a href="lwg-active.html#2441">2441</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R53:
+-2007-12-09 mid-term mailing.
++<li>R91:
++2014-11-23 post-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>183 open issues, up by 11.</li>
+-<li>581 closed issues, down by 1.</li>
+-<li>764 issues total, up by 10.</li>
++<li>259 open issues, up by 32.</li>
++<li>1722 closed issues, down by 20.</li>
++<li>1981 issues total, up by 12.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#756">756</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#757">757</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#758">758</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#759">759</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#760">760</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#761">761</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#763">763</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#764">764</a>.</li>
+-<li>Changed the following issues from NAD to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>.</li>
+-<li>Changed the following issues from Pending WP to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
++<li>Added the following 12 New issues: <a href="lwg-active.html#2447">2447</a>, <a href="lwg-defects.html#2448">2448</a>, <a href="lwg-active.html#2449">2449</a>, <a href="lwg-active.html#2450">2450</a>, <a href="lwg-active.html#2451">2451</a>, <a href="lwg-active.html#2452">2452</a>, <a href="lwg-active.html#2453">2453</a>, <a href="lwg-defects.html#2454">2454</a>, <a href="lwg-defects.html#2455">2455</a>, <a href="lwg-active.html#2456">2456</a>, <a href="lwg-active.html#2457">2457</a>, <a href="lwg-defects.html#2458">2458</a>.</li>
++<li>Changed the following 2 issues to Ready (from Review): <a href="lwg-defects.html#2160">2160</a>, <a href="lwg-defects.html#2364">2364</a>.</li>
++<li>Changed the following 11 issues to Ready (from New): <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>.</li>
++<li>Changed the following issue to Ready (from Open): <a href="lwg-defects.html#2168">2168</a>.</li>
++<li>Changed the following issue to Review (from New): <a href="lwg-active.html#2424">2424</a>.</li>
++<li>Changed the following 5 issues to Open (from New): <a href="lwg-active.html#2307">2307</a>, <a href="lwg-active.html#2310">2310</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-active.html#2441">2441</a>.</li>
++<li>Changed the following 2 issues to Open (from NAD Future): <a href="lwg-active.html#760">760</a>, <a href="lwg-active.html#1173">1173</a>.</li>
++<li>Changed the following 4 issues to LEWG (from New): <a href="lwg-active.html#2419">2419</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>Changed the following 48 issues to LEWG (from NAD Future): <a href="lwg-active.html#255">255</a>, <a href="lwg-active.html#423">423</a>, <a href="lwg-active.html#484">484</a>, <a href="lwg-active.html#523">523</a>, <a href="lwg-active.html#532">532</a>, <a href="lwg-active.html#708">708</a>, <a href="lwg-active.html#839">839</a>, <a href="lwg-active.html#851">851</a>, <a href="lwg-active.html#877">877</a>, <a href="lwg-active.html#933">933</a>, <a href="lwg-active.html#935">935</a>, <a href="lwg-active.html#936">936</a>, <a href="lwg-active.html#961">961</a>, <a href="lwg-active.html#1025">1025</a>, <a href="lwg-active.html#1031">1031</a>, <a href="lwg-active.html#1041">1041</a>, <a href="lwg-active.html#1052">1052</a>, <a href="lwg-active.html#1053">1053</a>, <a href="lwg-active.html#1112">1112</a>, <a href="lwg-active.html#1120">1120</a>, <a href="lwg-active.html#1121">1121</a>, <a href="lwg-active.html#1150">1150</a>, <a href="lwg-active.html#1154">1154</a>, <a href="lwg-active.html#1184">1184</a>, <a href="lwg-active.html#1188">1188</a>, <a href="lwg-active.html#1201">1201</a>, <a href="lwg-active.html#1203">1203</a>, <a href="lwg-active.html#1217">1217</a>, <a href="lwg-active.html#1235">1235</a>, <a href="lwg-active.html#1238">1238</a>, <a href="lwg-active.html#1242">1242</a>, <a href="lwg-active.html#1282">1282</a>, <a href="lwg-active.html#1289">1289</a>, <a href="lwg-active.html#1317">1317</a>, <a href="lwg-active.html#1320">1320</a>, <a href="lwg-active.html#1396">1396</a>, <a href="lwg-active.html#1406">1406</a>, <a href="lwg-active.html#1422">1422</a>, <a href="lwg-active.html#1459">1459</a>, <a href="lwg-active.html#1484">1484</a>, <a href="lwg-active.html#1488">1488</a>, <a href="lwg-active.html#1493">1493</a>, <a href="lwg-active.html#1499">1499</a>, <a href="lwg-active.html#1521">1521</a>, <a href="lwg-active.html#2040">2040</a>, <a href="lwg-active.html#2055">2055</a>, <a href="lwg-active.html#2226">2226</a>, <a href="lwg-active.html#2232">2232</a>.</li>
++<li>Changed the following 2 issues to Pending NAD (from Tentatively NAD): <a href="lwg-closed.html#2302">2302</a>, <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 11 issues to WP (from Ready): <a href="lwg-defects.html#2016">2016</a>, <a href="lwg-defects.html#2170">2170</a>, <a href="lwg-defects.html#2340">2340</a>, <a href="lwg-defects.html#2354">2354</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Changed the following 12 issues to WP (from Tentatively Ready): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2217">2217</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>, <a href="lwg-defects.html#2266">2266</a>, <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Resolved (from Ready): <a href="lwg-defects.html#2319">2319</a>.</li>
++<li>Changed the following issue to Resolved (from Review): <a href="lwg-defects.html#2118">2118</a>.</li>
++<li>Changed the following issue to Resolved (from New): <a href="lwg-defects.html#2416">2416</a>.</li>
++<li>Changed the following issue to Resolved (from Open): <a href="lwg-defects.html#2108">2108</a>.</li>
++<li>Changed the following issue to NAD (from New): <a href="lwg-closed.html#2429">2429</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R52:
+-2007-10-19 post-Kona mailing.
++<li>R90:
++2014-10-13 pre-Urbana mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>172 open issues, up by 4.</li>
+-<li>582 closed issues, up by 27.</li>
+-<li>754 issues total, up by 31.</li>
++<li>227 open issues, up by 31.</li>
++<li>1742 closed issues, up by 0.</li>
++<li>1969 issues total, up by 31.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#725">725</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#727">727</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#728">728</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#729">729</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#730">730</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#731">731</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#732">732</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#733">733</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#734">734</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#735">735</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#736">736</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#737">737</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#738">738</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#739">739</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#741">741</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#744">744</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#745">745</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#746">746</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#747">747</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#748">748</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#749">749</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#751">751</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#752">752</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#753">753</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#754">754</a>.</li>
+-<li>Changed the following issues from NAD Future to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#573">573</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#393">393</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
+-<li>Changed the following issues from New to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from New to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#574">574</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>.</li>
+-<li>Changed the following issues from New to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>.</li>
+-<li>Changed the following issues from Open to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#401">401</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
++<li>Added the following 31 New issues: <a href="lwg-defects.html#2416">2416</a>, <a href="lwg-active.html#2417">2417</a>, <a href="lwg-defects.html#2418">2418</a>, <a href="lwg-active.html#2419">2419</a>, <a href="lwg-defects.html#2420">2420</a>, <a href="lwg-active.html#2421">2421</a>, <a href="lwg-active.html#2422">2422</a>, <a href="lwg-active.html#2423">2423</a>, <a href="lwg-active.html#2424">2424</a>, <a href="lwg-defects.html#2425">2425</a>, <a href="lwg-active.html#2426">2426</a>, <a href="lwg-defects.html#2427">2427</a>, <a href="lwg-defects.html#2428">2428</a>, <a href="lwg-closed.html#2429">2429</a>, <a href="lwg-active.html#2430">2430</a>, <a href="lwg-active.html#2431">2431</a>, <a href="lwg-active.html#2432">2432</a>, <a href="lwg-defects.html#2433">2433</a>, <a href="lwg-defects.html#2434">2434</a>, <a href="lwg-active.html#2435">2435</a>, <a href="lwg-active.html#2436">2436</a>, <a href="lwg-defects.html#2437">2437</a>, <a href="lwg-defects.html#2438">2438</a>, <a href="lwg-defects.html#2439">2439</a>, <a href="lwg-defects.html#2440">2440</a>, <a href="lwg-active.html#2441">2441</a>, <a href="lwg-defects.html#2442">2442</a>, <a href="lwg-active.html#2443">2443</a>, <a href="lwg-active.html#2444">2444</a>, <a href="lwg-active.html#2445">2445</a>, <a href="lwg-active.html#2446">2446</a>.</li>
++<li>No issues changed.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R51:
+-2007-09-09 pre-Kona mailing.
++<li>R89:
++2014-07-08 post-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>168 open issues, up by 15.</li>
+-<li>555 closed issues, up by 0.</li>
+-<li>723 issues total, up by 15.</li>
++<li>196 open issues, up by 14.</li>
++<li>1742 closed issues, up by 12.</li>
++<li>1938 issues total, up by 26.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#709">709</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#710">710</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#712">712</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#713">713</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#714">714</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#715">715</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#716">716</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#717">717</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#719">719</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#722">722</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a>.</li>
++<li>Added the following 6 Ready issues: <a href="lwg-defects.html#2396">2396</a>, <a href="lwg-defects.html#2399">2399</a>, <a href="lwg-defects.html#2400">2400</a>, <a href="lwg-defects.html#2401">2401</a>, <a href="lwg-defects.html#2404">2404</a>, <a href="lwg-defects.html#2408">2408</a>.</li>
++<li>Added the following 15 New issues: <a href="lwg-active.html#2391">2391</a>, <a href="lwg-active.html#2392">2392</a>, <a href="lwg-active.html#2393">2393</a>, <a href="lwg-active.html#2394">2394</a>, <a href="lwg-active.html#2398">2398</a>, <a href="lwg-active.html#2402">2402</a>, <a href="lwg-defects.html#2403">2403</a>, <a href="lwg-defects.html#2406">2406</a>, <a href="lwg-defects.html#2407">2407</a>, <a href="lwg-defects.html#2410">2410</a>, <a href="lwg-defects.html#2411">2411</a>, <a href="lwg-active.html#2412">2412</a>, <a href="lwg-active.html#2413">2413</a>, <a href="lwg-active.html#2414">2414</a>, <a href="lwg-defects.html#2415">2415</a>.</li>
++<li>Added the following Open issue: <a href="lwg-defects.html#2397">2397</a>.</li>
++<li>Added the following 3 WP issues: <a href="lwg-defects.html#2390">2390</a>, <a href="lwg-defects.html#2395">2395</a>, <a href="lwg-defects.html#2409">2409</a>.</li>
++<li>Added the following NAD issue: <a href="lwg-closed.html#2405">2405</a>.</li>
++<li>Changed the following issue to Ready (from New): <a href="lwg-defects.html#2377">2377</a>.</li>
++<li>Changed the following 2 issues to Ready (from Deferred): <a href="lwg-active.html#2253">2253</a>, <a href="lwg-active.html#2255">2255</a>.</li>
++<li>Changed the following 2 issues to Tentatively Ready (from New): <a href="lwg-defects.html#2325">2325</a>, <a href="lwg-defects.html#2387">2387</a>.</li>
++<li>Changed the following issue to Tentatively NAD (from New): <a href="lwg-closed.html#2382">2382</a>.</li>
++<li>Changed the following 3 issues to Review (from New): <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2380">2380</a>.</li>
++<li>Changed the following 2 issues to Review (from Open): <a href="lwg-defects.html#2118">2118</a>, <a href="lwg-defects.html#2160">2160</a>.</li>
++<li>Changed the following 3 issues to Open (from New): <a href="lwg-defects.html#2168">2168</a>, <a href="lwg-active.html#2238">2238</a>, <a href="lwg-active.html#2273">2273</a>.</li>
++<li>Changed the following 3 issues to Open (from Deferred): <a href="lwg-active.html#2254">2254</a>, <a href="lwg-active.html#2264">2264</a>, <a href="lwg-active.html#2277">2277</a>.</li>
++<li>Changed the following 3 issues to WP (from New): <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 4 issues to Resolved (from Deferred): <a href="lwg-defects.html#2282">2282</a>, <a href="lwg-defects.html#2283">2283</a>, <a href="lwg-defects.html#2287">2287</a>, <a href="lwg-defects.html#2333">2333</a>.</li>
++<li>Changed the following issue to NAD (from Deferred): <a href="lwg-closed.html#2305">2305</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R50:
+-2007-08-05 post-Toronto mailing.
++<li>R88:
++2014-05-24 pre-Rapperswil mailing
+ <ul>
+ <li><b>Summary:</b><ul>
+-<li>153 open issues, down by 5.</li>
+-<li>555 closed issues, up by 17.</li>
+-<li>708 issues total, up by 12.</li>
++<li>182 open issues, up by 29.</li>
++<li>1730 closed issues, up by 0.</li>
++<li>1912 issues total, up by 29.</li>
+ </ul></li>
+ <li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#697">697</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#698">698</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#699">699</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#701">701</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#702">702</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#703">703</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#706">706</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#707">707</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#708">708</a>.</li>
+-<li>Changed the following issues from New to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>.</li>
+-<li>Changed the following issues from Open to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>.</li>
+-<li>Changed the following issues from Pending NAD Editorial to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>.</li>
+-<li>Changed the following issues from Pending WP to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>.</li>
+-<li>Changed the following issues from Open to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>.</li>
+-<li>Changed the following issues from Open to Review: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from DR to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#453">453</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
++<li>Added the following 3 Tentatively Ready issues: <a href="lwg-defects.html#2361">2361</a>, <a href="lwg-defects.html#2365">2365</a>, <a href="lwg-defects.html#2376">2376</a>.</li>
++<li>Added the following 26 New issues: <a href="lwg-active.html#2362">2362</a>, <a href="lwg-active.html#2363">2363</a>, <a href="lwg-defects.html#2364">2364</a>, <a href="lwg-active.html#2366">2366</a>, <a href="lwg-active.html#2367">2367</a>, <a href="lwg-active.html#2368">2368</a>, <a href="lwg-defects.html#2369">2369</a>, <a href="lwg-active.html#2370">2370</a>, <a href="lwg-defects.html#2371">2371</a>, <a href="lwg-active.html#2372">2372</a>, <a href="lwg-closed.html#2373">2373</a>, <a href="lwg-defects.html#2374">2374</a>, <a href="lwg-active.html#2375">2375</a>, <a href="lwg-defects.html#2377">2377</a>, <a href="lwg-defects.html#2378">2378</a>, <a href="lwg-active.html#2379">2379</a>, <a href="lwg-active.html#2380">2380</a>, <a href="lwg-active.html#2381">2381</a>, <a href="lwg-closed.html#2382">2382</a>, <a href="lwg-active.html#2383">2383</a>, <a href="lwg-active.html#2384">2384</a>, <a href="lwg-active.html#2385">2385</a>, <a href="lwg-closed.html#2386">2386</a>, <a href="lwg-defects.html#2387">2387</a>, <a href="lwg-closed.html#2388">2388</a>, <a href="lwg-defects.html#2389">2389</a>.</li>
++<li>Changed the following 5 issues to Tentatively Ready (from Open): <a href="lwg-defects.html#2106">2106</a>, <a href="lwg-defects.html#2129">2129</a>, <a href="lwg-defects.html#2212">2212</a>, <a href="lwg-defects.html#2230">2230</a>, <a href="lwg-defects.html#2233">2233</a>.</li>
+ </ul></li>
+ </ul>
+ </li>
+-<li>R49:
+-2007-06-23 pre-Toronto mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>158 open issues, up by 13.</li>
+-<li>538 closed issues, up by 7.</li>
+-<li>696 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#678">678</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#680">680</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#681">681</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#682">682</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#684">684</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#685">685</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#686">686</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#688">688</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#689">689</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#690">690</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#691">691</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#692">692</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#693">693</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#694">694</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#695">695</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#696">696</a>.</li>
+-<li>Added the following Pending NAD Editorial issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#683">683</a>.</li>
+-<li>Changed the following issues from New to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>.</li>
+-<li>Changed the following issues from Open to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R48:
+-2007-05-06 post-Oxford mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>145 open issues, down by 33.</li>
+-<li>531 closed issues, up by 53.</li>
+-<li>676 issues total, up by 20.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#657">657</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#658">658</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#659">659</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#660">660</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#661">661</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#662">662</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#663">663</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#664">664</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#665">665</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#666">666</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#667">667</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#668">668</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#669">669</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#671">671</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#676">676</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Dup: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Changed the following issues from NAD to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#357">357</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#368">368</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>.</li>
+-<li>Changed the following issues from NAD_Future to NAD Future: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#105">105</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#188">188</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#219">219</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#348">348</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#353">353</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#388">388</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>.</li>
+-<li>Changed the following issues from New to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending NAD Editorial: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to Pending WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>.</li>
+-<li>Changed the following issues from New to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>.</li>
+-<li>Changed the following issues from Review to Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>.</li>
+-<li>Changed the following issues from Ready to TRDec: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>.</li>
+-<li>Changed the following issues from Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>.</li>
+-<li>Changed the following issues from Tentatively Ready to WP: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R47:
+-2007-03-09 pre-Oxford mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>178 open issues, up by 37.</li>
+-<li>478 closed issues, up by 0.</li>
+-<li>656 issues total, up by 37.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added the following New issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#620">620</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#621">621</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#622">622</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#623">623</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#624">624</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#627">627</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#628">628</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#629">629</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#630">630</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#631">631</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#632">632</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#633">633</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#634">634</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#635">635</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#636">636</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#637">637</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#638">638</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#639">639</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#640">640</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#641">641</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#642">642</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#643">643</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#644">644</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#645">645</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#646">646</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#647">647</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#648">648</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#649">649</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#650">650</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#651">651</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#652">652</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#653">653</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#654">654</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#655">655</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#656">656</a>.</li>
+-<li>Added the following Open issues: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#625">625</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#626">626</a>.</li>
+-<li>Changed the following issues from New to Open: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>.</li>
+-<li>Changed the following issues from New to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-<li>Changed the following issues from Open to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#201">201</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#206">206</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#258">258</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#385">385</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#416">416</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#422">422</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#456">456</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#466">466</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#470">470</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#471">471</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#482">482</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>.</li>
+-<li>Changed the following issues from Review to Tentatively Ready: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R46:
+-2007-01-12 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>141 open issues, up by 11.</li>
+-<li>478 closed issues, down by 1.</li>
+-<li>619 issues total, up by 10.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#610">610</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#611">611</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#612">612</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#613">613</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#614">614</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#615">615</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#616">616</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#617">617</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#618">618</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#619">619</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R45:
+-2006-11-03 post-Portland mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>130 open issues, up by 0.</li>
+-<li>479 closed issues, up by 17.</li>
+-<li>609 issues total, up by 17.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a> to WP.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a> to NAD.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Dup.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#524">524</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a> to Open.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a> - <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a> to Review.</li>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#593">593</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#595">595</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#596">596</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#597">597</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#598">598</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#599">599</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#600">600</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#601">601</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#602">602</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#603">603</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#604">604</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#605">605</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#606">606</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#607">607</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#608">608</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#609">609</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R44:
+-2006-09-08 pre-Portland mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>130 open issues, up by 6.</li>
+-<li>462 closed issues, down by 1.</li>
+-<li>592 issues total, up by 5.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#583">583</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#584">584</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#585">585</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#586">586</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#587">587</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#589">589</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#590">590</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#591">591</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#592">592</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R43:
+-2006-06-23 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>124 open issues, up by 14.</li>
+-<li>463 closed issues, down by 1.</li>
+-<li>587 issues total, up by 13.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#575">575</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#576">576</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#577">577</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#578">578</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#579">579</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#582">582</a>.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#255">255</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#520">520</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a> to Tentatively Ready.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R42:
+-2006-04-21 post-Berlin mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>110 open issues, down by 16.</li>
+-<li>464 closed issues, up by 24.</li>
+-<li>574 issues total, up by 8.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#567">567</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#568">568</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#570">570</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#571">571</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#572">572</a>.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#499">499</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#501">501</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#517">517</a> to NAD.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#502">502</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#515">515</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#516">516</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#525">525</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a> to Open.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#521">521</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a> to Ready.</li>
+-<li>Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> to WP.</li>
+-<li>Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a> to Review.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R41:
+-2006-02-24 pre-Berlin mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>126 open issues, up by 31.</li>
+-<li>440 closed issues, up by 0.</li>
+-<li>566 issues total, up by 31.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#537">537</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#538">538</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#539">539</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#540">540</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">541</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#542">542</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#543">543</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#544">544</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#545">545</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#546">546</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#547">547</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#548">548</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#549">549</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a> ,<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#551">551</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#552">552</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#553">553</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#554">554</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#555">555</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#556">556</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#557">557</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#558">558</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#559">559</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#560">560</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#561">561</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#562">562</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#563">563</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#564">564</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#565">565</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#566">566</a>.</li>
+-<li>Moved <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a> from Ready to Open.</li>
+-<li>Reopened <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#309">309</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R40:
+-2005-12-16 mid-term mailing.
+-<ul>
+-<li><b>Summary:</b><ul>
+-<li>95 open issues.</li>
+-<li>440 closed issues.</li>
+-<li>535 issues total.</li>
+-</ul></li>
+-<li><b>Details:</b><ul>
+-<li>Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#529">529</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#530">530</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#531">531</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#532">532</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#533">533</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#534">534</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#535">535</a>.</li>
+-</ul></li>
+-</ul>
+-</li>
+-<li>R39:
+-2005-10-14 post-Mont Tremblant mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#526">526</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#528">528</a>.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#461">461</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464">464</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#465">465</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#467">467</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#474">474</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#496">496</a> from Ready to WP as per the vote from Mont Tremblant.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#247">247</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#294">294</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#369">369</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#376">376</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#475">475</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#495">495</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#497">497</a> from Review to Ready.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#506">506</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#509">509</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#510">510</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#511">511</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#512">512</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#513">513</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#514">514</a> from New to Open.
+-Moved issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#505">505</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#507">507</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#508">508</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#519">519</a> from New to Ready.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#500">500</a> from New to NAD.
+-Moved issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#518">518</a> from New to Review.
+-</li>
+-<li>R38:
+-2005-07-03 pre-Mont Tremblant mailing.
+-Merged open TR1 issues in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#504">504</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#523">523</a>
+-</li>
+-<li>R37:
+-2005-06 mid-term mailing.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#498">498</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#503">503</a>.
+-</li>
+-<li>R36:
+-2005-04 post-Lillehammer mailing. All issues in "ready" status except
+-for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#454">454</a> were moved to "DR" status, and all issues
+-previously in "DR" status were moved to "WP".
+-</li>
+-<li>R35:
+-2005-03 pre-Lillehammer mailing.
+-</li>
+-<li>R34:
+-2005-01 mid-term mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#494">494</a>.
+-</li>
+-<li>R33:
+-2004-11 post-Redmond mailing. Reflects actions taken in Redmond.
+-</li>
+-<li>R32:
+-2004-09 pre-Redmond mailing: reflects new proposed resolutions and
+-new issues received after the 2004-07 mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#479">479</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#481">481</a>.
+-</li>
+-<li>R31:
+-2004-07 mid-term mailing: reflects new proposed resolutions and
+-new issues received after the post-Sydney mailing. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#478">478</a>.
+-</li>
+-<li>R30:
+-Post-Sydney mailing: reflects decisions made at the Sydney meeting.
+-Voted all "Ready" issues from R29 into the working paper.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#460">460</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#462">462</a>.
+-</li>
+-<li>R29:
+-Pre-Sydney mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#441">441</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#457">457</a>.
+-</li>
+-<li>R28:
+-Post-Kona mailing: reflects decisions made at the Kona meeting.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#440">440</a>.
+-</li>
+-<li>R27:
+-Pre-Kona mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#404">404</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>.
+-</li>
+-<li>R26:
+-Post-Oxford mailing: reflects decisions made at the Oxford meeting.
+-All issues in Ready status were voted into DR status. All issues in
+-DR status were voted into WP status.
+-</li>
+-<li>R25:
+-Pre-Oxford mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#390">390</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a>.
+-</li>
+-<li>R24:
+-Post-Santa Cruz mailing: reflects decisions made at the Santa Cruz
+-meeting. All Ready issues from R23 with the exception of <iref ref="253">, which has been given a new proposed resolution, were
+-moved to DR status. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#383">383</a>-<iref ref="389">. (Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#387">387</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#389">389</a> were discussed
+-at the meeting.) Made progress on issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>, <iref ref="226">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a> and <iref ref="229"> have been moved to Ready status, and the only remaining
+-concerns with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a> involve wording.
+-</iref></iref></iref></iref></li>
+-<li>R23:
+-Pre-Santa Cruz mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#367">367</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#382">382</a>.
+-Moved issues in the TC to TC status.
+-</li>
+-<li>R22:
+-Post-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#362">362</a>-<iref ref="366">.
+-</iref></li>
+-<li>R21:
+-Pre-Curaçao mailing. Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#351">351</a>-<iref ref="361">.
+-</iref></li>
+-<li>R20:
+-Post-Redmond mailing; reflects actions taken in Redmond. Added
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#336">336</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a>, of which issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#347">347</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a> were added since Redmond, hence
+-not discussed at the meeting.
+-
+-All Ready issues were moved to DR status, with the exception of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a>, and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-
+-Noteworthy issues discussed at Redmond include
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#202">202</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#270">270</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#254">254</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.
+-</li>
+-<li>R19:
+-Pre-Redmond mailing. Added new issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#335">335</a>.
+-</li>
+-<li>R18:
+-Post-Copenhagen mailing; reflects actions taken in Copenhagen.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#317">317</a>, and discussed
+-new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#118">118</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#153">153</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#165">165</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#171">171</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#183">183</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#184">184</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#185">185</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#186">186</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#214">214</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#234">234</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#237">237</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#243">243</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#248">248</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#251">251</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#256">256</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#260">260</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#261">261</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#262">262</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#263">263</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#268">268</a>
+-to DR.
+-
+-Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#117">117</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#230">230</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#238">238</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#241">241</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#242">242</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#259">259</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#266">266</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#271">271</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#272">272</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#273">273</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#275">275</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#281">281</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#284">284</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#285">285</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#286">286</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#288">288</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#292">292</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#295">295</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#297">297</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#298">298</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#301">301</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#306">306</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#307">307</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#308">308</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#312">312</a>
+-to Ready.
+-
+-Closed issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#279">279</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#287">287</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#289">289</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#293">293</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#302">302</a> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#313">313</a>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#314">314</a>
+-as NAD.
+-
+-</li>
+-<li>R17:
+-Pre-Copenhagen mailing. Converted issues list to XML. Added proposed
+-resolutions for issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#49">49</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#76">76</a>, <iref ref="91">, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#235">235</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#267">267</a>.
+-Added new issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#311">311</a>.
+-</iref></li>
+-<li>R16:
+-post-Toronto mailing; reflects actions taken in Toronto. Added new
+-issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#265">265</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#277">277</a>. Changed status of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#3">3</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#8">8</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#9">9</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#19">19</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#26">26</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#31">31</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#61">61</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#63">63</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#108">108</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#115">115</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#122">122</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#142">142</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#144">144</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#146">146</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#147">147</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#159">159</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#164">164</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#170">170</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#181">181</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#208">208</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#209">209</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#210">210</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#217">217</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#220">220</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#222">222</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#223">223</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#224">224</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a> to "DR". Reopened issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#23">23</a>. Reopened
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#187">187</a>. Changed issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#2">2</a> and
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD. Fixed a typo in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a>. Fixed
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#70">70</a>: signature should be changed both places it
+-appears. Fixed issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#160">160</a>: previous version didn't fix
+-the bug in enough places.
+-</li>
+-<li>R15:
+-pre-Toronto mailing. Added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#233">233</a>-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#264">264</a>. Some small HTML formatting
+-changes so that we pass Weblint tests.
+-</li>
+-<li>R14:
+-post-Tokyo II mailing; reflects committee actions taken in
+-Tokyo. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#232">232</a>. (00-0019R1/N1242)
+-</li>
+-<li>R13:
+-pre-Tokyo II updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#212">212</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a>.
+-</li>
+-<li>R12:
+-pre-Tokyo II mailing: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#199">199</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#211">211</a>. Added "and paragraph 5" to the proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#29">29</a>. Add further rationale to issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#178">178</a>.
+-</li>
+-<li>R11:
+-post-Kona mailing: Updated to reflect LWG and full committee actions
+-in Kona (99-0048/N1224). Note changed resolution of issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#196">196</a>
+-to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198">198</a>. Closed issues list split into "defects" and
+-"closed" documents. Changed the proposed resolution of issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#4">4</a> to NAD, and changed the wording of proposed resolution
+-of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#38">38</a>.
+-</li>
+-<li>R10:
+-pre-Kona updated. Added proposed resolutions <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#86">86</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#91">91</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#92">92</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#190">190</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#195">195</a>. (99-0033/D1209, 14 Oct 99)
+-</li>
+-<li>R9:
+-pre-Kona mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a> to
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#189">189</a>. Issues list split into separate "active" and
+-"closed" documents. (99-0030/N1206, 25 Aug 99)
+-</li>
+-<li>R8:
+-post-Dublin mailing. Updated to reflect LWG and full committee actions
+-in Dublin. (99-0016/N1193, 21 Apr 99)
+-</li>
+-<li>R7:
+-pre-Dublin updated: Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#131">131</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#132">132</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#133">133</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#134">134</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#135">135</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#136">136</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#137">137</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#139">139</a> (31 Mar 99)
+-</li>
+-<li>R6:
+-pre-Dublin mailing. Added issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#127">127</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#128">128</a>,
+-and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#129">129</a>. (99-0007/N1194, 22 Feb 99)
+-</li>
+-<li>R5:
+-update issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>; added issues
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#114">114</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#126">126</a>. Format revisions to prepare
+-for making list public. (30 Dec 98)
+-</li>
+-<li>R4:
+-post-Santa Cruz II updated: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#111">111</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#112">112</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#113">113</a> added, several
+-issues corrected. (22 Oct 98)
+-</li>
+-<li>R3:
+-post-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#94">94</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#109">109</a>
+-added, many issues updated to reflect LWG consensus (12 Oct 98)
+-</li>
+-<li>R2:
+-pre-Santa Cruz II: Issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#73">73</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#93">93</a> added,
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#17">17</a> updated. (29 Sep 98)
+-</li>
+-<li>R1:
+-Correction to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#55">55</a> resolution, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#60">60</a> code
+-format, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a> title. (17 Sep 98)
+-</li>
+ </ul>
+
+ <h2>Defect Reports</h2>
+ <hr>
+ <h3><a name="1"></a>1. C library linkage editing oversight</h3>
+-<p><b>Section:</b> 17.6.2.3 [using.linkage] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1997-11-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 17.6.2.3 [using.linkage] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1997-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#using.linkage">issues</a> in [using.linkage].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The change specified in the proposed resolution below did not make
+ it into the Standard. This change was accepted in principle at the
+@@ -1118,17 +226,17 @@ from:</p>
+
+ <blockquote>
+ <p>It is unspecified whether a name from the Standard C library
+- declared with external linkage has either extern "C" or
+- extern "C++" linkage.</p>
++ declared with external linkage has either extern &quot;C&quot; or
++ extern &quot;C++&quot; linkage.</p>
+ </blockquote>
+
+ <p>to:</p>
+
+ <blockquote>
+ <p>Whether a name from the Standard C library declared with external
+- linkage has extern "C" or extern "C++" linkage
++ linkage has extern &quot;C&quot; or extern &quot;C++&quot; linkage
+ is implementation defined. It is recommended that an implementation
+- use extern "C++" linkage for this purpose.</p>
++ use extern &quot;C++&quot; linkage for this purpose.</p>
+ </blockquote>
+
+
+@@ -1137,15 +245,15 @@ from:</p>
+
+ <hr>
+ <h3><a name="3"></a>3. Atexit registration during atexit() call is not described</h3>
+-<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1997-12-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1997-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>We appear not to have covered all the possibilities of
+ exit processing with respect to
+-atexit registration. <br>
+-<br>
++atexit registration. <br/>
++<br/>
+ Example 1: (C and C++)</p>
+
+ <pre> #include &lt;stdlib.h&gt;
+@@ -1194,7 +302,7 @@ through its definition, and all static objects are destroyed during
+ exit processing. Is the code valid? If so, what are its semantics?</p>
+
+ <p>
+-Section 18.3 "Start and termination" says that if a function
++Section 18.3 &quot;Start and termination&quot; says that if a function
+ F is registered with atexit before a static object t is initialized, F
+ will not be called until after t's destructor completes.</p>
+
+@@ -1271,11 +379,11 @@ supporting to the proposed resolution.</p>
+
+ <hr>
+ <h3><a name="5"></a>5. String::compare specification questionable</h3>
+-<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Jack Reeves <b>Opened:</b> 1997-12-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::swap">issues</a> in [string::swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#87">87</a></p>
++<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Jack Reeves <b>Opened:</b> 1997-12-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::swap">issues</a> in [string::swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#87">87</a></p>
+ <p><b>Discussion:</b></p>
+ <p>At the very end of the basic_string class definition is the signature: int
+ compare(size_type pos1, size_type n1, const charT* s, size_type n2 = npos) const; In the
+@@ -1302,7 +410,7 @@ charT* s, size_type n2) const; each defined in terms of the corresponding constr
+ (at the very end of the basic_string synopsis) which reads:</p>
+
+ <blockquote>
+- <p><tt>int compare(size_type pos1, size_type n1,<br>
++ <p><tt>int compare(size_type pos1, size_type n1,<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT* s,
+ size_type n2 = npos) const;</tt></p>
+ </blockquote>
+@@ -1310,9 +418,9 @@ charT* s, size_type n2) const; each defined in terms of the corresponding constr
+ <p>with:</p>
+
+ <blockquote>
+- <p><tt>int compare(size_type pos1, size_type n1,<br>
+- &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT* s) const;<br>
+- int compare(size_type pos1, size_type n1,<br>
++ <p><tt>int compare(size_type pos1, size_type n1,<br/>
++ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT* s) const;<br/>
++ int compare(size_type pos1, size_type n1,<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT* s,
+ size_type n2) const;</tt></p>
+ </blockquote>
+@@ -1321,11 +429,11 @@ charT* s, size_type n2) const; each defined in terms of the corresponding constr
+ paragraphs 5 and 6 which read:</p>
+
+ <blockquote>
+- <p><tt>int compare(size_type pos, size_type n1,<br>
++ <p><tt>int compare(size_type pos, size_type n1,<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; charT * s, size_type n2
+- = npos) const;<br>
+- </tt>Returns:<tt><br>
+- basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br>
++ = npos) const;<br/>
++ </tt>Returns:<tt><br/>
++ basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+ basic_string&lt;charT,traits,Allocator&gt;( s, n2))</tt></p>
+ </blockquote>
+@@ -1333,18 +441,18 @@ paragraphs 5 and 6 which read:</p>
+ <p>with:</p>
+
+ <blockquote>
+- <p><tt>int compare(size_type pos, size_type n1,<br>
+- &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT * s) const;<br>
+- </tt>Returns:<tt><br>
+- basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br>
++ <p><tt>int compare(size_type pos, size_type n1,<br/>
++ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT * s) const;<br/>
++ </tt>Returns:<tt><br/>
++ basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+- basic_string&lt;charT,traits,Allocator&gt;( s ))<br>
+- <br>
+- int compare(size_type pos, size_type n1,<br>
++ basic_string&lt;charT,traits,Allocator&gt;( s ))<br/>
++ <br/>
++ int compare(size_type pos, size_type n1,<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; const charT * s,
+- size_type n2) const;<br>
+- </tt>Returns:<tt><br>
+- basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br>
++ size_type n2) const;<br/>
++ </tt>Returns:<tt><br/>
++ basic_string&lt;charT,traits,Allocator&gt;(*this, pos, n1).compare(<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+ basic_string&lt;charT,traits,Allocator&gt;( s, n2))</tt></p>
+ </blockquote>
+@@ -1364,10 +472,10 @@ identified in issues 7 (item 5) and 87.</p>
+
+ <hr>
+ <h3><a name="7"></a>7. String clause minor problems</h3>
+-<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#strings">issues</a> in [strings].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21 [strings] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#strings">issues</a> in [strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>(1) In 21.4.6.4 [string::insert], the description of template
+ &lt;class InputIterator&gt; insert(iterator, InputIterator,
+@@ -1393,8 +501,8 @@ getting thrown. This is paragraphs 5 and 6 of
+ 21.4.6.8 [string::swap]</p>
+
+ <p>(6) In table 37, in section 21.2.1 [char.traits.require],
+-there's a note for X::move(s, p, n). It says "Copies correctly
+-even where p is in [s, s+n)". This is correct as far as it goes,
++there's a note for X::move(s, p, n). It says &quot;Copies correctly
++even where p is in [s, s+n)&quot;. This is correct as far as it goes,
+ but it doesn't go far enough; it should also guarantee that the copy
+ is correct even where s in in [p, p+n). These are two orthogonal
+ guarantees, and neither one follows from the other. Both guarantees
+@@ -1405,39 +513,39 @@ useful. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>ITEM 1: In 21.3.5.4 [lib.string::insert], change paragraph 16 to <br>
+-<br>
+-&nbsp;&nbsp;&nbsp; EFFECTS: Equivalent to insert(p - begin(), basic_string(first, last)).<br>
+-<br>
++<p>ITEM 1: In 21.3.5.4 [lib.string::insert], change paragraph 16 to <br/>
++<br/>
++&nbsp;&nbsp;&nbsp; EFFECTS: Equivalent to insert(p - begin(), basic_string(first, last)).<br/>
++<br/>
+ ITEM 2:&nbsp; Not a defect; the Standard is clear.. There are ten versions of replace() in
+-the synopsis, and ten versions in 21.3.5.6 [lib.string::replace].<br>
+-<br>
++the synopsis, and ten versions in 21.3.5.6 [lib.string::replace].<br/>
++<br/>
+ ITEM 3: Change the declaration of push_back in the string synopsis (21.3,
+ [lib.basic.string]) from:</p>
+
+-<p>&nbsp;&nbsp;&nbsp;&nbsp; void push_back(const charT)<br>
+-<br>
+-to<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; void push_back(charT)<br>
+-<br>
+-Add the following text immediately after 21.3.5.2 [lib.string::append], paragraph 10.<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; void basic_string::push_back(charT c);<br>
+-&nbsp;&nbsp;&nbsp; EFFECTS: Equivalent to append(static_cast&lt;size_type&gt;(1), c);<br>
+-<br>
+-ITEM 4: Not a defect. The omission appears to have been deliberate.<br>
+-<br>
+-ITEM 5: Duplicate; see issue 5 (and 87).<br>
+-<br>
+-ITEM 6: In table 37, Replace:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; "Copies correctly even where p is in [s, s+n)."<br>
+-<br>
+-with:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; "Copies correctly even where the ranges [p, p+n) and [s,
+-s+n) overlap."</p>
++<p>&nbsp;&nbsp;&nbsp;&nbsp; void push_back(const charT)<br/>
++<br/>
++to<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; void push_back(charT)<br/>
++<br/>
++Add the following text immediately after 21.3.5.2 [lib.string::append], paragraph 10.<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; void basic_string::push_back(charT c);<br/>
++&nbsp;&nbsp;&nbsp; EFFECTS: Equivalent to append(static_cast&lt;size_type&gt;(1), c);<br/>
++<br/>
++ITEM 4: Not a defect. The omission appears to have been deliberate.<br/>
++<br/>
++ITEM 5: Duplicate; see issue 5 (and 87).<br/>
++<br/>
++ITEM 6: In table 37, Replace:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; &quot;Copies correctly even where p is in [s, s+n).&quot;<br/>
++<br/>
++with:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; &quot;Copies correctly even where the ranges [p, p+n) and [s,
++s+n) overlap.&quot;</p>
+
+
+
+@@ -1445,9 +553,9 @@ s+n) overlap."</p>
+
+ <hr>
+ <h3><a name="8"></a>8. Locale::global lacks guarantee</h3>
+-<p><b>Section:</b> 22.3.1.5 [locale.statics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1.5 [locale.statics] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1997-12-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It appears there's an important guarantee missing from clause
+ 22. We're told that invoking locale::global(L) sets the C locale if L
+@@ -1474,10 +582,10 @@ paragraph 2:&nbsp; </p>
+
+ <hr>
+ <h3><a name="9"></a>9. Operator new(0) calls should not yield the same pointer</h3>
+-<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-01-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete">issues</a> in [new.delete].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-01-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete">issues</a> in [new.delete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Scott Meyers, in a comp.std.c++ posting: I just noticed that
+ section 3.7.3.1 of CD2 seems to allow for the possibility that all
+@@ -1542,10 +650,11 @@ supporting to the proposed resolution.</p>
+
+ <hr>
+ <h3><a name="11"></a>11. Bitset minor problems</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-01-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>(1) bitset&lt;&gt;::operator[] is mentioned in the class synopsis (23.3.5), but it is
+ not documented in 23.3.5.2. </p>
+@@ -1560,30 +669,30 @@ go in the Effects clause.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>ITEMS 1 AND 2:<br>
+-<br>
+-In the bitset synopsis (20.5 [template.bitset]),
+-replace the member function <br>
+-<br>
+-<tt>&nbsp;&nbsp;&nbsp; reference operator[](size_t pos);<br>
+-</tt><br>
+-with the two member functions<br>
+-<br>
+-<tt>&nbsp;&nbsp;&nbsp; bool operator[](size_t pos) const; <br>
+-&nbsp;&nbsp;&nbsp; reference operator[](size_t pos); <br>
+-</tt><br>
+-Add the following text at the end of 20.5.2 [bitset.members],
++<p>ITEMS 1 AND 2:<br/>
++<br/>
++In the bitset synopsis (20.6 [template.bitset]),
++replace the member function <br/>
++<br/>
++<tt>&nbsp;&nbsp;&nbsp; reference operator[](size_t pos);<br/>
++</tt><br/>
++with the two member functions<br/>
++<br/>
++<tt>&nbsp;&nbsp;&nbsp; bool operator[](size_t pos) const; <br/>
++&nbsp;&nbsp;&nbsp; reference operator[](size_t pos); <br/>
++</tt><br/>
++Add the following text at the end of 20.6.2 [bitset.members],
+ immediately after paragraph 45:</p>
+
+ <blockquote>
+- <p><tt>bool operator[](size_t pos) const;</tt><br>
+- Requires: pos is valid<br>
+- Throws: nothing<br>
+- Returns: <tt>test(pos)</tt><br>
+- <br>
+- <tt>bitset&lt;N&gt;::reference operator[](size_t pos);</tt> <br>
+- Requires: pos is valid<br>
+- Throws: nothing<br>
++ <p><tt>bool operator[](size_t pos) const;</tt><br/>
++ Requires: pos is valid<br/>
++ Throws: nothing<br/>
++ Returns: <tt>test(pos)</tt><br/>
++ <br/>
++ <tt>bitset&lt;N&gt;::reference operator[](size_t pos);</tt> <br/>
++ Requires: pos is valid<br/>
++ Throws: nothing<br/>
+ Returns: An object of type <tt>bitset&lt;N&gt;::reference</tt> such that <tt>(*this)[pos]
+ == this-&gt;test(pos)</tt>, and such that <tt>(*this)[pos] = val</tt> is equivalent to <tt>this-&gt;set(pos,
+ val);</tt></p>
+@@ -1591,8 +700,8 @@ immediately after paragraph 45:</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>The LWG believes Item 3 is not a defect. "Formatted
+-input" implies the desired semantics. See 27.7.1.2 [istream.formatted].
++<p>The LWG believes Item 3 is not a defect. &quot;Formatted
++input&quot; implies the desired semantics. See 27.7.2.2 [istream.formatted].
+ </p>
+
+
+@@ -1601,19 +710,19 @@ input" implies the desired semantics. See 27.7.1.2 [istream.formatted].
+
+ <hr>
+ <h3><a name="13"></a>13. Eos refuses to die</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> William M. Miller <b>Opened:</b> 1998-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> William M. Miller <b>Opened:</b> 1998-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In 27.6.1.2.3, there is a reference to "eos", which is
++<p>In 27.6.1.2.3, there is a reference to &quot;eos&quot;, which is
+ the only one in the whole draft (at least using Acrobat search), so
+ it's undefined. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.1.2.3 [istream::extractors], replace "eos" with
+-"charT()"</p>
++<p>In 27.7.2.2.3 [istream::extractors], replace &quot;eos&quot; with
++&quot;charT()&quot;</p>
+
+
+
+@@ -1621,26 +730,26 @@ it's undefined. </p>
+
+ <hr>
+ <h3><a name="14"></a>14. Locale::combine should be const</h3>
+-<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.members">issues</a> in [locale.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.members">issues</a> in [locale.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>locale::combine is the only member function of locale (other than constructors and
+ destructor) that is not const. There is no reason for it not to be const, and good reasons
+ why it should have been const. Furthermore, leaving it non-const conflicts with 22.1.1
+-paragraph 6: "An instance of a locale is immutable." </p>
++paragraph 6: &quot;An instance of a locale is immutable.&quot; </p>
+
+ <p>History: this member function originally was a constructor. it happened that the
+ interface it specified had no corresponding language syntax, so it was changed to a member
+-function. As constructors are never const, there was no "const" in the interface
+-which was transformed into member "combine". It should have been added at that
++function. As constructors are never const, there was no &quot;const&quot; in the interface
++which was transformed into member &quot;combine&quot;. It should have been added at that
+ time, but the omission was not noticed. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.3.1 [locale] and also in 22.3.1.3 [locale.members], add
+-"const" to the declaration of member combine: </p>
++&quot;const&quot; to the declaration of member combine: </p>
+ <blockquote>
+ <pre>template &lt;class Facet&gt; locale combine(const locale&amp; other) const; </pre>
+ </blockquote>
+@@ -1651,10 +760,10 @@ time, but the omission was not noticed. </p>
+
+ <hr>
+ <h3><a name="15"></a>15. Locale::name requirement inconsistent</h3>
+-<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.members">issues</a> in [locale.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1.3 [locale.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.members">issues</a> in [locale.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>locale::name() is described as returning a string that can be passed to a locale
+ constructor, but there is no matching constructor. </p>
+@@ -1662,8 +771,8 @@ constructor, but there is no matching constructor. </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.3.1.3 [locale.members], paragraph 5, replace
+-"<tt>locale(name())</tt>" with
+-"<tt>locale(name().c_str())</tt>".
++&quot;<tt>locale(name())</tt>&quot; with
++&quot;<tt>locale(name().c_str())</tt>&quot;.
+ </p>
+
+
+@@ -1672,10 +781,10 @@ constructor, but there is no matching constructor. </p>
+
+ <hr>
+ <h3><a name="16"></a>16. Bad ctype_byname&lt;char&gt; decl</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The new virtual members ctype_byname&lt;char&gt;::do_widen and do_narrow did not get
+ edited in properly. Instead, the member do_widen appears four times, with wrong argument
+@@ -1693,22 +802,23 @@ from 22.4.1.3 [facet.ctype.special].</p>
+
+ <hr>
+ <h3><a name="17"></a>17. Bad bool parsing</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>This section describes the process of parsing a text boolean value from the input
+-stream. It does not say it recognizes either of the sequences "true" or
+-"false" and returns the corresponding bool value; instead, it says it recognizes
++stream. It does not say it recognizes either of the sequences &quot;true&quot; or
++&quot;false&quot; and returns the corresponding bool value; instead, it says it recognizes
+ only one of those sequences, and chooses which according to the received value of a
+ reference argument intended for returning the result, and reports an error if the other
+ sequence is found. (!) Furthermore, it claims to get the names from the ctype&lt;&gt;
+-facet rather than the numpunct&lt;&gt; facet, and it examines the "boolalpha"
+-flag wrongly; it doesn't define the value "loc"; and finally, it computes
+-wrongly whether to use numeric or "alpha" parsing.<br>
+-<br>
+-I believe the correct algorithm is "as if": </p>
++facet rather than the numpunct&lt;&gt; facet, and it examines the &quot;boolalpha&quot;
++flag wrongly; it doesn't define the value &quot;loc&quot;; and finally, it computes
++wrongly whether to use numeric or &quot;alpha&quot; parsing.<br/>
++<br/>
++I believe the correct algorithm is &quot;as if&quot;: </p>
+
+ <pre> // in, err, val, and str are arguments.
+ err = 0;
+@@ -1742,13 +852,13 @@ code above.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.4.2.1.2 [facet.num.get.virtuals], in the first line of paragraph 14,
+-change "&amp;&amp;" to "&amp;".</p>
++change &quot;&amp;&amp;&quot; to &quot;&amp;&quot;.</p>
+
+ <p>Then, replace paragraphs 15 and 16 as follows:</p>
+
+ <blockquote>
+
+- <p>Otherwise target sequences are determined "as if" by
++ <p>Otherwise target sequences are determined &quot;as if&quot; by
+ calling the members <tt>falsename()</tt> and
+ <tt>truename()</tt> of the facet obtained by
+ <tt>use_facet&lt;numpunct&lt;charT&gt;&nbsp;&gt;(str.getloc())</tt>.
+@@ -1769,12 +879,12 @@ change "&amp;&amp;" to "&amp;".</p>
+ <tt>(in==end)</tt>. If <tt>val</tt> is not set, then <i>err</i> is set to <tt>str.failbit</tt>; or to
+ <tt>(str.failbit|str.eofbit)</tt>if
+ the reason for the failure was that <tt>(in==end)</tt>. [Example: for targets
+- <tt>true</tt>:"a" and <tt>false</tt>:"abb", the input sequence "a" yields
+- <tt>val==true</tt> and <tt>err==str.eofbit</tt>; the input sequence "abc" yields
++ <tt>true</tt>:&quot;a&quot; and <tt>false</tt>:&quot;abb&quot;, the input sequence &quot;a&quot; yields
++ <tt>val==true</tt> and <tt>err==str.eofbit</tt>; the input sequence &quot;abc&quot; yields
+ <tt>err=str.failbit</tt>, with <tt>in</tt> ending at the 'c' element. For targets
+- <tt>true</tt>:"1"
+- and <tt>false</tt>:"0", the input sequence "1" yields <tt>val==true</tt>
+- and <tt>err=str.goodbit</tt>. For empty targets (""), any input sequence yields
++ <tt>true</tt>:&quot;1&quot;
++ and <tt>false</tt>:&quot;0&quot;, the input sequence &quot;1&quot; yields <tt>val==true</tt>
++ and <tt>err=str.goodbit</tt>. For empty targets (&quot;&quot;), any input sequence yields
+ <tt>err==str.failbit</tt>. --end example]</p>
+ </blockquote>
+
+@@ -1784,10 +894,10 @@ change "&amp;&amp;" to "&amp;".</p>
+
+ <hr>
+ <h3><a name="18"></a>18. Get(...bool&amp;) omitted</h3>
+-<p><b>Section:</b> 22.4.2.1.1 [facet.num.get.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.members">issues</a> in [facet.num.get.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.1 [facet.num.get.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.members">issues</a> in [facet.num.get.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In the list of num_get&lt;&gt; non-virtual members on page 22-23, the member
+ that parses bool values was omitted from the list of definitions of non-virtual
+@@ -1805,17 +915,17 @@ another get member for bool&amp;, copied from the entry in
+
+
+ <hr>
+-<h3><a name="19"></a>19. "Noconv" definition too vague</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#10">10</a></p>
++<h3><a name="19"></a>19. &quot;Noconv&quot; definition too vague</h3>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#10">10</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the definitions of codecvt&lt;&gt;::do_out and do_in, they are
+-specified to return noconv if "no conversion is
+-needed". This definition is too vague, and does not say
++specified to return noconv if &quot;no conversion is
++needed&quot;. This definition is too vague, and does not say
+ normatively what is done with the buffers.
+ </p>
+
+@@ -1843,19 +953,19 @@ Change the entry for noconv in the table under paragraph 4 in section
+
+ <hr>
+ <h3><a name="20"></a>20. Thousands_sep returns wrong type</h3>
+-<p><b>Section:</b> 22.4.3.1.2 [facet.numpunct.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.3.1.2 [facet.numpunct.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The synopsis for numpunct&lt;&gt;::do_thousands_sep, and the
+ definition of numpunct&lt;&gt;::thousands_sep which calls it, specify
+ that it returns a value of type char_type. Here it is erroneously
+-described as returning a "string_type". </p>
++described as returning a &quot;string_type&quot;. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.4.3.1.2 [facet.numpunct.virtuals], above paragraph 2, change
+-"string_type" to "char_type". </p>
++&quot;string_type&quot; to &quot;char_type&quot;. </p>
+
+
+
+@@ -1863,20 +973,20 @@ described as returning a "string_type". </p>
+
+ <hr>
+ <h3><a name="21"></a>21. Codecvt_byname&lt;&gt; instantiations</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In the second table in the section, captioned "Required
+-instantiations", the instantiations for codecvt_byname&lt;&gt;
++<p>In the second table in the section, captioned &quot;Required
++instantiations&quot;, the instantiations for codecvt_byname&lt;&gt;
+ have been omitted. These are necessary to allow users to construct a
+ locale by name from facets. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add in 22.3.1.1.1 [locale.category] to the table captioned
+-"Required instantiations", in the category "ctype"
++&quot;Required instantiations&quot;, in the category &quot;ctype&quot;
+ the lines </p>
+
+ <blockquote>
+@@ -1890,10 +1000,10 @@ codecvt_byname&lt;wchar_t,char,mbstate_t&gt; </pre>
+
+ <hr>
+ <h3><a name="22"></a>22. Member open vs. flags</h3>
+-<p><b>Section:</b> 27.9.1.9 [ifstream.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.9.1.9 [ifstream.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description of basic_istream&lt;&gt;::open leaves unanswered questions about how it
+ responds to or changes flags in the error status for the stream. A strict reading
+@@ -1930,10 +1040,11 @@ believes to have been the original intent.</p>
+
+ <hr>
+ <h3><a name="23"></a>23. Num_get overflow result</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The current description of numeric input does not account for the
+ possibility of overflow. This is an implicit result of changing the
+@@ -2092,7 +1203,8 @@ Change 22.4.2.1.2 [facet.num.get.virtuals], p6-p7:
+ </p>
+
+ <blockquote>
+-<pre>iter_type do_get(iter_type <i>in</i>, iter_type <i>end</i>, ios_base&amp; <i>str</i>,
++<pre>
++iter_type do_get(iter_type <i>in</i>, iter_type <i>end</i>, ios_base&amp; <i>str</i>,
+ ios_base::iostate&amp; <i>err</i>, bool&amp; <i>val</i>) const;
+ </pre>
+ <blockquote>
+@@ -2127,23 +1239,23 @@ is assigned to <i>err</i>.</ins>
+
+
+ <hr>
+-<h3><a name="24"></a>24. "do_convert" doesn't exist</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#72">72</a></p>
++<h3><a name="24"></a>24. &quot;do_convert&quot; doesn't exist</h3>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#72">72</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The description of codecvt&lt;&gt;::do_out and do_in mentions a
+-symbol "do_convert" which is not defined in the
+-standard. This is a leftover from an edit, and should be "do_in
+-and do_out". </p>
++symbol &quot;do_convert&quot; which is not defined in the
++standard. This is a leftover from an edit, and should be &quot;do_in
++and do_out&quot;. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.4.1.4 [locale.codecvt], paragraph 3, change
+-"do_convert" to "do_in or do_out". Also, in 22.4.1.4.2 [locale.codecvt.virtuals], change "do_convert()" to "do_in
+-or do_out". </p>
++&quot;do_convert&quot; to &quot;do_in or do_out&quot;. Also, in 22.4.1.4.2 [locale.codecvt.virtuals], change &quot;do_convert()&quot; to &quot;do_in
++or do_out&quot;. </p>
+
+
+
+@@ -2151,27 +1263,27 @@ or do_out". </p>
+
+ <hr>
+ <h3><a name="25"></a>25. String operator&lt;&lt; uses width() value wrong</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#67">67</a></p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#67">67</a></p>
+ <p><b>Discussion:</b></p>
+ <p>In the description of operator&lt;&lt; applied to strings, the standard says that uses
+-the smaller of os.width() and str.size(), to pad "as described in stage 3"
++the smaller of os.width() and str.size(), to pad &quot;as described in stage 3&quot;
+ elsewhere; but this is inconsistent, as this allows no possibility of space for padding. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 21.4.8.9 [string.io] paragraph 4 from:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; "... where <tt>n</tt> is the smaller of <tt>os.width()</tt> and <tt>str.size()</tt>;
+-..."<br>
+-<br>
+-to: <br>
+-<br>
+-&nbsp;&nbsp;&nbsp; "... where <tt>n</tt> is the larger of <tt>os.width()</tt> and <tt>str.size()</tt>;
+-..."</p>
++<p>Change 21.4.8.9 [string.io] paragraph 4 from:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; &quot;... where <tt>n</tt> is the smaller of <tt>os.width()</tt> and <tt>str.size()</tt>;
++...&quot;<br/>
++<br/>
++to: <br/>
++<br/>
++&nbsp;&nbsp;&nbsp; &quot;... where <tt>n</tt> is the larger of <tt>os.width()</tt> and <tt>str.size()</tt>;
++...&quot;</p>
+
+
+
+@@ -2179,10 +1291,10 @@ to: <br>
+
+ <hr>
+ <h3><a name="26"></a>26. Bad sentry example</h3>
+-<p><b>Section:</b> 27.7.1.1.3 [istream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.1.3 [istream::sentry] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In paragraph 6, the code in the example: </p>
+
+@@ -2209,7 +1321,7 @@ sequence without examining it.) </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Remove the example above from 27.7.1.1.3 [istream::sentry]
++<p>Remove the example above from 27.7.2.1.3 [istream::sentry]
+ paragraph 6.</p>
+
+
+@@ -2227,14 +1339,14 @@ example, which might well still contain errors.</p>
+
+ <hr>
+ <h3><a name="27"></a>27. String::erase(range) yields wrong iterator</h3>
+-<p><b>Section:</b> 21.4.6.5 [string::erase] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::erase">issues</a> in [string::erase].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4.6.5 [string::erase] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::erase">issues</a> in [string::erase].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The string::erase(iterator first, iterator last) is specified to return an element one
+ place beyond the next element after the last one erased. E.g. for the string
+-"abcde", erasing the range ['b'..'d') would yield an iterator for element 'e',
++&quot;abcde&quot;, erasing the range ['b'..'d') would yield an iterator for element 'e',
+ while 'd' has not been erased. </p>
+
+
+@@ -2259,11 +1371,11 @@ while 'd' has not been erased. </p>
+
+ <hr>
+ <h3><a name="28"></a>28. Ctype&lt;char&gt;is ambiguous</h3>
+-<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#236">236</a></p>
++<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#236">236</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the vector form of ctype&lt;char&gt;::is can be interpreted to mean
+ something very different from what was intended. Paragraph 4 says </p>
+@@ -2291,21 +1403,21 @@ vec[]. </p>
+
+ <hr>
+ <h3><a name="29"></a>29. Ios_base::init doesn't exist</h3>
+-<p><b>Section:</b> 27.4.1 [narrow.stream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#narrow.stream.objects">issues</a> in [narrow.stream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.4.2 [narrow.stream.objects] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#narrow.stream.objects">issues</a> in [narrow.stream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Sections 27.4.1 [narrow.stream.objects] and 27.4.2 [wide.stream.objects] mention
++<p>Sections 27.4.2 [narrow.stream.objects] and 27.4.3 [wide.stream.objects] mention
+ a function ios_base::init, which is not defined. Probably they mean
+-basic_ios&lt;&gt;::init, defined in 27.5.4.1 [basic.ios.cons],
++basic_ios&lt;&gt;::init, defined in 27.5.5.2 [basic.ios.cons],
+ paragraph 3. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>[R12: modified to include paragraph 5.]</p>
+
+-<p>In 27.4.1 [narrow.stream.objects] paragraph 2 and 5, change </p>
++<p>In 27.4.2 [narrow.stream.objects] paragraph 2 and 5, change </p>
+
+ <blockquote>
+ <p>ios_base::init </p>
+@@ -2317,7 +1429,7 @@ paragraph 3. </p>
+ <p>basic_ios&lt;char&gt;::init </p>
+ </blockquote>
+
+-<p>Also, make a similar change in 27.4.2 [wide.stream.objects] except it
++<p>Also, make a similar change in 27.4.3 [wide.stream.objects] except it
+ should read </p>
+
+ <blockquote>
+@@ -2330,10 +1442,10 @@ should read </p>
+
+ <hr>
+ <h3><a name="30"></a>30. Wrong header for LC_*</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 2 implies that the C macros LC_CTYPE etc. are defined in &lt;cctype&gt;,
+ where they are in fact defined elsewhere to appear in &lt;clocale&gt;. </p>
+@@ -2341,7 +1453,7 @@ where they are in fact defined elsewhere to appear in &lt;clocale&gt;. </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.3.1.1.1 [locale.category], paragraph 2, change
+-"&lt;cctype&gt;" to read "&lt;clocale&gt;". </p>
++&quot;&lt;cctype&gt;&quot; to read &quot;&lt;clocale&gt;&quot;. </p>
+
+
+
+@@ -2349,15 +1461,15 @@ where they are in fact defined elsewhere to appear in &lt;clocale&gt;. </p>
+
+ <hr>
+ <h3><a name="31"></a>31. Immutable locale values</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#378">378</a></p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#378">378</a></p>
+ <p><b>Discussion:</b></p>
+-<p>Paragraph 6, says "An instance of <tt>locale</tt> is
++<p>Paragraph 6, says &quot;An instance of <tt>locale</tt> is
+ <i>immutable</i>; once a facet reference is obtained from it,
+-...". This has caused some confusion, because locale variables
++...&quot;. This has caused some confusion, because locale variables
+ are manifestly assignable. </p>
+
+
+@@ -2385,9 +1497,9 @@ are manifestly assignable. </p>
+
+ <hr>
+ <h3><a name="32"></a>32. Pbackfail description inconsistent</h3>
+-<p><b>Section:</b> 27.6.2.4.4 [streambuf.virt.pback] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3.4.4 [streambuf.virt.pback] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the required state before calling virtual member
+ basic_streambuf&lt;&gt;::pbackfail requirements is inconsistent with the conditions
+@@ -2404,16 +1516,16 @@ Specifically, the latter says it calls pbackfail if: </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.6.2.4.4 [streambuf.virt.pback], paragraph 1, change:</p>
++<p>In 27.6.3.4.4 [streambuf.virt.pback], paragraph 1, change:</p>
+
+ <blockquote>
+- <p>"<tt>traits::eq(*gptr(),traits::to_char_type( c))</tt>"</p>
++ <p>&quot;<tt>traits::eq(*gptr(),traits::to_char_type( c))</tt>&quot;</p>
+ </blockquote>
+
+ <p>to </p>
+
+ <blockquote>
+- <p>"<tt>traits::eq(traits::to_char_type(c),gptr()[-1])</tt>"
++ <p>&quot;<tt>traits::eq(traits::to_char_type(c),gptr()[-1])</tt>&quot;
+ </p>
+ </blockquote>
+
+@@ -2428,11 +1540,11 @@ the argument value.</p>
+
+ <hr>
+ <h3><a name="33"></a>33. Codecvt&lt;&gt; mentions from_type</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#43">43</a></p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#43">43</a></p>
+ <p><b>Discussion:</b></p>
+ <p>In the table defining the results from do_out and do_in, the specification for the
+ result <i>error</i> says </p>
+@@ -2459,10 +1571,10 @@ in the table for the case of _error_ with </p>
+
+ <hr>
+ <h3><a name="34"></a>34. True/falsename() not in ctype&lt;&gt;</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In paragraph 19, Effects:, members truename() and falsename are used from facet
+ ctype&lt;charT&gt;, but it has no such members. Note that this is also a problem in
+@@ -2485,19 +1597,19 @@ string_type s = val ? np.truename() : np.falsename(); </pre>
+
+ <hr>
+ <h3><a name="35"></a>35. No manipulator unitbuf in synopsis</h3>
+-<p><b>Section:</b> 27.5 [iostreams.base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostreams.base">issues</a> in [iostreams.base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5 [iostreams.base] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostreams.base">issues</a> in [iostreams.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In 27.5.5.1 [fmtflags.manip], we have a definition for a manipulator
+-named "unitbuf". Unlike other manipulators, it's not listed
+-in synopsis. Similarly for "nounitbuf". </p>
++<p>In 27.5.6.1 [fmtflags.manip], we have a definition for a manipulator
++named &quot;unitbuf&quot;. Unlike other manipulators, it's not listed
++in synopsis. Similarly for &quot;nounitbuf&quot;. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add to the synopsis for &lt;ios&gt; in 27.5 [iostreams.base], after
+-the entry for "nouppercase", the prototypes: </p>
++the entry for &quot;nouppercase&quot;, the prototypes: </p>
+
+ <blockquote>
+ <pre>ios_base&amp; unitbuf(ios_base&amp; str);
+@@ -2510,10 +1622,10 @@ ios_base&amp; nounitbuf(ios_base&amp; str); </pre>
+
+ <hr>
+ <h3><a name="36"></a>36. Iword &amp; pword storage lifetime omitted</h3>
+-<p><b>Section:</b> 27.5.2.5 [ios.base.storage] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base.storage">issues</a> in [ios.base.storage].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.5 [ios.base.storage] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base.storage">issues</a> in [ios.base.storage].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In the definitions for ios_base::iword and pword, the lifetime of the storage is
+ specified badly, so that an implementation which only keeps the last value stored appears
+@@ -2526,7 +1638,7 @@ member with a different index ... </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add in 27.5.2.5 [ios.base.storage], in both paragraph 2 and also in
++<p>Add in 27.5.3.5 [ios.base.storage], in both paragraph 2 and also in
+ paragraph 4, replace the sentence: </p>
+
+ <blockquote>
+@@ -2543,18 +1655,18 @@ paragraph 4, replace the sentence: </p>
+ calling iword [pword] with the same index yields another reference to the same value. </p>
+ </blockquote>
+
+-<p>substituting "iword" or "pword" as appropriate. </p>
++<p>substituting &quot;iword&quot; or &quot;pword&quot; as appropriate. </p>
+
+
+
+
+
+ <hr>
+-<h3><a name="37"></a>37. Leftover "global" reference</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<h3><a name="37"></a>37. Leftover &quot;global&quot; reference</h3>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In the overview of locale semantics, paragraph 4, is the sentence </p>
+
+@@ -2581,12 +1693,12 @@ expression </p>
+
+ <hr>
+ <h3><a name="38"></a>38. Facet definition incomplete</h3>
+-<p><b>Section:</b> 22.3.2 [locale.global.templates] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.2 [locale.global.templates] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It has been noticed by Esa Pulkkinen that the definition of
+-"facet" is incomplete. In particular, a class derived from
++&quot;facet&quot; is incomplete. In particular, a class derived from
+ another facet, but which does not define a member <i>id</i>, cannot
+ safely serve as the argument <i>F</i> to use_facet&lt;F&gt;(loc),
+ because there is no guarantee that a reference to the facet instance
+@@ -2609,10 +1721,10 @@ reads: </p>
+ </blockquote>
+
+ <p><i>[
+-Kona: strike as overspecification the text "(not inherits)"
+-from the original resolution, which read "... whose definition
++Kona: strike as overspecification the text &quot;(not inherits)&quot;
++from the original resolution, which read &quot;... whose definition
+ contains (not inherits) the public static member
+-<tt>id</tt>..."
++<tt>id</tt>...&quot;
+ ]</i></p>
+
+
+@@ -2623,9 +1735,9 @@ contains (not inherits) the public static member
+
+ <hr>
+ <h3><a name="39"></a>39. istreambuf_iterator&lt;&gt;::operator++(int) definition garbled</h3>
+-<p><b>Section:</b> 24.6.3.4 [istreambuf.iterator::op++] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 24.6.3.4 [istreambuf.iterator::op++] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Following the definition of istreambuf_iterator&lt;&gt;::operator++(int) in paragraph
+ 3, the standard contains three lines of garbage text left over from a previous edit. </p>
+@@ -2647,10 +1759,10 @@ end of paragraph 3. </p>
+
+ <hr>
+ <h3><a name="40"></a>40. Meaningless normative paragraph in examples</h3>
+-<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 3 of the locale examples is a description of part of an
+ implementation technique that has lost its referent, and doesn't mean
+@@ -2658,8 +1770,8 @@ anything. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Delete 22.4.8 [facets.examples] paragraph 3 which begins "This
+-initialization/identification system depends...", or (at the
++<p>Delete 22.4.8 [facets.examples] paragraph 3 which begins &quot;This
++initialization/identification system depends...&quot;, or (at the
+ editor's option) replace it with a place-holder to keep the paragraph
+ numbering the same. </p>
+
+@@ -2669,20 +1781,20 @@ numbering the same. </p>
+
+ <hr>
+ <h3><a name="41"></a>41. Ios_base needs clear(), exceptions()</h3>
+-<p><b>Section:</b> 27.5.2 [ios.base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base">issues</a> in [ios.base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#157">157</a></p>
+-<p><b>Discussion:</b></p>
+-<p>The description of ios_base::iword() and pword() in 27.5.2.4 [ios.members.static], say that if they fail, they "set badbit,
+-which may throw an exception". However, ios_base offers no
++<p><b>Section:</b> 27.5.3 [ios.base] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base">issues</a> in [ios.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#157">157</a></p>
++<p><b>Discussion:</b></p>
++<p>The description of ios_base::iword() and pword() in 27.5.3.4 [ios.members.static], say that if they fail, they &quot;set badbit,
++which may throw an exception&quot;. However, ios_base offers no
+ interface to set or to test badbit; those interfaces are defined in
+ basic_ios&lt;&gt;. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change the description in 27.5.2.5 [ios.base.storage] in
++<p>Change the description in 27.5.3.5 [ios.base.storage] in
+ paragraph 2, and also in paragraph 4, as follows. Replace</p>
+
+ <blockquote>
+@@ -2709,10 +1821,11 @@ setstate(badbit).]</i></p>
+
+ <hr>
+ <h3><a name="42"></a>42. String ctors specify wrong default allocator</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The basic_string&lt;&gt; copy constructor: </p>
+
+@@ -2782,8 +1895,8 @@ the declaration of the copy constructor as follows: </p>
+ </blockquote>
+
+ <p>The proposed resolution reflects the original intent of the LWG. It
+-was also noted by Pete Becker that this fix "will cause
+-a small amount of existing code to now work correctly."</p>
++was also noted by Pete Becker that this fix &quot;will cause
++a small amount of existing code to now work correctly.&quot;</p>
+
+ <p><i>[
+ Kona: issue editing snafu fixed - the proposed resolution now correctly
+@@ -2797,10 +1910,10 @@ reflects the LWG consensus.
+
+ <hr>
+ <h3><a name="44"></a>44. Iostreams use operator== on int_type values</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Many of the specifications for iostreams specify that character
+ values or their int_type equivalents are compared using operators ==
+@@ -2820,12 +1933,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.basic.ios.members paragraph 13 (postcondition clause for
+ 'fill(cT)') change
+
+-<blockquote><pre> fillch == fill()
++<blockquote><pre>
++ fillch == fill()
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(fillch, fill())
++<blockquote><pre>
++ traits::eq(fillch, fill())
+ </pre></blockquote>
+
+
+@@ -2834,25 +1949,29 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.istream.unformatted paragraph 7 (effects clause for
+ 'get(cT,streamsize,cT)'), third bullet, change
+
+-<blockquote><pre> c == delim for the next available input character c
++<blockquote><pre>
++ c == delim for the next available input character c
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(c, delim) for the next available input character c
++<blockquote><pre>
++ traits::eq(c, delim) for the next available input character c
+ </pre></blockquote>
+
+ </li>
+ <li>
+ In lib.istream.unformatted paragraph 12 (effects clause for
+- 'get(basic_streambuf&lt;cT,Tr&gt;&amp;,cT)'), third bullet, change
++ 'get(basic_streambuf&lt;cT,Tr>&amp;,cT)'), third bullet, change
+
+-<blockquote><pre> c == delim for the next available input character c
++<blockquote><pre>
++ c == delim for the next available input character c
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(c, delim) for the next available input character c
++<blockquote><pre>
++ traits::eq(c, delim) for the next available input character c
+ </pre></blockquote>
+
+ </li>
+@@ -2860,12 +1979,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.istream.unformatted paragraph 17 (effects clause for
+ 'getline(cT,streamsize,cT)'), second bullet, change
+
+-<blockquote><pre> c == delim for the next available input character c
++<blockquote><pre>
++ c == delim for the next available input character c
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(c, delim) for the next available input character c
++<blockquote><pre>
++ traits::eq(c, delim) for the next available input character c
+ </pre></blockquote>
+
+ </li>
+@@ -2873,12 +1994,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.istream.unformatted paragraph 24 (effects clause for
+ 'ignore(int,int_type)'), second bullet, change
+
+-<blockquote><pre> c == delim for the next available input character c
++<blockquote><pre>
++ c == delim for the next available input character c
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq_int_type(c, delim) for the next available input
++<blockquote><pre>
++ traits::eq_int_type(c, delim) for the next available input
+ character c
+ </pre></blockquote>
+
+@@ -2887,12 +2010,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.istream.unformatted paragraph 25 (notes clause for
+ 'ignore(int,int_type)'), second bullet, change
+
+-<blockquote><pre> The last condition will never occur if delim == traits::eof()
++<blockquote><pre>
++ The last condition will never occur if delim == traits::eof()
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> The last condition will never occur if
++<blockquote><pre>
++ The last condition will never occur if
+ traits::eq_int_type(delim, traits::eof()).
+ </pre></blockquote>
+
+@@ -2901,12 +2026,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.istream.sentry paragraph 6 (example implementation for the
+ sentry constructor) change
+
+-<blockquote><pre> while ((c = is.rdbuf()-&gt;snextc()) != traits::eof()) {
++<blockquote><pre>
++ while ((c = is.rdbuf()->snextc()) != traits::eof()) {
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> while (!traits::eq_int_type(c = is.rdbuf()-&gt;snextc(), traits::eof())) {
++<blockquote><pre>
++ while (!traits::eq_int_type(c = is.rdbuf()->snextc(), traits::eof())) {
+ </pre></blockquote>
+
+ </li>
+@@ -2919,12 +2046,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::find paragraph 1 (effects clause for find()),
+ second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+
+ </li>
+@@ -2932,12 +2061,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::rfind paragraph 1 (effects clause for rfind()),
+ second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+
+ </li>
+@@ -2945,12 +2076,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::find.first.of paragraph 1 (effects clause for
+ find_first_of()), second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+
+ </li>
+@@ -2958,12 +2091,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::find.last.of paragraph 1 (effects clause for
+ find_last_of()), second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+
+ </li>
+@@ -2971,12 +2106,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::find.first.not.of paragraph 1 (effects clause for
+ find_first_not_of()), second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+ </li>
+
+@@ -2984,12 +2121,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string::find.last.not.of paragraph 1 (effects clause for
+ find_last_not_of()), second bullet, change
+
+-<blockquote><pre> at(xpos+I) == str.at(I) for all elements ...
++<blockquote><pre>
++ at(xpos+I) == str.at(I) for all elements ...
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(at(xpos+I), str.at(I)) for all elements ...
++<blockquote><pre>
++ traits::eq(at(xpos+I), str.at(I)) for all elements ...
+ </pre></blockquote>
+ </li>
+
+@@ -2997,12 +2136,14 @@ change uses of == and != to use the traits members instead. </p>
+ In lib.string.ios paragraph 5 (effects clause for getline()),
+ second bullet, change
+
+-<blockquote><pre> c == delim for the next available input character c
++<blockquote><pre>
++ c == delim for the next available input character c
+ </pre></blockquote>
+
+ to
+
+-<blockquote><pre> traits::eq(c, delim) for the next available input character c
++<blockquote><pre>
++ traits::eq(c, delim) for the next available input character c
+ </pre></blockquote>
+ </li>
+
+@@ -3048,13 +2189,13 @@ change uses of == and != to use the traits members instead. </p>
+
+ <hr>
+ <h3><a name="46"></a>46. Minor Annex D errors</h3>
+-<p><b>Section:</b> D.9 [depr.str.strstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Brendan Kehoe <b>Opened:</b> 1998-06-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.7 [depr.str.strstreams] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Brendan Kehoe <b>Opened:</b> 1998-06-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p><p>See lib-6522 and edit-814.</p>
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change D.9.1 [depr.strstreambuf] (since streambuf is a typedef of
++<p>Change D.7.1 [depr.strstreambuf] (since streambuf is a typedef of
+ basic_streambuf&lt;char&gt;) from:</p>
+
+ <pre> virtual streambuf&lt;char&gt;* setbuf(char* s, streamsize n);</pre>
+@@ -3063,7 +2204,7 @@ basic_streambuf&lt;char&gt;) from:</p>
+
+ <pre> virtual streambuf* setbuf(char* s, streamsize n);</pre>
+
+-<p>In D.9.4 [depr.strstream] insert the semicolon now missing after
++<p>In D.7.4 [depr.strstream] insert the semicolon now missing after
+ int_type:</p>
+
+ <pre> namespace std {
+@@ -3081,10 +2222,10 @@ int_type:</p>
+
+ <hr>
+ <h3><a name="47"></a>47. Imbue() and getloc() Returns clauses swapped</h3>
+-<p><b>Section:</b> 27.5.2.3 [ios.base.locales] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base.locales">issues</a> in [ios.base.locales].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.3 [ios.base.locales] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base.locales">issues</a> in [ios.base.locales].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 27.4.2.3 specifies how imbue() and getloc() work. That
+ section has two RETURNS clauses, and they make no sense as
+@@ -3094,7 +2235,7 @@ accident?</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.5.2.3 [ios.base.locales] swap paragraphs 2 and 4.</p>
++<p>In 27.5.3.3 [ios.base.locales] swap paragraphs 2 and 4.</p>
+
+
+
+@@ -3102,10 +2243,10 @@ accident?</p>
+
+ <hr>
+ <h3><a name="48"></a>48. Use of non-existent exception constructor</h3>
+-<p><b>Section:</b> 27.5.2.1.1 [ios::failure] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.4.2.1.1, paragraph 2, says that class failure initializes the
+ base class, exception, with exception(msg). Class exception (see
+@@ -3113,7 +2254,7 @@ base class, exception, with exception(msg). Class exception (see
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace 27.5.2.1.1 [ios::failure], paragraph 2, with</p>
++<p>Replace 27.5.3.1.1 [ios::failure], paragraph 2, with</p>
+
+ <blockquote>
+ <p>EFFECTS: Constructs an object of class <tt>failure</tt>.</p>
+@@ -3125,9 +2266,9 @@ base class, exception, with exception(msg). Class exception (see
+
+ <hr>
+ <h3><a name="49"></a>49. Underspecification of ios_base::sync_with_stdio</h3>
+-<p><b>Section:</b> 27.5.2.4 [ios.members.static] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.3.4 [ios.members.static] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Two problems</p>
+
+@@ -3143,7 +2284,7 @@ guesses, but that's another matter.)</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change the following sentence in 27.5.2.4 [ios.members.static]
++<p>Change the following sentence in 27.5.3.4 [ios.members.static]
+ returns clause from:</p>
+
+ <blockquote>
+@@ -3159,35 +2300,41 @@ returns clause from:</p>
+ <tt>false</tt>.</p>
+ </blockquote>
+
+-<p>Add the following immediately after 27.5.2.4 [ios.members.static],
++<p>Add the following immediately after 27.5.3.4 [ios.members.static],
+ paragraph 2:</p>
+
+ <blockquote>
+ <p>When a standard iostream object str is <i>synchronized</i> with a
+ standard stdio stream f, the effect of inserting a character c by</p>
+-<pre> fputc(f, c);
++<pre>
++ fputc(f, c);
+ </pre>
+
+ <p>is the same as the effect of</p>
+-<pre> str.rdbuf()-&gt;sputc(c);
++<pre>
++ str.rdbuf()-&gt;sputc(c);
+ </pre>
+
+ <p>for any sequence of characters; the effect of extracting a
+ character c by</p>
+-<pre> c = fgetc(f);
++<pre>
++ c = fgetc(f);
+ </pre>
+
+ <p>is the same as the effect of:</p>
+-<pre> c = str.rdbuf()-&gt;sbumpc(c);
++<pre>
++ c = str.rdbuf()-&gt;sbumpc(c);
+ </pre>
+
+ <p>for any sequences of characters; and the effect of pushing
+ back a character c by</p>
+-<pre> ungetc(c, f);
++<pre>
++ ungetc(c, f);
+ </pre>
+
+ <p>is the same as the effect of</p>
+-<pre> str.rdbuf()-&gt;sputbackc(c);
++<pre>
++ str.rdbuf()-&gt;sputbackc(c);
+ </pre>
+
+ <p>for any sequence of characters. [<i>Footnote</i>: This implies
+@@ -3212,10 +2359,10 @@ on the two streams can be mixed arbitrarily.]</i></p>
+
+ <hr>
+ <h3><a name="50"></a>50. Copy constructor and assignment operator of ios_base</h3>
+-<p><b>Section:</b> 27.5.2 [ios.base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base">issues</a> in [ios.base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3 [ios.base] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base">issues</a> in [ios.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>As written, ios_base has a copy constructor and an assignment
+ operator. (Nothing in the standard says it doesn't have one, and all
+@@ -3238,7 +2385,7 @@ semantics (e.g. what happens to the iarray and parray stuff).
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.5.2 [ios.base], class ios_base, specify the copy
++<p>In 27.5.3 [ios.base], class ios_base, specify the copy
+ constructor and operator= members as being private.</p>
+
+
+@@ -3252,10 +2399,11 @@ outweighs any benefit of allowing ios_base objects to be copyable.</p>
+
+ <hr>
+ <h3><a name="51"></a>51. Requirement to not invalidate iterators missing</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> David Vandevoorde <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> David Vandevoorde <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The std::sort algorithm can in general only sort a given sequence
+ by moving around values. The list&lt;&gt;::sort() member on the other
+@@ -3303,8 +2451,8 @@ function otherwise.</p>
+ <p>This was US issue CD2-23-011; it was accepted in London but the
+ change was not made due to an editing oversight. The wording in the
+ proposed resolution below is somewhat updated from CD2-23-011,
+-particularly the addition of the phrase "or change the values
+-of"</p>
++particularly the addition of the phrase &quot;or change the values
++of&quot;</p>
+
+
+
+@@ -3312,23 +2460,23 @@ of"</p>
+
+ <hr>
+ <h3><a name="52"></a>52. Small I/O problems</h3>
+-<p><b>Section:</b> 27.5.3.2 [fpos.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos.operations">issues</a> in [fpos.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.4.2 [fpos.operations] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos.operations">issues</a> in [fpos.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>First, 27.5.4.1 [basic.ios.cons], table 89. This is pretty obvious:
+-it should be titled "basic_ios&lt;&gt;() effects", not
+-"ios_base() effects". </p>
++<p>First, 27.5.5.2 [basic.ios.cons], table 89. This is pretty obvious:
++it should be titled &quot;basic_ios&lt;&gt;() effects&quot;, not
++&quot;ios_base() effects&quot;. </p>
+
+-<p>[The second item is a duplicate; see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#6">6</a> for
++<p>[The second item is a duplicate; see issue <a href="lwg-closed.html#6">6</a> for
+ resolution.]</p>
+
+-<p>Second, 27.5.3.2 [fpos.operations] table 88 . There are a couple
++<p>Second, 27.5.4.2 [fpos.operations] table 88 . There are a couple
+ different things wrong with it, some of which I've already discussed
+ with Jerry, but the most obvious mechanical sort of error is that it
+ uses expressions like P(i) and p(i), without ever defining what sort
+-of thing "i" is.
++of thing &quot;i&quot; is.
+ </p>
+
+ <p>(The other problem is that it requires support for streampos
+@@ -3341,9 +2489,9 @@ arithmetic is possible.) </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.5.4.1 [basic.ios.cons] table 89 title from
+-"ios_base() effects" to "basic_ios&lt;&gt;()
+-effects". </p>
++<p>Change 27.5.5.2 [basic.ios.cons] table 89 title from
++&quot;ios_base() effects&quot; to &quot;basic_ios&lt;&gt;()
++effects&quot;. </p>
+
+
+
+@@ -3351,10 +2499,10 @@ effects". </p>
+
+ <hr>
+ <h3><a name="53"></a>53. Basic_ios destructor unspecified</h3>
+-<p><b>Section:</b> 27.5.4.1 [basic.ios.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.5.2 [basic.ios.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There's nothing in 27.4.4 saying what basic_ios's destructor does.
+ The important question is whether basic_ios::~basic_ios() destroys
+@@ -3362,7 +2510,7 @@ rdbuf().</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add after 27.5.4.1 [basic.ios.cons] paragraph 2:</p>
++<p>Add after 27.5.5.2 [basic.ios.cons] paragraph 2:</p>
+
+ <blockquote>
+ <p><tt>virtual ~basic_ios();</tt></p>
+@@ -3373,10 +2521,10 @@ rdbuf().</p>
+ <p><b>Rationale:</b></p>
+ <p>The LWG reviewed the additional question of whether or not
+ <tt>rdbuf(0)</tt> may set <tt>badbit</tt>. The answer is
+-clearly yes; it may be set via <tt>clear()</tt>. See 27.5.4.2 [basic.ios.members], paragraph 6. This issue was reviewed at length
++clearly yes; it may be set via <tt>clear()</tt>. See 27.5.5.3 [basic.ios.members], paragraph 6. This issue was reviewed at length
+ by the LWG, which removed from the original proposed resolution a
+-footnote which incorrectly said "<tt>rdbuf(0)</tt> does not set
+-<tt>badbit</tt>".</p>
++footnote which incorrectly said &quot;<tt>rdbuf(0)</tt> does not set
++<tt>badbit</tt>&quot;.</p>
+
+
+
+@@ -3384,10 +2532,10 @@ footnote which incorrectly said "<tt>rdbuf(0)</tt> does not set
+
+ <hr>
+ <h3><a name="54"></a>54. Basic_streambuf's destructor</h3>
+-<p><b>Section:</b> 27.6.2.1 [streambuf.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf.cons">issues</a> in [streambuf.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3.1 [streambuf.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf.cons">issues</a> in [streambuf.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The class synopsis for basic_streambuf shows a (virtual)
+ destructor, but the standard doesn't say what that destructor does. My
+@@ -3396,7 +2544,7 @@ explicitly. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add after 27.6.2.1 [streambuf.cons] paragraph 2:</p>
++<p>Add after 27.6.3.1 [streambuf.cons] paragraph 2:</p>
+
+ <blockquote>
+ <p><tt>virtual&nbsp; ~basic_streambuf();</tt></p>
+@@ -3409,13 +2557,13 @@ explicitly. </p>
+
+ <hr>
+ <h3><a name="55"></a>55. Invalid stream position is undefined</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Several member functions in clause 27 are defined in certain
+-circumstances to return an "invalid stream position", a term
++circumstances to return an &quot;invalid stream position&quot;, a term
+ that is defined nowhere in the standard. Two places (27.5.2.4.2,
+ paragraph 4, and 27.8.1.4, paragraph 15) contain a cross-reference to
+ a definition in _lib.iostreams.definitions_, a nonexistent
+@@ -3424,54 +2572,54 @@ section. </p>
+ <p>I suspect that the invalid stream position is just supposed to be
+ pos_type(-1). Probably best to say explicitly in (for example)
+ 27.5.2.4.2 that the return value is pos_type(-1), rather than to use
+-the term "invalid stream position", define that term
++the term &quot;invalid stream position&quot;, define that term
+ somewhere, and then put in a cross-reference. </p>
+
+-<p>The phrase "invalid stream position" appears ten times in
++<p>The phrase &quot;invalid stream position&quot; appears ten times in
+ the C++ Standard. In seven places it refers to a return value, and it
+ should be changed. In three places it refers to an argument, and it
+-should not be changed. Here are the three places where "invalid
+-stream position" should not be changed:</p>
++should not be changed. Here are the three places where &quot;invalid
++stream position&quot; should not be changed:</p>
+
+ <blockquote>
+- <p>27.8.1.4 [stringbuf.virtuals], paragraph 14<br>
+- 27.9.1.5 [filebuf.virtuals], paragraph 14<br>
+- D.9.1.3 [depr.strstreambuf.virtuals], paragraph 17
++ <p>27.8.2.4 [stringbuf.virtuals], paragraph 14<br/>
++ 27.9.1.5 [filebuf.virtuals], paragraph 14<br/>
++ D.7.1.3 [depr.strstreambuf.virtuals], paragraph 17
+ </p>
+ </blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.6.2.4.2 [streambuf.virt.buffer], paragraph 4, change "Returns an
++<p>In 27.6.3.4.2 [streambuf.virt.buffer], paragraph 4, change &quot;Returns an
+ object of class pos_type that stores an invalid stream position
+-(_lib.iostreams.definitions_)" to "Returns
+-<tt>pos_type(off_type(-1))</tt>".
++(_lib.iostreams.definitions_)&quot; to &quot;Returns
++<tt>pos_type(off_type(-1))</tt>&quot;.
+ </p>
+
+-<p>In 27.6.2.4.2 [streambuf.virt.buffer], paragraph 6, change "Returns
++<p>In 27.6.3.4.2 [streambuf.virt.buffer], paragraph 6, change &quot;Returns
+ an object of class pos_type that stores an invalid stream
+-position" to "Returns <tt>pos_type(off_type(-1))</tt>".</p>
++position&quot; to &quot;Returns <tt>pos_type(off_type(-1))</tt>&quot;.</p>
+
+-<p>In 27.8.1.4 [stringbuf.virtuals], paragraph 13, change "the object
+-stores an invalid stream position" to "the return value is
+-<tt>pos_type(off_type(-1))</tt>". </p>
++<p>In 27.8.2.4 [stringbuf.virtuals], paragraph 13, change &quot;the object
++stores an invalid stream position&quot; to &quot;the return value is
++<tt>pos_type(off_type(-1))</tt>&quot;. </p>
+
+-<p>In 27.9.1.5 [filebuf.virtuals], paragraph 13, change "returns an
+-invalid stream position (27.4.3)" to "returns
+-<tt>pos_type(off_type(-1))</tt>" </p>
++<p>In 27.9.1.5 [filebuf.virtuals], paragraph 13, change &quot;returns an
++invalid stream position (27.4.3)&quot; to &quot;returns
++<tt>pos_type(off_type(-1))</tt>&quot; </p>
+
+-<p>In 27.9.1.5 [filebuf.virtuals], paragraph 15, change "Otherwise
+-returns an invalid stream position (_lib.iostreams.definitions_)"
+-to "Otherwise returns <tt>pos_type(off_type(-1))</tt>"
++<p>In 27.9.1.5 [filebuf.virtuals], paragraph 15, change &quot;Otherwise
++returns an invalid stream position (_lib.iostreams.definitions_)&quot;
++to &quot;Otherwise returns <tt>pos_type(off_type(-1))</tt>&quot;
+ </p>
+
+-<p>In D.9.1.3 [depr.strstreambuf.virtuals], paragraph 15, change "the object
+-stores an invalid stream position" to "the return value is
+-<tt>pos_type(off_type(-1))</tt>" </p>
++<p>In D.7.1.3 [depr.strstreambuf.virtuals], paragraph 15, change &quot;the object
++stores an invalid stream position&quot; to &quot;the return value is
++<tt>pos_type(off_type(-1))</tt>&quot; </p>
+
+-<p>In D.9.1.3 [depr.strstreambuf.virtuals], paragraph 18, change "the object
+-stores an invalid stream position" to "the return value is
+-<tt>pos_type(off_type(-1))</tt>"</p>
++<p>In D.7.1.3 [depr.strstreambuf.virtuals], paragraph 18, change &quot;the object
++stores an invalid stream position&quot; to &quot;the return value is
++<tt>pos_type(off_type(-1))</tt>&quot;</p>
+
+
+
+@@ -3479,10 +2627,10 @@ stores an invalid stream position" to "the return value is
+
+ <hr>
+ <h3><a name="56"></a>56. Showmanyc's return type</h3>
+-<p><b>Section:</b> 27.6.2 [streambuf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf">issues</a> in [streambuf].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3 [streambuf] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-06-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf">issues</a> in [streambuf].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The class summary for basic_streambuf&lt;&gt;, in 27.5.2, says that
+ showmanyc has return type int. However, 27.5.2.4.3 says that its
+@@ -3491,7 +2639,7 @@ return type is streamsize. </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change <tt>showmanyc</tt>'s return type in the
+-27.6.2 [streambuf] class summary to <tt>streamsize</tt>.</p>
++27.6.3 [streambuf] class summary to <tt>streamsize</tt>.</p>
+
+
+
+@@ -3499,14 +2647,14 @@ return type is streamsize. </p>
+
+ <hr>
+ <h3><a name="57"></a>57. Mistake in char_traits</h3>
+-<p><b>Section:</b> 21.2.3.4 [char.traits.specializations.wchar.t] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.2.3.4 [char.traits.specializations.wchar.t] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>21.1.3.2, paragraph 3, says "The types streampos and
++<p>21.1.3.2, paragraph 3, says &quot;The types streampos and
+ wstreampos may be different if the implementation supports no shift
+ encoding in narrow-oriented iostreams but supports one or more shift
+-encodings in wide-oriented streams". </p>
++encodings in wide-oriented streams&quot;. </p>
+
+ <p>That's wrong: the two are the same type. The &lt;iosfwd&gt; summary
+ in 27.2 says that streampos and wstreampos are, respectively, synonyms
+@@ -3519,8 +2667,8 @@ char_traits&lt;wchar_t&gt;::state_type must both be mbstate_t. </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Remove the sentence in 21.2.3.4 [char.traits.specializations.wchar.t] paragraph 3 which
+-begins "The types streampos and wstreampos may be
+-different..." . </p>
++begins &quot;The types streampos and wstreampos may be
++different...&quot; . </p>
+
+
+
+@@ -3528,12 +2676,12 @@ different..." . </p>
+
+ <hr>
+ <h3><a name="59"></a>59. Ambiguity in specification of gbump</h3>
+-<p><b>Section:</b> 27.6.2.3.2 [streambuf.get.area] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3.3.2 [streambuf.get.area] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>27.5.2.3.1 says that basic_streambuf::gbump() "Advances the
+-next pointer for the input sequence by n." </p>
++<p>27.5.2.3.1 says that basic_streambuf::gbump() &quot;Advances the
++next pointer for the input sequence by n.&quot; </p>
+
+ <p>The straightforward interpretation is that it is just gptr() +=
+ n. An alternative interpretation, though, is that it behaves as if it
+@@ -3541,12 +2689,12 @@ calls sbumpc n times. (The issue, of course, is whether it might ever
+ call underflow.) There is a similar ambiguity in the case of
+ pbump. </p>
+
+-<p>(The "classic" AT&amp;T implementation used the
++<p>(The &quot;classic&quot; AT&amp;T implementation used the
+ former interpretation.)</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.6.2.3.2 [streambuf.get.area] paragraph 4 gbump effects from:</p>
++<p>Change 27.6.3.3.2 [streambuf.get.area] paragraph 4 gbump effects from:</p>
+
+ <blockquote>
+ <p>Effects: Advances the next pointer for the input sequence by n.</p>
+@@ -3558,7 +2706,7 @@ former interpretation.)</p>
+ <p>Effects: Adds <tt>n</tt> to the next pointer for the input sequence.</p>
+ </blockquote>
+
+-<p>Make the same change to 27.6.2.3.3 [streambuf.put.area] paragraph 4 pbump
++<p>Make the same change to 27.6.3.3.3 [streambuf.put.area] paragraph 4 pbump
+ effects.</p>
+
+
+@@ -3567,21 +2715,21 @@ effects.</p>
+
+ <hr>
+ <h3><a name="60"></a>60. What is a formatted input function?</h3>
+-<p><b>Section:</b> 27.7.1.2.1 [istream.formatted.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.reqmts">issues</a> in [istream.formatted.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#162">162</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#163">163</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#166">166</a></p>
++<p><b>Section:</b> 27.7.2.2.1 [istream.formatted.reqmts] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.reqmts">issues</a> in [istream.formatted.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#162">162</a>, <a href="lwg-closed.html#163">163</a>, <a href="lwg-closed.html#166">166</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 1 of 27.6.1.2.1 contains general requirements for all
+ formatted input functions. Some of the functions defined in section
+-27.6.1.2 explicitly say that those requirements apply ("Behaves
+-like a formatted input member (as described in 27.6.1.2.1)"), but
++27.6.1.2 explicitly say that those requirements apply (&quot;Behaves
++like a formatted input member (as described in 27.6.1.2.1)&quot;), but
+ others don't. The question: is 27.6.1.2.1 supposed to apply to
+ everything in 27.6.1.2, or only to those member functions that
+-explicitly say "behaves like a formatted input member"? Or
++explicitly say &quot;behaves like a formatted input member&quot;? Or
+ to put it differently: are we to assume that everything that appears
+-in a section called "Formatted input functions" really is a
++in a section called &quot;Formatted input functions&quot; really is a
+ formatted input function? I assume that 27.6.1.2.1 is intended to
+ apply to the arithmetic extractors (27.6.1.2.2), but I assume that it
+ is not intended to apply to extractors like </p>
+@@ -3599,33 +2747,33 @@ output. </p>
+ basic_istream and basic_ostream operator &lt;&lt;()'s that are used
+ for the manipulators and streambuf* are in the wrong section and
+ should have their own separate section or be modified to make it clear
+-that the "Common requirements" listed in section 27.6.1.2.1
++that the &quot;Common requirements&quot; listed in section 27.6.1.2.1
+ (for basic_istream) and section 27.6.2.5.1 (for basic_ostream) do not
+ apply to them. </p>
+
+-<p>Additional comments from Dietmar Kühl: It appears to be somewhat
+-nonsensical to consider the functions defined in 27.7.1.2.3 [istream::extractors] paragraphs 1 to 5 to be "Formatted input
+-function" but since these functions are defined in a section
+-labeled "Formatted input functions" it is unclear to me
++<p>Additional comments from Dietmar K&uuml;hl: It appears to be somewhat
++nonsensical to consider the functions defined in 27.7.2.2.3 [istream::extractors] paragraphs 1 to 5 to be &quot;Formatted input
++function&quot; but since these functions are defined in a section
++labeled &quot;Formatted input functions&quot; it is unclear to me
+ whether these operators are considered formatted input functions which
+-have to conform to the "common requirements" from 27.7.1.2.1 [istream.formatted.reqmts]: If this is the case, all manipulators, not
++have to conform to the &quot;common requirements&quot; from 27.7.2.2.1 [istream.formatted.reqmts]: If this is the case, all manipulators, not
+ just <tt>ws</tt>, would skip whitespace unless <tt>noskipws</tt> is
+ set (... but setting <tt>noskipws</tt> using the manipulator syntax
+ would also skip whitespace :-)</p> <p>It is not clear which functions
+ are to be considered unformatted input functions. As written, it seems
+-that all functions in 27.7.1.3 [istream.unformatted] are unformatted input
++that all functions in 27.7.2.3 [istream.unformatted] are unformatted input
+ functions. However, it does not really make much sense to construct a
+ sentry object for <tt>gcount()</tt>, <tt>sync()</tt>, ... Also it is
+ unclear what happens to the <tt>gcount()</tt> if
+ eg. <tt>gcount()</tt>, <tt>putback()</tt>, <tt>unget()</tt>, or
+ <tt>sync()</tt> is called: These functions don't extract characters,
+-some of them even "unextract" a character. Should this still
++some of them even &quot;unextract&quot; a character. Should this still
+ be reflected in <tt>gcount()</tt>? Of course, it could be read as if
+ after a call to <tt>gcount()</tt> <tt>gcount()</tt> return <tt>0</tt>
+ (the last unformatted input function, <tt>gcount()</tt>, didn't
+ extract any character) and after a call to <tt>putback()</tt>
+ <tt>gcount()</tt> returns <tt>-1</tt> (the last unformatted input
+-function <tt>putback()</tt> did "extract" back into the
++function <tt>putback()</tt> did &quot;extract&quot; back into the
+ stream). Correspondingly for <tt>unget()</tt>. Is this what is
+ intended? If so, this should be clarified. Otherwise, a corresponding
+ clarification should be used.</p>
+@@ -3634,69 +2782,69 @@ clarification should be used.</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ In 27.6.1.2.2 [lib.istream.formatted.arithmetic], paragraph 1.
+-Change the beginning of the second sentence from "The conversion
+-occurs" to "These extractors behave as formatted input functions (as
++Change the beginning of the second sentence from &quot;The conversion
++occurs&quot; to &quot;These extractors behave as formatted input functions (as
+ described in 27.6.1.2.1). After a sentry object is constructed,
+-the conversion occurs"
++the conversion occurs&quot;
+ </p>
+
+ <p>
+ In 27.6.1.2.3, [lib.istream::extractors], before paragraph 1.
+-Add an effects clause. "Effects: None. This extractor does
++Add an effects clause. &quot;Effects: None. This extractor does
+ not behave as a formatted input function (as described in
+ 27.6.1.2.1).
+ </p>
+
+ <p>
+ In 27.6.1.2.3, [lib.istream::extractors], paragraph 2. Change the
+-effects clause to "Effects: Calls pf(*this). This extractor does not
++effects clause to &quot;Effects: Calls pf(*this). This extractor does not
+ behave as a formatted input function (as described in 27.6.1.2.1).
+ </p>
+
+ <p>
+ In 27.6.1.2.3, [lib.istream::extractors], paragraph 4. Change the
+-effects clause to "Effects: Calls pf(*this). This extractor does not
++effects clause to &quot;Effects: Calls pf(*this). This extractor does not
+ behave as a formatted input function (as described in 27.6.1.2.1).
+ </p>
+
+ <p>
+ In 27.6.1.2.3, [lib.istream::extractors], paragraph 12. Change the
+-first two sentences from "If sb is null, calls setstate(failbit),
++first two sentences from &quot;If sb is null, calls setstate(failbit),
+ which may throw ios_base::failure (27.4.4.3). Extracts characters
+-from *this..." to "Behaves as a formatted input function (as described
++from *this...&quot; to &quot;Behaves as a formatted input function (as described
+ in 27.6.1.2.1). If sb is null, calls setstate(failbit), which may
+ throw ios_base::failure (27.4.4.3). After a sentry object is
+-constructed, extracts characters from *this...".
++constructed, extracts characters from *this...&quot;.
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], before paragraph 2. Add an
+-effects clause. "Effects: none. This member function does not behave
+-as an unformatted input function (as described in 27.6.1.3, paragraph 1)."
++effects clause. &quot;Effects: none. This member function does not behave
++as an unformatted input function (as described in 27.6.1.3, paragraph 1).&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 3. Change the
+-beginning of the first sentence of the effects clause from "Extracts a
+-character" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts a
++character&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts a
+-character"
++character&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 5. Change the
+-beginning of the first sentence of the effects clause from "Extracts a
+-character" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts a
++character&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts a
+-character"
++character&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 7. Change the
+-beginning of the first sentence of the effects clause from "Extracts
+-characters" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts
++characters&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts
+-characters"
++characters&quot;
+ </p>
+
+ <p>
+@@ -3705,10 +2853,10 @@ characters"
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 12. Change the
+-beginning of the first sentence of the effects clause from "Extracts
+-characters" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts
++characters&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts
+-characters"
++characters&quot;
+ </p>
+
+ <p>
+@@ -3717,10 +2865,10 @@ characters"
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 17. Change the
+-beginning of the first sentence of the effects clause from "Extracts
+-characters" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts
++characters&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts
+-characters"
++characters&quot;
+ </p>
+
+ <p>
+@@ -3729,75 +2877,75 @@ characters"
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 24. Change the
+-beginning of the first sentence of the effects clause from "Extracts
+-characters" to "Behaves as an unformatted input function (as described
++beginning of the first sentence of the effects clause from &quot;Extracts
++characters&quot; to &quot;Behaves as an unformatted input function (as described
+ in 27.6.1.3, paragraph 1). After constructing a sentry object, extracts
+-characters"
++characters&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], before paragraph 27. Add an
+-Effects clause: "Effects: Behaves as an unformatted input function (as
++Effects clause: &quot;Effects: Behaves as an unformatted input function (as
+ described in 27.6.1.3, paragraph 1). After constructing a sentry
+-object, reads but does not extract the current input character."
++object, reads but does not extract the current input character.&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 28. Change the
+-first sentence of the Effects clause from "If !good() calls" to
++first sentence of the Effects clause from &quot;If !good() calls&quot; to
+ Behaves as an unformatted input function (as described in 27.6.1.3,
+-paragraph 1). After constructing a sentry object, if !good() calls"
++paragraph 1). After constructing a sentry object, if !good() calls&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 30. Change the
+-first sentence of the Effects clause from "If !good() calls" to
+-"Behaves as an unformatted input function (as described in 27.6.1.3,
+-paragraph 1). After constructing a sentry object, if !good() calls"
++first sentence of the Effects clause from &quot;If !good() calls&quot; to
++&quot;Behaves as an unformatted input function (as described in 27.6.1.3,
++paragraph 1). After constructing a sentry object, if !good() calls&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 32. Change the
+-first sentence of the Effects clause from "If !good() calls..." to
+-"Behaves as an unformatted input function (as described in 27.6.1.3,
++first sentence of the Effects clause from &quot;If !good() calls...&quot; to
++&quot;Behaves as an unformatted input function (as described in 27.6.1.3,
+ paragraph 1). After constructing a sentry object, if !good()
+-calls..." Add a new sentence to the end of the Effects clause:
+-"[Note: this function extracts no characters, so the value returned
+-by the next call to gcount() is 0.]"
++calls...&quot; Add a new sentence to the end of the Effects clause:
++&quot;[Note: this function extracts no characters, so the value returned
++by the next call to gcount() is 0.]&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 34. Change the
+-first sentence of the Effects clause from "If !good() calls" to
+-"Behaves as an unformatted input function (as described in 27.6.1.3,
+-paragraph 1). After constructing a sentry object, if !good() calls".
+-Add a new sentence to the end of the Effects clause: "[Note: this
++first sentence of the Effects clause from &quot;If !good() calls&quot; to
++&quot;Behaves as an unformatted input function (as described in 27.6.1.3,
++paragraph 1). After constructing a sentry object, if !good() calls&quot;.
++Add a new sentence to the end of the Effects clause: &quot;[Note: this
+ function extracts no characters, so the value returned by the next
+-call to gcount() is 0.]"
++call to gcount() is 0.]&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 36. Change the
+-first sentence of the Effects clause from "If !rdbuf() is" to "Behaves
++first sentence of the Effects clause from &quot;If !rdbuf() is&quot; to &quot;Behaves
+ as an unformatted input function (as described in 27.6.1.3, paragraph
+ 1), except that it does not count the number of characters extracted
+ and does not affect the value returned by subsequent calls to
+-gcount(). After constructing a sentry object, if rdbuf() is"
++gcount(). After constructing a sentry object, if rdbuf() is&quot;
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], before paragraph 37. Add an
+-Effects clause: "Effects: Behaves as an unformatted input function (as
++Effects clause: &quot;Effects: Behaves as an unformatted input function (as
+ described in 27.6.1.3, paragraph 1), except that it does not count the
+ number of characters extracted and does not affect the value returned
+-by subsequent calls to gcount()." Change the first sentence of
+-paragraph 37 from "if fail()" to "after constructing a sentry object,
+-if fail()".
++by subsequent calls to gcount().&quot; Change the first sentence of
++paragraph 37 from &quot;if fail()&quot; to &quot;after constructing a sentry object,
++if fail()&quot;.
+ </p>
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 38. Change the
+-first sentence of the Effects clause from "If fail()" to "Behaves
++first sentence of the Effects clause from &quot;If fail()&quot; to &quot;Behaves
+ as an unformatted input function (as described in 27.6.1.3, paragraph
+ 1), except that it does not count the number of characters extracted
+ and does not affect the value returned by subsequent calls to
+@@ -3806,7 +2954,7 @@ gcount(). After constructing a sentry object, if fail()
+
+ <p>
+ In 27.6.1.3, [lib.istream.unformatted], paragraph 40. Change the
+-first sentence of the Effects clause from "If fail()" to "Behaves
++first sentence of the Effects clause from &quot;If fail()&quot; to &quot;Behaves
+ as an unformatted input function (as described in 27.6.1.3, paragraph
+ 1), except that it does not count the number of characters extracted
+ and does not affect the value returned by subsequent calls to
+@@ -3815,55 +2963,55 @@ gcount(). After constructing a sentry object, if fail()
+
+ <p>
+ In 27.6.2.5.2 [lib.ostream.inserters.arithmetic], paragraph 1. Change
+-the beginning of the third sentence from "The formatting conversion"
+-to "These extractors behave as formatted output functions (as
++the beginning of the third sentence from &quot;The formatting conversion&quot;
++to &quot;These extractors behave as formatted output functions (as
+ described in 27.6.2.5.1). After the sentry object is constructed, the
+-conversion occurs".
++conversion occurs&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.5.3 [lib.ostream.inserters], before paragraph 1. Add an
+-effects clause: "Effects: None. Does not behave as a formatted output
+-function (as described in 27.6.2.5.1).".
++effects clause: &quot;Effects: None. Does not behave as a formatted output
++function (as described in 27.6.2.5.1).&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.5.3 [lib.ostream.inserters], paragraph 2. Change the
+-effects clause to "Effects: calls pf(*this). This extractor does not
+-behave as a formatted output function (as described in 27.6.2.5.1).".
++effects clause to &quot;Effects: calls pf(*this). This extractor does not
++behave as a formatted output function (as described in 27.6.2.5.1).&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.5.3 [lib.ostream.inserters], paragraph 4. Change the
+-effects clause to "Effects: calls pf(*this). This extractor does not
+-behave as a formatted output function (as described in 27.6.2.5.1).".
++effects clause to &quot;Effects: calls pf(*this). This extractor does not
++behave as a formatted output function (as described in 27.6.2.5.1).&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.5.3 [lib.ostream.inserters], paragraph 6. Change the first
+-sentence from "If sb" to "Behaves as a formatted output function (as
++sentence from &quot;If sb&quot; to &quot;Behaves as a formatted output function (as
+ described in 27.6.2.5.1). After the sentry object is constructed, if
+-sb".
++sb&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.6 [lib.ostream.unformatted], paragraph 2. Change the first
+-sentence from "Inserts the character" to "Behaves as an unformatted
++sentence from &quot;Inserts the character&quot; to &quot;Behaves as an unformatted
+ output function (as described in 27.6.2.6, paragraph 1). After
+-constructing a sentry object, inserts the character".
++constructing a sentry object, inserts the character&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.6 [lib.ostream.unformatted], paragraph 5. Change the first
+-sentence from "Obtains characters" to "Behaves as an unformatted
++sentence from &quot;Obtains characters&quot; to &quot;Behaves as an unformatted
+ output function (as described in 27.6.2.6, paragraph 1). After
+-constructing a sentry object, obtains characters".
++constructing a sentry object, obtains characters&quot;.
+ </p>
+
+ <p>
+ In 27.6.2.6 [lib.ostream.unformatted], paragraph 7. Add a new
+-sentence at the end of the paragraph: "Does not behave as an
+-unformatted output function (as described in 27.6.2.6, paragraph 1)."
++sentence at the end of the paragraph: &quot;Does not behave as an
++unformatted output function (as described in 27.6.2.6, paragraph 1).&quot;
+ </p>
+
+
+@@ -3878,10 +3026,11 @@ VI of that paper.</p>
+
+ <hr>
+ <h3><a name="61"></a>61. Ambiguity in iostreams exception policy</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The introduction to the section on unformatted input (27.6.1.3)
+ says that every unformatted input function catches all exceptions that
+@@ -3892,7 +3041,7 @@ circumstances as setting eofbit and/or failbit. (The standard notes,
+ correctly, that setting eofbit or failbit can sometimes result in an
+ exception being thrown.) The question: if one of these functions
+ throws an exception triggered by setting failbit, is this an exception
+-"thrown during input" and hence covered by 27.6.1.3, or does
++&quot;thrown during input&quot; and hence covered by 27.6.1.3, or does
+ 27.6.1.3 only refer to a limited class of exceptions? Just to make
+ this concrete, suppose you have the following snippet. </p>
+
+@@ -3911,9 +3060,9 @@ be thrown? </p>
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ In 27.6.1.3, paragraph 1, after the sentence that begins
+-"If an exception is thrown...", add the following
+-parenthetical comment: "(Exceptions thrown from
+-<tt>basic_ios&lt;&gt;::clear()</tt> are not caught or rethrown.)"
++&quot;If an exception is thrown...&quot;, add the following
++parenthetical comment: &quot;(Exceptions thrown from
++<tt>basic_ios&lt;&gt;::clear()</tt> are not caught or rethrown.)&quot;
+ </p>
+
+
+@@ -3927,22 +3076,23 @@ resolution as better standardese.</p>
+
+ <hr>
+ <h3><a name="62"></a>62. <tt>Sync</tt>'s return value</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The Effects clause for sync() (27.6.1.3, paragraph 36) says that it
+-"calls rdbuf()-&gt;pubsync() and, if that function returns -1
+-... returns traits::eof()." </p>
++&quot;calls rdbuf()-&gt;pubsync() and, if that function returns -1
++... returns traits::eof().&quot; </p>
+
+ <p>That looks suspicious, because traits::eof() is of type
+ traits::int_type while the return type of sync() is int. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.1.3 [istream.unformatted], paragraph 36, change "returns
+-<tt>traits::eof()</tt>" to "returns <tt>-1</tt>".
++<p>In 27.7.2.3 [istream.unformatted], paragraph 36, change &quot;returns
++<tt>traits::eof()</tt>&quot; to &quot;returns <tt>-1</tt>&quot;.
+ </p>
+
+
+@@ -3951,10 +3101,10 @@ traits::int_type while the return type of sync() is int. </p>
+
+ <hr>
+ <h3><a name="63"></a>63. Exception-handling policy for unformatted output</h3>
+-<p><b>Section:</b> 27.7.2.7 [ostream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.3.7 [ostream.unformatted] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Clause 27 details an exception-handling policy for formatted input,
+ unformatted input, and formatted output. It says nothing for
+@@ -3966,10 +3116,10 @@ deliberate. </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 27.6.2.6, paragraph 1, replace the last sentence ("In any
++In 27.6.2.6, paragraph 1, replace the last sentence (&quot;In any
+ case, the unformatted output function ends by destroying the sentry
+ object, then returning the value specified for the formatted output
+-function.") with the following text:
++function.&quot;) with the following text:
+ </p>
+ <blockquote><p>
+ If an exception is thrown during output, then <tt>ios::badbit</tt> is
+@@ -3994,10 +3144,10 @@ input, unformatted input, and formatted output.
+
+ <hr>
+ <h3><a name="64"></a>64. Exception handling in <tt>basic_istream::operator&gt;&gt;(basic_streambuf*)</tt></h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.6.1.2.3, paragraph 13, is ambiguous. It can be interpreted two
+ different ways, depending on whether the second sentence is read as an
+@@ -4005,8 +3155,8 @@ elaboration of the first. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace 27.7.1.2.3 [istream::extractors], paragraph 13, which begins
+-"If the function inserts no characters ..." with:</p>
++<p>Replace 27.7.2.2.3 [istream::extractors], paragraph 13, which begins
++&quot;If the function inserts no characters ...&quot; with:</p>
+
+ <blockquote>
+ <p>If the function inserts no characters, it calls
+@@ -4023,22 +3173,22 @@ elaboration of the first. </p>
+
+ <hr>
+ <h3><a name="66"></a>66. Strstreambuf::setbuf</h3>
+-<p><b>Section:</b> D.9.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.7.1.3 [depr.strstreambuf.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.strstreambuf.virtuals">issues</a> in [depr.strstreambuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>D.7.1.3, paragraph 19, says that strstreambuf::setbuf
+-"Performs an operation that is defined separately for each class
+-derived from strstreambuf". This is obviously an incorrect
++&quot;Performs an operation that is defined separately for each class
++derived from strstreambuf&quot;. This is obviously an incorrect
+ cut-and-paste from basic_streambuf. There are no classes derived from
+ strstreambuf. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>D.9.1.3 [depr.strstreambuf.virtuals], paragraph 19, replace the setbuf effects
+-clause which currently says "Performs an operation that is
+-defined separately for each class derived from strstreambuf"
++<p>D.7.1.3 [depr.strstreambuf.virtuals], paragraph 19, replace the setbuf effects
++clause which currently says &quot;Performs an operation that is
++defined separately for each class derived from strstreambuf&quot;
+ with:</p>
+
+ <blockquote>
+@@ -4052,10 +3202,10 @@ with:</p>
+
+ <hr>
+ <h3><a name="68"></a>68. Extractors for char* should store null at end</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1998-07-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1998-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Extractors for char* (27.6.1.2.3) do not store a null character
+ after the extracted character sequence whereas the unformatted
+@@ -4068,7 +3218,7 @@ said a null is stored.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>27.7.1.2.3 [istream::extractors], paragraph 7, change the last list
++<p>27.7.2.2.3 [istream::extractors], paragraph 7, change the last list
+ item from:</p>
+
+ <blockquote><p>
+@@ -4090,21 +3240,21 @@ item from:</p>
+
+ <hr>
+ <h3><a name="69"></a>69. Must elements of a vector be contiguous?</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1998-07-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1998-07-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The issue is this: Must the elements of a vector be in contiguous memory?</p>
+
+ <p>(Please note that this is entirely separate from the question of
+ whether a vector iterator is required to be a pointer; the answer to
+-that question is clearly "no," as it would rule out
++that question is clearly &quot;no,&quot; as it would rule out
+ debugging implementations)</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add the following text to the end of 23.4.1 [vector],
++<p>Add the following text to the end of 23.3.6 [vector],
+ paragraph 1. </p>
+
+ <blockquote>
+@@ -4117,16 +3267,16 @@ paragraph 1. </p>
+
+ <p><b>Rationale:</b></p>
+ <p>The LWG feels that as a practical matter the answer is clearly
+-"yes". There was considerable discussion as to the best way
+-to express the concept of "contiguous", which is not
++&quot;yes&quot;. There was considerable discussion as to the best way
++to express the concept of &quot;contiguous&quot;, which is not
+ directly defined in the standard. Discussion included:</p>
+
+ <ul>
+ <li>An operational definition similar to the above proposed resolution is
+- already used for valarray (26.6.2.3 [valarray.access]).</li>
++ already used for valarray (26.6.2.4 [valarray.access]).</li>
+ <li>There is no need to explicitly consider a user-defined operator&amp;
+ because elements must be copyconstructible (23.2 [container.requirements] para 3)
+- and copyconstructible (20.2.1 [utility.arg.requirements]) specifies
++ and copyconstructible (17.6.3.1 [utility.arg.requirements]) specifies
+ requirements for operator&amp;.</li>
+ <li>There is no issue of one-past-the-end because of language rules.</li>
+ </ul>
+@@ -4137,10 +3287,10 @@ directly defined in the standard. Discussion included:</p>
+
+ <hr>
+ <h3><a name="70"></a>70. Uncaught_exception() missing throw() specification</h3>
+-<p><b>Section:</b> 18.8 [support.exception], 18.8.4 [uncaught] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-08-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.exception">issues</a> in [support.exception].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 18.8 [support.exception], X [uncaught] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-08-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.exception">issues</a> in [support.exception].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In article 3E04@pratique.fr, Valentin Bonnard writes: </p>
+
+@@ -4154,27 +3304,27 @@ exception safety is very important.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 15.5.3 [except.uncaught], paragraph 1, 18.8 [support.exception], and 18.8.4 [uncaught], add "throw()" to uncaught_exception().</p>
++<p>In 15.5.3 [except.uncaught], paragraph 1, 18.8 [support.exception], and X [uncaught], add &quot;throw()&quot; to uncaught_exception().</p>
+
+
+
+
+ <hr>
+ <h3><a name="71"></a>71. Do_get_monthname synopsis missing argument</h3>
+-<p><b>Section:</b> 22.4.5.1 [locale.time.get] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.5.1 [locale.time.get] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-08-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The locale facet member <tt>time_get&lt;&gt;::do_get_monthname</tt>
+ is described in 22.4.5.1.2 [locale.time.get.virtuals] with five arguments,
+ consistent with do_get_weekday and with its specified use by member
+ get_monthname. However, in the synopsis, it is specified instead with
+-four arguments. The missing argument is the "end" iterator
++four arguments. The missing argument is the &quot;end&quot; iterator
+ value.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 22.4.5.1 [locale.time.get], add an "end" argument to
++<p>In 22.4.5.1 [locale.time.get], add an &quot;end&quot; argument to
+ the declaration of member do_monthname as follows:</p>
+
+ <pre> virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&amp;,
+@@ -4185,12 +3335,12 @@ the declaration of member do_monthname as follows:</p>
+
+ <hr>
+ <h3><a name="74"></a>74. Garbled text for <tt>codecvt::do_max_length</tt></h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-09-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-09-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The text of <tt>codecvt::do_max_length</tt>'s "Returns"
++<p>The text of <tt>codecvt::do_max_length</tt>'s &quot;Returns&quot;
+ clause (22.2.1.5.2, paragraph 11) is garbled. It has unbalanced
+ parentheses and a spurious <b>n</b>.</p>
+
+@@ -4212,11 +3362,11 @@ following:</p>
+
+ <hr>
+ <h3><a name="75"></a>75. Contradiction in <tt>codecvt::length</tt>'s argument types</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
+ <b>Submitter:</b> Matt
+-Austern <b>Opened:</b> 1998-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++Austern <b>Opened:</b> 1998-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The class synopses for classes <tt>codecvt&lt;&gt;</tt> (22.2.1.5)
+ and <tt>codecvt_byname&lt;&gt;</tt> (22.2.1.6) say that the first
+@@ -4261,10 +3411,10 @@ change the <tt>stateT</tt> argument type on both member
+
+ <hr>
+ <h3><a name="76"></a>76. Can a <tt>codecvt</tt> facet always convert one internal character at a time?</h3>
+-<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-09-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.4 [locale.codecvt] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt">issues</a> in [locale.codecvt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>This issue concerns the requirements on classes derived from
+ <tt>codecvt</tt>, including user-defined classes. What are the
+@@ -4293,7 +3443,7 @@ that the corresponding sequence of internal characters is the single
+ character <tt>*ifirst</tt>?
+ </p>
+
+-<p>(What a "no" answer would mean is that
++<p>(What a &quot;no&quot; answer would mean is that
+ <tt>my_encoding</tt> translates sequences only as blocks. There's a
+ sequence of <i>M</i> external characters that maps to a sequence of
+ <i>N</i> internal characters, but that external sequence has no
+@@ -4321,16 +3471,20 @@ and several of <tt>codecvt</tt>'s member functions. </p>
+ <blockquote>
+ <p>A <tt>codecvt</tt> facet that is used by <tt>basic_filebuf</tt>
+ (27.9 [file.streams]) must have the property that if</p>
+-<pre> do_out(state, from, from_end, from_next, to, to_lim, to_next)
++<pre>
++ do_out(state, from, from_end, from_next, to, to_lim, to_next)
+ </pre>
+ <p>would return <tt>ok</tt>, where <tt>from != from_end</tt>, then </p>
+-<pre> do_out(state, from, from + 1, from_next, to, to_end, to_next)
++<pre>
++ do_out(state, from, from + 1, from_next, to, to_end, to_next)
+ </pre>
+ <p>must also return <tt>ok</tt>, and that if</p>
+-<pre> do_in(state, from, from_end, from_next, to, to_lim, to_next)
++<pre>
++ do_in(state, from, from_end, from_next, to, to_lim, to_next)
+ </pre>
+ <p>would return <tt>ok</tt>, where <tt>to != to_lim</tt>, then</p>
+-<pre> do_in(state, from, from_end, from_next, to, to + 1, to_next)
++<pre>
++ do_in(state, from, from_end, from_next, to, to + 1, to_next)
+ </pre>
+ <p>must also return <tt>ok</tt>. [<i>Footnote:</i> Informally, this
+ means that <tt>basic_filebuf</tt> assumes that the mapping from
+@@ -4384,27 +3538,27 @@ return value.]</i></p>
+
+ <hr>
+ <h3><a name="78"></a>78. Typo: event_call_back</h3>
+-<p><b>Section:</b> 27.5.2 [ios.base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base">issues</a> in [ios.base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3 [ios.base] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base">issues</a> in [ios.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>typo: event_call_back should be event_callback &nbsp; </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In the 27.5.2 [ios.base] synopsis change
+-"event_call_back" to "event_callback". </p>
++<p>In the 27.5.3 [ios.base] synopsis change
++&quot;event_call_back&quot; to &quot;event_callback&quot;. </p>
+
+
+
+
+ <hr>
+ <h3><a name="79"></a>79. Inconsistent declaration of polar()</h3>
+-<p><b>Section:</b> 26.4.1 [complex.syn], 26.4.7 [complex.value.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.syn">issues</a> in [complex.syn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 26.4.1 [complex.syn], 26.4.7 [complex.value.ops] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.syn">issues</a> in [complex.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 26.4.1 [complex.syn] polar is declared as follows:</p>
+ <pre> template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp;, const T&amp;); </pre>
+@@ -4428,10 +3582,10 @@ return value.]</i></p>
+
+ <hr>
+ <h3><a name="80"></a>80. Global Operators of complex declared twice</h3>
+-<p><b>Section:</b> 26.4.1 [complex.syn], 26.4.2 [complex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.syn">issues</a> in [complex.syn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 26.4.1 [complex.syn], 26.4.2 [complex] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.syn">issues</a> in [complex.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Both 26.2.1 and 26.2.2 contain declarations of global operators for
+ class complex. This redundancy should be removed.</p>
+@@ -4445,11 +3599,12 @@ class complex. This redundancy should be removed.</p>
+
+ <hr>
+ <h3><a name="83"></a>83. String::npos vs. string::max_size()</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#89">89</a></p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#89">89</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Many string member functions throw if size is getting or exceeding
+ npos. However, I wonder why they don't throw if size is getting or
+@@ -4460,8 +3615,8 @@ lacks some clarifications here.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>After 21.4 [basic.string] paragraph 4 ("The functions
+-described in this clause...") add a new paragraph:</p>
++<p>After 21.4 [basic.string] paragraph 4 (&quot;The functions
++described in this clause...&quot;) add a new paragraph:</p>
+
+ <blockquote>
+ <p>For any string operation, if as a result of the operation, <tt> size()</tt> would exceed
+@@ -4478,10 +3633,10 @@ described in this clause...") add a new paragraph:</p>
+
+ <hr>
+ <h3><a name="86"></a>86. String constructors don't describe exceptions</h3>
+-<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.require">issues</a> in [string.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The constructor from a range:</p>
+
+@@ -4496,24 +3651,24 @@ the range equals npos (or exceeds max_size(), see above). </p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 21.4.1 [string.require], Strike throws paragraphs for
+-constructors which say "Throws: length_error if n ==
+-npos."</p>
++constructors which say &quot;Throws: length_error if n ==
++npos.&quot;</p>
+
+
+ <p><b>Rationale:</b></p>
+ <p>Throws clauses for length_error if n == npos are no longer needed
+ because they are subsumed by the general wording added by the
+-resolution for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#83">83</a>.</p>
++resolution for issue <a href="lwg-defects.html#83">83</a>.</p>
+
+
+
+
+ <hr>
+ <h3><a name="90"></a>90. Incorrect description of operator &gt;&gt; for strings</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The effect of operator &gt;&gt; for strings contain the following item:</p>
+
+@@ -4542,10 +3697,10 @@ character c.</p>
+
+ <hr>
+ <h3><a name="91"></a>91. Description of operator&gt;&gt; and getline() for string&lt;&gt; might cause endless loop</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Operator &gt;&gt; and getline() for strings read until eof()
+ in the input stream is true. However, this might never happen, if the
+@@ -4566,7 +3721,7 @@ extracted and appended until any of the following occurs:
+ </p></blockquote>
+ <p>with:</p>
+ <blockquote><p>
+-Effects: Behaves as a formatted input function (27.7.1.2.1 [istream.formatted.reqmts]). After constructing a sentry object, if the
++Effects: Behaves as a formatted input function (27.7.2.2.1 [istream.formatted.reqmts]). After constructing a sentry object, if the
+ sentry converts to true, calls str.erase() and then extracts
+ characters from is and appends them to str as if by calling
+ str.append(1,c). If is.width() is greater than zero, the maximum
+@@ -4585,7 +3740,7 @@ following occurs:
+ </p></blockquote>
+ <p>with:</p>
+ <blockquote><p>
+-Effects: Behaves as an unformatted input function (27.7.1.3 [istream.unformatted]), except that it does not affect the value returned
++Effects: Behaves as an unformatted input function (27.7.2.3 [istream.unformatted]), except that it does not affect the value returned
+ by subsequent calls to basic_istream&lt;&gt;::gcount(). After
+ constructing a sentry object, if the sentry converts to true, calls
+ str.erase() and then extracts characters from is and appends them to
+@@ -4600,7 +3755,7 @@ there is no mechanism for <tt>gcount</tt> to be set except by one of
+ <tt>basic_istream</tt>'s member functions.]</i></p>
+
+
+-<p><i>[Curaçao: Nico agrees with proposed resolution.]</i></p>
++<p><i>[Cura&ccedil;ao: Nico agrees with proposed resolution.]</i></p>
+
+
+
+@@ -4619,10 +3774,11 @@ functions do get characters from a streambuf.</p>
+
+ <hr>
+ <h3><a name="92"></a>92. Incomplete Algorithm Requirements</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 1998-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The standard does not state, how often a function object is copied,
+ called, or the order of calls inside an algorithm. This may lead to
+@@ -4691,19 +3847,19 @@ affect the behavior of the function object.]</i></p>
+
+
+ <p><i>[Pre-Kona: Nico comments: It seems the problem is that we don't
+-have a clear statement of "predicate" in the
+-standard. People including me seemed to think "a function
++have a clear statement of &quot;predicate&quot; in the
++standard. People including me seemed to think &quot;a function
+ returning a Boolean value and being able to be called by an STL
+ algorithm or be used as sorting criterion or ... is a
+-predicate". But a predicate has more requirements: It should
++predicate&quot;. But a predicate has more requirements: It should
+ never change its behavior due to a call or being copied. IMHO we have
+ to state this in the standard. If you like, see section 8.1.4 of my
+ library book for a detailed discussion.]</i></p>
+
+
+-<p><i>[Kona: Nico will provide wording to the effect that "unless
++<p><i>[Kona: Nico will provide wording to the effect that &quot;unless
+ otherwise specified, the number of copies of and calls to function
+-objects by algorithms is unspecified".&nbsp; Consider placing in
++objects by algorithms is unspecified&quot;.&nbsp; Consider placing in
+ 25 [algorithms] after paragraph 9.]</i></p>
+
+
+@@ -4728,10 +3884,10 @@ objects by algorithms is unspecified".&nbsp; Consider placing in
+
+ <hr>
+ <h3><a name="98"></a>98. Input iterator requirements are badly written</h3>
+-<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.2.3 [input.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.iterators">issues</a> in [input.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Table 72 in 24.2.3 [input.iterators] specifies semantics for
+ <tt>*r++</tt> of:</p>
+@@ -4746,7 +3902,7 @@ This is too specific: we want to allow *r++ to return an lvalue.</p>
+ suggests that the effects *r++ should precisely replicate the behavior
+ of this code, including side effects. (Does this mean that *r++
+ should invoke the copy constructor exactly as many times as the sample
+-code above would?) See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#334">334</a> for a similar
++code above would?) See issue <a href="lwg-defects.html#334">334</a> for a similar
+ problem.</p>
+
+
+@@ -4782,11 +3938,11 @@ for <tt>*r++</tt> from <tt>T</tt> to "convertible to T".</p>
+
+ <hr>
+ <h3><a name="103"></a>103. set::iterator is required to be modifiable, but this allows modification of keys</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Set::iterator is described as implementation-defined with a
+ reference to the container requirement; the container requirement says
+@@ -4799,7 +3955,7 @@ specified. Especially considering that the current standard requires
+ that iterator for associative containers be different from
+ const_iterator. Set, for example, has the following: </p>
+
+-<p><tt>typedef implementation defined iterator;<br>
++<p><tt>typedef implementation defined iterator;<br/>
+ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // See _lib.container.requirements_</tt></p>
+
+ <p>23.2 [container.requirements] actually requires that iterator type pointing
+@@ -4816,7 +3972,7 @@ goes in line with trusting user knows what he is doing. </p>
+ <p><b>Other Options Evaluated:</b> </p>
+
+ <p>Option A.&nbsp;&nbsp; In 23.2.4 [associative.reqmts], paragraph 2, after
+-first sentence, and before "In addition,...", add one line:
++first sentence, and before &quot;In addition,...&quot;, add one line:
+ </p>
+
+ <blockquote>
+@@ -4826,13 +3982,13 @@ first sentence, and before "In addition,...", add one line:
+ <p>Option B.&nbsp;Add three new sentences to 23.2.4 [associative.reqmts]:</p>
+
+ <blockquote>
+- <p>At the end of paragraph 5: "Keys in an associative container
+- are immutable." At the end of paragraph 6: "For
++ <p>At the end of paragraph 5: &quot;Keys in an associative container
++ are immutable.&quot; At the end of paragraph 6: &quot;For
+ associative containers where the value type is the same as the key
+ type, both <tt>iterator</tt> and <tt>const_iterator</tt> are
+ constant iterators. It is unspecified whether or not
+ <tt>iterator</tt> and <tt>const_iterator</tt> are the same
+- type."</p>
++ type.&quot;</p>
+ </blockquote>
+
+ <p>Option C.&nbsp;To 23.2.4 [associative.reqmts], paragraph 3, which
+@@ -4865,14 +4021,14 @@ currently reads:</p>
+ the indicated location:</p>
+
+ <blockquote>
+- <p>At the end of paragraph 3: "For any two keys k1 and k2 in the same container,
++ <p>At the end of paragraph 3: &quot;For any two keys k1 and k2 in the same container,
+ calling comp(k1, k2) shall always return the same
+- value."</p>
+- <p>At the end of paragraph 5: "Keys in an associative container are immutable."</p>
+- <p>At the end of paragraph 6: "For associative containers where the value type is the
++ value.&quot;</p>
++ <p>At the end of paragraph 5: &quot;Keys in an associative container are immutable.&quot;</p>
++ <p>At the end of paragraph 6: &quot;For associative containers where the value type is the
+ same as the key type, both <tt>iterator</tt> and <tt>const_iterator</tt> are constant
+ iterators. It is unspecified whether or not <tt>iterator</tt> and <tt>const_iterator</tt>
+- are the same type."</p>
++ are the same type.&quot;</p>
+ </blockquote>
+
+
+@@ -4908,10 +4064,10 @@ conversion from <tt>iterator</tt> to <tt>const_iterator</tt>.
+
+ <hr>
+ <h3><a name="106"></a>106. Numeric library private members are implementation defined</h3>
+-<p><b>Section:</b> 26.6.5 [template.slice.array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.slice.array">issues</a> in [template.slice.array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 26.6.5 [template.slice.array] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.slice.array">issues</a> in [template.slice.array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>This is the only place in the whole standard where the implementation has to document
+ something private.</p>
+@@ -4919,7 +4075,7 @@ something private.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Remove the comment which says "// remainder implementation defined" from:
++Remove the comment which says &quot;// remainder implementation defined&quot; from:
+ </p>
+
+ <ul>
+@@ -4935,9 +4091,10 @@ Remove the comment which says "// remainder implementation defined" from:
+
+ <hr>
+ <h3><a name="108"></a>108. Lifetime of exception::what() return unspecified</h3>
+-<p><b>Section:</b> 18.7.1 [type.info] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 18.7.1 [type.info] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> AFNOR <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#type.info">issues</a> in [type.info].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 18.6.1, paragraphs 8-9, the lifetime of the return value of
+ exception::what() is left unspecified. This issue has implications
+@@ -4967,15 +4124,15 @@ returned by <tt>what()</tt>.
+
+ <hr>
+ <h3><a name="109"></a>109. Missing binders for non-const sequence elements</h3>
+-<p><b>Section:</b> D.11 [depr.lib.binders] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bjarne Stroustrup <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [depr.lib.binders] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bjarne Stroustrup <b>Opened:</b> 1998-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>There are no versions of binders that apply to non-const elements
+ of a sequence. This makes examples like for_each() using bind2nd() on
+-page 521 of "The C++ Programming Language (3rd)"
++page 521 of &quot;The C++ Programming Language (3rd)&quot;
+ non-conforming. Suitable versions of the binders need to be added.</p>
+
+ <p>Further discussion from Nico:</p>
+@@ -5048,24 +4205,24 @@ public:
+ <p><b>Howard believes there is a flaw</b> in this resolution.
+ See c++std-lib-9127. We may need to reopen this issue.</p>
+
+-<p>In D.11 [depr.lib.binders] in the declaration of binder1st after:</p>
++<p>In X [depr.lib.binders] in the declaration of binder1st after:</p>
+ <blockquote>
+- <p><tt>typename Operation::result_type<br>
++ <p><tt>typename Operation::result_type<br/>
+ &nbsp;operator()(const typename Operation::second_argument_type&amp; x) const;</tt></p>
+ </blockquote>
+ <p>insert:</p>
+ <blockquote>
+- <p><tt>typename Operation::result_type<br>
++ <p><tt>typename Operation::result_type<br/>
+ &nbsp;operator()(typename Operation::second_argument_type&amp; x) const;</tt></p>
+ </blockquote>
+-<p>In D.11 [depr.lib.binders] in the declaration of binder2nd after:</p>
++<p>In X [depr.lib.binders] in the declaration of binder2nd after:</p>
+ <blockquote>
+- <p><tt>typename Operation::result_type<br>
++ <p><tt>typename Operation::result_type<br/>
+ &nbsp;operator()(const typename Operation::first_argument_type&amp; x) const;</tt></p>
+ </blockquote>
+ <p>insert:</p>
+ <blockquote>
+- <p><tt>typename Operation::result_type<br>
++ <p><tt>typename Operation::result_type<br/>
+ &nbsp;operator()(typename Operation::first_argument_type&amp; x) const;</tt></p>
+ </blockquote>
+
+@@ -5087,13 +4244,13 @@ Leave open - 1.]</i></p>
+
+ <hr>
+ <h3><a name="110"></a>110. istreambuf_iterator::equal not const</h3>
+-<p><b>Section:</b> 24.6.3 [istreambuf.iterator], 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istreambuf.iterator">issues</a> in [istreambuf.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 24.6.3 [istreambuf.iterator], 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 1998-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istreambuf.iterator">issues</a> in [istreambuf.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Member istreambuf_iterator&lt;&gt;::equal is not declared
+-"const", yet 24.6.3.6 [istreambuf.iterator::op==] says that operator==,
++&quot;const&quot;, yet 24.6.3.6 [istreambuf.iterator::op==] says that operator==,
+ which is const, calls it. This is contradictory. </p>
+
+
+@@ -5117,21 +4274,21 @@ replace:</p>
+
+ <hr>
+ <h3><a name="112"></a>112. Minor typo in <tt>ostreambuf_iterator</tt> constructor</h3>
+-<p><b>Section:</b> 24.6.4.1 [ostreambuf.iter.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-10-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 24.6.4.1 [ostreambuf.iter.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-10-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The <b>requires</b> clause for <tt>ostreambuf_iterator</tt>'s
+ constructor from an <tt>ostream_type</tt> (24.5.4.1, paragraph 1)
+-reads "<i>s</i> is not null". However, <i>s</i> is a
++reads &quot;<i>s</i> is not null&quot;. However, <i>s</i> is a
+ reference, and references can't be null. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 24.6.4.1 [ostreambuf.iter.cons]:</p>
+
+-<p>Move the current paragraph 1, which reads "Requires: s is not
+-null.", from the first constructor to the second constructor.</p>
++<p>Move the current paragraph 1, which reads &quot;Requires: s is not
++null.&quot;, from the first constructor to the second constructor.</p>
+
+ <p>Insert a new paragraph 1 Requires clause for the first constructor
+ reading:</p>
+@@ -5146,11 +4303,11 @@ reading:</p>
+
+ <hr>
+ <h3><a name="114"></a>114. Placement forms example in error twice</h3>
+-<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-10-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#196">196</a></p>
++<p><b>Section:</b> 18.6.1.3 [new.delete.placement] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-10-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.placement">issues</a> in [new.delete.placement].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#196">196</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Section 18.5.1.3 contains the following example: </p>
+
+@@ -5159,7 +4316,7 @@ reading:</p>
+ Something* p = new (place) Something();
+ -end example]</pre>
+
+-<p>First code line: "place" need not have any special alignment, and the
++<p>First code line: &quot;place&quot; need not have any special alignment, and the
+ following constructor could fail due to misaligned data.</p>
+
+ <p>Second code line: Aren't the parens on Something() incorrect?&nbsp; [Dublin: the LWG
+@@ -5184,9 +4341,9 @@ likely to fail.</p>
+
+ <hr>
+ <h3><a name="115"></a>115. Typo in strstream constructors</h3>
+-<p><b>Section:</b> D.9.4.1 [depr.strstream.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.7.4.1 [depr.strstream.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 1998-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>D.7.4.1 strstream constructors paragraph 2 says: </p>
+
+@@ -5201,12 +4358,12 @@ likely to fail.</p>
+ </blockquote>
+
+ <p>Notice the second condition is the same as the first. I think the second condition
+-should be "If mode&amp;app==app", or "mode&amp;app!=0", meaning that
++should be &quot;If mode&amp;app==app&quot;, or &quot;mode&amp;app!=0&quot;, meaning that
+ the append bit is set.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In D.9.3.1 [depr.ostrstream.cons] paragraph 2 and D.9.4.1 [depr.strstream.cons]
++<p>In D.7.3.1 [depr.ostrstream.cons] paragraph 2 and D.7.4.1 [depr.strstream.cons]
+ paragraph 2, change the first condition to <tt>(mode&amp;app)==0</tt>
+ and the second condition to <tt>(mode&amp;app)!=0</tt>.</p>
+
+@@ -5216,10 +4373,10 @@ and the second condition to <tt>(mode&amp;app)!=0</tt>.</p>
+
+ <hr>
+ <h3><a name="117"></a>117. <tt>basic_ostream</tt> uses nonexistent <tt>num_put</tt> member functions</h3>
+-<p><b>Section:</b> 27.7.2.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-11-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The <b>effects</b> clause for numeric inserters says that
+ insertion of a value <tt>x</tt>, whose type is either <tt>bool</tt>,
+@@ -5259,7 +4416,8 @@ formatting conversion occurs as if it performed the following code
+ fragment:
+ </p>
+
+-<pre>bool failed = use_facet&lt;
++<pre>
++bool failed = use_facet&lt;
+ num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt; &gt;
+ &gt;(getloc()).put(*this, *this, fill(), val). failed();
+ </pre>
+@@ -5269,7 +4427,8 @@ When val is of type short the formatting conversion occurs as if it
+ performed the following code fragment:
+ </p>
+
+-<pre>ios_base::fmtflags baseflags = ios_base::flags() &amp; ios_base::basefield;
++<pre>
++ios_base::fmtflags baseflags = ios_base::flags() &amp; ios_base::basefield;
+ bool failed = use_facet&lt;
+ num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt; &gt;
+ &gt;(getloc()).put(*this, *this, fill(),
+@@ -5283,7 +4442,8 @@ When val is of type int the formatting conversion occurs as if it performed
+ the following code fragment:
+ </p>
+
+-<pre>ios_base::fmtflags baseflags = ios_base::flags() &amp; ios_base::basefield;
++<pre>
++ios_base::fmtflags baseflags = ios_base::flags() &amp; ios_base::basefield;
+ bool failed = use_facet&lt;
+ num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt; &gt;
+ &gt;(getloc()).put(*this, *this, fill(),
+@@ -5297,7 +4457,8 @@ When val is of type unsigned short or unsigned int the formatting conversion
+ occurs as if it performed the following code fragment:
+ </p>
+
+-<pre>bool failed = use_facet&lt;
++<pre>
++bool failed = use_facet&lt;
+ num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt; &gt;
+ &gt;(getloc()).put(*this, *this, fill(), static_cast&lt;unsigned long&gt;(val)).
+ failed();
+@@ -5308,7 +4469,8 @@ When val is of type float the formatting conversion occurs as if it
+ performed the following code fragment:
+ </p>
+
+-<pre>bool failed = use_facet&lt;
++<pre>
++bool failed = use_facet&lt;
+ num_put&lt;charT,ostreambuf_iterator&lt;charT,traits&gt; &gt;
+ &gt;(getloc()).put(*this, *this, fill(), static_cast&lt;double&gt;(val)).
+ failed();
+@@ -5337,10 +4499,10 @@ example, printing short(-1) in hex format should yield 0xffff.)</p>
+
+ <hr>
+ <h3><a name="118"></a>118. <tt>basic_istream</tt> uses nonexistent <tt>num_get</tt> member functions</h3>
+-<p><b>Section:</b> 27.7.1.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-11-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1998-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Formatted input is defined for the types <tt>short</tt>, <tt>unsigned short</tt>, <tt>int</tt>,
+ <tt>unsigned int</tt>, <tt>long</tt>, <tt>unsigned long</tt>, <tt>float</tt>, <tt>double</tt>,
+@@ -5363,7 +4525,7 @@ that 27.6.1.2.2 is using a nonexistent function for types
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.1.2.2 [istream.formatted.arithmetic] Arithmetic Extractors, remove the
++<p>In 27.7.2.2.2 [istream.formatted.arithmetic] Arithmetic Extractors, remove the
+ two lines (1st and 3rd) which read:</p>
+ <blockquote>
+ <pre>operator&gt;&gt;(short&amp; val);
+@@ -5407,15 +4569,15 @@ operator&gt;&gt;(int&amp; val);</pre>
+
+ <hr>
+ <h3><a name="119"></a>119. Should virtual functions be allowed to strengthen the exception specification?</h3>
+-<p><b>Section:</b> 17.6.4.12 [res.on.exception.handling] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.exception.handling">issues</a> in [res.on.exception.handling].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 17.6.5.12 [res.on.exception.handling] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.exception.handling">issues</a> in [res.on.exception.handling].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Section 17.6.4.12 [res.on.exception.handling] states: </p>
++<p>Section 17.6.5.12 [res.on.exception.handling] states: </p>
+
+-<p>"An implementation may strengthen the exception-specification
+-for a function by removing listed exceptions." </p>
++<p>&quot;An implementation may strengthen the exception-specification
++for a function by removing listed exceptions.&quot; </p>
+
+ <p>The problem is that if an implementation is allowed to do this for
+ virtual functions, then a library user cannot write a class that
+@@ -5436,15 +4598,15 @@ public:
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change Section 17.6.4.12 [res.on.exception.handling] from:</p>
++<p>Change Section 17.6.5.12 [res.on.exception.handling] from:</p>
+
+-<p>&nbsp;&nbsp;&nbsp;&nbsp; "may strengthen the
+-exception-specification for a function"</p>
++<p>&nbsp;&nbsp;&nbsp;&nbsp; &quot;may strengthen the
++exception-specification for a function&quot;</p>
+
+ <p>to:</p>
+
+-<p>&nbsp;&nbsp;&nbsp;&nbsp; "may strengthen the
+-exception-specification for a non-virtual function". </p>
++<p>&nbsp;&nbsp;&nbsp;&nbsp; &quot;may strengthen the
++exception-specification for a non-virtual function&quot;. </p>
+
+
+
+@@ -5452,10 +4614,10 @@ exception-specification for a non-virtual function". </p>
+
+ <hr>
+ <h3><a name="120"></a>120. Can an implementor add specializations?</h3>
+-<p><b>Section:</b> 17.6.3.3 [reserved.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.3 [reserved.names] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>The original issue asked whether a library implementor could
+@@ -5503,7 +4665,7 @@ different explicit instantiations might be harmless.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+- <p>Append to 17.6.3.3 [reserved.names] paragraph 1: </p>
++ <p>Append to 17.6.4.3 [reserved.names] paragraph 1: </p>
+ <blockquote><p>
+ A program may explicitly instantiate any templates in the standard
+ library only if the declaration depends on the name of a user-defined
+@@ -5522,7 +4684,7 @@ different explicit instantiations might be harmless.</p>
+ <blockquote>
+ <p>In light of the resolution to core issue 259, no normative changes
+ in the library clauses are necessary. Add the following non-normative
+- note to the end of 17.6.3.3 [reserved.names] paragraph 1:</p>
++ note to the end of 17.6.4.3 [reserved.names] paragraph 1:</p>
+ <blockquote><p>
+ [<i>Note:</i> A program may explicitly instantiate standard library
+ templates, even when an explicit instantiation does not depend on
+@@ -5567,10 +4729,10 @@ different explicit instantiations might be harmless.</p>
+
+ <hr>
+ <h3><a name="122"></a>122. streambuf/wstreambuf description should not say they are specializations</h3>
+-<p><b>Section:</b> 27.6.2 [streambuf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf">issues</a> in [streambuf].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3 [streambuf] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf">issues</a> in [streambuf].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 27.5.2 describes the streambuf classes this way: </p>
+
+@@ -5590,7 +4752,7 @@ specialized for the type wchar_t. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Remove 27.6.2 [streambuf] paragraphs 2 and 3 (the above two
++<p>Remove 27.6.3 [streambuf] paragraphs 2 and 3 (the above two
+ sentences). </p>
+
+
+@@ -5604,17 +4766,17 @@ typedefs and that is sufficient. </p>
+
+ <hr>
+ <h3><a name="123"></a>123. Should valarray helper arrays fill functions be const?</h3>
+-<p><b>Section:</b> 26.6.5.3 [slice.arr.fill], 26.6.7.3 [gslice.array.fill], 26.6.8.3 [mask.array.fill], 26.6.9.3 [indirect.array.fill] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.5.4 [slice.arr.fill], 26.6.7.4 [gslice.array.fill], 26.6.8.4 [mask.array.fill], 26.6.9.4 [indirect.array.fill] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>One of the operator= in the valarray helper arrays is const and one
+ is not. For example, look at slice_array. This operator= in Section
+-26.6.5.1 [slice.arr.assign] is const: </p>
++26.6.5.2 [slice.arr.assign] is const: </p>
+
+ <p>&nbsp;&nbsp;&nbsp; <tt>void operator=(const valarray&lt;T&gt;&amp;) const;</tt> </p>
+
+-<p>but this one in Section 26.6.5.3 [slice.arr.fill] is not: </p>
++<p>but this one in Section 26.6.5.4 [slice.arr.fill] is not: </p>
+
+ <p>&nbsp;&nbsp;&nbsp; <tt>void operator=(const T&amp;); </tt></p>
+
+@@ -5628,21 +4790,25 @@ is not. For example, look at slice_array. This operator= in Section
+
+ <p>In the class template definition for slice_array, replace the member
+ function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>with</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+-<p>26.6.5.3 [slice.arr.fill] slice_array fill function</p>
++<p>26.6.5.4 [slice.arr.fill] slice_array fill function</p>
+ <blockquote>
+
+ <p>Change the function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>to</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+@@ -5651,21 +4817,25 @@ is not. For example, look at slice_array. This operator= in Section
+
+ <p>In the class template definition for gslice_array, replace the member
+ function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>with</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+-<p>26.6.7.3 [gslice.array.fill] gslice_array fill function</p>
++<p>26.6.7.4 [gslice.array.fill] gslice_array fill function</p>
+ <blockquote>
+
+ <p>Change the function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>to</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+@@ -5674,21 +4844,25 @@ is not. For example, look at slice_array. This operator= in Section
+
+ <p>In the class template definition for mask_array, replace the member
+ function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>with</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+-<p>26.6.8.3 [mask.array.fill] mask_array fill function</p>
++<p>26.6.8.4 [mask.array.fill] mask_array fill function</p>
+ <blockquote>
+
+ <p>Change the function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>to</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+@@ -5697,21 +4871,25 @@ is not. For example, look at slice_array. This operator= in Section
+
+ <p>In the class template definition for indirect_array, replace the member
+ function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>with</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+-<p>26.6.9.3 [indirect.array.fill] indirect_array fill function</p>
++<p>26.6.9.4 [indirect.array.fill] indirect_array fill function</p>
+ <blockquote>
+
+ <p>Change the function declaration</p>
+- <pre> void operator=(const T&amp;);
++ <pre>
++ void operator=(const T&amp;);
+ </pre>
+ <p>to</p>
+- <pre> void operator=(const T&amp;) const;
++ <pre>
++ void operator=(const T&amp;) const;
+ </pre>
+ </blockquote>
+
+@@ -5723,7 +4901,7 @@ is not. For example, look at slice_array. This operator= in Section
+
+ <p><b>Rationale:</b></p>
+ <p>There's no good reason for one version of operator= being const and
+-another one not. Because of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#253">253</a>, this now
++another one not. Because of issue <a href="lwg-defects.html#253">253</a>, this now
+ matters: these functions are now callable in more circumstances. In
+ many existing implementations, both versions are already const.</p>
+
+@@ -5733,10 +4911,10 @@ many existing implementations, both versions are already const.</p>
+
+ <hr>
+ <h3><a name="124"></a>124. ctype_byname&lt;charT&gt;::do_scan_is &amp; do_scan_not return type should be const charT*</h3>
+-<p><b>Section:</b> 22.4.1.2 [locale.ctype.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.byname">issues</a> in [locale.ctype.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.1.2 [locale.ctype.byname] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.byname">issues</a> in [locale.ctype.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Section 22.4.1.2 [locale.ctype.byname]
+ ctype_byname&lt;charT&gt;::do_scan_is() and do_scan_not() are declared
+@@ -5754,13 +4932,13 @@ charT*</tt>. </p>
+
+ <hr>
+ <h3><a name="125"></a>125. valarray&lt;T&gt;::operator!() return type is inconsistent</h3>
+-<p><b>Section:</b> 26.6.2 [template.valarray] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.valarray">issues</a> in [template.valarray].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 26.6.2 [template.valarray] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.valarray">issues</a> in [template.valarray].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Section 26.6.2 [template.valarray] valarray&lt;T&gt;::operator!() is
+-declared to return a valarray&lt;T&gt;, but in Section 26.6.2.5 [valarray.unary] it is declared to return a valarray&lt;bool&gt;. The
++declared to return a valarray&lt;T&gt;, but in Section 26.6.2.6 [valarray.unary] it is declared to return a valarray&lt;bool&gt;. The
+ latter appears to be correct. </p>
+
+
+@@ -5774,10 +4952,10 @@ latter appears to be correct. </p>
+
+ <hr>
+ <h3><a name="126"></a>126. typos in Effects clause of ctype::do_narrow()</h3>
+-<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p><p>Typos in 22.2.1.1.2 need to be fixed.</p>
+
+ <p><b>Proposed resolution:</b></p>
+@@ -5803,10 +4981,10 @@ latter appears to be correct. </p>
+
+ <hr>
+ <h3><a name="127"></a>127. auto_ptr&lt;&gt; conversion issues</h3>
+-<p><b>Section:</b> D.12.1 [auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Greg Colvin <b>Opened:</b> 1999-02-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> X [auto.ptr] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Greg Colvin <b>Opened:</b> 1999-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There are two problems with the current <tt>auto_ptr</tt> wording
+ in the standard: </p>
+@@ -5826,8 +5004,8 @@ of the standard. </p>
+
+ <p>25 Aug 1999: The proposed resolution now reflects changes suggested
+ by Dave Abrahams, with Greg Colvin's concurrence; 1) changed
+-"assignment operator" to "public assignment
+-operator", 2) changed effects to specify use of release(), 3)
++&quot;assignment operator&quot; to &quot;public assignment
++operator&quot;, 2) changed effects to specify use of release(), 3)
+ made the conversion to auto_ptr_ref const. </p>
+
+ <p>2 Feb 2000: Lisa Lippincott comments: [The resolution of] this issue
+@@ -5844,7 +5022,7 @@ object parameter may be bound to an rvalue [13.3.3.1.4/3]
+
+ <p>Tokyo: The LWG removed the following from the proposed resolution:</p>
+
+- <p>In 20.7.4 [meta.unary], paragraph 2, and 20.7.4.3 [meta.unary.prop],
++ <p>In 20.10.4 [meta.unary], paragraph 2, and 20.10.4.3 [meta.unary.prop],
+ paragraph 2, make the conversion to auto_ptr_ref const:</p>
+ <blockquote>
+ <pre>template&lt;class Y&gt; operator auto_ptr_ref&lt;Y&gt;() const throw();</pre>
+@@ -5852,23 +5030,23 @@ object parameter may be bound to an rvalue [13.3.3.1.4/3]
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.7.4 [meta.unary], paragraph 2, move
++<p>In 20.10.4 [meta.unary], paragraph 2, move
+ the <tt>auto_ptr_ref</tt> definition to namespace scope.</p>
+
+-<p>In 20.7.4 [meta.unary], paragraph 2, add
++<p>In 20.10.4 [meta.unary], paragraph 2, add
+ a public assignment operator to the <tt>auto_ptr</tt> definition: </p>
+
+ <blockquote>
+ <pre>auto_ptr&amp; operator=(auto_ptr_ref&lt;X&gt; r) throw();</pre>
+ </blockquote>
+
+-<p>Also add the assignment operator to 20.7.4.3 [meta.unary.prop]: </p>
++<p>Also add the assignment operator to 20.10.4.3 [meta.unary.prop]: </p>
+
+ <blockquote>
+ <pre>auto_ptr&amp; operator=(auto_ptr_ref&lt;X&gt; r) throw()</pre>
+
+ <p><b>Effects:</b> Calls <tt>reset(p.release())</tt> for the <tt>auto_ptr
+- p</tt> that <tt>r</tt> holds a reference to.<br>
++ p</tt> that <tt>r</tt> holds a reference to.<br/>
+ <b>Returns: </b><tt>*this</tt>.</p>
+
+ </blockquote>
+@@ -5879,10 +5057,11 @@ a public assignment operator to the <tt>auto_ptr</tt> definition: </p>
+
+ <hr>
+ <h3><a name="129"></a>129. Need error indication from seekp() and seekg()</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted], 27.7.2.5 [ostream.seeks] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-02-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted], 27.7.3.5 [ostream.seeks] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-02-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Currently, the standard does not specify how seekg() and seekp()
+ indicate failure. They are not required to set failbit, and they can't
+@@ -5898,8 +5077,8 @@ stream state in case of failure.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add to the Effects: clause of&nbsp; seekg() in
+-27.7.1.3 [istream.unformatted] and to the Effects: clause of seekp() in
+-27.7.2.5 [ostream.seeks]: </p>
++27.7.2.3 [istream.unformatted] and to the Effects: clause of seekp() in
++27.7.3.5 [ostream.seeks]: </p>
+
+ <blockquote>
+ <p>In case of failure, the function calls <tt>setstate(failbit)</tt> (which may throw <tt>ios_base::failure</tt>).
+@@ -5915,12 +5094,12 @@ stream state in case of failure.</p>
+
+ <hr>
+ <h3><a name="130"></a>130. Return type of container::erase(iterator) differs for associative containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-03-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#451">451</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-03-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#451">451</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Table 67 (23.1.1) says that container::erase(iterator) returns an
+ iterator. Table 69 (23.1.2) says that in addition to this requirement,
+@@ -5953,16 +5132,18 @@ q2)</tt>. Returns q2."
+ </p>
+
+ <p>
+-In 23.6.1 [map], in the <tt>map</tt> class synopsis; and
+-in 23.6.2 [multimap], in the <tt>multimap</tt> class synopsis; and
+-in 23.6.3 [set], in the <tt>set</tt> class synopsis; and
+-in 23.6.4 [multiset], in the <tt>multiset</tt> class synopsis:
++In 23.4.4 [map], in the <tt>map</tt> class synopsis; and
++in 23.4.5 [multimap], in the <tt>multimap</tt> class synopsis; and
++in 23.4.6 [set], in the <tt>set</tt> class synopsis; and
++in 23.4.7 [multiset], in the <tt>multiset</tt> class synopsis:
+ change the signature of the first <tt>erase</tt> overload to
+ </p>
+-<pre> iterator erase(iterator position);
++<pre>
++ iterator erase(iterator position);
+ </pre>
+ <p>and change the signature of the third <tt>erase</tt> overload to</p>
+-<pre> iterator erase(iterator first, iterator last);
++<pre>
++ iterator erase(iterator first, iterator last);
+ </pre>
+
+
+@@ -5996,10 +5177,10 @@ Redmond: formally voted into WP.
+
+ <hr>
+ <h3><a name="132"></a>132. list::resize description uses random access iterators</h3>
+-<p><b>Section:</b> 23.3.4.2 [list.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.capacity">issues</a> in [list.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.3.5.3 [list.capacity] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.capacity">issues</a> in [list.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description reads:</p>
+
+@@ -6016,7 +5197,7 @@ Redmond: formally voted into WP.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 23.3.4.2 [list.capacity] paragraph 1 to:</p>
++<p>Change 23.3.5.3 [list.capacity] paragraph 1 to:</p>
+
+ <p>Effects:</p>
+
+@@ -6040,14 +5221,14 @@ no issue of exception safety with the proposed resolution.]</i></p>
+
+ <hr>
+ <h3><a name="133"></a>133. map missing get_allocator()</h3>
+-<p><b>Section:</b> 23.6.1 [map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map">issues</a> in [map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map">issues</a> in [map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p><p>The title says it all.</p>
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Insert in 23.6.1 [map], paragraph 2,
++<p>Insert in 23.4.4 [map], paragraph 2,
+ after operator= in the map declaration:</p>
+
+ <pre> allocator_type get_allocator() const;</pre>
+@@ -6057,19 +5238,19 @@ after operator= in the map declaration:</p>
+
+ <hr>
+ <h3><a name="134"></a>134. vector constructors over specified</h3>
+-<p><b>Section:</b> 23.4.1.1 [vector.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.3.6.2 [vector.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The complexity description says: "It does at most 2N calls to the copy constructor
+-of T and logN reallocations if they are just input iterators ...".</p>
++<p>The complexity description says: &quot;It does at most 2N calls to the copy constructor
++of T and logN reallocations if they are just input iterators ...&quot;.</p>
+
+ <p>This appears to be overly restrictive, dictating the precise memory/performance
+ tradeoff for the implementor.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 23.4.1.1 [vector.cons], paragraph 1 to:</p>
++<p>Change 23.3.6.2 [vector.cons], paragraph 1 to:</p>
+
+ <p>-1- Complexity: The constructor template &lt;class
+ InputIterator&gt; vector(InputIterator first, InputIterator last)
+@@ -6082,7 +5263,7 @@ order logN reallocations if they are just input iterators.
+
+
+ <p><b>Rationale:</b></p>
+-<p>"at most 2N calls" is correct only if the growth factor
++<p>&quot;at most 2N calls&quot; is correct only if the growth factor
+ is greater than or equal to 2.
+ </p>
+
+@@ -6091,10 +5272,11 @@ is greater than or equal to 2.
+
+ <hr>
+ <h3><a name="136"></a>136. seekp, seekg setting wrong streams?</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>I may be misunderstanding the intent, but should not seekg set only
+ the input stream and seekp set only the output stream? The description
+@@ -6139,7 +5321,7 @@ Effects: If fail() != true, executes rdbuf()-&gt;pubseekoff(off, dir, ios_base::
+
+ <pre>-4- Effects: If fail() != true, executes rdbuf()-&gt;pubseekoff(off, dir, ios_base::out). </pre>
+
+-<p><i>[Dublin: Dietmar Kühl thinks this is probably correct, but would
++<p><i>[Dublin: Dietmar K&uuml;hl thinks this is probably correct, but would
+ like the opinion of more iostream experts before taking action.]</i></p>
+
+
+@@ -6148,14 +5330,14 @@ incorrect, his implementation already implements the Proposed
+ Resolution.]</i></p>
+
+
+-<p><i>[Post-Tokyo: Matt Austern comments:<br>
++<p><i>[Post-Tokyo: Matt Austern comments:<br/>
+ Is it a problem with basic_istream and basic_ostream, or is it a problem
+ with basic_stringbuf?
+ We could resolve the issue either by changing basic_istream and
+ basic_ostream, or by changing basic_stringbuf. I prefer the latter
+ change (or maybe both changes): I don't see any reason for the standard to
+-require that std::stringbuf s(std::string("foo"), std::ios_base::in);
+-s.pubseekoff(0, std::ios_base::beg); must fail.<br>
++require that std::stringbuf s(std::string(&quot;foo&quot;), std::ios_base::in);
++s.pubseekoff(0, std::ios_base::beg); must fail.<br/>
+ This requirement is a bit weird. There's no similar requirement
+ for basic_streambuf&lt;&gt;::seekpos, or for basic_filebuf&lt;&gt;::seekoff or
+ basic_filebuf&lt;&gt;::seekpos.]</i></p>
+@@ -6167,10 +5349,10 @@ basic_filebuf&lt;&gt;::seekpos.]</i></p>
+
+ <hr>
+ <h3><a name="137"></a>137. Do use_facet and has_facet look in the global locale?</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-03-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-03-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 22.3.1 [locale] says:</p>
+
+@@ -6183,19 +5365,19 @@ function has_facet&lt;Facet&gt;(). </p>
+
+ <p>This contradicts the specification given in section
+ 22.3.2 [locale.global.templates]:
+-<br><br>
++<br/><br/>
+ template &lt;class&nbsp; Facet&gt; const&nbsp; Facet&amp; use_facet(const
+-locale&amp;&nbsp; loc); <br>
+-<br>
+--1- Get a reference to a facet of a locale. <br>
+--2- Returns: a reference to the corresponding facet of loc, if present. <br>
+--3- Throws: bad_cast if has_facet&lt;Facet&gt;(loc) is false. <br>
++locale&amp;&nbsp; loc); <br/>
++<br/>
++-1- Get a reference to a facet of a locale. <br/>
++-2- Returns: a reference to the corresponding facet of loc, if present. <br/>
++-3- Throws: bad_cast if has_facet&lt;Facet&gt;(loc) is false. <br/>
+ -4- Notes: The reference returned remains valid at least as long as any copy of loc exists
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Remove the phrase "(or, failing that, in the global locale)"
++<p>Remove the phrase &quot;(or, failing that, in the global locale)&quot;
+ from section 22.1.1. </p>
+
+
+@@ -6208,26 +5390,26 @@ in the standard.</p>
+
+ <hr>
+ <h3><a name="139"></a>139. Optional sequence operation table description unclear</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-03-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-03-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The sentence introducing the Optional sequence operation table
+ (23.1.1 paragraph 12) has two problems:</p>
+
+ <p>A. It says ``The operations in table 68 are provided only for the containers for which
+-they take constant time.''<br>
+-<br>
++they take constant time.''<br/>
++<br/>
+ That could be interpreted in two ways, one of them being ``Even though table 68 shows
+ particular operations as being provided, implementations are free to omit them if they
+-cannot implement them in constant time.''<br>
+-<br>
++cannot implement them in constant time.''<br/>
++<br/>
+ B. That paragraph says nothing about amortized constant time, and it should.&nbsp;</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace the wording in 23.1.1 paragraph 12&nbsp; which begins ``The operations in table 68 are provided only..."
++<p>Replace the wording in 23.1.1 paragraph 12&nbsp; which begins ``The operations in table 68 are provided only...&quot;
+ with:</p>
+
+ <blockquote>
+@@ -6242,15 +5424,15 @@ with:</p>
+
+ <hr>
+ <h3><a name="141"></a>141. basic_string::find_last_of, find_last_not_of say pos instead of xpos</h3>
+-<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.6 [string::replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Arch Robison <b>Opened:</b> 1999-04-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::insert">issues</a> in [string::insert].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4.6.4 [string::insert], 21.4.6.6 [string::replace] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Arch Robison <b>Opened:</b> 1999-04-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::insert">issues</a> in [string::insert].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Sections 21.3.6.4 paragraph 1 and 21.3.6.6 paragraph 1 surely have misprints where they
+-say:<br>
+-<br>
+-— <tt>xpos &lt;= pos</tt> and <tt>pos &lt; size();</tt></p>
++say:<br/>
++<br/>
++&#151; <tt>xpos &lt;= pos</tt> and <tt>pos &lt; size();</tt></p>
+
+ <p>Surely the document meant to say ``<tt>xpos &lt; size()</tt>'' in both places.</p>
+
+@@ -6260,28 +5442,28 @@ proposed resolution.]</i></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change Sections 21.3.6.4 paragraph 1 and 21.3.6.6 paragraph 1, the line which says:<br>
+-<br>
+-— <tt>xpos &lt;= pos</tt> and <tt>pos &lt; size();<br>
+-<br>
+-</tt>to:<br>
+-<tt><br>
+-</tt>— <tt>xpos &lt;= pos</tt> and <tt>xpos &lt; size();</tt></p>
++<p>Change Sections 21.3.6.4 paragraph 1 and 21.3.6.6 paragraph 1, the line which says:<br/>
++<br/>
++&#151; <tt>xpos &lt;= pos</tt> and <tt>pos &lt; size();<br/>
++<br/>
++</tt>to:<br/>
++<tt><br/>
++</tt>&#151; <tt>xpos &lt;= pos</tt> and <tt>xpos &lt; size();</tt></p>
+
+
+
+
+ <hr>
+ <h3><a name="142"></a>142. lexicographical_compare complexity wrong</h3>
+-<p><b>Section:</b> 25.4.8 [alg.lex.comparison] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-06-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>The lexicographical_compare complexity is specified as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; "At most min((last1 - first1), (last2 - first2))
+-applications of the corresponding comparison."<br>
+-<br>
++<p><b>Section:</b> 25.4.8 [alg.lex.comparison] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-06-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The lexicographical_compare complexity is specified as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; &quot;At most min((last1 - first1), (last2 - first2))
++applications of the corresponding comparison.&quot;<br/>
++<br/>
+ The best I can do is twice that expensive.</p>
+
+ <p>Nicolai Josuttis comments in lib-6862: You mean, to check for
+@@ -6299,15 +5481,15 @@ right! (and Matt states this complexity in his book)</p>
+
+ <p>Change the example at the end of paragraph 3 to read:</p>
+ <blockquote><p>
+- [Example:<br>
+- <br>
++ [Example:<br/>
++ <br/>
+ &nbsp;&nbsp;&nbsp; for ( ; first1 != last1 &amp;&amp; first2 != last2 ;
+- ++first1, ++first2) {<br>
+- &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (*first1 &lt; *first2) return true;<br>
+- &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (*first2 &lt; *first1) return false;<br>
+- &nbsp;&nbsp;&nbsp; }<br>
+- &nbsp;&nbsp;&nbsp; return first1 == last1 &amp;&amp; first2 != last2;<br>
+- &nbsp;&nbsp;&nbsp;<br>
++ ++first1, ++first2) {<br/>
++ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (*first1 &lt; *first2) return true;<br/>
++ &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (*first2 &lt; *first1) return false;<br/>
++ &nbsp;&nbsp;&nbsp; }<br/>
++ &nbsp;&nbsp;&nbsp; return first1 == last1 &amp;&amp; first2 != last2;<br/>
++ &nbsp;&nbsp;&nbsp;<br/>
+ --end example]
+ </p></blockquote>
+
+@@ -6316,12 +5498,12 @@ right! (and Matt states this complexity in his book)</p>
+
+ <hr>
+ <h3><a name="144"></a>144. Deque constructor complexity wrong </h3>
+-<p><b>Section:</b> 23.3.2.1 [deque.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 1999-05-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#deque.cons">issues</a> in [deque.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.3.3.2 [deque.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 1999-05-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.cons">issues</a> in [deque.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In 23.3.2.1 [deque.cons] paragraph 6, the deque ctor that takes an iterator range appears
++<p>In 23.3.3.2 [deque.cons] paragraph 6, the deque ctor that takes an iterator range appears
+ to have complexity requirements which are incorrect, and which contradict the
+ complexity requirements for insert(). I suspect that the text in question,
+ below, was taken from vector:</p>
+@@ -6331,7 +5513,7 @@ below, was taken from vector:</p>
+ N calls to the copy constructor, and performs no reallocations, where N is
+ last - first.</p>
+ </blockquote>
+-<p>The word "reallocations" does not really apply to deque. Further,
++<p>The word &quot;reallocations&quot; does not really apply to deque. Further,
+ all of the following appears to be spurious:</p>
+ <blockquote>
+ <p>It makes at most 2N calls to the copy constructor of T and log N
+@@ -6346,8 +5528,8 @@ insert?</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 23.3.2.1 [deque.cons] paragraph 6, replace the Complexity description, including the
+-footnote, with the following text (which also corrects the "abd"
++<p>In 23.3.3.2 [deque.cons] paragraph 6, replace the Complexity description, including the
++footnote, with the following text (which also corrects the &quot;abd&quot;
+ typo):</p>
+ <blockquote>
+ <p>Complexity: Makes last - first calls to the copy constructor of T.</p>
+@@ -6358,52 +5540,52 @@ typo):</p>
+
+ <hr>
+ <h3><a name="146"></a>146. complex&lt;T&gt; Inserter and Extractor need sentries</h3>
+-<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-05-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-05-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The extractor for complex numbers is specified as:&nbsp;</p>
+
+ <blockquote>
+
+-<p> template&lt;class T, class charT, class traits&gt;&nbsp;<br>
+- basic_istream&lt;charT, traits&gt;&amp;&nbsp;<br>
+- operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, complex&lt;T&gt;&amp; x);<br>
+-&nbsp;<br>
++<p> template&lt;class T, class charT, class traits&gt;&nbsp;<br/>
++ basic_istream&lt;charT, traits&gt;&amp;&nbsp;<br/>
++ operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, complex&lt;T&gt;&amp; x);<br/>
++&nbsp;<br/>
+ Effects: Extracts a complex number x of the form: u, (u), or (u,v),
+ where u is the real part and v is the imaginary part
+-(lib.istream.formatted).&nbsp;<br>
++(lib.istream.formatted).&nbsp;<br/>
+ Requires: The input values be convertible to T. If bad input is
+ encountered, calls is.setstate(ios::failbit) (which may throw
+-ios::failure (lib.iostate.flags).&nbsp;<br>
++ios::failure (lib.iostate.flags).&nbsp;<br/>
+ Returns: is .</p>
+
+ </blockquote>
+ <p>Is it intended that the extractor for complex numbers does not skip
+ whitespace, unlike all other extractors in the standard library do?
+-Shouldn't a sentry be used?&nbsp;<br>
+-<br>
++Shouldn't a sentry be used?&nbsp;<br/>
++<br/>
+ The inserter for complex numbers is specified as:</p>
+
+ <blockquote>
+
+-<p> template&lt;class T, class charT, class traits&gt;&nbsp;<br>
+- basic_ostream&lt;charT, traits&gt;&amp;&nbsp;<br>
+- operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; o, const complex&lt;T&gt;&amp; x);<br>
+-<br>
+-Effects: inserts the complex number x onto the stream o as if it were implemented as follows:<br>
+-<br>
+- template&lt;class T, class charT, class traits&gt;&nbsp;<br>
+- basic_ostream&lt;charT, traits&gt;&amp;&nbsp;<br>
+- operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; o, const complex&lt;T&gt;&amp; x)&nbsp;<br>
+- {&nbsp;<br>
+- basic_ostringstream&lt;charT, traits&gt; s;&nbsp;<br>
+- s.flags(o.flags());&nbsp;<br>
+- s.imbue(o.getloc());&nbsp;<br>
+- s.precision(o.precision());&nbsp;<br>
+- s &lt;&lt; '(' &lt;&lt; x.real() &lt;&lt; "," &lt;&lt; x.imag() &lt;&lt; ')';&nbsp;<br>
+- return o &lt;&lt; s.str();&nbsp;<br>
++<p> template&lt;class T, class charT, class traits&gt;&nbsp;<br/>
++ basic_ostream&lt;charT, traits&gt;&amp;&nbsp;<br/>
++ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; o, const complex&lt;T&gt;&amp; x);<br/>
++<br/>
++Effects: inserts the complex number x onto the stream o as if it were implemented as follows:<br/>
++<br/>
++ template&lt;class T, class charT, class traits&gt;&nbsp;<br/>
++ basic_ostream&lt;charT, traits&gt;&amp;&nbsp;<br/>
++ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; o, const complex&lt;T&gt;&amp; x)&nbsp;<br/>
++ {&nbsp;<br/>
++ basic_ostringstream&lt;charT, traits&gt; s;&nbsp;<br/>
++ s.flags(o.flags());&nbsp;<br/>
++ s.imbue(o.getloc());&nbsp;<br/>
++ s.precision(o.precision());&nbsp;<br/>
++ s &lt;&lt; '(' &lt;&lt; x.real() &lt;&lt; "," &lt;&lt; x.imag() &lt;&lt; ')';&nbsp;<br/>
++ return o &lt;&lt; s.str();&nbsp;<br/>
+ }</p>
+
+ </blockquote>
+@@ -6435,7 +5617,7 @@ same for each of the simpler extractions.</p>
+
+ <p><b>Rationale:</b></p>
+ <p>For extractors, the note is added to make it clear that skipping whitespace
+-follows an "all-or-none" rule.</p>
++follows an &quot;all-or-none&quot; rule.</p>
+
+ <p>For inserters, the LWG believes there is no defect; the standard is correct
+ as written.</p>
+@@ -6445,10 +5627,10 @@ as written.</p>
+
+ <hr>
+ <h3><a name="147"></a>147. Library Intro refers to global functions that aren't global</h3>
+-<p><b>Section:</b> 17.6.4.4 [global.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Lois Goldthwaite <b>Opened:</b> 1999-06-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#global.functions">issues</a> in [global.functions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 17.6.5.4 [global.functions] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Lois Goldthwaite <b>Opened:</b> 1999-06-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#global.functions">issues</a> in [global.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The library had many global functions until 17.4.1.1 [lib.contents]
+ paragraph 2 was added: </p>
+@@ -6465,26 +5647,26 @@ within namespace std. </p>
+
+ <blockquote>
+
+-<p>17.4.4.3 - Global functions [lib.global.functions]<br>
+-<br>
++<p>17.4.4.3 - Global functions [lib.global.functions]<br/>
++<br/>
+ -1- It is unspecified whether any global functions in the C++ Standard
+-Library are defined as inline (dcl.fct.spec).<br>
+-<br>
++Library are defined as inline (dcl.fct.spec).<br/>
++<br/>
+ -2- A call to a global function signature described in Clauses
+ lib.language.support through lib.input.output behaves the same as if
+ the implementation declares no additional global function
+-signatures.*<br>
+-<br>
++signatures.*<br/>
++<br/>
+ [Footnote: A valid C++ program always calls the expected library
+ global function. An implementation may also define additional
+ global functions that would otherwise not be called by a valid C++
+- program. --- end footnote]<br>
+-<br>
++ program. --- end footnote]<br/>
++<br/>
+ -3- A global function cannot be declared by the implementation as
+-taking additional default arguments.&nbsp;<br>
+-<br>
+-17.4.4.4 - Member functions [lib.member.functions]<br>
+-<br>
++taking additional default arguments.&nbsp;<br/>
++<br/>
++17.4.4.4 - Member functions [lib.member.functions]<br/>
++<br/>
+ -2- An implementation can declare additional non-virtual member
+ function signatures within a class: </p>
+
+@@ -6499,13 +5681,13 @@ virtual or global functions, however. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p> Change "global" to "global or non-member" in:</p>
++<p> Change "global" to &quot;global or non-member&quot; in:</p>
+ <blockquote>
+- <p>17.4.4.3 [lib.global.functions] section title,<br>
+- 17.4.4.3 [lib.global.functions] para 1,<br>
++ <p>17.4.4.3 [lib.global.functions] section title,<br/>
++ 17.4.4.3 [lib.global.functions] para 1,<br/>
+ 17.4.4.3 [lib.global.functions] para 2 in 2 places plus 2
+- places in the footnote,<br>
+- 17.4.4.3 [lib.global.functions] para 3,<br>
++ places in the footnote,<br/>
++ 17.4.4.3 [lib.global.functions] para 3,<br/>
+ 17.4.4.4 [lib.member.functions] para 2</p>
+ </blockquote>
+
+@@ -6513,7 +5695,7 @@ virtual or global functions, however. </p>
+ <p><b>Rationale:</b></p>
+ <p>
+ Because operator new and delete are global, the proposed resolution
+-was changed from "non-member" to "global or non-member.
++was changed from &quot;non-member&quot; to &quot;global or non-member.
+ </p>
+
+
+@@ -6521,10 +5703,10 @@ was changed from "non-member" to "global or non-member.
+
+ <hr>
+ <h3><a name="148"></a>148. Functions in the example facet BoolNames should be const</h3>
+-<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Jeremy Siek <b>Opened:</b> 1999-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Jeremy Siek <b>Opened:</b> 1999-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 22.4.8 [facets.examples] paragraph 13, the do_truename() and
+ do_falsename() functions in the example facet BoolNames should be
+@@ -6533,11 +5715,11 @@ numpunct_byname&lt;char&gt; are const. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 22.4.8 [facets.examples] paragraph 13, insert "const" in
++<p>In 22.4.8 [facets.examples] paragraph 13, insert &quot;const&quot; in
+ two places:</p>
+ <blockquote>
+- <p><tt>string do_truename() const { return "Oui Oui!"; }<br>
+- string do_falsename() const { return "Mais Non!"; }</tt></p>
++ <p><tt>string do_truename() const { return &quot;Oui Oui!&quot;; }<br/>
++ string do_falsename() const { return &quot;Mais Non!&quot;; }</tt></p>
+ </blockquote>
+
+
+@@ -6545,10 +5727,10 @@ two places:</p>
+
+ <hr>
+ <h3><a name="149"></a>149. Insert should return iterator to first element inserted</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Suppose that c and c1 are sequential containers and i is an
+ iterator that refers to an element of c. Then I can insert a copy of
+@@ -6571,9 +5753,12 @@ c.insert(i, c1.begin(), c1.end());</pre>
+ </blockquote>
+
+ <p>and now the first inserted element is at c.begin()+i_loc and one
+-past the last is at c.begin()+i_loc+c1.size().<br>
+-<br>
+-But what if c is a list? I can still find the location of one past the last inserted element, because i is still valid. To find the location of the first inserted element, though, I must execute something like </p>
++past the last is at c.begin()+i_loc+c1.size().<br/>
++<br/>
++But what if c is a list? I can still find the location of one
++past the last inserted element, because i is still valid.
++To find the location of the first inserted element, though,
++I must execute something like </p>
+
+ <blockquote>
+
+@@ -6582,8 +5767,8 @@ But what if c is a list? I can still find the location of one past the last
+
+ </blockquote>
+
+-<p>because i is now no longer a random-access iterator.<br>
+-<br>
++<p>because i is now no longer a random-access iterator.<br/>
++<br/>
+ Alternatively, I might write something like </p>
+
+ <blockquote>
+@@ -6599,8 +5784,8 @@ else
+
+ </blockquote>
+
+-<p>which, although wretched, requires less overhead.<br>
+-<br>
++<p>which, although wretched, requires less overhead.<br/>
++<br/>
+ But I think the right solution is to change the definition of insert
+ so that instead of returning void, it returns an iterator that refers
+ to the first element inserted, if any, and otherwise is a copy of its
+@@ -6611,9 +5796,9 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Reopened by Alisdair.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair adds:
+@@ -6655,17 +5840,17 @@ Moved to Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-<sef ref="[sequence.reqmts]"> Table 83
++23.2.3 [sequence.reqmts] Table 83
+ change return type from <tt>void</tt> to <tt>iterator</tt> for the following rows:
+-</sef></p>
++</p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 83 -- Sequence container requirements (in addition to container)</caption>
+-<tbody><tr>
++<caption>Table 83 &mdash; Sequence container requirements (in addition to container)</caption>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note pre-/post-condition</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
+ </tr>
+ <tr>
+ <td>
+@@ -6705,7 +5890,7 @@ Inserts copies of elements in <tt>[i, j)</tt> before <tt>p</tt>
+ <tt>a.insert(p, il.begin(), il.end())</tt>.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -6733,21 +5918,23 @@ first element inserted into <tt>a</tt>, or <tt>p</tt> if <tt>il</tt> is empty.
+ </blockquote>
+
+ <p>
+-p2 23.3.2 [deque] Update class definition, change return type
++p2 23.3.3 [deque] Update class definition, change return type
+ from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, initializer_list&lt;T&gt;);
+ </pre></blockquote>
+
+ <p>
+-23.3.2.3 [deque.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
++23.3.3.4 [deque.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
+ </p>
+
+-<blockquote><pre> <del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++ <del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+ </pre></blockquote>
+@@ -6756,40 +5943,44 @@ template &lt;class InputIterator&gt;
+ Add the following (missing) declaration
+ </p>
+
+-<blockquote><pre><ins>iterator insert(const_iterator position, initializer_list&lt;T&gt;);</ins>
++<blockquote><pre>
++<ins>iterator insert(const_iterator position, initializer_list&lt;T&gt;);</ins>
+ </pre></blockquote>
+
+ <p>
+-23.3.3 [forwardlist] Update class definition, change return type
++23.3.4 [forwardlist] Update class definition, change return type
+ from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert_after(const_iterator position, initializer_list&lt;T&gt; il);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert_after(const_iterator position, initializer_list&lt;T&gt; il);
+ <del>void</del> <ins>iterator</ins> insert_after(const_iterator position, size_type n, const T&amp; x);
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert_after(const_iterator position, InputIterator first, InputIterator last);
+ </pre></blockquote>
+
+ <p>
+-p8 23.3.3.4 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt>:
++p8 23.3.4.5 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert_after(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert_after(const_iterator position, size_type n, const T&amp; x);
+ </pre></blockquote>
+
+ <p>
+ Add paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Returns: position.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-p10 23.3.3.4 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt>:
++p10 23.3.4.5 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre>template &lt;class InputIterator&gt;
++<blockquote><pre>
++template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert_after(const_iterator position, InputIterator first, InputIterator last);
+ </pre></blockquote>
+
+@@ -6797,15 +5988,16 @@ p10 23.3.3.4 [forwardlist.modifiers] change return type from <tt>void</tt> to <t
+ Add paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Returns: position.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-p12 23.3.3.4 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
++p12 23.3.4.5 [forwardlist.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert_after(const_iterator position, initializer_list&lt;T&gt; il);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert_after(const_iterator position, initializer_list&lt;T&gt; il);
+ </pre></blockquote>
+
+ <p>
+@@ -6813,10 +6005,11 @@ change return type from <tt>void</tt> to <tt>iterator</tt> on following declarat
+ </p>
+
+ <p>
+-p2 23.3.4 [list] Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
++p2 23.3.5 [list] Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+@@ -6825,10 +6018,11 @@ template &lt;class InputIterator&gt;
+ </pre></blockquote>
+
+ <p>
+-23.3.4.3 [list.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
++23.3.5.4 [list.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+@@ -6838,18 +6032,20 @@ template &lt;class InputIterator&gt;
+ Add the following (missing) declaration
+ </p>
+
+-<blockquote><pre>iterator insert(const_iterator position, initializer_list&lt;T&gt;);
++<blockquote><pre>
++iterator insert(const_iterator position, initializer_list&lt;T&gt;);
+ </pre></blockquote>
+
+ <p>
+-p2 23.4.1 [vector]
++p2 23.3.6 [vector]
+ </p>
+
+ <p>
+ Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator position, T&amp;&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator position, T&amp;&amp; x);
+
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+
+@@ -6860,10 +6056,11 @@ template &lt;class InputIterator&gt;
+ </pre></blockquote>
+
+ <p>
+-23.4.1.4 [vector.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
++23.3.6.5 [vector.modifiers] change return type from <tt>void</tt> to <tt>iterator</tt> on following declarations:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator position, size_type n, const T&amp; x);
+
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+@@ -6873,15 +6070,17 @@ template &lt;class InputIterator&gt;
+ Add the following (missing) declaration
+ </p>
+
+-<blockquote><pre>iterator insert(const_iterator position, initializer_list&lt;T&gt;);
++<blockquote><pre>
++iterator insert(const_iterator position, initializer_list&lt;T&gt;);
+ </pre></blockquote>
+
+
+ <p>
+-p1 23.4.2 [vector.bool] Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
++p1 23.3.7 [vector.bool] Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert (const_iterator position, size_type n, const bool&amp; x);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert (const_iterator position, size_type n, const bool&amp; x);
+
+ template &lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator position, InputIterator first, InputIterator last);
+@@ -6893,7 +6092,8 @@ template &lt;class InputIterator&gt;
+ p5 21.4 [basic.string] Update class definition, change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator p, size_type n, charT c);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator p, size_type n, charT c);
+
+ template&lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator p, InputIterator first, InputIterator last);
+@@ -6905,23 +6105,25 @@ template&lt;class InputIterator&gt;
+ p13 21.4.6.4 [string::insert] change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator p, size_type n, charT c);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator p, size_type n, charT c);
+ </pre></blockquote>
+
+ <p>
+ Add paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> an iterator which refers to the copy of the first inserted
+ character, or <tt>p</tt> if <tt>n == 0</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ p15 21.4.6.4 [string::insert] change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator&gt;
++<blockquote><pre>
++template&lt;class InputIterator&gt;
+ <del>void</del> <ins>iterator</ins> insert(const_iterator p, InputIterator first, InputIterator last);
+ </pre></blockquote>
+
+@@ -6929,33 +6131,34 @@ p15 21.4.6.4 [string::insert] change return type from <tt>void</tt> to <tt>itera
+ Add paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> an iterator which refers to the copy of the first inserted
+ character, or <tt>p</tt> if <tt>first == last</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ p17 21.4.6.4 [string::insert] change return type from <tt>void</tt> to <tt>iterator</tt>:
+ </p>
+
+-<blockquote><pre><del>void</del> <ins>iterator</ins> insert(const_iterator p, initializer_list&lt;charT&gt; il);
++<blockquote><pre>
++<del>void</del> <ins>iterator</ins> insert(const_iterator p, initializer_list&lt;charT&gt; il);
+ </pre></blockquote>
+
+ <p>
+ Add paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> an iterator which refers to the copy of the first inserted
+ character, or <tt>p</tt> if <tt>il</tt> is empty.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+
+ <p><i>[
+-The following was the C++98/03 rationale and does not necessarily apply to the
++The following was the C++98&#47;03 rationale and does not necessarily apply to the
+ proposed resolution in the C++0X time frame:
+ ]</i></p>
+
+@@ -6970,10 +6173,10 @@ not a defect. It may be worth revisiting for the next standard.</p>
+
+ <hr>
+ <h3><a name="150"></a>150. Find_first_of says integer instead of iterator </h3>
+-<p><b>Section:</b> 25.2.7 [alg.find.first.of] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt McClure <b>Opened:</b> 1999-06-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.find.first.of">issues</a> in [alg.find.first.of].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 25.2.7 [alg.find.first.of] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt McClure <b>Opened:</b> 1999-06-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.find.first.of">issues</a> in [alg.find.first.of].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+
+@@ -6997,21 +6200,21 @@ that for some iterator j in the range [first2, last2) ...</p>
+
+ <hr>
+ <h3><a name="151"></a>151. Can't currently clear() empty container</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Ed Brey <b>Opened:</b> 1999-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Ed Brey <b>Opened:</b> 1999-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>For both sequences and associative containers, a.clear() has the
+ semantics of erase(a.begin(),a.end()), which is undefined for an empty
+ container since erase(q1,q2) requires that q1 be dereferenceable
+ (23.1.1,3 and 23.1.2,7). When the container is empty, a.begin() is
+-not dereferenceable.<br>
+-<br>
++not dereferenceable.<br/>
++<br/>
+ The requirement that q1 be unconditionally dereferenceable causes many
+ operations to be intuitively undefined, of which clearing an empty
+-container is probably the most dire.<br>
+-<br>
++container is probably the most dire.<br/>
++<br/>
+ Since q1 and q2 are only referenced in the range [q1, q2), and [q1,
+ q2) is required to be a valid range, stating that q1 and q2 must be
+ iterators or certain kinds of iterators is unnecessary.
+@@ -7044,10 +6247,10 @@ iterators or certain kinds of iterators is unnecessary.
+
+ <hr>
+ <h3><a name="152"></a>152. Typo in <tt>scan_is()</tt> semantics</h3>
+-<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The semantics of <tt>scan_is()</tt> (paragraphs 4 and 6) is not exactly described
+ because there is no function <tt>is()</tt> which only takes a character as
+@@ -7059,11 +6262,11 @@ vague.</p>
+ <p>In 22.4.1.1.2 [locale.ctype.virtuals] paragraphs 4 and 6, change the returns
+ clause from:</p>
+ <blockquote>
+- <p>"... such that <tt>is(*p)</tt>
+-would..."</p>
++ <p>&quot;... such that <tt>is(*p)</tt>
++would...&quot;</p>
+ </blockquote>
+-<p>to:&nbsp; "... such that <tt>is(m, *p)</tt>
+- would...."</p>
++<p>to:&nbsp; &quot;... such that <tt>is(m, *p)</tt>
++ would....&quot;</p>
+
+
+
+@@ -7071,11 +6274,11 @@ would..."</p>
+
+ <hr>
+ <h3><a name="153"></a>153. Typo in <tt>narrow()</tt> semantics</h3>
+-<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#207">207</a></p>
++<p><b>Section:</b> 22.4.1.3.2 [facet.ctype.char.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.ctype.char.members">issues</a> in [facet.ctype.char.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#207">207</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the array version of <tt>narrow()</tt> (in
+ paragraph 11) is flawed: There is no member <tt>do_narrow()</tt> which
+@@ -7115,13 +6318,13 @@ defined version could be different.]</i></p>
+
+ <p><i>[Post-Tokyo: Dietmar provided the above wording at the request of
+ the LWG. He could find no other places the problem occurred. He
+-asks for clarification of the Kona "a user defined
+-version..." comment above. Perhaps it was a circuitous way of
+-saying "dfault" needed to be uncommented?]</i></p>
++asks for clarification of the Kona &quot;a user defined
++version...&quot; comment above. Perhaps it was a circuitous way of
++saying &quot;dfault&quot; needed to be uncommented?]</i></p>
+
+
+ <p><i>[Post-Toronto: the issues list maintainer has merged in the
+-proposed resolution from issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#207">207</a>, which addresses the
++proposed resolution from issue <a href="lwg-closed.html#207">207</a>, which addresses the
+ same paragraphs.]</i></p>
+
+
+@@ -7131,10 +6334,11 @@ same paragraphs.]</i></p>
+
+ <hr>
+ <h3><a name="154"></a>154. Missing <tt>double</tt> specifier for <tt>do_get()</tt></h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The table in paragraph 7 for the length modifier does not list the length
+ modifier <tt>l</tt> to be applied if the type is <tt>double</tt>. Thus, the
+@@ -7157,20 +6361,20 @@ Modifier table to say that for <tt>double</tt> a length modifier
+
+ <hr>
+ <h3><a name="155"></a>155. Typo in naming the class defining the class <tt>Init</tt></h3>
+-<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There are conflicting statements about where the class
+ <tt>Init</tt> is defined. According to 27.4 [iostream.objects] paragraph 2
+-it is defined as <tt>basic_ios::Init</tt>, according to 27.5.2 [ios.base] it is defined as <tt>ios_base::Init</tt>.</p>
++it is defined as <tt>basic_ios::Init</tt>, according to 27.5.3 [ios.base] it is defined as <tt>ios_base::Init</tt>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change 27.4 [iostream.objects] paragraph 2 from
+-"<tt>basic_ios::Init"</tt> to
+-"<tt>ios_base::Init"</tt>.</p>
++&quot;<tt>basic_ios::Init&quot;</tt> to
++&quot;<tt>ios_base::Init&quot;</tt>.</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -7182,31 +6386,31 @@ the change.</p>
+
+ <hr>
+ <h3><a name="156"></a>156. Typo in <tt>imbue()</tt> description</h3>
+-<p><b>Section:</b> 27.5.2.3 [ios.base.locales] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios.base.locales">issues</a> in [ios.base.locales].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.3 [ios.base.locales] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base.locales">issues</a> in [ios.base.locales].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There is a small discrepancy between the declarations of
+-<tt>imbue()</tt>: in 27.5.2 [ios.base] the argument is passed as
+-<tt>locale const&amp;</tt> (correct), in 27.5.2.3 [ios.base.locales] it
++<tt>imbue()</tt>: in 27.5.3 [ios.base] the argument is passed as
++<tt>locale const&amp;</tt> (correct), in 27.5.3.3 [ios.base.locales] it
+ is passed as <tt>locale const</tt> (wrong).</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.5.2.3 [ios.base.locales] change the <tt>imbue</tt> argument
+-from "<tt>locale const" to "locale
+-const&amp;".</tt></p>
++<p>In 27.5.3.3 [ios.base.locales] change the <tt>imbue</tt> argument
++from &quot;<tt>locale const&quot; to &quot;locale
++const&amp;&quot;.</tt></p>
+
+
+
+
+ <hr>
+ <h3><a name="158"></a>158. Underspecified semantics for <tt>setbuf()</tt></h3>
+-<p><b>Section:</b> 27.6.2.4.2 [streambuf.virt.buffer] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf.virt.buffer">issues</a> in [streambuf.virt.buffer].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3.4.2 [streambuf.virt.buffer] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf.virt.buffer">issues</a> in [streambuf.virt.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The default behavior of <tt>setbuf()</tt> is described only for the
+ situation that <tt>gptr() != 0 &amp;&amp; gptr() != egptr()</tt>:
+@@ -7221,17 +6425,17 @@ to do nothing.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.6.2.4.2 [streambuf.virt.buffer], paragraph 3, Default behavior,
+-to: "Default behavior: Does nothing. Returns this."</p>
++<p>Change 27.6.3.4.2 [streambuf.virt.buffer], paragraph 3, Default behavior,
++to: &quot;Default behavior: Does nothing. Returns this.&quot;</p>
+
+
+
+
+ <hr>
+ <h3><a name="159"></a>159. Strange use of <tt>underflow()</tt></h3>
+-<p><b>Section:</b> 27.6.2.4.3 [streambuf.virt.get] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.6.3.4.3 [streambuf.virt.get] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the meaning of the result of
+ <tt>showmanyc()</tt> seems to be rather strange: It uses calls to
+@@ -7242,20 +6446,20 @@ be fixed to use <tt>sbumpc()</tt> instead.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.6.2.4.3 [streambuf.virt.get] paragraph 1,
++<p>Change 27.6.3.4.3 [streambuf.virt.get] paragraph 1,
+ <tt>showmanyc()</tt>returns clause, by replacing the word
+-"supplied" with the words "extracted from the
+-stream".</p>
++&quot;supplied&quot; with the words &quot;extracted from the
++stream&quot;.</p>
+
+
+
+
+ <hr>
+ <h3><a name="160"></a>160. Typo: Use of non-existing function <tt>exception()</tt></h3>
+-<p><b>Section:</b> 27.7.1.1 [istream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream">issues</a> in [istream].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.1 [istream] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream">issues</a> in [istream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The paragraph 4 refers to the function <tt>exception()</tt> which
+ is not defined. Probably, the referred function is
+@@ -7263,12 +6467,12 @@ is not defined. Probably, the referred function is
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.1.1 [istream], 27.7.1.3 [istream.unformatted], paragraph 1,
+-27.7.2.1 [ostream], paragraph 3, and 27.7.2.6.1 [ostream.formatted.reqmts],
+-paragraph 1, change "<tt>exception()" to
+-"exceptions()"</tt>.</p>
++<p>In 27.7.2.1 [istream], 27.7.2.3 [istream.unformatted], paragraph 1,
++27.7.3.1 [ostream], paragraph 3, and 27.7.3.6.1 [ostream.formatted.reqmts],
++paragraph 1, change &quot;<tt>exception()&quot; to
++&quot;exceptions()&quot;</tt>.</p>
+
+-<p><i>[Note to Editor: "exceptions" with an "s"
++<p><i>[Note to Editor: &quot;exceptions&quot; with an &quot;s&quot;
+ is the correct spelling.]</i></p>
+
+
+@@ -7278,10 +6482,10 @@ is the correct spelling.]</i></p>
+
+ <hr>
+ <h3><a name="161"></a>161. Typo: <tt>istream_iterator</tt> vs. <tt>istreambuf_iterator</tt></h3>
+-<p><b>Section:</b> 27.7.1.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The note in the second paragraph pretends that the first argument
+ is an object of type <tt>istream_iterator</tt>. This is wrong: It is
+@@ -7289,7 +6493,7 @@ an object of type <tt>istreambuf_iterator</tt>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.7.1.2.2 [istream.formatted.arithmetic] from:</p>
++<p>Change 27.7.2.2.2 [istream.formatted.arithmetic] from:</p>
+ <blockquote>
+ <p>The first argument provides an object of the istream_iterator class...</p>
+ </blockquote>
+@@ -7304,9 +6508,9 @@ an object of type <tt>istreambuf_iterator</tt>.</p>
+
+ <hr>
+ <h3><a name="164"></a>164. do_put() has apparently unused fill argument</h3>
+-<p><b>Section:</b> 22.4.5.3.2 [locale.time.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.5.3.2 [locale.time.put.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 22.4.5.3.2 [locale.time.put.virtuals] the do_put() function is specified
+ as taking a fill character as an argument, but the description of the
+@@ -7315,7 +6519,7 @@ in which way. The same holds for any format control parameters that
+ are accessible through the ios_base&amp; argument, such as the
+ adjustment or the field width. Is strftime() supposed to use the fill
+ character in any way? In any case, the specification of
+-time_put.do_put() looks inconsistent to me.<br> <br> Is the
++time_put.do_put() looks inconsistent to me.<br/> <br/> Is the
+ signature of do_put() wrong, or is the effects clause incomplete?</p>
+
+
+@@ -7338,14 +6542,14 @@ argument since the standard doesn't say how it's used.</p>
+
+ <hr>
+ <h3><a name="165"></a>165. <tt>xsputn()</tt>, <tt>pubsync()</tt> never called by <tt>basic_ostream</tt> members?</h3>
+-<p><b>Section:</b> 27.7.2.1 [ostream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream">issues</a> in [ostream].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.1 [ostream] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream">issues</a> in [ostream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 2 explicitly states that none of the <tt>basic_ostream</tt>
+-functions falling into one of the groups "formatted output functions"
+-and "unformatted output functions" calls any stream buffer function
++functions falling into one of the groups &quot;formatted output functions&quot;
++and &quot;unformatted output functions&quot; calls any stream buffer function
+ which might call a virtual function other than <tt>overflow()</tt>. Basically
+ this is fine but this implies that <tt>sputn()</tt> (this function would call
+ the virtual function <tt>xsputn()</tt>) is never called by any of the standard
+@@ -7354,10 +6558,10 @@ call <tt>xsputn()</tt> for strings... Also, the statement that <tt>overflow()</t
+ is the only virtual member of <tt>basic_streambuf</tt> called is in conflict
+ with the definition of <tt>flush()</tt> which calls <tt>rdbuf()-&gt;pubsync()</tt>
+ and thereby the virtual function <tt>sync()</tt> (<tt>flush()</tt> is listed
+-under "unformatted output functions").</p>
+-<p>In addition, I guess that the sentence starting with "They may use other
+-public members of <tt>basic_ostream</tt> ..." probably was intended to
+-start with "They may use other public members of <tt>basic_streamuf</tt>..."
++under &quot;unformatted output functions&quot;).</p>
++<p>In addition, I guess that the sentence starting with &quot;They may use other
++public members of <tt>basic_ostream</tt> ...&quot; probably was intended to
++start with &quot;They may use other public members of <tt>basic_streamuf</tt>...&quot;
+ although the problem with the virtual members exists in both cases.</p>
+ <p>I see two obvious resolutions:</p>
+ <ol>
+@@ -7398,10 +6602,10 @@ is allowed to call sync() while other functions are not.]</i></p>
+
+ <hr>
+ <h3><a name="167"></a>167. Improper use of <tt>traits_type::length()</tt></h3>
+-<p><b>Section:</b> 27.7.2.6.4 [ostream.inserters.character] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.inserters.character">issues</a> in [ostream.inserters.character].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.6.4 [ostream.inserters.character] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.inserters.character">issues</a> in [ostream.inserters.character].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 4 states that the length is determined using
+ <tt>traits::length(s)</tt>. Unfortunately, this function is not
+@@ -7413,7 +6617,7 @@ const*</tt>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 27.7.2.6.4 [ostream.inserters.character] paragraph 4 from:</p>
++<p>Change 27.7.3.6.4 [ostream.inserters.character] paragraph 4 from:</p>
+ <blockquote>
+ <p>Effects: Behaves like an formatted inserter (as described in
+ lib.ostream.formatted.reqmts) of out. After a sentry object is
+@@ -7478,10 +6682,10 @@ to char_traits&lt;char&gt;</p>
+
+ <hr>
+ <h3><a name="168"></a>168. Typo: formatted vs. unformatted</h3>
+-<p><b>Section:</b> 27.7.2.7 [ostream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.3.7 [ostream.unformatted] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The first paragraph begins with a descriptions what has to be done
+ in <i>formatted</i> output functions. Probably this is a typo and the
+@@ -7489,13 +6693,13 @@ paragraph really want to describe unformatted output functions...</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.2.7 [ostream.unformatted] paragraph 1, the first and last
+-sentences, change the word "formatted" to
+-"unformatted":</p>
++<p>In 27.7.3.7 [ostream.unformatted] paragraph 1, the first and last
++sentences, change the word &quot;formatted&quot; to
++&quot;unformatted&quot;:</p>
+ <blockquote>
+- <p>"Each <b>unformatted </b> output function begins ..."<br>
+- "... value specified for the <b>unformatted </b> output
+- function."</p>
++ <p>&quot;Each <b>unformatted </b> output function begins ...&quot;<br/>
++ &quot;... value specified for the <b>unformatted </b> output
++ function.&quot;</p>
+ </blockquote>
+
+
+@@ -7503,15 +6707,15 @@ sentences, change the word "formatted" to
+
+ <hr>
+ <h3><a name="169"></a>169. Bad efficiency of <tt>overflow()</tt> mandated</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Paragraph 8, Notes, of this section seems to mandate an extremely
+ inefficient way of buffer handling for <tt>basic_stringbuf</tt>,
+ especially in view of the restriction that <tt>basic_ostream</tt>
+-member functions are not allowed to use <tt>xsputn()</tt> (see 27.7.2.1 [ostream]): For each character to be inserted, a new buffer
++member functions are not allowed to use <tt>xsputn()</tt> (see 27.7.3.1 [ostream]): For each character to be inserted, a new buffer
+ is to be created.</p>
+ <p>Of course, the resolution below requires some handling of
+ simultaneous input and output since it is no longer possible to update
+@@ -7520,8 +6724,8 @@ solution is to handle this in <tt>underflow()</tt>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.8.1.4 [stringbuf.virtuals] paragraph 8, Notes, insert the words
+-"at least" as in the following:</p>
++<p>In 27.8.2.4 [stringbuf.virtuals] paragraph 8, Notes, insert the words
++&quot;at least&quot; as in the following:</p>
+ <blockquote>
+ <p>To make a write position available, the function reallocates (or initially
+ allocates) an array object with a sufficient number of elements to hold the
+@@ -7534,13 +6738,13 @@ solution is to handle this in <tt>underflow()</tt>.</p>
+
+ <hr>
+ <h3><a name="170"></a>170. Inconsistent definition of <tt>traits_type</tt></h3>
+-<p><b>Section:</b> 27.8.4 [stringstream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.8.5 [stringstream] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The classes <tt>basic_stringstream</tt> (27.8.4 [stringstream]),
+-<tt>basic_istringstream</tt> (27.8.2 [istringstream]), and
+-<tt>basic_ostringstream</tt> (27.8.3 [ostringstream]) are inconsistent
++<p>The classes <tt>basic_stringstream</tt> (27.8.5 [stringstream]),
++<tt>basic_istringstream</tt> (27.8.3 [istringstream]), and
++<tt>basic_ostringstream</tt> (27.8.4 [ostringstream]) are inconsistent
+ in their definition of the type <tt>traits_type</tt>: For
+ <tt>istringstream</tt>, this type is defined, for the other two it is
+ not. This should be consistent.</p>
+@@ -7548,8 +6752,8 @@ not. This should be consistent.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p><b>Proposed resolution:</b></p> <p>To the declarations of
+-<tt>basic_ostringstream</tt> (27.8.3 [ostringstream]) and
+-<tt>basic_stringstream</tt> (27.8.4 [stringstream]) add:</p>
++<tt>basic_ostringstream</tt> (27.8.4 [ostringstream]) and
++<tt>basic_stringstream</tt> (27.8.5 [stringstream]) add:</p>
+ <blockquote>
+ <pre>typedef traits traits_type;</pre>
+ </blockquote>
+@@ -7559,10 +6763,10 @@ not. This should be consistent.</p>
+
+ <hr>
+ <h3><a name="171"></a>171. Strange <tt>seekpos()</tt> semantics due to joint position</h3>
+-<p><b>Section:</b> 27.9.1.5 [filebuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#filebuf.virtuals">issues</a> in [filebuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.5 [filebuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.virtuals">issues</a> in [filebuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Overridden virtual functions, seekpos()</p> <p>In 27.9.1.1 [filebuf] paragraph 3, it is stated that a joint input and
+ output position is maintained by <tt>basic_filebuf</tt>. Still, the
+@@ -7625,21 +6829,22 @@ paragraph 14 from:</p>
+
+ <hr>
+ <h3><a name="172"></a>172. Inconsistent types for <tt>basic_istream::ignore()</tt></h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Greg Comeau, Dietmar Kühl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Greg Comeau, Dietmar K&uuml;hl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In 27.7.1.1 [istream] the function
++<p>In 27.7.2.1 [istream] the function
+ <tt>ignore()</tt> gets an object of type <tt>streamsize</tt> as first
+-argument. However, in 27.7.1.3 [istream.unformatted]
++argument. However, in 27.7.2.3 [istream.unformatted]
+ paragraph 23 the first argument is of type <tt>int.</tt></p>
+
+ <p>As far as I can see this is not really a contradiction because
+ everything is consistent if <tt>streamsize</tt> is typedef to be
+ <tt>int</tt>. However, this is almost certainly not what was
+ intended. The same thing happened to <tt>basic_filebuf::setbuf()</tt>,
+-as described in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#173">173</a>.</p>
++as described in issue <a href="lwg-defects.html#173">173</a>.</p>
+
+ <p>Darin Adler also
+ submitted this issue, commenting: Either 27.6.1.1 should be modified
+@@ -7649,7 +6854,7 @@ numeric_limits&lt;streamsize&gt;::max.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 27.7.1.3 [istream.unformatted] paragraph 23 and 24, change both uses
++<p>In 27.7.2.3 [istream.unformatted] paragraph 23 and 24, change both uses
+ of <tt>int</tt> in the description of <tt>ignore()</tt> to
+ <tt>streamsize</tt>.</p>
+
+@@ -7658,10 +6863,10 @@ of <tt>int</tt> in the description of <tt>ignore()</tt> to
+
+ <hr>
+ <h3><a name="173"></a>173. Inconsistent types for <tt>basic_filebuf::setbuf()</tt></h3>
+-<p><b>Section:</b> 27.9.1.5 [filebuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Greg Comeau, Dietmar Kühl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#filebuf.virtuals">issues</a> in [filebuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.9.1.5 [filebuf.virtuals] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Greg Comeau, Dietmar K&uuml;hl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.virtuals">issues</a> in [filebuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -7676,7 +6881,7 @@ As far as I can see this is not really a contradiction because
+ everything is consistent if <tt>streamsize</tt> is typedef to be
+ <tt>int</tt>. However, this is almost certainly not what was
+ intended. The same thing happened to <tt>basic_istream::ignore()</tt>,
+-as described in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#172">172</a>.
++as described in issue <a href="lwg-defects.html#172">172</a>.
+ </p>
+
+
+@@ -7691,10 +6896,10 @@ as described in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-d
+
+ <hr>
+ <h3><a name="174"></a>174. Typo: <tt>OFF_T</tt> vs. <tt>POS_T</tt></h3>
+-<p><b>Section:</b> D.8 [depr.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.6 [depr.ios.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>According to paragraph 1 of this section, <tt>streampos</tt> is the
+ type <tt>OFF_T</tt>, the same type as <tt>streamoff</tt>. However, in
+@@ -7702,24 +6907,24 @@ paragraph 6 the <tt>streampos</tt> gets the type <tt>POS_T</tt></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change D.8 [depr.ios.members] paragraph 1 from "<tt>typedef
+-OFF_T streampos;</tt>" to "<tt>typedef POS_T
+-streampos;</tt>"</p>
++<p>Change D.6 [depr.ios.members] paragraph 1 from &quot;<tt>typedef
++OFF_T streampos;</tt>&quot; to &quot;<tt>typedef POS_T
++streampos;</tt>&quot;</p>
+
+
+
+
+ <hr>
+ <h3><a name="175"></a>175. Ambiguity for <tt>basic_streambuf::pubseekpos()</tt> and a few other functions.</h3>
+-<p><b>Section:</b> D.8 [depr.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.6 [depr.ios.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>According to paragraph 8 of this section, the methods
+ <tt>basic_streambuf::pubseekpos()</tt>,
+ <tt>basic_ifstream::open()</tt>, and <tt>basic_ofstream::open</tt>
+-"may" be overloaded by a version of this function taking the
++&quot;may&quot; be overloaded by a version of this function taking the
+ type <tt>ios_base::open_mode</tt> as last argument argument instead of
+ <tt>ios_base::openmode</tt> (<tt>ios_base::open_mode</tt> is defined
+ in this section to be an alias for one of the integral types). The
+@@ -7730,7 +6935,7 @@ argument is not specified.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In D.8 [depr.ios.members] paragraph 8, remove the default arguments for
++<p>In D.6 [depr.ios.members] paragraph 8, remove the default arguments for
+ <tt>basic_streambuf::pubseekpos()</tt>,
+ <tt>basic_ifstream::open()</tt>, and
+ <tt>basic_ofstream::open().</tt></p>
+@@ -7740,21 +6945,21 @@ argument is not specified.</p>
+
+ <hr>
+ <h3><a name="176"></a>176. <tt>exceptions()</tt> in <tt>ios_base</tt>...?</h3>
+-<p><b>Section:</b> D.8 [depr.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> D.6 [depr.ios.members] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 1999-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.ios.members">issues</a> in [depr.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The "overload" for the function <tt>exceptions()</tt> in
++<p>The &quot;overload&quot; for the function <tt>exceptions()</tt> in
+ paragraph 8 gives the impression that there is another function of
+ this function defined in class <tt>ios_base</tt>. However, this is not
+ the case. Thus, it is hard to tell how the semantics (paragraph 9) can
+-be implemented: "Call the corresponding member function specified
+-in clause 27 [input.output]."</p>
++be implemented: &quot;Call the corresponding member function specified
++in clause 27 [input.output].&quot;</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In D.8 [depr.ios.members] paragraph 8, move the declaration of the
++<p>In D.6 [depr.ios.members] paragraph 8, move the declaration of the
+ function <tt>exceptions()</tt>into class <tt>basic_ios</tt>.</p>
+
+
+@@ -7762,10 +6967,11 @@ function <tt>exceptions()</tt>into class <tt>basic_ios</tt>.</p>
+
+ <hr>
+ <h3><a name="179"></a>179. Comparison of const_iterators to iterators doesn't work</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-07-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 1998-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Currently the following will not compile on two well-known standard
+ library implementations:</p>
+@@ -7818,7 +7024,8 @@ return i == ci;
+ The fix is to make the comparison operators templated on two types.
+ </p>
+
+- <pre> template &lt;class Iterator1, class Iterator2&gt;
++ <pre>
++ template &lt;class Iterator1, class Iterator2&gt;
+ bool operator== (reverse_iterator&lt;Iterator1&gt; const&amp; x,
+ reverse_iterator&lt;Iterator2&gt; const&amp; y);
+ </pre>
+@@ -7844,7 +7051,8 @@ return i == ci;
+ <p>Insert this paragraph after 23.2 [container.requirements] paragraph 7:</p>
+ <blockquote>
+ <p>In the expressions</p>
+- <pre> i == j
++ <pre>
++ i == j
+ i != j
+ i &lt; j
+ i &lt;= j
+@@ -7876,7 +7084,7 @@ the nested types <tt>X::iterator</tt> and <tt>X::const_iterator</tt>,
+ where <tt>X</tt> is a container. There is no requirement that
+ <tt>X::reverse_iterator</tt> and <tt>X::const_reverse_iterator</tt>
+ can be mixed. If mixing them is considered important, that's a
+-separate issue. (Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#280">280</a>.)
++separate issue. (Issue <a href="lwg-defects.html#280">280</a>.)
+ </p>
+
+
+@@ -7884,10 +7092,11 @@ separate issue. (Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg
+
+ <hr>
+ <h3><a name="180"></a>180. Container member iterator arguments constness has unintended consequences</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 1999-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 1999-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It is the constness of the container which should control whether
+ it can be modified through a member function such as erase(), not the
+@@ -7956,7 +7165,8 @@ We note that the supplied wording addresses the initializer list provided in
+ Update the following signature in the <tt>basic_string</tt> class template definition in
+ 21.4 [basic.string], p5:
+ </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
+ class Allocator = allocator&lt;charT&gt; &gt;
+ class basic_string {
+@@ -7984,7 +7194,8 @@ Update the following signature in the <tt>basic_string</tt> class template defin
+ Update the following signatures in 21.4.6.4 [string::insert]:
+ </p>
+
+-<blockquote><pre>iterator insert(<ins>const_</ins>iterator p, charT c);
++<blockquote><pre>
++iterator insert(<ins>const_</ins>iterator p, charT c);
+ void insert(<ins>const_</ins>iterator p, size_type n, charT c);
+ template&lt;class InputIterator&gt;
+ void insert(<ins>const_</ins>iterator p, InputIterator first, InputIterator last);
+@@ -7995,7 +7206,8 @@ void insert(<ins>const_</ins>iterator <ins>p</ins>, initializer_list&lt;charT&gt
+ Update the following signatures in 21.4.6.5 [string::erase]:
+ </p>
+
+-<blockquote><pre>iterator erase(<ins>const_</ins>iterator <ins>const_</ins>position);
++<blockquote><pre>
++iterator erase(<ins>const_</ins>iterator <ins>const_</ins>position);
+ iterator erase(<ins>const_</ins>iterator first, <ins>const_</ins>iterator last);
+ </pre></blockquote>
+
+@@ -8012,31 +7224,31 @@ seems more of a design issue that an out-and-out defect.</p>
+
+ <p>The LWG believes that this issue should be considered as part of a
+ general review of const issues for the next revision of the
+-standard. Also see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#200">200</a>.</p>
++standard. Also see issue <a href="lwg-defects.html#200">200</a>.</p>
+
+
+
+
+ <hr>
+ <h3><a name="181"></a>181. make_pair() unintended behavior</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Discussion:</b></p>
+-<p>The claim has surfaced in Usenet that expressions such as<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>make_pair("abc", 3)</tt><br>
+-<br>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The claim has surfaced in Usenet that expressions such as<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>make_pair(&quot;abc&quot;, 3)</tt><br/>
++<br/>
+ are illegal, notwithstanding their use in examples, because template instantiation tries to bind the first template
+-parameter to <tt> const char (&amp;)[4]</tt>, which type is uncopyable.<br>
+-<br>
++parameter to <tt> const char (&amp;)[4]</tt>, which type is uncopyable.<br/>
++<br/>
+ I doubt anyone intended that behavior...
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.3 [utility], paragraph 1 change the following
++<p>In 20.2 [utility], paragraph 1 change the following
+ declaration of make_pair():</p>
+ <blockquote>
+ <pre>template &lt;class T1, class T2&gt; pair&lt;T1,T2&gt; make_pair(const T1&amp;, const T2&amp;);</pre>
+@@ -8045,7 +7257,7 @@ declaration of make_pair():</p>
+ <blockquote>
+ <pre>template &lt;class T1, class T2&gt; pair&lt;T1,T2&gt; make_pair(T1, T2);</pre>
+ </blockquote>
+-<p> In 20.3.5 [pairs] paragraph 7 and the line before, change:</p>
++<p> In 20.3 [pairs] paragraph 7 and the line before, change:</p>
+ <blockquote>
+ <pre>template &lt;class T1, class T2&gt;
+ pair&lt;T1, T2&gt; make_pair(const T1&amp; x, const T2&amp; y);</pre>
+@@ -8065,7 +7277,7 @@ pair&lt;T1, T2&gt; make_pair(T1 x, T2 y);</pre>
+
+ <p><b>Rationale:</b></p>
+ <p>Two potential fixes were suggested by Matt Austern and Dietmar
+-Kühl, respectively, 1) overloading with array arguments, and 2) use of
++K&uuml;hl, respectively, 1) overloading with array arguments, and 2) use of
+ a reference_traits class with a specialization for arrays. Andy
+ Koenig suggested changing to pass by value. In discussion, it appeared
+ that this was a much smaller change to the standard that the other two
+@@ -8078,15 +7290,15 @@ proposed resolution passed their test suites.</p>
+
+ <hr>
+ <h3><a name="182"></a>182. Ambiguous references to size_t</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Al Stevens <b>Opened:</b> 1999-08-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Al Stevens <b>Opened:</b> 1999-08-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Many references to <tt> size_t</tt> throughout the document
+ omit the <tt> std::</tt> namespace qualification.</p> <p>For
+-example, 17.6.3.6 [replacement.functions] paragraph 2:</p>
++example, 17.6.4.6 [replacement.functions] paragraph 2:</p>
+ <blockquote>
+ <pre> operator new(size_t)
+ operator new(size_t, const std::nothrow_t&amp;)
+@@ -8096,11 +7308,11 @@ example, 17.6.3.6 [replacement.functions] paragraph 2:</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p> In 17.6.3.6 [replacement.functions] paragraph 2: replace:</p>
++<p> In 17.6.4.6 [replacement.functions] paragraph 2: replace:</p>
+ <blockquote>
+-<p><tt> - operator new(size_t)<br>
+- - operator new(size_t, const std::nothrow_t&amp;)<br>
+- - operator new[](size_t)<br>
++<p><tt> - operator new(size_t)<br/>
++ - operator new(size_t, const std::nothrow_t&amp;)<br/>
++ - operator new[](size_t)<br/>
+ - operator new[](size_t, const std::nothrow_t&amp;)</tt></p>
+ </blockquote>
+ <p> by:</p>
+@@ -8154,17 +7366,17 @@ example, 17.6.3.6 [replacement.functions] paragraph 2:</p>
+ pos denotes a value of type X::pos_type; and state denotes a value of type X::state_type.</p>
+ </blockquote>
+ <p>In [lib.char.traits.require] 21.1.1, table 37: replace the return type of
+-X::length(p): "size_t" by "std::size_t".</p>
+-<p> In [lib.std.iterator.tags] 24.3.3, paragraph 2: replace:<br>
+-&nbsp;&nbsp;&nbsp; typedef ptrdiff_t difference_type;<br>
+- by:<br>
++X::length(p): &quot;size_t&quot; by &quot;std::size_t&quot;.</p>
++<p> In [lib.std.iterator.tags] 24.3.3, paragraph 2: replace:<br/>
++&nbsp;&nbsp;&nbsp; typedef ptrdiff_t difference_type;<br/>
++ by:<br/>
+ &nbsp;&nbsp;&nbsp; typedef std::ptrdiff_t difference_type;</p>
+-<p> In [lib.locale.ctype] 22.2.1.1 put namespace std { ...} around the declaration of template &lt;class charT&gt; class ctype.<br>
+-<br>
+- In [lib.iterator.traits] 24.3.1, paragraph 2 put namespace std { ...} around the declaration of:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; template&lt;class Iterator&gt; struct iterator_traits<br>
+-&nbsp;&nbsp;&nbsp; template&lt;class T&gt; struct iterator_traits&lt;T*&gt;<br>
++<p> In [lib.locale.ctype] 22.2.1.1 put namespace std { ...} around the declaration of template &lt;class charT&gt; class ctype.<br/>
++<br/>
++ In [lib.iterator.traits] 24.3.1, paragraph 2 put namespace std { ...} around the declaration of:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; template&lt;class Iterator&gt; struct iterator_traits<br/>
++&nbsp;&nbsp;&nbsp; template&lt;class T&gt; struct iterator_traits&lt;T*&gt;<br/>
+ &nbsp;&nbsp;&nbsp; template&lt;class T&gt; struct iterator_traits&lt;const T*&gt;</p>
+
+
+@@ -8172,7 +7384,7 @@ X::length(p): "size_t" by "std::size_t".</p>
+ <p>The LWG believes correcting names like <tt>size_t</tt> and
+ <tt>ptrdiff_t</tt> to <tt>std::size_t</tt> and <tt>std::ptrdiff_t</tt>
+ to be essentially editorial. There there can't be another size_t or
+-ptrdiff_t meant anyway because, according to 17.6.3.3.4 [extern.types],</p>
++ptrdiff_t meant anyway because, according to 17.6.4.3.3 [extern.types],</p>
+
+ <blockquote><p>
+ For each type T from the Standard C library, the types ::T and std::T
+@@ -8187,7 +7399,7 @@ Editor's authority to make this change.</p>
+ request of the LWG.]</i></p>
+
+
+-<p><i>[Toronto: This is tangentially related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>, but only tangentially: the intent of this issue is to
++<p><i>[Toronto: This is tangentially related to issue <a href="lwg-defects.html#229">229</a>, but only tangentially: the intent of this issue is to
+ address use of the name <tt>size_t</tt> in contexts outside of
+ namespace std, such as in the description of <tt>::operator new</tt>.
+ The proposed changes should be reviewed to make sure they are
+@@ -8205,12 +7417,12 @@ them to be correct.]</i></p>
+
+ <hr>
+ <h3><a name="183"></a>183. I/O stream manipulators don't work for wide character streams</h3>
+-<p><b>Section:</b> 27.7.3 [std.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 1999-07-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#std.manip">issues</a> in [std.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.4 [std.manip] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 1999-07-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#std.manip">issues</a> in [std.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>27.7.3 [std.manip] paragraph 3 says (clause numbering added for
++<p>27.7.4 [std.manip] paragraph 3 says (clause numbering added for
+ exposition):</p>
+ <blockquote>
+ <p>Returns: An object s of unspecified type such that if [1] out is an (instance
+@@ -8223,130 +7435,130 @@ out&lt;&lt;s has type ostream&amp; and value out. [4] The expression in&gt;&gt;s
+ has type istream&amp; and value in.</p>
+ </blockquote>
+ <p>Given the definitions [1] and [2] for out and in, surely [3] should read:
+-"The expression out &lt;&lt; s has type basic_ostream&amp; ..." and
+-[4] should read: "The expression in &gt;&gt; s has type basic_istream&amp;
+-..."</p>
++&quot;The expression out &lt;&lt; s has type basic_ostream&amp; ...&quot; and
++[4] should read: &quot;The expression in &gt;&gt; s has type basic_istream&amp;
++...&quot;</p>
+ <p>If the wording in the standard is correct, I can see no way of implementing
+ any of the manipulators so that they will work with wide character streams.</p>
+ <p>e.g. wcout &lt;&lt; setbase( 16 );</p>
+ <p>Must have value 'wcout' (which makes sense) and type 'ostream&amp;' (which
+ doesn't).</p>
+-<p>The same "cut'n'paste" type also seems to occur in Paras 4,5,7 and
++<p>The same &quot;cut'n'paste&quot; type also seems to occur in Paras 4,5,7 and
+ 8. In addition, Para 6 [setfill] has a similar error, but relates only to
+ ostreams.</p>
+ <p>I'd be happier if there was a better way of saying this, to make it clear
+-that the value of the expression is "the same specialization of
+-basic_ostream as out"&amp;</p>
++that the value of the expression is &quot;the same specialization of
++basic_ostream as out&quot;&amp;</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace section 27.7.3 [std.manip] except paragraph 1 with the
++<p>Replace section 27.7.4 [std.manip] except paragraph 1 with the
+ following:</p>
+ <blockquote>
+ <p>2- The type designated smanip in each of the following function descriptions is implementation-specified and may be different for each
+-function.<br>
+-<br>
+-<tt>smanip resetiosflags(ios_base::fmtflags mask);</tt><br>
+-<br>
++function.<br/>
++<br/>
++<tt>smanip resetiosflags(ios_base::fmtflags mask);</tt><br/>
++<br/>
+ -3- Returns: An object s of unspecified type such that if out is an instance of basic_ostream&lt;charT,traits&gt; then the expression out&lt;&lt;s behaves
+ as if f(s, mask) were called, or if in is an instance of basic_istream&lt;charT,traits&gt; then the expression in&gt;&gt;s behaves as if
+-f(s, mask) were called. The function f can be defined as:*<br>
+-<br>
++f(s, mask) were called. The function f can be defined as:*<br/>
++<br/>
+ [Footnote: The expression cin &gt;&gt; resetiosflags(ios_base::skipws) clears ios_base::skipws in the format flags stored in the
+ basic_istream&lt;charT,traits&gt; object cin (the same as cin &gt;&gt; noskipws), and the expression cout &lt;&lt; resetiosflags(ios_base::showbase) clears
+ ios_base::showbase in the format flags stored in the basic_ostream&lt;charT,traits&gt; object cout (the same as cout &lt;&lt;
+-noshowbase). --- end footnote]<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, ios_base::fmtflags mask)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // reset specified flags<br>
+-&nbsp;&nbsp; str.setf(ios_base::fmtflags(0), mask);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
++noshowbase). --- end footnote]<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, ios_base::fmtflags mask)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // reset specified flags<br/>
++&nbsp;&nbsp; str.setf(ios_base::fmtflags(0), mask);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
+ The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.
+-The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br>
+-<br>
+-&nbsp;<tt>smanip setiosflags(ios_base::fmtflags mask);</tt><br>
+-<br>
++The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br/>
++<br/>
++&nbsp;<tt>smanip setiosflags(ios_base::fmtflags mask);</tt><br/>
++<br/>
+ -4- Returns: An object s of unspecified type such that if out is an instance of basic_ostream&lt;charT,traits&gt; then the expression out&lt;&lt;s behaves
+ as if f(s, mask) were called, or if in is an instance of basic_istream&lt;charT,traits&gt; then the expression in&gt;&gt;s behaves as if f(s,
+-mask) were called. The function f can be defined as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, ios_base::fmtflags mask)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // set specified flags<br>
+-&nbsp;&nbsp; str.setf(mask);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
++mask) were called. The function f can be defined as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, ios_base::fmtflags mask)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // set specified flags<br/>
++&nbsp;&nbsp; str.setf(mask);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
+ The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.
+-The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br>
+-<br>
+-<tt>smanip setbase(int base);</tt><br>
+-<br>
++The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br/>
++<br/>
++<tt>smanip setbase(int base);</tt><br/>
++<br/>
+ -5- Returns: An object s of unspecified type such that if out is an instance of basic_ostream&lt;charT,traits&gt; then the expression out&lt;&lt;s behaves
+ as if f(s, base) were called, or if in is an instance of basic_istream&lt;charT,traits&gt; then the expression in&gt;&gt;s behaves as if f(s,
+-base) were called. The function f can be defined as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int base)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // set basefield<br>
+-&nbsp;&nbsp; str.setf(base == 8 ? ios_base::oct :<br>
+-&nbsp;&nbsp; base == 10 ? ios_base::dec :<br>
+-&nbsp;&nbsp; base == 16 ? ios_base::hex :<br>
+-&nbsp;&nbsp; ios_base::fmtflags(0), ios_base::basefield);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
++base) were called. The function f can be defined as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int base)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // set basefield<br/>
++&nbsp;&nbsp; str.setf(base == 8 ? ios_base::oct :<br/>
++&nbsp;&nbsp; base == 10 ? ios_base::dec :<br/>
++&nbsp;&nbsp; base == 16 ? ios_base::hex :<br/>
++&nbsp;&nbsp; ios_base::fmtflags(0), ios_base::basefield);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
+ The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.
+-The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br>
+-<br>
+-<tt>smanip setfill(char_type c);<br>
+-</tt><br>
++The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in.<br/>
++<br/>
++<tt>smanip setfill(char_type c);<br/>
++</tt><br/>
+ -6- Returns: An object s of unspecified type such that if out is (or is derived from) basic_ostream&lt;charT,traits&gt; and c has type charT then the
+ expression out&lt;&lt;s behaves as if f(s, c) were called. The function f can be
+-defined as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>template&lt;class charT, class traits&gt;<br>
+-&nbsp;&nbsp; basic_ios&lt;charT,traits&gt;&amp; f(basic_ios&lt;charT,traits&gt;&amp; str, charT c)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // set fill character<br>
+-&nbsp;&nbsp; str.fill(c);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
+-The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.<br>
+-<br>
+-<tt>smanip setprecision(int n);</tt><br>
+-<br>
++defined as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>template&lt;class charT, class traits&gt;<br/>
++&nbsp;&nbsp; basic_ios&lt;charT,traits&gt;&amp; f(basic_ios&lt;charT,traits&gt;&amp; str, charT c)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // set fill character<br/>
++&nbsp;&nbsp; str.fill(c);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
++The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.<br/>
++<br/>
++<tt>smanip setprecision(int n);</tt><br/>
++<br/>
+ -7- Returns: An object s of unspecified type such that if out is an instance of basic_ostream&lt;charT,traits&gt; then the expression out&lt;&lt;s behaves
+ as if f(s, n) were called, or if in is an instance of basic_istream&lt;charT,traits&gt; then the expression in&gt;&gt;s behaves as if f(s, n)
+-were called. The function f can be defined as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int n)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // set precision<br>
+-&nbsp;&nbsp; str.precision(n);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
++were called. The function f can be defined as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int n)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // set precision<br/>
++&nbsp;&nbsp; str.precision(n);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
+ The expression out&lt;&lt;s has type basic_ostream&lt;charT,traits&gt;&amp; and value out.
+-The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in<br>
+-.<br>
+-<tt>smanip setw(int n);<br>
+-</tt><br>
++The expression in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value in<br/>
++.<br/>
++<tt>smanip setw(int n);<br/>
++</tt><br/>
+ -8- Returns: An object s of unspecified type such that if out is an instance of basic_ostream&lt;charT,traits&gt; then the expression out&lt;&lt;s behaves
+ as if f(s, n) were called, or if in is an instance of basic_istream&lt;charT,traits&gt; then the expression in&gt;&gt;s behaves as if f(s, n)
+-were called. The function f can be defined as:<br>
+-<br>
+-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int n)<br>
+-&nbsp;&nbsp; {<br>
+-&nbsp;&nbsp; // set width<br>
+-&nbsp;&nbsp; str.width(n);<br>
+-&nbsp;&nbsp; return str;<br>
+-&nbsp;&nbsp; }<br>
+-</tt><br>
++were called. The function f can be defined as:<br/>
++<br/>
++&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <tt>ios_base&amp; f(ios_base&amp; str, int n)<br/>
++&nbsp;&nbsp; {<br/>
++&nbsp;&nbsp; // set width<br/>
++&nbsp;&nbsp; str.width(n);<br/>
++&nbsp;&nbsp; return str;<br/>
++&nbsp;&nbsp; }<br/>
++</tt><br/>
+ The expression out&lt;&lt;s has type
+ basic_ostream&lt;charT,traits&gt;&amp; and value out. The expression
+ in&gt;&gt;s has type basic_istream&lt;charT,traits&gt;&amp; and value
+@@ -8358,12 +7570,12 @@ in.
+ the proposed resolution.]</i></p>
+
+
+-<p><i>[Tokyo - The LWG noted that issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#216">216</a> involves
++<p><i>[Tokyo - The LWG noted that issue <a href="lwg-closed.html#216">216</a> involves
+ the same paragraphs.]</i></p>
+
+
+ <p><i>[Post-Tokyo: The issues list maintainer combined the proposed
+-resolution of this issue with the proposed resolution for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#216">216</a> as they both involved the same paragraphs, and were so
++resolution of this issue with the proposed resolution for issue <a href="lwg-closed.html#216">216</a> as they both involved the same paragraphs, and were so
+ intertwined that dealing with them separately appear fraught with
+ error. The full text was supplied by Bill Plauger; it was cross
+ checked against changes supplied by Andy Sawyer. It should be further
+@@ -8376,13 +7588,13 @@ checked by the LWG.]</i></p>
+
+ <hr>
+ <h3><a name="184"></a>184. numeric_limits&lt;bool&gt; wording problems</h3>
+-<p><b>Section:</b> 18.3.1.5 [numeric.special] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 1999-07-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2.7 [numeric.special] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 1999-07-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>bools are defined by the standard to be of integer types, as per
+-3.9.1 [basic.fundamental] paragraph 7. However "integer types"
++3.9.1 [basic.fundamental] paragraph 7. However &quot;integer types&quot;
+ seems to have a special meaning for the author of 18.2. The net effect
+ is an unclear and confusing specification for
+ numeric_limits&lt;bool&gt; as evidenced below.</p>
+@@ -8410,11 +7622,11 @@ to be meaningful.</p>
+ </blockquote>
+
+ <p>This disposition is at best misleading and confusing for the standard
+-requires a "pure binary numeration system" for integer types as per
++requires a &quot;pure binary numeration system&quot; for integer types as per
+ 3.9.1/7</p>
+
+-<p>The footnote 186) says: "Distinguishes types with base other than 2 (e.g
+-BCD)."&nbsp; This also erroneous as the standard never defines any integer
++<p>The footnote 186) says: &quot;Distinguishes types with base other than 2 (e.g
++BCD).&quot;&nbsp; This also erroneous as the standard never defines any integer
+ types with base representation other than 2.</p>
+
+ <p>Furthermore, numeric_limits&lt;bool&gt;::is_modulo and
+@@ -8422,7 +7634,7 @@ numeric_limits&lt;bool&gt;::is_signed have similar problems.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Append to the end of 18.3.1.5 [numeric.special]:</p>
++<p>Append to the end of 18.3.2.7 [numeric.special]:</p>
+ <blockquote>
+ <p>The specialization for bool shall be provided as follows:</p>
+ <pre> namespace std {
+@@ -8481,21 +7693,21 @@ Josuttis provided the above wording.]</i></p>
+
+
+ <hr>
+-<h3><a name="185"></a>185. Questionable use of term "inline"</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> UK Panel <b>Opened:</b> 1999-07-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="185"></a>185. Questionable use of term &quot;inline&quot;</h3>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> UK Panel <b>Opened:</b> 1999-07-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Paragraph 4 of 20.8 [function.objects] says:</p>
++<p>Paragraph 4 of 20.9 [function.objects] says:</p>
+ <blockquote>
+ <p>&nbsp;[Example: To negate every element of a: transform(a.begin(), a.end(),
+ a.begin(), negate&lt;double&gt;()); The corresponding functions will inline
+ the addition and the negation. end example]</p>
+ </blockquote>
+-<p>(Note: The "addition" referred to in the above is in para 3) we can
++<p>(Note: The &quot;addition&quot; referred to in the above is in para 3) we can
+ find no other wording, except this (non-normative) example which suggests that
+-any "inlining" will take place in this case.</p>
++any &quot;inlining&quot; will take place in this case.</p>
+ <p>Indeed both:</p>
+ <blockquote>
+ <p>17.4.4.3 Global Functions [lib.global.functions] 1 It is
+@@ -8509,22 +7721,22 @@ any "inlining" will take place in this case.</p>
+ are defined as inline (7.1.2).</p>
+ </blockquote>
+ <p>take care to state that this may indeed NOT be the case.</p>
+-<p>Thus the example "mandates" behavior that is explicitly
++<p>Thus the example &quot;mandates&quot; behavior that is explicitly
+ not required elsewhere.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.8 [function.objects] paragraph 1, remove the sentence:</p>
++<p>In 20.9 [function.objects] paragraph 1, remove the sentence:</p>
+ <blockquote>
+ <p>They are important for the effective use of the library.</p>
+ </blockquote>
+-<p>Remove 20.8 [function.objects] paragraph 2, which reads:</p>
++<p>Remove 20.9 [function.objects] paragraph 2, which reads:</p>
+ <blockquote>
+ <p> Using function objects together with function templates
+ increases the expressive power of the library as well as making the
+ resulting code much more efficient.</p>
+ </blockquote>
+-<p>In 20.8 [function.objects] paragraph 4, remove the sentence:</p>
++<p>In 20.9 [function.objects] paragraph 4, remove the sentence:</p>
+ <blockquote>
+ <p>The corresponding functions will inline the addition and the
+ negation.</p>
+@@ -8541,12 +7753,12 @@ not required elsewhere.</p>
+
+ <hr>
+ <h3><a name="186"></a>186. bitset::set() second parameter should be bool</h3>
+-<p><b>Section:</b> 20.5.2 [bitset.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Darin Adler <b>Opened:</b> 1999-08-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6.2 [bitset.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Darin Adler <b>Opened:</b> 1999-08-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In section 20.5.2 [bitset.members], paragraph 13 defines the
++<p>In section 20.6.2 [bitset.members], paragraph 13 defines the
+ bitset::set operation to take a second parameter of type int. The
+ function tests whether this value is non-zero to determine whether to
+ set the bit to true or false. The type of this second parameter should
+@@ -8558,7 +7770,7 @@ translating 0 to false and any non-zero value to true.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.5 [template.bitset] Para 1 Replace:</p>
++<p>In 20.6 [template.bitset] Para 1 Replace:</p>
+ <blockquote>
+ <pre>bitset&lt;N&gt;&amp; set(size_t pos, int val = true ); </pre>
+ </blockquote>
+@@ -8566,7 +7778,7 @@ translating 0 to false and any non-zero value to true.</p>
+ <blockquote>
+ <pre>bitset&lt;N&gt;&amp; set(size_t pos, bool val = true );</pre>
+ </blockquote>
+-<p>In 20.5.2 [bitset.members] Para 12(.5) Replace:</p>
++<p>In 20.6.2 [bitset.members] Para 12(.5) Replace:</p>
+ <blockquote>
+ <pre>bitset&lt;N&gt;&amp; set(size_t pos, int val = 1 );</pre>
+ </blockquote>
+@@ -8595,17 +7807,17 @@ nonvirtual member of a standard library class.</p>
+
+ <hr>
+ <h3><a name="187"></a>187. iter_swap underspecified</h3>
+-<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description of iter_swap in 25.2.2 paragraph 7,says that it
+ ``exchanges the values'' of the objects to which two iterators
+-refer.<br> <br> What it doesn't say is whether it does so using swap
+-or using the assignment operator and copy constructor.<br> <br> This
++refer.<br/> <br/> What it doesn't say is whether it does so using swap
++or using the assignment operator and copy constructor.<br/> <br/> This
+ question is an important one to answer, because swap is specialized to
+-work efficiently for standard containers.<br> For example:</p>
++work efficiently for standard containers.<br/> For example:</p>
+ <blockquote>
+ <pre>vector&lt;int&gt; v1, v2;
+ iter_swap(&amp;v1, &amp;v2);</pre>
+@@ -8666,48 +7878,49 @@ one list to another. That would surely be inappropriate.</p>
+
+ <hr>
+ <h3><a name="189"></a>189. setprecision() not specified correctly</h3>
+-<p><b>Section:</b> 27.5.2.2 [fmtflags.state] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fmtflags.state">issues</a> in [fmtflags.state].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.2 [fmtflags.state] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 1999-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fmtflags.state">issues</a> in [fmtflags.state].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.4.2.2 paragraph 9 claims that setprecision() sets the precision,
+ and includes a parenthetical note saying that it is the number of
+-digits after the decimal point.<br>
+-<br>
++digits after the decimal point.<br/>
++<br/>
+ This claim is not strictly correct. For example, in the default
+ floating-point output format, setprecision sets the number of
+ significant digits printed, not the number of digits after the decimal
+-point.<br>
+-<br>
++point.<br/>
++<br/>
+ I would like the committee to look at the definition carefully and
+ correct the statement in 27.4.2.2</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Remove from 27.5.2.2 [fmtflags.state], paragraph 9, the text
+-"(number of digits after the decimal point)".</p>
++<p>Remove from 27.5.3.2 [fmtflags.state], paragraph 9, the text
++&quot;(number of digits after the decimal point)&quot;.</p>
+
+
+
+
+ <hr>
+ <h3><a name="193"></a>193. Heap operations description incorrect</h3>
+-<p><b>Section:</b> 25.4.6 [alg.heap.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 1999-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#216">216</a></p>
++<p><b>Section:</b> 25.4.6 [alg.heap.operations] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 1999-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.heap.operations">issues</a> in [alg.heap.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#216">216</a></p>
+ <p><b>Discussion:</b></p>
+ <p>25.3.6 [lib.alg.heap.operations] states two key properties of a heap [a,b), the first of them
+-is<br>
+-<br>
+-&nbsp;&nbsp;&nbsp; `"(1) *a is the largest element"<br>
+-<br>
++is<br/>
++<br/>
++&nbsp;&nbsp;&nbsp; `"(1) *a is the largest element"<br/>
++<br/>
+ I think this is incorrect and should be changed to the wording in the proposed
+ resolution.</p>
+ <p>Actually there are two independent changes:</p>
+ <blockquote>
+- <p>A-"part of largest equivalence class" instead of "largest", cause 25.3
++ <p>A-&quot;part of largest equivalence class" instead of "largest", cause 25.3
+ [lib.alg.sorting] asserts "strict weak ordering" for all its sub clauses.</p>
+ <p>B-Take 'an oldest' from that equivalence class, otherwise the heap functions could not be used for a
+ priority queue as explained in 23.2.3.2.2 [lib.priqueue.members] (where I assume that a "priority queue" respects priority AND time).</p>
+@@ -8730,10 +7943,10 @@ resolution.</p>
+
+ <hr>
+ <h3><a name="195"></a>195. Should <tt>basic_istream::sentry</tt>'s constructor ever set eofbit?</h3>
+-<p><b>Section:</b> 27.7.1.1.3 [istream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-10-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.7.2.1.3 [istream::sentry] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Suppose that <tt>is.flags() &amp; ios_base::skipws</tt> is nonzero.
+ What should <tt>basic_istream&lt;&gt;::sentry</tt>'s constructor do if it
+@@ -8741,13 +7954,13 @@ reaches eof while skipping whitespace? 27.6.1.1.2/5 suggests it
+ should set failbit. Should it set eofbit as well? The standard
+ doesn't seem to answer that question.</p>
+
+-<p>On the one hand, nothing in 27.7.1.1.3 [istream::sentry] says that
++<p>On the one hand, nothing in 27.7.2.1.3 [istream::sentry] says that
+ <tt>basic_istream&lt;&gt;::sentry</tt> should ever set eofbit. On the
+-other hand, 27.7.1.1 [istream] paragraph 4 says that if
+-extraction from a <tt>streambuf</tt> "returns
++other hand, 27.7.2.1 [istream] paragraph 4 says that if
++extraction from a <tt>streambuf</tt> &quot;returns
+ <tt>traits::eof()</tt>, then the input function, except as explicitly
+ noted otherwise, completes its actions and does
+-<tt>setstate(eofbit)"</tt>. So the question comes down to
++<tt>setstate(eofbit)&quot;</tt>. So the question comes down to
+ whether <tt>basic_istream&lt;&gt;::sentry</tt>'s constructor is an
+ input function.</p>
+
+@@ -8763,12 +7976,12 @@ signaled eof.</p>
+ <p>
+ The classic case is a streambuf reading from a UNIX file. EOF isn't
+ really a state for UNIX file descriptors. The convention is that a
+-read on UNIX returns 0 bytes to indicate "EOF", but the file
++read on UNIX returns 0 bytes to indicate &quot;EOF&quot;, but the file
+ descriptor isn't shut down in any way and future reads do not
+ necessarily also return 0 bytes. In particular, you can read from
+-tty's on UNIX even after they have signaled "EOF". (It
++tty's on UNIX even after they have signaled &quot;EOF&quot;. (It
+ isn't always understood that a ^D on UNIX is not an EOF indicator, but
+-an EOL indicator. By typing a "line" consisting solely of
++an EOL indicator. By typing a &quot;line&quot; consisting solely of
+ ^D you cause a read to return 0 bytes, and by convention this is
+ interpreted as end of file.)</p>
+ </blockquote>
+@@ -8789,10 +8002,10 @@ returns <tt>traits::eof()</tt>, the function calls
+
+ <hr>
+ <h3><a name="198"></a>198. Validity of pointers and references unspecified after iterator destruction</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1999-11-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 1999-11-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Is a pointer or reference obtained from an iterator still valid after
+@@ -8803,7 +8016,8 @@ Is a pointer or reference obtained from an iterator still valid after the value
+ of the iterator changes?
+ </p>
+ <blockquote>
+-<pre>#include &lt;iostream&gt;
++<pre>
++#include &lt;iostream&gt;
+ #include &lt;vector&gt;
+ #include &lt;iterator&gt;
+
+@@ -8870,9 +8084,10 @@ previously obtained from that iterator.
+
+ <blockquote>
+ <p><b>Effects:</b></p>
+-<pre> this-&gt;tmp = current;
+- --this-&gt;tmp;
+- return *this-&gt;tmp;
++<pre>
++ this->tmp = current;
++ --this->tmp;
++ return *this->tmp;
+ </pre>
+
+ <p>
+@@ -8897,7 +8112,7 @@ reformulated yet again to reflect this reality.]</i></p>
+ assumes its underlying iterator has persistent pointers and
+ references. Andy Koenig pointed out that it is possible to rewrite
+ reverse_iterator so that it no longer makes such an assupmption.
+-However, this issue is related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>. If we
++However, this issue is related to issue <a href="lwg-closed.html#299">299</a>. If we
+ decide it is intentional that <tt>p[n]</tt> may return by value
+ instead of reference when <tt>p</tt> is a Random Access Iterator,
+ other changes in reverse_iterator will be necessary.]</i></p>
+@@ -8929,10 +8144,11 @@ predefined iterators are as strong as users expect.</p>
+
+ <hr>
+ <h3><a name="199"></a>199. What does <tt>allocate(0)</tt> return?</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-11-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-11-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Suppose that <tt>A</tt> is a class that conforms to the
+@@ -8948,7 +8164,7 @@ unique non-null pointer.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Add a note to the <tt>allocate</tt> row of Table 32:
+-"[<i>Note:</i> If <tt>n == 0</tt>, the return value is unspecified. <i>--end note</i>]"</p>
++&quot;[<i>Note:</i> If <tt>n == 0</tt>, the return value is unspecified. <i>--end note</i>]&quot;</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -8964,10 +8180,10 @@ would be over-specification to mandate the return value.
+
+ <hr>
+ <h3><a name="200"></a>200. Forward iterator requirements don't allow constant iterators</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-11-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 1999-11-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In table 74, the return type of the expression <tt>*a</tt> is given
+@@ -8992,7 +8208,7 @@ otherwise <tt>const U&amp;</tt>".
+ <p><i>[Tokyo: The LWG believes this is the tip of a larger iceberg;
+ there are multiple const problems with the STL portion of the library
+ and that these should be addressed as a single package.&nbsp; Note
+-that issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#180">180</a> has already been declared NAD Future for
++that issue <a href="lwg-defects.html#180">180</a> has already been declared NAD Future for
+ that very reason.]</i></p>
+
+
+@@ -9010,10 +8226,10 @@ that we also need to worry about *r++ and a-&gt;m.]</i></p>
+
+ <hr>
+ <h3><a name="201"></a>201. Numeric limits terminology wrong</h3>
+-<p><b>Section:</b> 18.3.1 [limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stephen Cleary <b>Opened:</b> 1999-12-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#limits">issues</a> in [limits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2 [limits] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stephen Cleary <b>Opened:</b> 1999-12-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#limits">issues</a> in [limits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In some places in this section, the terms "fundamental types" and
+@@ -9045,7 +8261,7 @@ characteristics of implementation-dependent <del>fundamental</del>
+ </blockquote>
+
+ <p>
+-Change 18.3.1 [limits] to:
++Change 18.3.2 [limits] to:
+ </p>
+
+ <blockquote>
+@@ -9068,7 +8284,7 @@ as <tt>complex&lt;T&gt;</tt> (26.3.2), shall not have specializations.
+ </blockquote>
+
+ <p>
+-Change 18.3.1.1 [numeric.limits] to:
++Change 18.3.2.3 [numeric.limits] to:
+ </p>
+
+ <blockquote>
+@@ -9086,10 +8302,10 @@ which do not.</del>
+
+ <hr>
+ <h3><a name="202"></a>202. unique() effects unclear when predicate not an equivalence relation</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-01-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-01-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ What should unique() do if you give it a predicate that is not an
+@@ -9151,8 +8367,8 @@ sequence into subsequences whose elements are in strictly increasing
+ order, and keep only the first element of each subsequence". So the
+ result would be 1, 1, 2. If we take the description at its word, it
+ would seem to call for strictly DEcreasing order, in which case the
+-result should be 1, 3, 7, 2.<br>
+-<br>
++result should be 1, 3, 7, 2.<br/>
++<br/>
+ In fact, the SGI implementation of unique() does neither: It yields 1,
+ 3, 7.
+ </p>
+@@ -9184,8 +8400,8 @@ iterator in the range. Matt provided wording to address this
+ problem.]</i></p>
+
+
+-<p><i>[Curaçao: The LWG changed "... the range (first,
+-last)..." to "... the range [first+1, last)..." for
++<p><i>[Cura&ccedil;ao: The LWG changed &quot;... the range (first,
++last)...&quot; to &quot;... the range [first+1, last)...&quot; for
+ clarity. They considered this change close enough to editorial to not
+ require another round of review.]</i></p>
+
+@@ -9223,10 +8439,10 @@ existing implementations.</p>
+
+ <hr>
+ <h3><a name="206"></a>206. operator new(size_t, nothrow) may become unlinked to ordinary operator new if ordinary version replaced</h3>
+-<p><b>Section:</b> 18.6.1.1 [new.delete.single] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-08-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.6.1.1 [new.delete.single] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 1999-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>As specified, the implementation of the nothrow version of operator
+ new does not necessarily call the ordinary operator new, but may
+@@ -9272,7 +8488,8 @@ Change 18.5.1.1 [new.delete.single]:
+ </p>
+
+ <blockquote>
+-<pre>void* operator new(std::size_t <i>size</i>, const std::nothrow_t&amp;) throw();
++<pre>
++void* operator new(std::size_t <i>size</i>, const std::nothrow_t&amp;) throw();
+ </pre>
+ <blockquote>
+ <p>
+@@ -9334,7 +8551,8 @@ exception</tt>, the function returns a null pointer.
+ <p>
+ -9- [<i>Example:</i>
+ </p>
+-<blockquote><pre>T* p1 = new T; <i>// throws bad_alloc if it fails</i>
++<blockquote><pre>
++T* p1 = new T; <i>// throws bad_alloc if it fails</i>
+ T* p2 = new(nothrow) T; <i>// returns 0 if it fails</i>
+ </pre></blockquote>
+ <p>
+@@ -9342,7 +8560,8 @@ T* p2 = new(nothrow) T; <i>// returns 0 if it fails</i>
+ </p>
+ </blockquote>
+
+-<pre>void operator delete(void* <i>ptr</i>) throw();
++<pre>
++void operator delete(void* <i>ptr</i>) throw();
+ <del>void operator delete(void* <i>ptr</i>, const std::nothrow_t&amp;) throw();</del>
+ </pre>
+
+@@ -9385,7 +8604,8 @@ declared in <tt>&lt;cstdlib&gt;</tt>.
+ </p>
+ </blockquote>
+
+-<pre><ins>void operator delete(void* <i>ptr</i>, const std::nothrow_t&amp;) throw();</ins>
++<pre>
++<ins>void operator delete(void* <i>ptr</i>, const std::nothrow_t&amp;) throw();</ins>
+ </pre>
+
+ <blockquote>
+@@ -9416,7 +8636,8 @@ Change 18.5.1.2 [new.delete.array]
+ </p>
+
+ <blockquote>
+-<pre>void* operator new[](std::size_t <i>size</i>, const std::nothrow_t&amp;) throw();
++<pre>
++void* operator new[](std::size_t <i>size</i>, const std::nothrow_t&amp;) throw();
+ </pre>
+
+ <blockquote>
+@@ -9463,7 +8684,8 @@ a null pointer.
+ </ul>
+ </blockquote>
+
+-<pre>void operator delete[](void* <i>ptr</i>) throw();
++<pre>
++void operator delete[](void* <i>ptr</i>) throw();
+ void operator delete[](void* <i>ptr</i>, const std::nothrow_t&amp;) throw();
+ </pre>
+
+@@ -9520,19 +8742,19 @@ his customers.
+
+ <hr>
+ <h3><a name="208"></a>208. Unnecessary restriction on past-the-end iterators</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Stephen Cleary <b>Opened:</b> 2000-02-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Stephen Cleary <b>Opened:</b> 2000-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>In 24.1 paragraph 5, it is stated ". . . Dereferenceable and
+-past-the-end values are always non-singular."</p>
++<p>In 24.1 paragraph 5, it is stated &quot;. . . Dereferenceable and
++past-the-end values are always non-singular.&quot;</p>
+ <p>This places an unnecessary restriction on past-the-end iterators for
+ containers with forward iterators (for example, a singly-linked list). If the
+ past-the-end value on such a container was a well-known singular value, it would
+ still satisfy all forward iterator requirements.</p>
+ <p>Removing this restriction would allow, for example, a singly-linked list
+-without a "footer" node.</p>
++without a &quot;footer&quot; node.</p>
+ <p>This would have an impact on existing code that expects past-the-end
+ iterators obtained from different (generic) containers being not equal.</p>
+
+@@ -9559,10 +8781,11 @@ iterators. Null pointers are singular.
+
+ <hr>
+ <h3><a name="209"></a>209. basic_string declarations inconsistent</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Igor Stauder <b>Opened:</b> 2000-02-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Igor Stauder <b>Opened:</b> 2000-02-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In Section 21.4 [basic.string] the basic_string member function
+ declarations use a consistent style except for the following functions:</p>
+@@ -9571,9 +8794,9 @@ declarations use a consistent style except for the following functions:</p>
+ basic_string&amp; assign(const basic_string&amp;);
+ void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;);</pre>
+ </blockquote>
+-<p>- push_back, assign, swap: missing argument name&nbsp;<br>
++<p>- push_back, assign, swap: missing argument name&nbsp;<br/>
+ - push_back: use of const with charT (i.e. POD type passed by value
+-not by reference - should be charT or const charT&amp; )<br>
++not by reference - should be charT or const charT&amp; )<br/>
+ - swap: redundant use of template parameters in argument
+ basic_string&lt;charT,traits,Allocator&gt;&amp;</p>
+
+@@ -9601,25 +8824,26 @@ change.
+
+ <hr>
+ <h3><a name="210"></a>210. distance first and last confused</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Lisa Lippincott <b>Opened:</b> 2000-02-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Lisa Lippincott <b>Opened:</b> 2000-02-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In paragraph 9 of section 25 [algorithms], it is written:</p>
+ <blockquote>
+ <p> In the description of the algorithms operators + and - are used
+ for some of the iterator categories for which they do not have to
+ be defined. In these cases the semantics of [...] a-b is the same
+- as of<br>
+- <br>
++ as of<br/>
++ <br/>
+ &nbsp;&nbsp;&nbsp;&nbsp; <tt>return distance(a, b);</tt></p>
+ </blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>On the last line of paragraph 9 of section 25 [algorithms] change
+-<tt>"a-b"</tt> to <tt>"b-a".</tt></p>
++<tt>&quot;a-b&quot;</tt> to <tt>&quot;b-a&quot;.</tt></p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -9632,10 +8856,10 @@ former for consistency.</p>
+
+ <hr>
+ <h3><a name="211"></a>211. operator&gt;&gt;(istream&amp;, string&amp;) doesn't set failbit</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Scott Snyder <b>Opened:</b> 2000-02-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Scott Snyder <b>Opened:</b> 2000-02-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The description of the stream extraction operator for std::string (section
+ 21.3.7.9 [lib.string.io]) does not contain a requirement that failbit be set in
+@@ -9650,7 +8874,7 @@ while (is &gt;&gt; str) ... ;</pre>
+ </blockquote>
+ <p>(which tests failbit) is not required to terminate at EOF.</p>
+ <p>Furthermore, this is inconsistent with other extraction operators,
+-which do include this requirement. (See sections 27.7.1.2 [istream.formatted] and 27.7.1.3 [istream.unformatted]), where this
++which do include this requirement. (See sections 27.7.2.2 [istream.formatted] and 27.7.2.3 [istream.unformatted]), where this
+ requirement is present, either explicitly or implicitly, for the
+ extraction operators. It is also present explicitly in the description
+ of getline (istream&amp;, string&amp;, charT) in section 21.4.8.9 [string.io] paragraph 8.)</p>
+@@ -9670,10 +8894,10 @@ is.setstate(ios::failbit) which may throw ios_base::failure
+
+ <hr>
+ <h3><a name="212"></a>212. Empty range behavior unclear for several algorithms</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 2000-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Nico Josuttis <b>Opened:</b> 2000-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The standard doesn't specify what min_element() and max_element() shall
+ return if the range is empty (first equals last). The usual implementations
+@@ -9697,15 +8921,15 @@ last.</p>
+
+ <hr>
+ <h3><a name="214"></a>214. set::find() missing const overload</h3>
+-<p><b>Section:</b> 23.6.3 [set], 23.6.4 [multiset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-02-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#set">issues</a> in [set].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#450">450</a></p>
++<p><b>Section:</b> 23.4.6 [set], 23.4.7 [multiset] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-02-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#set">issues</a> in [set].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#450">450</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The specification for the associative container requirements in
+-Table 69 state that the find member function should "return
+-iterator; const_iterator for constant a". The map and multimap
++Table 69 state that the find member function should &quot;return
++iterator; const_iterator for constant a&quot;. The map and multimap
+ container descriptions have two overloaded versions of find, but set
+ and multiset do not, all they have is:</p>
+ <blockquote>
+@@ -9715,7 +8939,7 @@ and multiset do not, all they have is:</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change the prototypes for find(), lower_bound(), upper_bound(), and
+-equal_range() in section 23.6.3 [set] and section 23.6.4 [multiset] to each have two overloads:</p>
++equal_range() in section 23.4.6 [set] and section 23.4.7 [multiset] to each have two overloads:</p>
+ <blockquote>
+ <pre>iterator find(const key_type &amp; x);
+ const_iterator find(const key_type &amp; x) const;</pre>
+@@ -9738,10 +8962,10 @@ equal_range.]</i></p>
+
+ <hr>
+ <h3><a name="217"></a>217. Facets example (Classifying Japanese characters) contains errors</h3>
+-<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 22.4.8 [facets.examples] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-02-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facets.examples">issues</a> in [facets.examples].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The example in 22.2.8, paragraph 11 contains the following errors:</p>
+ <p>1) The member function `My::JCtype::is_kanji()' is non-const; the function
+@@ -9755,7 +8979,7 @@ rather than `My::JCType'.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace the "Classifying Japanese characters" example in 22.2.8,
++<p>Replace the &quot;Classifying Japanese characters&quot; example in 22.2.8,
+ paragraph 11 with the following:</p>
+ <pre>#include &lt;locale&gt;</pre>
+ <pre>namespace My {
+@@ -9772,18 +8996,18 @@ paragraph 11 with the following:</p>
+ <pre>// file: filt.C
+ #include &lt;iostream&gt;
+ #include &lt;locale&gt;
+-#include "jctype" // above
++#include &quot;jctype&quot; // above
+ std::locale::id My::JCtype::id; // the static JCtype member
+ declared above.</pre>
+ <pre>int main()
+ {
+ using namespace std;
+ typedef ctype&lt;wchar_t&gt; wctype;
+- locale loc(locale(""), // the user's preferred locale...
++ locale loc(locale(&quot;&quot;), // the user's preferred locale...
+ new My::JCtype); // and a new feature ...
+ wchar_t c = use_facet&lt;wctype&gt;(loc).widen('!');
+ if (!use_facet&lt;My::JCtype&gt;(loc).is_kanji(c))
+- cout &lt;&lt; "no it isn't!" &lt;&lt; endl;
++ cout &lt;&lt; &quot;no it isn't!&quot; &lt;&lt; endl;
+ return 0;
+ }</pre>
+
+@@ -9792,9 +9016,9 @@ declared above.</pre>
+
+ <hr>
+ <h3><a name="220"></a>220. ~ios_base() usage valid?</h3>
+-<p><b>Section:</b> 27.5.2.7 [ios.base.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Jonathan Schilling, Howard Hinnant <b>Opened:</b> 2000-03-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 27.5.3.7 [ios.base.cons] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Jonathan Schilling, Howard Hinnant <b>Opened:</b> 2000-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The pre-conditions for the ios_base destructor are described in 27.4.2.7
+ paragraph 2:</p>
+@@ -9843,10 +9067,11 @@ behavior.</p>
+
+ <hr>
+ <h3><a name="221"></a>221. num_get&lt;&gt;::do_get stage 2 processing broken</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-03-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-03-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Stage 2 processing of numeric conversion is broken.</p>
+
+@@ -9855,13 +9080,13 @@ conversion specifier is %i. A %i specifier determines a number's base
+ by its prefix (0 for octal, 0x for hex), so the intention is clearly
+ that a 0x prefix is allowed. Paragraph 8 in the same section,
+ however, describes very precisely how characters are processed. (It
+-must be done "as if" by a specified code fragment.) That
++must be done &quot;as if&quot; by a specified code fragment.) That
+ description does not allow a 0x prefix to be recognized.</p>
+
+ <p>Very roughly, stage 2 processing reads a char_type ct. It converts
+ ct to a char, not by using narrow but by looking it up in a
+ translation table that was created by widening the string literal
+-"0123456789abcdefABCDEF+-". The character "x" is
++&quot;0123456789abcdefABCDEF+-&quot;. The character &quot;x&quot; is
+ not found in that table, so it can't be recognized by stage 2
+ processing.</p>
+
+@@ -9869,11 +9094,11 @@ processing.</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.2.2.1.2 paragraph 8, replace the line:</p>
+ <blockquote>
+- <pre>static const char src[] = "0123456789abcdefABCDEF+-";</pre>
++ <pre>static const char src[] = &quot;0123456789abcdefABCDEF+-&quot;;</pre>
+ </blockquote>
+ <p>with the line:</p>
+ <blockquote>
+- <pre>static const char src[] = "0123456789abcdefxABCDEFX+-";</pre>
++ <pre>static const char src[] = &quot;0123456789abcdefxABCDEFX+-&quot;;</pre>
+ </blockquote>
+
+
+@@ -9890,10 +9115,10 @@ deliberately, with full knowledge of that limitation.</p>
+
+ <hr>
+ <h3><a name="222"></a>222. Are throw clauses necessary if a throw is already implied by the effects clause?</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-03-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-03-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Section 21.3.6.8 describes the basic_string::compare function this way:</p>
+ <blockquote>
+@@ -9913,22 +9138,22 @@ defined to throw an out-of-range exception if pos &gt; str.size(). See
+ section 21.4.1 [string.require] paragraph 4.</p>
+
+ <p>On the other hand, the compare function descriptions themselves don't have
+-"Throws: " clauses and according to 17.3.1.3, paragraph 3, elements
++&quot;Throws: &quot; clauses and according to 17.3.1.3, paragraph 3, elements
+ that do not apply to a function are omitted.</p>
+ <p>So it seems there is an inconsistency in the standard -- are the
+-"Effects" clauses correct, or are the "Throws" clauses
++&quot;Effects&quot; clauses correct, or are the &quot;Throws&quot; clauses
+ missing?</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 17.5.1.4 [structure.specifications] paragraph 3, the footnote 148 attached to
+-the sentence "Descriptions of function semantics contain the
+-following elements (as appropriate):", insert the word
+-"further" so that the foot note reads:</p>
++the sentence &quot;Descriptions of function semantics contain the
++following elements (as appropriate):&quot;, insert the word
++&quot;further&quot; so that the foot note reads:</p>
+ <blockquote>
+ <p>To save space, items that do not apply to a function are
+ omitted. For example, if a function does not specify any further
+- preconditions, there will be no "Requires" paragraph.</p>
++ preconditions, there will be no &quot;Requires&quot; paragraph.</p>
+ </blockquote>
+
+
+@@ -9944,9 +9169,10 @@ footnote.</p>
+
+ <hr>
+ <h3><a name="223"></a>223. reverse algorithm should use iter_swap rather than swap</h3>
+-<p><b>Section:</b> 25.3.10 [alg.reverse] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-03-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 25.3.10 [alg.reverse] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.reverse">issues</a> in [alg.reverse].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Shouldn't the effects say "applies iter_swap to all pairs..."?</p>
+
+@@ -9968,25 +9194,25 @@ footnote.</p>
+
+ <hr>
+ <h3><a name="224"></a>224. clear() complexity for associative containers refers to undefined N</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Ed Brey <b>Opened:</b> 2000-03-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Ed Brey <b>Opened:</b> 2000-03-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In the associative container requirements table in 23.1.2 paragraph 7,
+-a.clear() has complexity "log(size()) + N". However, the meaning of N
++a.clear() has complexity &quot;log(size()) + N&quot;. However, the meaning of N
+ is not defined.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In the associative container requirements table in 23.1.2 paragraph
+-7, the complexity of a.clear(), change "log(size()) + N" to
+-"linear in <tt>size()</tt>".</p>
++7, the complexity of a.clear(), change &quot;log(size()) + N&quot; to
++&quot;linear in <tt>size()</tt>&quot;.</p>
+
+
+ <p><b>Rationale:</b></p>
+-<p>It's the "log(size())", not the "N", that is in
++<p>It's the &quot;log(size())&quot;, not the &quot;N&quot;, that is in
+ error: there's no difference between <i>O(N)</i> and <i>O(N +
+ log(N))</i>. The text in the standard is probably an incorrect
+ cut-and-paste from the range version of <tt>erase</tt>.</p>
+@@ -9996,10 +9222,10 @@ cut-and-paste from the range version of <tt>erase</tt>.</p>
+
+ <hr>
+ <h3><a name="225"></a>225. std:: algorithms use of other unqualified algorithms</h3>
+-<p><b>Section:</b> 17.6.4.4 [global.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#global.functions">issues</a> in [global.functions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.5.4 [global.functions] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#global.functions">issues</a> in [global.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Are algorithms in std:: allowed to use other algorithms without qualification, so functions in
+ user namespaces might be found through Koenig lookup?</p>
+@@ -10016,8 +9242,8 @@ implementation of std::unique:</p>
+ </blockquote>
+ <p>Imagine two users on opposite sides of town, each using unique on his own
+ sequences bounded by my_iterators . User1 looks at his standard library
+-implementation and says, "I know how to implement a more efficient
+-unique_copy for my_iterators", and writes:</p>
++implementation and says, &quot;I know how to implement a more efficient
++unique_copy for my_iterators&quot;, and writes:</p>
+ <blockquote>
+ <pre>namespace user1 {
+ class my_iterator;
+@@ -10056,14 +9282,14 @@ implementation of unique() shown is non-conforming because it uses unique_copy()
+ rather than ::std::unique_copy(). Most standard library implementations,
+ however, seem to disagree with this notion.</p>
+ <p> <i>[Tokyo:&nbsp; Steve Adamczyk from
+-the core working group indicates that "std::" is sufficient;&nbsp;
+-leading "::" qualification is not required because any namespace
++the core working group indicates that &quot;std::&quot; is sufficient;&nbsp;
++leading &quot;::&quot; qualification is not required because any namespace
+ qualification is sufficient to suppress Koenig lookup.]</i></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add a paragraph and a note at the end of
+-17.6.4.4 [global.functions]:</p>
++17.6.5.4 [global.functions]:</p>
+ <blockquote>
+
+ <p>Unless otherwise specified, no global or non-member function in the
+@@ -10071,13 +9297,13 @@ standard library shall use a function from another namespace which is
+ found through <i>argument-dependent name lookup</i> (3.4.2 [basic.lookup.argdep]).</p>
+
+ <p>[Note: the phrase "unless otherwise specified" is intended to
+-allow Koenig lookup in cases like that of ostream_iterators:<br>
++allow Koenig lookup in cases like that of ostream_iterators:<br/>
+
+-<br>
++<br/>
+ Effects:</p>
+ <blockquote>
+-<p>*out_stream &lt;&lt; value;<br>
+- if(delim != 0) *out_stream &lt;&lt; delim;<br>
++<p>*out_stream &lt;&lt; value;<br/>
++ if(delim != 0) *out_stream &lt;&lt; delim;<br/>
+ return (*this);</p>
+ <p>--end note]</p>
+ </blockquote>
+@@ -10087,9 +9313,9 @@ allow Koenig lookup in cases like that of ostream_iterators:<br>
+ is as yet unsure if the proposed resolution is the best
+ solution. Furthermore, the LWG believes that the same problem of
+ unqualified library names applies to wording in the standard itself,
+-and has opened issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a> accordingly. Any resolution of
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a> should be coordinated with the resolution of
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#229">229</a>.]</i></p>
++and has opened issue <a href="lwg-defects.html#229">229</a> accordingly. Any resolution of
++issue <a href="lwg-defects.html#225">225</a> should be coordinated with the resolution of
++issue <a href="lwg-defects.html#229">229</a>.]</i></p>
+
+
+ <p><i>[Toronto: The LWG is not sure if this is a defect in the
+@@ -10101,7 +9327,7 @@ those specified in the standard. The standard's description of
+ should have any effect.]</i></p>
+
+
+-<p><i>[Curaçao: An LWG-subgroup spent an afternoon working on issues
++<p><i>[Cura&ccedil;ao: An LWG-subgroup spent an afternoon working on issues
+ 225, 226, and 229. Their conclusion was that the issues should be
+ separated into an LWG portion (Howard's paper, N1387=02-0045), and a
+ EWG portion (Dave will write a proposal). The LWG and EWG had
+@@ -10119,7 +9345,7 @@ resolution for this issue is in accordance with Howard's paper.]</i></p>
+ other namespace. However, this is at worst a clarification. It is
+ surely right that algorithsm shouldn't pick up random names, that
+ user-defined names should have no effect unless otherwise specified.
+- Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#226">226</a> deals with the question of when it is
++ Issue <a href="lwg-defects.html#226">226</a> deals with the question of when it is
+ appropriate for the standard to explicitly specify otherwise.</p>
+
+
+@@ -10128,10 +9354,10 @@ resolution for this issue is in accordance with Howard's paper.]</i></p>
+
+ <hr>
+ <h3><a name="226"></a>226. User supplied specializations or overloads of namespace std function templates</h3>
+-<p><b>Section:</b> 17.6.3.3 [reserved.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.3 [reserved.names] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The issues are:&nbsp;</p>
+ <p>1. How can a 3rd party library implementor (lib1) write a version of a standard
+@@ -10170,12 +9396,12 @@ namespace lib2
+ and somewhat slippery. The implementor needs to remember to write the
+ using-declaration, or generic_sort will fail to compile when T is a built-in
+ type. The second drawback is that the use of this style in lib2 effectively
+-"reserves" names in any namespace which defines types which may
++&quot;reserves&quot; names in any namespace which defines types which may
+ eventually be used with lib2. This may seem innocuous at first when applied to
+ names like swap, but consider more ambiguous names like unique_copy() instead.
+ It is easy to imagine the user wanting to define these names differently in his
+ own namespace. A definition with semantics incompatible with the standard
+-library could cause serious problems (see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>).</p>
++library could cause serious problems (see issue <a href="lwg-defects.html#225">225</a>).</p>
+ <p>Why, you may ask, can't we just partially specialize std::swap()? It's
+ because the language doesn't allow for partial specialization of function
+ templates. If you write:</p>
+@@ -10196,8 +9422,8 @@ language rules. On the other hand, the following full specialization is legal:</
+ }</pre>
+ </blockquote>
+
+-<p>This issue reflects concerns raised by the "Namespace issue
+-with specialized swap" thread on comp.lang.c++.moderated. A
++<p>This issue reflects concerns raised by the &quot;Namespace issue
++with specialized swap&quot; thread on comp.lang.c++.moderated. A
+ similar set of concerns was earlier raised on the boost.org mailing
+ list and the ACCU-general mailing list. Also see library reflector
+ message c++std-lib-7354.</p>
+@@ -10223,8 +9449,8 @@ not provide an operator&lt;&lt; for std::pair&lt;&gt;.
+ N1523=03-0106, "Proposed Resolution To LWG issues 225, 226, 229".</p>
+
+
+-<p><i>[Tokyo: Summary, "There is no conforming way to extend
+-std::swap for user defined templates."&nbsp; The LWG agrees that
++<p><i>[Tokyo: Summary, &quot;There is no conforming way to extend
++std::swap for user defined templates.&quot;&nbsp; The LWG agrees that
+ there is a problem. Would like more information before
+ proceeding. This may be a core issue. Core issue 229 has been opened
+ to discuss the core aspects of this problem. It was also noted that
+@@ -10234,8 +9460,8 @@ sources, but too late to be integrated into the issues list.
+
+
+ <p><i>[Post-Tokyo: A paper with several proposed resolutions,
+-J16/00-0029==WG21/N1252, "Shades of namespace std functions
+-" by Alan Griffiths, is in the Post-Tokyo mailing. It
++J16/00-0029==WG21/N1252, &quot;Shades of namespace std functions
++&quot; by Alan Griffiths, is in the Post-Tokyo mailing. It
+ should be considered a part of this issue.]</i></p>
+
+
+@@ -10283,7 +9509,7 @@ A small group (Nathan, Howard, Jeremy, Dave, Matt, Walter, Marc) will
+ try to put together a proposal before the next meeting.]</i></p>
+
+
+-<p><i>[Curaçao: An LWG-subgroup spent an afternoon working on issues
++<p><i>[Cura&ccedil;ao: An LWG-subgroup spent an afternoon working on issues
+ 225, 226, and 229. Their conclusion was that the issues should be
+ separated into an LWG portion (Howard's paper, N1387=02-0045), and a
+ EWG portion (Dave will write a proposal). The LWG and EWG had
+@@ -10319,16 +9545,16 @@ resolution is the one proposed by Howard.]</i></p>
+
+ <hr>
+ <h3><a name="227"></a>227. std::swap() should require CopyConstructible or DefaultConstructible arguments</h3>
+-<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TC1">TC1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TC1">TC1</a> status.</p>
++<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="lwg-active.html#TC1">TC1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-04-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TC1">TC1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>25.2.2 reads:</p>
+ <blockquote>
+- <p><tt> template&lt;class T&gt; void swap(T&amp; a, T&amp; b);</tt><br>
+- <br>
+- Requires: Type T is Assignable (_lib.container.requirements_).<br>
++ <p><tt> template&lt;class T&gt; void swap(T&amp; a, T&amp; b);</tt><br/>
++ <br/>
++ Requires: Type T is Assignable (_lib.container.requirements_).<br/>
+ Effects: Exchanges values stored in two locations.</p>
+ </blockquote>
+ <p>The only reasonable** generic implementation of swap requires construction of a
+@@ -10371,20 +9597,20 @@ resolution is the one proposed by Howard.]</i></p>
+
+
+ <hr>
+-<h3><a name="228"></a>228. Incorrect specification of "..._byname" facets</h3>
+-<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-04-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="228"></a>228. Incorrect specification of &quot;..._byname&quot; facets</h3>
++<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-04-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The sections 22.4.1.2 [locale.ctype.byname], 22.4.1.5 [locale.codecvt.byname],
+ sref ref="22.2.1.6", 22.4.3.2 [locale.numpunct.byname], 22.4.4.2 [locale.collate.byname], 22.4.5.4 [locale.time.put.byname], 22.4.6.4 [locale.moneypunct.byname], and 22.4.7.2 [locale.messages.byname] overspecify the
+-definitions of the "..._byname" classes by listing a bunch
++definitions of the &quot;..._byname&quot; classes by listing a bunch
+ of virtual functions. At the same time, no semantics of these
+ functions are defined. Real implementations do not define these
+ functions because the functional part of the facets is actually
+ implemented in the corresponding base classes and the constructor of
+-the "..._byname" version just provides suitable date used by
++the &quot;..._byname&quot; version just provides suitable date used by
+ these implementations. For example, the 'numpunct' methods just return
+ values from a struct. The base class uses a statically initialized
+ struct while the derived version reads the contents of this struct
+@@ -10474,7 +9700,7 @@ specialization it is not virtual.</p>
+ protected:
+ ~time_put_byname(); // virtual
+ };
+- }"</pre>
++ }&quot;</pre>
+ <p>&nbsp; Change section 22.2.6.4 (lib.locale.moneypunct.byname) to become:</p>
+ <pre> namespace std {
+ template &lt;class charT, bool Intl = false&gt;
+@@ -10503,8 +9729,8 @@ specialization it is not virtual.</p>
+ this case only those members are defined to be virtual which are
+ defined to be virtual in 'ctype&lt;cT&gt;'.)</p>
+
+-<p><i>[Post-Tokyo: Dietmar Kühl submitted this issue at the request of
+-the LWG to solve the underlying problems raised by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#138">138</a>.]</i></p>
++<p><i>[Post-Tokyo: Dietmar K&uuml;hl submitted this issue at the request of
++the LWG to solve the underlying problems raised by issue <a href="lwg-closed.html#138">138</a>.]</i></p>
+
+
+ <p><i>[Copenhagen: proposed resolution was revised slightly, to remove
+@@ -10518,31 +9744,31 @@ three last virtual functions from <tt>messages_byname</tt>.]</i></p>
+
+ <hr>
+ <h3><a name="229"></a>229. Unqualified references of other library entities</h3>
+-<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2000-04-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#contents">issues</a> in [contents].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2000-04-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#contents">issues</a> in [contents].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Throughout the library chapters, the descriptions of library entities refer
+ to other library entities without necessarily qualifying the names.</p>
+
+-<p>For example, section 25.2.2 "Swap" describes the effect of
+-swap_ranges in terms of the unqualified name "swap". This section
++<p>For example, section 25.2.2 &quot;Swap&quot; describes the effect of
++swap_ranges in terms of the unqualified name &quot;swap&quot;. This section
+ could reasonably be interpreted to mean that the library must be implemented so
+-as to do a lookup of the unqualified name "swap", allowing users to
++as to do a lookup of the unqualified name &quot;swap&quot;, allowing users to
+ override any ::std::swap function when Koenig lookup applies.</p>
+
+ <p>Although it would have been best to use explicit qualification with
+-"::std::" throughout, too many lines in the standard would have to be
++&quot;::std::&quot; throughout, too many lines in the standard would have to be
+ adjusted to make that change in a Technical Corrigendum.</p>
+
+-<p>Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#182">182</a>, which addresses qualification of
++<p>Issue <a href="lwg-defects.html#182">182</a>, which addresses qualification of
+ <tt>size_t</tt>, is a special case of this.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>To section 17.4.1.1 "Library contents" Add the following paragraph:</p>
++<p>To section 17.4.1.1 &quot;Library contents&quot; Add the following paragraph:</p>
+ <blockquote>
+ <p>Whenever a name x defined in the standard library is mentioned, the name x
+ is assumed to be fully qualified as ::std::x, unless explicitly described
+@@ -10552,7 +9778,7 @@ adjusted to make that change in a Technical Corrigendum.</p>
+
+ <p><i>[Post-Tokyo: Steve Clamage submitted this issue at the request of
+ the LWG to solve a problem in the standard itself similar to the
+-problem within implementations of library identified by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a>. Any resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">225</a> should be
++problem within implementations of library identified by issue <a href="lwg-defects.html#225">225</a>. Any resolution of issue <a href="lwg-defects.html#225">225</a> should be
+ coordinated with the resolution of this issue.]</i></p>
+
+
+@@ -10565,10 +9791,10 @@ class, and this requires argument-dependent lookup if those functions
+ are intended to be called by library code. Several LWG members are
+ concerned that valarray appears to require argument-dependent lookup,
+ but that the wording may not be clear enough to fall under
+-"unless explicitly described otherwise".]</i></p>
++&quot;unless explicitly described otherwise&quot;.]</i></p>
+
+
+-<p><i>[Curaçao: An LWG-subgroup spent an afternoon working on issues
++<p><i>[Cura&ccedil;ao: An LWG-subgroup spent an afternoon working on issues
+ 225, 226, and 229. Their conclusion was that the issues should be
+ separated into an LWG portion (Howard's paper, N1387=02-0045), and a
+ EWG portion (Dave will write a proposal). The LWG and EWG had
+@@ -10584,13 +9810,13 @@ resolution for the current issue makes sense.]</i></p>
+
+ <hr>
+ <h3><a name="230"></a>230. Assignable specified without also specifying CopyConstructible</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2000-04-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2000-04-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#227">227</a> identified an instance (std::swap) where
++<p>Issue <a href="lwg-defects.html#227">227</a> identified an instance (std::swap) where
+ Assignable was specified without also specifying
+ CopyConstructible. The LWG asked that the standard be searched to
+ determine if the same defect existed elsewhere.</p>
+@@ -10604,12 +9830,12 @@ specified. For example, 26.5.1 [rand.req].</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>In 23.2 [container.requirements] table 65 for value_type:
+ change "T is Assignable" to "T is CopyConstructible and
+-Assignable"
++Assignable&quot;
+ </p>
+
+ <p>In 23.2.4 [associative.reqmts] table 69 X::key_type; change
+-"Key is Assignable" to "Key is
+-CopyConstructible and Assignable"<br>
++&quot;Key is Assignable" to &quot;Key is
++CopyConstructible and Assignable&quot;<br/>
+ </p>
+
+ <p>In 24.2.4 [output.iterators] paragraph 1, change:
+@@ -10637,7 +9863,7 @@ overspecification.]</i></p>
+
+
+ <p><i>[Portions of the resolution for issue 230 have been superceded by
+-the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a>.]</i></p>
++the resolution of issue <a href="lwg-defects.html#276">276</a>.]</i></p>
+
+
+
+@@ -10655,10 +9881,10 @@ Copy Constructible property.</p>
+
+ <hr>
+ <h3><a name="231"></a>231. Precision in iostream?</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> James Kanze, Stephen Clamage <b>Opened:</b> 2000-04-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> James Kanze, Stephen Clamage <b>Opened:</b> 2000-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>What is the following program supposed to output?</p>
+ <pre>#include &lt;iostream&gt;
+@@ -10671,14 +9897,14 @@ Copy Constructible property.</p>
+ std::cout &lt;&lt; 1.00 &lt;&lt; '\n' ;
+ return 0 ;
+ }</pre>
+-<p>From my C experience, I would expect "1e+00"; this is what
+-<tt>printf("%.0e" , 1.00 );</tt> does. G++ outputs
+-"1.000000e+00".</p>
++<p>From my C experience, I would expect &quot;1e+00&quot;; this is what
++<tt>printf(&quot;%.0e&quot; , 1.00 );</tt> does. G++ outputs
++&quot;1.000000e+00&quot;.</p>
+
+ <p>The only indication I can find in the standard is 22.2.2.2.2/11,
+-where it says "For conversion from a floating-point type, if
++where it says &quot;For conversion from a floating-point type, if
+ (flags &amp; fixed) != 0 or if str.precision() &gt; 0, then
+-str.precision() is specified in the conversion specification."
++str.precision() is specified in the conversion specification.&quot;
+ This is an obvious error, however, fixed is not a mask for a field,
+ but a value that a multi-bit field may take -- the results of and'ing
+ fmtflags with ios::fixed are not defined, at least not if
+@@ -10725,9 +9951,9 @@ precision 1.</p>
+ specifying a precision of 0, which will be internally
+ turned into 1. There's no need to call it out as a special
+ case.</p>
+-<p>The output of the above program will be "1e+00".</p>
++<p>The output of the above program will be &quot;1e+00&quot;.</p>
+
+-<p><i>[Post-Curaçao: Howard provided improved wording covering the case
++<p><i>[Post-Cura&ccedil;ao: Howard provided improved wording covering the case
+ where precision is 0 and mode is %g.]</i></p>
+
+
+@@ -10737,15 +9963,15 @@ where precision is 0 and mode is %g.]</i></p>
+
+
+ <hr>
+-<h3><a name="232"></a>232. "depends" poorly defined in 17.4.3.1</h3>
+-<p><b>Section:</b> 17.6.3.3 [reserved.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2000-04-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="232"></a>232. &quot;depends&quot; poorly defined in 17.4.3.1</h3>
++<p><b>Section:</b> 17.6.4.3 [reserved.names] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2000-04-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>17.4.3.1/1 uses the term "depends" to limit the set of allowed
+-specializations of standard templates to those that "depend on a
+-user-defined name of external linkage."</p>
++<p>17.4.3.1/1 uses the term &quot;depends&quot; to limit the set of allowed
++specializations of standard templates to those that &quot;depend on a
++user-defined name of external linkage.&quot;</p>
+ <p>This term, however, is not adequately defined, making it possible to
+ construct a specialization that is, I believe, technically legal according to
+ 17.4.3.1/1, but that specializes a standard template for a built-in type such as
+@@ -10765,8 +9991,8 @@ construct a specialization that is, I believe, technically legal according to
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change "user-defined name" to "user-defined
+-type".</p>
++<p>Change &quot;user-defined name&quot; to &quot;user-defined
++type&quot;.</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -10778,7 +10004,7 @@ possible way for a user to come up with a specialization for bitset,
+ for example, that might not have already been specialized by the
+ implementor?</p>
+
+-<p><i>[Toronto: this may be related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#120">120</a>.]</i></p>
++<p><i>[Toronto: this may be related to issue <a href="lwg-defects.html#120">120</a>.]</i></p>
+
+
+ <p><i>[post-Toronto: Judy provided the above proposed resolution and
+@@ -10791,12 +10017,12 @@ rationale.]</i></p>
+
+ <hr>
+ <h3><a name="233"></a>233. Insertion hints in associative containers</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-04-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#192">192</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#246">246</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2000-04-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#192">192</a>, <a href="lwg-closed.html#246">246</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ If <tt>mm</tt> is a multimap and <tt>p</tt> is an iterator
+@@ -10819,7 +10045,7 @@ can supply <tt>p</tt>, and the implementation is allowed to
+ disregard it entirely.
+ </p>
+
+-<p><b>Additional comments from Nathan:</b><br>
++<p><b>Additional comments from Nathan:</b><br/>
+
+ The vote [in Redmond] was on whether to elaborately specify the use of
+ the hint, or to require behavior only if the value could be inserted
+@@ -10860,7 +10086,7 @@ other (perhaps better) balanced tree techniques that might differ
+ enough to make the detailed semantics hard to satisfy."]</i></p>
+
+
+-<p><i>[Curaçao: Nathan should give us the alternative wording he
++<p><i>[Cura&ccedil;ao: Nathan should give us the alternative wording he
+ suggests so the LWG can decide between the two options.]</i></p>
+
+
+@@ -10887,7 +10113,7 @@ accepted with minor wording changes in the proposed wording (reflected in the
+ proposed resolution below). Concerns about the performance of the algorithm
+ were satisfactorily met by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1780.html">1780</a>.
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#371">371</a> already handles the stability of equal ranges
++<a href="lwg-defects.html#371">371</a> already handles the stability of equal ranges
+ and so that part of the resolution from
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1780.html">1780</a>
+ is no longer needed (or reflected in the proposed wording below).
+@@ -10903,11 +10129,10 @@ Change the indicated rows of the "Associative container requirements" Table in
+ 23.2.4 [associative.reqmts] to:
+ </p>
+
+-<p></p><center>
+ <table border="1">
+ <caption>Associative container requirements</caption>
+-<tbody><tr><th>expression</th> <th>return type</th>
+-<th>assertion/note<br>pre/post-condition</th>
++<tr><th>expression</th> <th>return type</th>
++<th>assertion&#47;note<br/>pre&#47;post-condition</th>
+ <th>complexity</th></tr>
+ <tr><td><tt>a_eq.insert(t)</tt></td>
+ <td><tt>iterator</tt></td>
+@@ -10933,8 +10158,7 @@ to the position just prior to <tt>p</tt>.</ins>
+ logarithmic in general, but amortized constant if <tt>t</tt> is inserted right <del>after</del>
+ <ins>before</ins> <tt>p</tt>.
+ </td></tr>
+-</tbody></table>
+-</center><p></p>
++</table>
+
+
+
+@@ -10943,10 +10167,10 @@ logarithmic in general, but amortized constant if <tt>t</tt> is inserted right <
+
+ <hr>
+ <h3><a name="234"></a>234. Typos in allocator definition</h3>
+-<p><b>Section:</b> 20.9.5.1 [allocator.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In paragraphs 12 and 13 the effects of <tt>construct()</tt> and
+ <tt>destruct()</tt> are described as returns but the functions actually
+@@ -10954,16 +10178,17 @@ return <tt>void</tt>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Substitute "Returns" by "Effect".</p>
++<p>Substitute &quot;Returns&quot; by &quot;Effect&quot;.</p>
+
+
+
+
+ <hr>
+ <h3><a name="235"></a>235. No specification of default ctor for reverse_iterator</h3>
+-<p><b>Section:</b> 24.5.1.1 [reverse.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.1.1 [reverse.iterator] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iterator">issues</a> in [reverse.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The declaration of <tt>reverse_iterator</tt> lists a default
+ constructor. However, no specification is given what this constructor
+@@ -10991,10 +10216,10 @@ should do.</p>
+
+ <hr>
+ <h3><a name="237"></a>237. Undefined expression in complexity specification</h3>
+-<p><b>Section:</b> 23.3.2.1 [deque.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#deque.cons">issues</a> in [deque.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.3.2 [deque.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-04-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.cons">issues</a> in [deque.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The complexity specification in paragraph 6 says that the complexity
+ is linear in <tt>first - last</tt>. Even if <tt>operator-()</tt> is
+@@ -11013,16 +10238,17 @@ would have to be <tt>last - first</tt>.</p>
+
+ <hr>
+ <h3><a name="238"></a>238. Contradictory results of stringbuf initialization.</h3>
+-<p><b>Section:</b> 27.8.1.1 [stringbuf.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dietmar Kühl <b>Opened:</b> 2000-05-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.cons">issues</a> in [stringbuf.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.1 [stringbuf.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dietmar K&uuml;hl <b>Opened:</b> 2000-05-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.cons">issues</a> in [stringbuf.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 27.7.1.1 paragraph 4 the results of calling the constructor of
+ 'basic_stringbuf' are said to be <tt>str() == str</tt>. This is fine
+ that far but consider this code:</p>
+
+-<pre> std::basic_stringbuf&lt;char&gt; sbuf("hello, world", std::ios_base::openmode(0));
++<pre>
++ std::basic_stringbuf&lt;char&gt; sbuf("hello, world", std::ios_base::openmode(0));
+ std::cout &lt;&lt; "'" &lt;&lt; sbuf.str() &lt;&lt; "'\n";
+ </pre>
+
+@@ -11051,10 +10277,10 @@ in the standard.</p>
+
+ <hr>
+ <h3><a name="239"></a>239. Complexity of unique() and/or unique_copy incorrect</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The complexity of unique and unique_copy are inconsistent with each
+ other and inconsistent with the implementations.&nbsp; The standard
+@@ -11096,15 +10322,16 @@ applications of the corresponding predicate.</p></blockquote>
+
+ <hr>
+ <h3><a name="240"></a>240. Complexity of adjacent_find() is meaningless</h3>
+-<p><b>Section:</b> 25.2.8 [alg.adjacent.find] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.adjacent.find">issues</a> in [alg.adjacent.find].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.2.8 [alg.adjacent.find] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.adjacent.find">issues</a> in [alg.adjacent.find].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The complexity section of adjacent_find is defective:</p>
+
+ <blockquote>
+-<pre>template &lt;class ForwardIterator&gt;
++<pre>
++template &lt;class ForwardIterator&gt;
+ ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last
+ BinaryPredicate pred);
+ </pre>
+@@ -11119,8 +10346,8 @@ of the corresponding predicate.
+ </p>
+ </blockquote>
+
+-<p>In the Complexity section, it is not defined what "value"
+-is supposed to mean. My best guess is that "value" means an
++<p>In the Complexity section, it is not defined what &quot;value&quot;
++is supposed to mean. My best guess is that &quot;value&quot; means an
+ object for which one of the conditions pred(*i,value) or
+ pred(value,*i) is true, where i is the iterator defined in the Returns
+ section. However, the value type of the input sequence need not be
+@@ -11133,7 +10360,7 @@ the intended specification. Binders can only be applied to function
+ objects that have the function call operator declared const, which is
+ not required of predicates because they can have non-const data
+ members. For this reason, a specification using a binder could only be
+-an "as-if" specification.</p>
++an &quot;as-if&quot; specification.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -11156,10 +10383,10 @@ bound. The LWG preferred an exact count.]</i></p>
+
+ <hr>
+ <h3><a name="241"></a>241. Does unique_copy() require CopyConstructible and Assignable?</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>Some popular implementations of unique_copy() create temporary
+@@ -11210,9 +10437,9 @@ that requirement. Howard provided new wording.]</i></p>
+
+
+ <p><i>[
+-Curaçao: The LWG changed the PR editorially to specify
+-"neither...nor...meet..." as clearer than
+-"both...and...do not meet...". Change believed to be so
++Cura&ccedil;ao: The LWG changed the PR editorially to specify
++&quot;neither...nor...meet...&quot; as clearer than
++&quot;both...and...do not meet...&quot;. Change believed to be so
+ minor as not to require re-review.
+ ]</i></p>
+
+@@ -11225,10 +10452,10 @@ minor as not to require re-review.
+
+ <hr>
+ <h3><a name="242"></a>242. Side effects of function objects</h3>
+-<p><b>Section:</b> 25.3.4 [alg.transform], 26.5 [rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.transform">issues</a> in [alg.transform].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.4 [alg.transform], 26.5 [rand] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Angelika Langer <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.transform">issues</a> in [alg.transform].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The algorithms transform(), accumulate(), inner_product(),
+ partial_sum(), and adjacent_difference() require that the function
+@@ -11413,26 +10640,27 @@ intentional.]</i></p>
+
+ <hr>
+ <h3><a name="243"></a>243. <tt>get</tt> and <tt>getline</tt> when sentry reports failure</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>basic_istream&lt;&gt;::get(), and basic_istream&lt;&gt;::getline(),
+ are unclear with respect to the behavior and side-effects of the named
+ functions in case of an error.</p>
+
+-<p>27.6.1.3, p1 states that "... If the sentry object returns
++<p>27.6.1.3, p1 states that &quot;... If the sentry object returns
+ true, when converted to a value of type bool, the function endeavors
+-to obtain the requested input..." It is not clear from this (or
++to obtain the requested input...&quot; It is not clear from this (or
+ the rest of the paragraph) what precisely the behavior should be when
+ the sentry ctor exits by throwing an exception or when the sentry
+ object returns false. In particular, what is the number of characters
+ extracted that gcount() returns supposed to be?</p>
+
+ <p>27.6.1.3 p8 and p19 say about the effects of get() and getline():
+-"... In any case, it then stores a null character (using
+-charT()) into the next successive location of the array." Is not
++&quot;... In any case, it then stores a null character (using
++charT()) into the next successive location of the array.&quot; Is not
+ clear whether this sentence applies if either of the conditions above
+ holds (i.e., when sentry fails).</p>
+
+@@ -11441,21 +10669,21 @@ holds (i.e., when sentry fails).</p>
+ <p>Add to 27.6.1.3, p1 after the sentence</p>
+
+ <blockquote><p>
+-"... If the sentry object returns true, when converted to a value of
+-type bool, the function endeavors to obtain the requested input."
++&quot;... If the sentry object returns true, when converted to a value of
++type bool, the function endeavors to obtain the requested input.&quot;
+ </p></blockquote>
+
+ <p>the following</p>
+
+
+ <blockquote><p>
+-"Otherwise, if the sentry constructor exits by throwing an exception or
++&quot;Otherwise, if the sentry constructor exits by throwing an exception or
+ if the sentry object returns false, when converted to a value of type
+ bool, the function returns without attempting to obtain any input. In
+ either case the number of extracted characters is set to 0; unformatted
+ input functions taking a character array of non-zero size as an argument
+ shall also store a null character (using charT()) in the first location
+-of the array."
++of the array.&quot;
+ </p></blockquote>
+
+
+@@ -11473,12 +10701,13 @@ Jerry Schwarz's message c++std-lib-7618.</p>
+
+ <hr>
+ <h3><a name="247"></a>247. <tt>vector</tt>, <tt>deque::insert</tt> complexity</h3>
+-<p><b>Section:</b> 23.4.1.4 [vector.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Lisa Lippincott <b>Opened:</b> 2000-06-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Lisa Lippincott <b>Opened:</b> 2000-06-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Paragraph 2 of 23.4.1.4 [vector.modifiers] describes the complexity
++<p>Paragraph 2 of 23.3.6.5 [vector.modifiers] describes the complexity
+ of <tt>vector::insert</tt>:</p>
+
+ <blockquote><p>
+@@ -11499,7 +10728,7 @@ the end of a <tt>vector</tt> in constant time.</p>
+
+ <p>I looked to see if <tt>deque</tt> had a similar problem, and was
+ surprised to find that <tt>deque</tt> places no requirement on the
+-complexity of inserting multiple elements (23.3.2.3 [deque.modifiers],
++complexity of inserting multiple elements (23.3.3.4 [deque.modifiers],
+ paragraph 3):</p>
+
+ <blockquote><p>
+@@ -11515,7 +10744,7 @@ paragraph 3):</p>
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Change Paragraph 2 of 23.4.1.4 [vector.modifiers] to</p>
++<p>Change Paragraph 2 of 23.3.6.5 [vector.modifiers] to</p>
+ <blockquote><p>
+ Complexity: The complexity is linear in the number of elements
+ inserted plus the distance to the end of the vector.
+@@ -11526,7 +10755,7 @@ paragraph 3):</p>
+ <tt>rotate</tt>.]</i></p>
+
+
+-<p>Change 23.3.2.3 [deque.modifiers], paragraph 3, to:</p>
++<p>Change 23.3.3.4 [deque.modifiers], paragraph 3, to:</p>
+
+ <blockquote><p>
+ Complexity: The complexity is linear in the number of elements
+@@ -11551,9 +10780,9 @@ paragraph 3):</p>
+
+ <hr>
+ <h3><a name="248"></a>248. time_get fails to set eofbit</h3>
+-<p><b>Section:</b> 22.4.5 [category.time] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.5 [category.time] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>There is no requirement that any of time_get member functions set
+ ios::eofbit when they reach the end iterator while parsing their input.
+@@ -11581,15 +10810,16 @@ input facets.</p>
+
+ <hr>
+ <h3><a name="250"></a>250. splicing invalidates iterators</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Brian Parker <b>Opened:</b> 2000-07-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Brian Parker <b>Opened:</b> 2000-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Section 23.3.4.4 [list.ops] states that
++Section 23.3.5.5 [list.ops] states that
+ </p>
+-<pre> void splice(iterator position, list&lt;T, Allocator&gt;&amp; x);
++<pre>
++ void splice(iterator position, list&lt;T, Allocator&gt;&amp; x);
+ </pre>
+ <p>
+ <i>invalidates</i> all iterators and references to list <tt>x</tt>.
+@@ -11604,14 +10834,14 @@ after <tt>splice</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Add a footnote to 23.3.4.4 [list.ops], paragraph 1:</p>
++<p>Add a footnote to 23.3.5.5 [list.ops], paragraph 1:</p>
+ <blockquote><p>
+ [<i>Footnote:</i> As specified in [default.con.req], paragraphs
+ 4-5, the semantics described in this clause applies only to the case
+ where allocators compare equal. --end footnote]
+ </p></blockquote>
+
+-<p>In 23.3.4.4 [list.ops], replace paragraph 4 with:</p>
++<p>In 23.3.5.5 [list.ops], replace paragraph 4 with:</p>
+ <blockquote><p>
+ Effects: Inserts the contents of x before position and x becomes
+ empty. Pointers and references to the moved elements of x now refer to
+@@ -11620,7 +10850,7 @@ moved elements will continue to refer to their elements, but they now
+ behave as iterators into *this, not into x.
+ </p></blockquote>
+
+-<p>In 23.3.4.4 [list.ops], replace paragraph 7 with:</p>
++<p>In 23.3.5.5 [list.ops], replace paragraph 7 with:</p>
+ <blockquote><p>
+ Effects: Inserts an element pointed to by i from list x before
+ position and removes the element from x. The result is unchanged if
+@@ -11630,7 +10860,7 @@ to refer to this same element but as a member of *this. Iterators to *i
+ behave as iterators into *this, not into x.
+ </p></blockquote>
+
+-<p>In 23.3.4.4 [list.ops], replace paragraph 12 with:</p>
++<p>In 23.3.5.5 [list.ops], replace paragraph 12 with:</p>
+ <blockquote><p>
+ Requires: [first, last) is a valid range in x. The result is
+ undefined if position is an iterator in the range [first, last).
+@@ -11656,9 +10886,9 @@ allocators compare nonequal is outside the scope of the standard.</p>
+
+ <hr>
+ <h3><a name="251"></a>251. basic_stringbuf missing allocator_type</h3>
+-<p><b>Section:</b> 27.8.1 [stringbuf] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-07-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2 [stringbuf] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The synopsis for the template class <tt>basic_stringbuf</tt>
+ doesn't list a typedef for the template parameter
+@@ -11672,7 +10902,8 @@ template classes in the library that do provide a typedef for the
+ <p>Add to the synopses of the class templates basic_stringbuf (27.7.1),
+ basic_istringstream (27.7.2), basic_ostringstream (27.7.3), and
+ basic_stringstream (27.7.4) the typedef:</p>
+-<pre> typedef Allocator allocator_type;
++<pre>
++ typedef Allocator allocator_type;
+ </pre>
+
+
+@@ -11680,10 +10911,10 @@ basic_stringstream (27.7.4) the typedef:</p>
+
+ <hr>
+ <h3><a name="252"></a>252. missing casts/C-style casts used in iostreams</h3>
+-<p><b>Section:</b> 27.8 [string.streams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-07-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.streams">issues</a> in [string.streams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8 [string.streams] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.streams">issues</a> in [string.streams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.7.2.2, p1 uses a C-style cast rather than the more appropriate
+ const_cast&lt;&gt; in the Returns clause for basic_istringstream&lt;&gt;::rdbuf().
+@@ -11726,10 +10957,10 @@ issue is stylistic rather than a matter of correctness.</p>
+
+ <hr>
+ <h3><a name="253"></a>253. valarray helper functions are almost entirely useless</h3>
+-<p><b>Section:</b> 26.6.2.1 [valarray.cons], 26.6.2.2 [valarray.assign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2000-07-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.2.2 [valarray.cons], 26.6.2.3 [valarray.assign] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2000-07-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>This discussion is adapted from message c++std-lib-7056 posted
+ November 11, 1999. I don't think that anyone can reasonably claim
+@@ -11737,7 +10968,8 @@ that the problem described below is NAD.</p>
+
+ <p>These valarray constructors can never be called:</p>
+
+-<pre> template &lt;class T&gt;
++<pre>
++ template &lt;class T&gt;
+ valarray&lt;T&gt;::valarray(const slice_array&lt;T&gt; &amp;);
+ template &lt;class T&gt;
+ valarray&lt;T&gt;::valarray(const gslice_array&lt;T&gt; &amp;);
+@@ -11750,7 +10982,8 @@ that the problem described below is NAD.</p>
+ <p>Similarly, these valarray assignment operators cannot be
+ called:</p>
+
+-<pre> template &lt;class T&gt;
++<pre>
++ template &lt;class T&gt;
+ valarray&lt;T&gt; valarray&lt;T&gt;::operator=(const slice_array&lt;T&gt; &amp;);
+ template &lt;class T&gt;
+ valarray&lt;T&gt; valarray&lt;T&gt;::operator=(const gslice_array&lt;T&gt; &amp;);
+@@ -11762,7 +10995,8 @@ called:</p>
+
+ <p>Please consider the following example:</p>
+
+-<pre> #include &lt;valarray&gt;
++<pre>
++ #include &lt;valarray&gt;
+ using namespace std;
+
+ int main()
+@@ -11779,7 +11013,8 @@ std::slice_array&lt;double&gt;. This slice_array rvalue is then used to
+ construct va2. The constructor that is used to construct va2 is
+ declared like this:</p>
+
+-<pre> template &lt;class T&gt;
++<pre>
++ template &lt;class T&gt;
+ valarray&lt;T&gt;::valarray(const slice_array&lt;T&gt; &amp;);
+ </pre>
+
+@@ -11812,9 +11047,9 @@ classes are almost entirely useless.</p>
+ <li> remove the copy constructor declaration from [cons.slice.arr]</li>
+ <li> change paragraph 1 of [cons.slice.arr] to read "This constructor is declared
+ to be private. This constructor need not be defined."</li>
+-<li> remove the first sentence of paragraph 1 of 26.6.5.1 [slice.arr.assign]</li>
++<li> remove the first sentence of paragraph 1 of 26.6.5.2 [slice.arr.assign]</li>
+ <li> Change the first three words of the second sentence of paragraph 1 of
+- 26.6.5.1 [slice.arr.assign] to "These assignment operators have"</li>
++ 26.6.5.2 [slice.arr.assign] to "These assignment operators have"</li>
+ </ul>
+
+ <p>gslice_array:</p>
+@@ -11825,9 +11060,9 @@ classes are almost entirely useless.</p>
+ <li> remove the copy constructor declaration from [gslice.array.cons]</li>
+ <li> change paragraph 1 of [gslice.array.cons] to read "This constructor is declared
+ to be private. This constructor need not be defined."</li>
+-<li> remove the first sentence of paragraph 1 of 26.6.7.1 [gslice.array.assign]</li>
++<li> remove the first sentence of paragraph 1 of 26.6.7.2 [gslice.array.assign]</li>
+ <li> Change the first three words of the second sentence of paragraph 1 of
+- 26.6.7.1 [gslice.array.assign] to "These assignment operators have"</li>
++ 26.6.7.2 [gslice.array.assign] to "These assignment operators have"</li>
+ </ul>
+
+ <p>mask_array:</p>
+@@ -11838,9 +11073,9 @@ classes are almost entirely useless.</p>
+ <li> remove the copy constructor declaration from [mask.array.cons]</li>
+ <li> change paragraph 1 of [mask.array.cons] to read "This constructor is declared
+ to be private. This constructor need not be defined."</li>
+-<li> remove the first sentence of paragraph 1 of 26.6.8.1 [mask.array.assign]</li>
++<li> remove the first sentence of paragraph 1 of 26.6.8.2 [mask.array.assign]</li>
+ <li> Change the first three words of the second sentence of paragraph 1 of
+- 26.6.8.1 [mask.array.assign] to "These assignment operators have"</li>
++ 26.6.8.2 [mask.array.assign] to "These assignment operators have"</li>
+ </ul>
+
+ <p>indirect_array:</p>
+@@ -11851,9 +11086,9 @@ classes are almost entirely useless.</p>
+ <li> remove the copy constructor declaration from [indirect.array.cons]</li>
+ <li> change the descriptive text in [indirect.array.cons] to read "This constructor is
+ declared to be private. This constructor need not be defined."</li>
+-<li> remove the first sentence of paragraph 1 of 26.6.9.1 [indirect.array.assign]</li>
++<li> remove the first sentence of paragraph 1 of 26.6.9.2 [indirect.array.assign]</li>
+ <li> Change the first three words of the second sentence of paragraph 1 of
+- 26.6.9.1 [indirect.array.assign] to "These assignment operators have"</li>
++ 26.6.9.2 [indirect.array.assign] to "These assignment operators have"</li>
+ </ul>
+ <p><i>[Proposed resolution was modified in Santa Cruz: explicitly make
+ copy constructor and copy assignment operators public, instead of
+@@ -11879,9 +11114,10 @@ expectation.</p>
+
+ <hr>
+ <h3><a name="254"></a>254. Exception types in clause 19 are constructed from <tt>std::string</tt></h3>
+-<p><b>Section:</b> 19.2 [std.exceptions], 27.5.2.1.1 [ios::failure] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-08-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 19.2 [std.exceptions], 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2000-08-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#std.exceptions">issues</a> in [std.exceptions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Many of the standard exception types which implementations are
+@@ -11889,7 +11125,8 @@ required to throw are constructed with a const std::string&amp;
+ parameter. For example:
+ </p>
+
+-<pre> 19.1.5 Class out_of_range [lib.out.of.range]
++<pre>
++ 19.1.5 Class out_of_range [lib.out.of.range]
+ namespace std {
+ class out_of_range : public logic_error {
+ public:
+@@ -11934,7 +11171,7 @@ a lot, though.
+ There is a cure for (2), but it isn't completely obvious. I think a
+ note for implementors should be made in the standard. Avoiding
+ possible termination in this case shouldn't be left up to chance. The
+-cure is to use a reference-counted "string" implementation
++cure is to use a reference-counted &quot;string&quot; implementation
+ in the exception object. I am not necessarily referring to a
+ std::string here; any simple reference-counting scheme for a NTBS
+ would do.
+@@ -11953,9 +11190,9 @@ std::bad_alloc don't require a temporary basic_string.
+ <p>
+ ...I don't think the fixed-size buffer is a solution to the problem,
+ strictly speaking, because you can't satisfy the postcondition
+-<br>
++<br/>
+ <tt>&nbsp;&nbsp;strcmp(what(), what_arg.c_str()) == 0</tt>
+-<br>
++<br/>
+ For all values of what_arg (i.e. very long values). That means that
+ the only truly conforming solution requires a dynamic allocation.
+ </p>
+@@ -11971,7 +11208,7 @@ copy constructor is potentially invoked during stack unwinding.</p>
+
+ <p>The copy constructor is a more serious problem, becuase failure
+ during stack unwinding invokes <tt>terminate</tt>. The copy
+-constructor must be nothrow. <i>Curaçao: Howard thinks this
++constructor must be nothrow. <i>Cura&ccedil;ao: Howard thinks this
+ requirement may already be present.</i></p>
+
+ <p>The fundamental problem is that it's difficult to get the nothrow
+@@ -12006,7 +11243,8 @@ Change 19.2.1 [logic.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class logic_error : public exception {
+ public:
+ explicit logic_error(const string&amp; <i>what_arg</i>);
+@@ -12034,7 +11272,8 @@ Change 19.2.2 [domain.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class domain_error : public logic_error {
+ public:
+ explicit domain_error(const string&amp; <i>what_arg</i>);
+@@ -12062,7 +11301,8 @@ Change 19.2.3 [invalid.argument]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class invalid_argument : public logic_error {
+ public:
+ explicit invalid_argument(const string&amp; <i>what_arg</i>);
+@@ -12090,7 +11330,8 @@ Change 19.2.4 [length.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class length_error : public logic_error {
+ public:
+ explicit length_error(const string&amp; <i>what_arg</i>);
+@@ -12118,7 +11359,8 @@ Change 19.2.5 [out.of.range]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class out_of_range : public logic_error {
+ public:
+ explicit out_of_range(const string&amp; <i>what_arg</i>);
+@@ -12146,7 +11388,8 @@ Change 19.2.6 [runtime.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class runtime_error : public exception {
+ public:
+ explicit runtime_error(const string&amp; <i>what_arg</i>);
+@@ -12174,7 +11417,8 @@ Change 19.2.7 [range.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class range_error : public runtime_error {
+ public:
+ explicit range_error(const string&amp; <i>what_arg</i>);
+@@ -12202,7 +11446,8 @@ Change 19.2.8 [overflow.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class overflow_error : public runtime_error {
+ public:
+ explicit overflow_error(const string&amp; <i>what_arg</i>);
+@@ -12230,7 +11475,8 @@ Change 19.2.9 [underflow.error]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class underflow_error : public runtime_error {
+ public:
+ explicit underflow_error(const string&amp; <i>what_arg</i>);
+@@ -12254,11 +11500,12 @@ Change 19.2.9 [underflow.error]
+ </blockquote>
+
+ <p>
+-Change 27.5.2.1.1 [ios::failure]
++Change 27.5.3.1.1 [ios::failure]
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class ios_base::failure : public exception {
+ public:
+ explicit failure(const string&amp; <i>msg</i>);
+@@ -12329,10 +11576,10 @@ the need to explicit include or construct a <tt>std::string</tt>.
+
+ <hr>
+ <h3><a name="256"></a>256. typo in 27.4.4.2, p17: copy_event does not exist</h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 27.4.4.2, p17 says
+@@ -12359,10 +11606,11 @@ copyfmt_event.
+
+ <hr>
+ <h3><a name="258"></a>258. Missing allocator requirement</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-08-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-08-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ From lib-7752:
+@@ -12412,9 +11660,9 @@ Given x1 == x2 and x2 == x3, this does not mean x1 == x3.
+
+ <blockquote>
+ <p>
+-x1 can deallocate pointers from: x1, x2, x3 <br>
+-x2 can deallocate pointers from: x1, x2, x4 <br>
+-x3 can deallocate pointers from: x1, x3 <br>
++x1 can deallocate pointers from: x1, x2, x3 <br/>
++x2 can deallocate pointers from: x1, x2, x4 <br/>
++x3 can deallocate pointers from: x1, x3 <br/>
+ x4 can deallocate pointers from: x2, x4
+ </p>
+
+@@ -12468,10 +11716,10 @@ issue to Ready status to be voted into the WP at Kona.
+
+ <hr>
+ <h3><a name="259"></a>259. <tt>basic_string::operator[]</tt> and const correctness</h3>
+-<p><b>Section:</b> 21.4.4 [string.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Chris Newton <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.capacity">issues</a> in [string.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.4 [string.capacity] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Chris Newton <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.capacity">issues</a> in [string.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <i>Paraphrased from a message that Chris Newton posted to comp.std.c++:</i>
+@@ -12483,8 +11731,8 @@ seems to violate const correctness.
+ </p>
+
+ <p>
+-The standard (21.3.4/1) says that "If <tt>pos &lt; size()</tt>,
+-returns <tt>data()[pos]</tt>." The types don't work. The
++The standard (21.3.4/1) says that &quot;If <tt>pos &lt; size()</tt>,
++returns <tt>data()[pos]</tt>.&quot; The types don't work. The
+ return value of <tt>data()</tt> is <tt>const charT*</tt>, but
+ <tt>operator[]</tt> has a non-const version whose return type is <tt>reference</tt>.
+ </p>
+@@ -12493,8 +11741,8 @@ return value of <tt>data()</tt> is <tt>const charT*</tt>, but
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ In section 21.3.4, paragraph 1, change
+-"<tt>data()[<i>pos</i>]</tt>" to "<tt>*(begin() +
+-<i>pos</i>)</tt>".
++&quot;<tt>data()[<i>pos</i>]</tt>&quot; to &quot;<tt>*(begin() +
++<i>pos</i>)</tt>&quot;.
+ </p>
+
+
+@@ -12502,10 +11750,10 @@ In section 21.3.4, paragraph 1, change
+
+ <hr>
+ <h3><a name="260"></a>260. Inconsistent return type of <tt>istream_iterator::operator++(int)</tt></h3>
+-<p><b>Section:</b> 24.6.1.2 [istream.iterator.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator.ops">issues</a> in [istream.iterator.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.6.1.2 [istream.iterator.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator.ops">issues</a> in [istream.iterator.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The synopsis of istream_iterator::operator++(int) in 24.5.1 shows
+ it as returning the iterator by value. 24.5.1.2, p5 shows the same
+@@ -12516,10 +11764,12 @@ given the Effects clause below (since a temporary is returned). The
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change the declaration in 24.5.1.2, p5 from</p>
+- <pre> istream_iterator&lt;T,charT,traits,Distance&gt;&amp; operator++(int);
++ <pre>
++ istream_iterator&lt;T,charT,traits,Distance&gt;&amp; operator++(int);
+ </pre>
+ <p>to</p>
+- <pre> istream_iterator&lt;T,charT,traits,Distance&gt; operator++(int);
++ <pre>
++ istream_iterator&lt;T,charT,traits,Distance&gt; operator++(int);
+ </pre>
+ <p>(that is, remove the `&amp;').</p>
+
+@@ -12528,16 +11778,17 @@ given the Effects clause below (since a temporary is returned). The
+
+ <hr>
+ <h3><a name="261"></a>261. Missing description of <tt>istream_iterator::operator!=</tt></h3>
+-<p><b>Section:</b> 24.6.1.2 [istream.iterator.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator.ops">issues</a> in [istream.iterator.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.6.1.2 [istream.iterator.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator.ops">issues</a> in [istream.iterator.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 24.5.1, p3 lists the synopsis for
+ </p>
+
+-<pre> template &lt;class T, class charT, class traits, class Distance&gt;
++<pre>
++ template &lt;class T, class charT, class traits, class Distance&gt;
+ bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
+ const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
+ </pre>
+@@ -12553,7 +11804,8 @@ or Returns clause) in 24.5.1.2.
+ Add paragraph 7 to the end of section 24.5.1.2 with the following text:
+ </p>
+
+-<pre> template &lt;class T, class charT, class traits, class Distance&gt;
++<pre>
++ template &lt;class T, class charT, class traits, class Distance&gt;
+ bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
+ const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
+ </pre>
+@@ -12565,10 +11817,10 @@ Add paragraph 7 to the end of section 24.5.1.2 with the following text:
+
+ <hr>
+ <h3><a name="262"></a>262. Bitmask operator ~ specified incorrectly</h3>
+-<p><b>Section:</b> 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2000-09-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitmask.types">issues</a> in [bitmask.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2000-09-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitmask.types">issues</a> in [bitmask.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The ~ operation should be applied after the cast to int_type.
+@@ -12580,7 +11832,8 @@ The ~ operation should be applied after the cast to int_type.
+ Change 17.3.2.1.2 [lib.bitmask.types] operator~ from:
+ </p>
+
+-<pre> bitmask operator~ ( bitmask X )
++<pre>
++ bitmask operator~ ( bitmask X )
+ { return static_cast&lt; bitmask&gt;(static_cast&lt;int_type&gt;(~ X)); }
+ </pre>
+
+@@ -12588,7 +11841,8 @@ Change 17.3.2.1.2 [lib.bitmask.types] operator~ from:
+ to:
+ </p>
+
+-<pre> bitmask operator~ ( bitmask X )
++<pre>
++ bitmask operator~ ( bitmask X )
+ { return static_cast&lt; bitmask&gt;(~static_cast&lt;int_type&gt;(X)); }
+ </pre>
+
+@@ -12597,16 +11851,17 @@ to:
+
+ <hr>
+ <h3><a name="263"></a>263. Severe restriction on <tt>basic_string</tt> reference counting</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Kevlin Henney <b>Opened:</b> 2000-09-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Kevlin Henney <b>Opened:</b> 2000-09-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The note in paragraph 6 suggests that the invalidation rules for
+ references, pointers, and iterators in paragraph 5 permit a reference-
+ counted implementation (actually, according to paragraph 6, they permit
+-a "reference counted implementation", but this is a minor editorial fix).
++a &quot;reference counted implementation&quot;, but this is a minor editorial fix).
+ </p>
+
+ <p>
+@@ -12615,8 +11870,9 @@ implementation unviable. In the following example none of the
+ conditions for iterator invalidation are satisfied:
+ </p>
+
+-<pre> // first example: "*******************" should be printed twice
+- string original = "some arbitrary text", copy = original;
++<pre>
++ // first example: &quot;*******************&quot; should be printed twice
++ string original = &quot;some arbitrary text&quot;, copy = original;
+ const string &amp; alias = original;
+
+ string::const_iterator i = alias.begin(), e = alias.end();
+@@ -12632,8 +11888,9 @@ conditions for iterator invalidation are satisfied:
+ Similarly, in the following example:
+ </p>
+
+-<pre> // second example: "some arbitrary text" should be printed out
+- string original = "some arbitrary text", copy = original;
++<pre>
++ // second example: &quot;some arbitrary text&quot; should be printed out
++ string original = &quot;some arbitrary text&quot;, copy = original;
+ const string &amp; alias = original;
+
+ string::const_iterator i = alias.begin();
+@@ -12645,7 +11902,7 @@ Similarly, in the following example:
+ <p>
+ I have tested this on three string implementations, two of which were
+ reference counted. The reference-counted implementations gave
+-"surprising behavior" because they invalidated iterators on
++&quot;surprising behavior&quot; because they invalidated iterators on
+ the first call to non-const begin since construction. The current
+ wording does not permit such invalidation because it does not take
+ into account the first call since construction, only the first call
+@@ -12678,12 +11935,12 @@ Change the following sentence in 21.3 paragraph 5 from
+
+ <hr>
+ <h3><a name="264"></a>264. Associative container <tt>insert(i, j)</tt> complexity requirements are not feasible.</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> John Potter <b>Opened:</b> 2000-09-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#102">102</a></p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> John Potter <b>Opened:</b> 2000-09-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#102">102</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 69 requires linear time if [i, j) is sorted. Sorted is necessary but not sufficient.
+@@ -12691,16 +11948,16 @@ Consider inserting a sorted range of even integers into a set&lt;int&gt; contain
+ integers in the same range.
+ </p>
+
+-<p><i>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#102">102</a></i></p>
++<p><i>Related issue: <a href="lwg-closed.html#102">102</a></i></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ In Table 69, in section 23.1.2, change the complexity clause for
+-insertion of a range from "N log(size() + N) (N is the distance
++insertion of a range from &quot;N log(size() + N) (N is the distance
+ from i to j) in general; linear if [i, j) is sorted according to
+-value_comp()" to "N log(size() + N), where N is the distance
+-from i to j".
++value_comp()&quot; to &quot;N log(size() + N), where N is the distance
++from i to j&quot;.
+ </p>
+
+ <p><i>[Copenhagen: Minor fix in proposed resolution: fixed unbalanced
+@@ -12733,10 +11990,10 @@ linear in some special cases.
+
+ <hr>
+ <h3><a name="265"></a>265. std::pair::pair() effects overly restrictive</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-09-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-09-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I don't see any requirements on the types of the elements of the
+@@ -12783,9 +12040,9 @@ the straightforward implementation is correct.</p>
+
+ <hr>
+ <h3><a name="266"></a>266. bad_exception::~bad_exception() missing Effects clause</h3>
+-<p><b>Section:</b> 18.8.2 [bad.exception] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.8.2 [bad.exception] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The synopsis for std::bad_exception lists the function ~bad_exception()
+@@ -12818,10 +12075,10 @@ described in clause 19.
+
+ <hr>
+ <h3><a name="268"></a>268. Typo in locale synopsis</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-10-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The synopsis of the class std::locale in 22.1.1 contains two typos:
+ the semicolons after the declarations of the default ctor
+@@ -12832,14 +12089,16 @@ are missing.</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>Add the missing semicolons, i.e., change</p>
+
+-<pre> // construct/copy/destroy:
++<pre>
++ // construct/copy/destroy:
+ locale() throw()
+ locale(const locale&amp; other) throw()
+ </pre>
+
+ <p>in the synopsis in 22.1.1 to</p>
+
+-<pre> // construct/copy/destroy:
++<pre>
++ // construct/copy/destroy:
+ locale() throw();
+ locale(const locale&amp; other) throw();
+ </pre>
+@@ -12849,11 +12108,11 @@ are missing.</p>
+
+ <hr>
+ <h3><a name="270"></a>270. Binary search requirements overly strict</h3>
+-<p><b>Section:</b> 25.4.3 [alg.binary.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-10-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.binary.search">issues</a> in [alg.binary.search].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#472">472</a></p>
++<p><b>Section:</b> 25.4.3 [alg.binary.search] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.binary.search">issues</a> in [alg.binary.search].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#472">472</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Each of the four binary search algorithms (lower_bound, upper_bound,
+@@ -12869,7 +12128,8 @@ large record with an integer key. We might reasonably want to look
+ up a record by key, in which case we would want to write something
+ like this:
+ </p>
+-<pre> struct key_comp {
++<pre>
++ struct key_comp {
+ bool operator()(const X&amp; x, int n) const {
+ return x.key() &lt; n;
+ }
+@@ -13064,7 +12324,8 @@ The proposed resolution is based on that alternative formulation.</li>
+
+ <p>to:</p>
+
+-<pre> -2- Returns:
++<pre>
++ -2- Returns:
+ make_pair(lower_bound(first, last, value),
+ upper_bound(first, last, value))
+ or
+@@ -13116,9 +12377,9 @@ part of that pair is the lower bound.</p>
+
+ <hr>
+ <h3><a name="271"></a>271. basic_iostream missing typedefs</h3>
+-<p><b>Section:</b> 27.7.1.5 [iostreamclass] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.5 [iostreamclass] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Class template basic_iostream has no typedefs. The typedefs it
+@@ -13130,9 +12391,10 @@ basic_iostream&lt;T&gt;::traits_type is ambiguous.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>Add the following to basic_iostream's class synopsis in
+-27.7.1.5 [iostreamclass], immediately after <tt>public</tt>:</p>
++27.7.2.5 [iostreamclass], immediately after <tt>public</tt>:</p>
+
+-<pre> // types:
++<pre>
++ // types:
+ typedef charT char_type;
+ typedef typename traits::int_type int_type;
+ typedef typename traits::pos_type pos_type;
+@@ -13145,11 +12407,11 @@ basic_iostream&lt;T&gt;::traits_type is ambiguous.
+
+ <hr>
+ <h3><a name="272"></a>272. Missing parentheses around subexpression</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#569">569</a></p>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#569">569</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 27.4.4.3, p4 says about the postcondition of the function: If
+@@ -13174,10 +12436,10 @@ Add parentheses like so: rdstate()==(state|ios_base::badbit).
+
+ <hr>
+ <h3><a name="273"></a>273. Missing ios_base qualification on members of a dependent class</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.5.2.4.2, p4, and 27.8.1.6, p2, 27.8.1.7, p3, 27.8.1.9, p2,
+ 27.8.1.10, p3 refer to in and/or out w/o ios_base:: qualification.
+@@ -13194,10 +12456,11 @@ members, i.e., ios_base.</p>
+
+ <hr>
+ <h3><a name="274"></a>274. a missing/impossible allocator requirement</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I see that table 31 in 20.1.5, p3 allows T in std::allocator&lt;T&gt; to be of
+@@ -13254,7 +12517,7 @@ The original text for proposed resolution 2 was modified so that it
+ also forbids volatile types and reference types.
+ </p>
+
+-<p><i>[Curaçao: LWG double checked and believes volatile is correctly
++<p><i>[Cura&ccedil;ao: LWG double checked and believes volatile is correctly
+ excluded from the PR.]</i></p>
+
+
+@@ -13265,10 +12528,10 @@ excluded from the PR.]</i></p>
+
+ <hr>
+ <h3><a name="275"></a>275. Wrong type in num_get::get() overloads</h3>
+-<p><b>Section:</b> 22.4.2.1.1 [facet.num.get.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.members">issues</a> in [facet.num.get.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.1 [facet.num.get.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2000-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.members">issues</a> in [facet.num.get.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 22.2.2.1.1, we have a list of overloads for num_get&lt;&gt;::get().
+@@ -13311,11 +12574,13 @@ the arguments it was given.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 22.4.2.1.1 [facet.num.get.members], change</p>
+-<pre> iter_type get(iter_type in, iter_type end, ios_base&amp; str,
++<pre>
++ iter_type get(iter_type in, iter_type end, ios_base&amp; str,
+ ios_base::iostate&amp; err, short&amp; val) const;
+ </pre>
+ <p>to</p>
+-<pre> iter_type get(iter_type in, iter_type end, ios_base&amp; str,
++<pre>
++ iter_type get(iter_type in, iter_type end, ios_base&amp; str,
+ ios_base::iostate&amp; err, float&amp; val) const;
+ </pre>
+
+@@ -13324,14 +12589,15 @@ the arguments it was given.
+
+ <hr>
+ <h3><a name="276"></a>276. Assignable requirement for container value type overly strict</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2000-11-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2000-11-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 23.1/3 states that the objects stored in a container must be
+-Assignable. 23.6.1 [map], paragraph 2,
++Assignable. 23.4.4 [map], paragraph 2,
+ states that map satisfies all requirements for a container, while in
+ the same time defining value_type as pair&lt;const Key, T&gt; - a type
+ that is not Assignable.
+@@ -13340,8 +12606,8 @@ that is not Assignable.
+ <p>
+ It should be noted that there exists a valid and non-contradictory
+ interpretation of the current text. The wording in 23.1/3 avoids
+-mentioning value_type, referring instead to "objects stored in a
+-container." One might argue that map does not store objects of
++mentioning value_type, referring instead to &quot;objects stored in a
++container.&quot; One might argue that map does not store objects of
+ type map::value_type, but of map::mapped_type instead, and that the
+ Assignable requirement applies to map::mapped_type, not
+ map::value_type.
+@@ -13355,14 +12621,14 @@ general.
+
+ <p>
+ For example, the proposed resolution of active library issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#103">103</a> is to make set::iterator a constant iterator; this
++<a href="lwg-defects.html#103">103</a> is to make set::iterator a constant iterator; this
+ means that no set operations can exploit the fact that the stored
+ objects are Assignable.
+ </p>
+
+ <p>
+ This is related to, but slightly broader than, closed issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#140">140</a>.
++<a href="lwg-closed.html#140">140</a>.
+ </p>
+
+
+@@ -13424,7 +12690,8 @@ following methods are instantiated:
+ [Footnote: Implementors are permitted but not required to take advantage
+ of T's Assignable properties for these methods. -- end foonote]
+ </p>
+-<pre> list&lt;T,Allocator&gt;&amp; operator=(const list&lt;T,Allocator&gt;&amp; x );
++<pre>
++ list&lt;T,Allocator&gt;&amp; operator=(const list&lt;T,Allocator&gt;&amp; x );
+ template &lt;class InputIterator&gt;
+ void assign(InputIterator first, InputIterator last);
+ void assign(size_type n, const T&amp; t);
+@@ -13462,7 +12729,7 @@ to forbid such implementations.</p>
+
+ <p>Note that the type stored in a standard container must still satisfy
+ the requirements of the container's allocator; this rules out, for
+-example, such types as "const int". See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#274">274</a>
++example, such types as "const int". See issue <a href="lwg-defects.html#274">274</a>
+ for more details.
+ </p>
+
+@@ -13479,22 +12746,23 @@ implement <tt>vector::push_back</tt> in terms of
+
+ <hr>
+ <h3><a name="278"></a>278. What does iterator validity mean?</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Section 23.3.4.4 [list.ops] states that
++Section 23.3.5.5 [list.ops] states that
+ </p>
+-<pre> void splice(iterator position, list&lt;T, Allocator&gt;&amp; x);
++<pre>
++ void splice(iterator position, list&lt;T, Allocator&gt;&amp; x);
+ </pre>
+ <p>
+ <i>invalidates</i> all iterators and references to list <tt>x</tt>.
+ </p>
+
+ <p>
+-But what does the C++ Standard mean by "invalidate"? You
++But what does the C++ Standard mean by &quot;invalidate&quot;? You
+ can still dereference the iterator to a spliced list element, but
+ you'd better not use it to delimit a range within the original
+ list. For the latter operation, it has definitely lost some of its
+@@ -13502,13 +12770,13 @@ validity.
+ </p>
+
+ <p>
+-If we accept the proposed resolution to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#250">250</a>,
+-then we'd better clarify that a "valid" iterator need no
++If we accept the proposed resolution to issue <a href="lwg-defects.html#250">250</a>,
++then we'd better clarify that a &quot;valid&quot; iterator need no
+ longer designate an element within the same container as it once did.
+ We then have to clarify what we mean by invalidating a past-the-end
+ iterator, as when a vector or string grows by reallocation. Clearly,
+ such an iterator has a different kind of validity. Perhaps we should
+-introduce separate terms for the two kinds of "validity."
++introduce separate terms for the two kinds of &quot;validity.&quot;
+ </p>
+
+
+@@ -13549,30 +12817,31 @@ the wording. Dave provided new wording.]</i></p>
+
+ <hr>
+ <h3><a name="280"></a>280. Comparison of reverse_iterator to const reverse_iterator</h3>
+-<p><b>Section:</b> 24.5.1 [reverse.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.1 [reverse.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve Cleary <b>Opened:</b> 2000-11-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iterators">issues</a> in [reverse.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This came from an email from Steve Cleary to Fergus in reference to
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#179">179</a>. The library working group briefly discussed
++issue <a href="lwg-defects.html#179">179</a>. The library working group briefly discussed
+ this in Toronto and believed it should be a separate issue. There was
+ also some reservations about whether this was a worthwhile problem to
+ fix.
+ </p>
+
+ <p>
+-Steve said: "Fixing reverse_iterator. std::reverse_iterator can
++Steve said: &quot;Fixing reverse_iterator. std::reverse_iterator can
+ (and should) be changed to preserve these additional
+-requirements." He also said in email that it can be done without
+-breaking user's code: "If you take a look at my suggested
++requirements.&quot; He also said in email that it can be done without
++breaking user's code: &quot;If you take a look at my suggested
+ solution, reverse_iterator doesn't have to take two parameters; there
+ is no danger of breaking existing code, except someone taking the
+ address of one of the reverse_iterator global operator functions, and
+ I have to doubt if anyone has ever done that. . . <i>But</i>, just in
+ case they have, you can leave the old global functions in as well --
+ they won't interfere with the two-template-argument functions. With
+-that, I don't see how <i>any</i> user code could break."
++that, I don't see how <i>any</i> user code could break.&quot;
+ </p>
+
+
+@@ -13580,7 +12849,8 @@ that, I don't see how <i>any</i> user code could break."
+ <p>
+ <b>Section:</b> 24.5.1.1 [reverse.iterator]
+ add/change the following declarations:</p>
+-<pre> A) Add a templated assignment operator, after the same manner
++<pre>
++ A) Add a templated assignment operator, after the same manner
+ as the templated copy constructor, i.e.:
+
+ template &lt; class U &gt;
+@@ -13629,15 +12899,15 @@ this solution is safe and correct.
+
+ <hr>
+ <h3><a name="281"></a>281. std::min() and max() requirements overly restrictive</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#486">486</a></p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#486">486</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The requirements in 25.3.7, p1 and 4 call for T to satisfy the
+ requirements of <tt>LessThanComparable</tt> ( [lessthancomparable])
+-and <tt>CopyConstructible</tt> (20.2.1 [utility.arg.requirements]).
++and <tt>CopyConstructible</tt> (17.6.3.1 [utility.arg.requirements]).
+ Since the functions take and return their arguments and result by
+ const reference, I believe the <tt>CopyConstructible</tt> requirement
+ is unnecessary.
+@@ -13660,10 +12930,10 @@ is unnecessary.
+
+ <hr>
+ <h3><a name="282"></a>282. What types does numpunct grouping refer to?</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2000-12-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2000-12-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 16 mistakenly singles out integral types for inserting
+@@ -13708,7 +12978,7 @@ standard.
+ ]</i></p>
+
+
+-<p><i>[Post-Curaçao: the above proposed resolution is the consensus of
++<p><i>[Post-Cura&ccedil;ao: the above proposed resolution is the consensus of
+ Howard, Bill, Pete, Benjamin, Nathan, Dietmar, Boris, and Martin.]</i></p>
+
+
+@@ -13718,11 +12988,11 @@ Howard, Bill, Pete, Benjamin, Nathan, Dietmar, Boris, and Martin.]</i></p>
+
+ <hr>
+ <h3><a name="283"></a>283. std::replace() requirement incorrect/insufficient</h3>
+-<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#483">483</a></p>
++<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#483">483</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ (revision of the further discussion)
+@@ -13880,15 +13150,17 @@ imposing a greater restriction that what the standard currently says
+
+ <hr>
+ <h3><a name="284"></a>284. unportable example in 20.3.7, p6</h3>
+-<p><b>Section:</b> 20.8.6 [comparisons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.6 [comparisons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#comparisons">active issues</a> in [comparisons].</p>
++<p><b>View all other</b> <a href="lwg-index.html#comparisons">issues</a> in [comparisons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The example in 20.8.6 [comparisons], p6 shows how to use the C
++<p>The example in 20.9.6 [comparisons], p6 shows how to use the C
+ library function <tt>strcmp()</tt> with the function pointer adapter
+ <tt>ptr_fun()</tt>. But since it's unspecified whether the C library
+-functions have <tt>extern "C"</tt> or <tt>extern
+-"C++"</tt> linkage [17.6.2.3 [using.linkage]], and since
++functions have <tt>extern &quot;C&quot;</tt> or <tt>extern
++&quot;C++&quot;</tt> linkage [17.6.2.3 [using.linkage]], and since
+ function pointers with different the language linkage specifications
+ (7.5 [dcl.link]) are incompatible, whether this example is
+ well-formed is unspecified.
+@@ -13896,10 +13168,11 @@ well-formed is unspecified.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 20.8.6 [comparisons] paragraph 6 from:</p>
++<p>Change 20.9.6 [comparisons] paragraph 6 from:</p>
+ <blockquote>
+ <p>[<i>Example:</i></p>
+- <pre> replace_if(v.begin(), v.end(), not1(bind2nd(ptr_fun(strcmp), "C")), "C++");
++ <pre>
++ replace_if(v.begin(), v.end(), not1(bind2nd(ptr_fun(strcmp), "C")), "C++");
+ </pre>
+ <p>replaces each <tt>C</tt> with <tt>C++</tt> in sequence <tt>v</tt>.</p>
+ </blockquote>
+@@ -13908,7 +13181,8 @@ well-formed is unspecified.
+ <p>to:</p>
+ <blockquote>
+ <p>[<i>Example:</i></p>
+- <pre> int compare(const char*, const char*);
++ <pre>
++ int compare(const char*, const char*);
+ replace_if(v.begin(), v.end(),
+ not1(bind2nd(ptr_fun(compare), "abc")), "def");
+ </pre>
+@@ -13935,9 +13209,9 @@ it corresponds to the new code fragment.]</i></p>
+
+ <hr>
+ <h3><a name="285"></a>285. minor editorial errors in fstream ctors</h3>
+-<p><b>Section:</b> 27.9.1.7 [ifstream.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.7 [ifstream.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2000-12-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.9.1.7 [ifstream.cons], p2, 27.9.1.11 [ofstream.cons], p2, and
+ 27.9.1.15 [fstream.cons], p2 say about the effects of each constructor:
+@@ -13948,7 +13222,7 @@ it corresponds to the new code fragment.]</i></p>
+ </p>
+
+ <p>The parenthetical note doesn't apply since the ctors cannot throw an
+-exception due to the requirement in 27.5.4.1 [basic.ios.cons], p3
++exception due to the requirement in 27.5.5.2 [basic.ios.cons], p3
+ that <tt>exceptions()</tt> be initialized to <tt>ios_base::goodbit</tt>.
+ </p>
+
+@@ -13964,10 +13238,10 @@ paragraphs mentioned above.
+
+ <hr>
+ <h3><a name="286"></a>286. &lt;cstdlib&gt; requirements missing size_t typedef</h3>
+-<p><b>Section:</b> 25.5 [alg.c.library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.c.library">issues</a> in [alg.c.library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.5 [alg.c.library] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.c.library">issues</a> in [alg.c.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The &lt;cstdlib&gt; header file contains prototypes for bsearch and
+@@ -13994,14 +13268,14 @@ the type size_t &lt;cstdlib&gt; to Table 97 (section C.2).
+
+ <hr>
+ <h3><a name="288"></a>288. &lt;cerrno&gt; requirements missing macro EILSEQ</h3>
+-<p><b>Section:</b> 19.4 [errno] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 19.4 [errno] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Judy Ward <b>Opened:</b> 2000-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-ISO/IEC 9899:1990/Amendment1:1994 Section 4.3 States: "The list
++ISO/IEC 9899:1990/Amendment1:1994 Section 4.3 States: &quot;The list
+ of macros defined in &lt;errno.h&gt; is adjusted to include a new
+-macro, EILSEQ"
++macro, EILSEQ&quot;
+ </p>
+
+ <p>
+@@ -14013,8 +13287,8 @@ to the above amendment.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Update Table 26 (section 19.3) "Header &lt;cerrno&gt; synopsis"
+-and Table 95 (section C.2) "Standard Macros" to include EILSEQ.
++Update Table 26 (section 19.3) &quot;Header &lt;cerrno&gt; synopsis&quot;
++and Table 95 (section C.2) &quot;Standard Macros&quot; to include EILSEQ.
+ </p>
+
+
+@@ -14023,10 +13297,10 @@ and Table 95 (section C.2) "Standard Macros" to include EILSEQ.
+
+ <hr>
+ <h3><a name="291"></a>291. Underspecification of set algorithms</h3>
+-<p><b>Section:</b> 25.4.5 [alg.set.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-01-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.set.operations">issues</a> in [alg.set.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.5 [alg.set.operations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-01-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.set.operations">issues</a> in [alg.set.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard library contains four algorithms that compute set
+@@ -14040,7 +13314,7 @@ in the output range are sorted.
+ <p>
+ The ordinary mathematical definitions are generalized so that they
+ apply to ranges containing multiple copies of a given element. Two
+-elements are considered to be "the same" if, according to an
++elements are considered to be &quot;the same&quot; if, according to an
+ ordering relation provided by the user, neither one is less than the
+ other. So, for example, if one input range contains five copies of an
+ element and another contains three, the output range of <tt>set_union</tt>
+@@ -14051,7 +13325,7 @@ will contain five copies, the output range of
+ </p>
+
+ <p>
+-Because two elements can be "the same" for the purposes
++Because two elements can be &quot;the same&quot; for the purposes
+ of these set algorithms, without being identical in other respects
+ (consider, for example, strings under case-insensitive comparison),
+ this raises a number of unanswered questions:
+@@ -14139,10 +13413,10 @@ m</i> of these elements from [first2, last2) if <i>m</i> &lt; <i>n</i>.
+
+ <hr>
+ <h3><a name="292"></a>292. effects of a.copyfmt (a)</h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The Effects clause of the member function <tt>copyfmt()</tt> in
+ 27.4.4.2, p15 doesn't consider the case where the left-hand side
+@@ -14178,17 +13452,18 @@ objects of <tt>rhs</tt>, except that...
+
+ <hr>
+ <h3><a name="294"></a>294. User defined macros and standard headers</h3>
+-<p><b>Section:</b> 17.6.3.3.1 [macro.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2001-01-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#macro.names">issues</a> in [macro.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.3.1 [macro.names] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2001-01-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#macro.names">issues</a> in [macro.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Paragraph 2 of 17.6.3.3.1 [macro.names] reads: "A
++<p>Paragraph 2 of 17.6.4.3.1 [macro.names] reads: &quot;A
+ translation unit that includes a header shall not contain any macros
+-that define names declared in that header." As I read this, it
++that define names declared in that header.&quot; As I read this, it
+ would mean that the following program is legal:</p>
+
+-<pre> #define npos 3.14
++<pre>
++ #define npos 3.14
+ #include &lt;sstream&gt;
+ </pre>
+
+@@ -14199,12 +13474,12 @@ which &lt;sstream&gt; didn't include &lt;string&gt;.</p>
+ <p>I think that this phrase was probably formulated before it was
+ decided that a standard header may freely include other standard
+ headers. The phrase would be perfectly appropriate for C, for
+-example. In light of 17.6.4.2 [res.on.headers] paragraph 1, however,
++example. In light of 17.6.5.2 [res.on.headers] paragraph 1, however,
+ it isn't stringent enough.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>For 17.6.3.3.1 [macro.names], replace the current wording, which reads:</p>
++<p>For 17.6.4.3.1 [macro.names], replace the current wording, which reads:</p>
+ <blockquote>
+ <p>Each name defined as a macro in a header is reserved to the
+ implementation for any use if the translation unit includes
+@@ -14238,10 +13513,11 @@ it isn't stringent enough.</p>
+
+ <hr>
+ <h3><a name="295"></a>295. Is abs defined in &lt;cmath&gt;?</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2001-01-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2001-01-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 80 lists the contents of the &lt;cmath&gt; header. It does not
+@@ -14268,7 +13544,7 @@ rid of that vestigial list of functions in paragraph 1.]</i></p>
+ <p>All this DR does is fix a typo; it's uncontroversial. A
+ separate question is whether we're doing the right thing in
+ putting some overloads in &lt;cmath&gt; that we aren't also
+-putting in &lt;cstdlib&gt;. That's issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#323">323</a>.</p>
++putting in &lt;cstdlib&gt;. That's issue <a href="lwg-closed.html#323">323</a>.</p>
+
+
+
+@@ -14276,12 +13552,12 @@ putting in &lt;cstdlib&gt;. That's issue <a href="http://www.open-std.org/jtc1/
+
+ <hr>
+ <h3><a name="296"></a>296. Missing descriptions and requirements of pair operators</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The synopsis of the header <tt>&lt;utility&gt;</tt> in 20.3 [utility]
++<p>The synopsis of the header <tt>&lt;utility></tt> in 20.2 [utility]
+ lists the complete set of equality and relational operators for <tt>pair</tt>
+ but the section describing the template and the operators only describes
+ <tt>operator==()</tt> and <tt>operator&lt;()</tt>, and it fails to mention
+@@ -14306,7 +13582,7 @@ precedes <tt>pair</tt> in the document this is an easy connection to make.
+ Reading the current working paper I make two observations:
+ </p>
+
+-<ol type="i">
++<ol style="list-style-type:lower-roman">
+ <li>
+ relops no longer immediately precedes <tt>pair</tt> in the order of
+ specification. However, even if it did, there is a lot of <tt>pair</tt>
+@@ -14323,7 +13599,8 @@ manner that could have deferred to the relops clause.
+ </li>
+ </ol>
+
+-<blockquote><pre>tuple
++<blockquote><pre>
++tuple
+ unique_ptr
+ duration
+ time_point
+@@ -14369,7 +13646,7 @@ with the rest of the library.
+ </blockquote>
+
+ <p><i>[
+-2009-10-11 Daniel opens <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1233">1233</a> which deals with the same issue as
++2009-10-11 Daniel opens <a href="lwg-closed.html#1233">1233</a> which deals with the same issue as
+ it pertains to <tt>unique_ptr</tt>.
+ ]</i></p>
+
+@@ -14379,56 +13656,60 @@ it pertains to <tt>unique_ptr</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-After p20 20.3.5 [pairs] add:
++After p20 20.3 [pairs] add:
+ </p>
+
+-<blockquote><pre>template &lt;class T1, class T2&gt;
++<blockquote><pre>
++template &lt;class T1, class T2&gt;
+ bool operator!=(const pair&lt;T1,T2&gt;&amp; x, const pair&lt;T1,T2&gt;&amp; y);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>!(x==y)</tt>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class T1, class T2&gt;
++<pre>
++template &lt;class T1, class T2&gt;
+ bool operator&gt; (const pair&lt;T1,T2&gt;&amp; x, const pair&lt;T1,T2&gt;&amp; y);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>y &lt; x</tt>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class T1, class T2&gt;
++<pre>
++template &lt;class T1, class T2&gt;
+ bool operator&gt;=(const pair&lt;T1,T2&gt;&amp; x, const pair&lt;T1,T2&gt;&amp; y);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>!(x &lt; y)</tt>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class T1, class T2&gt;
++<pre>
++template &lt;class T1, class T2&gt;
+ bool operator&lt;=(const pair&lt;T1,T2&gt;&amp; x, const pair&lt;T1,T2&gt;&amp; y);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>!(y &lt; x)</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+ <p><b>Rationale:</b></p>
+-<p>20.3.1 [operators] paragraph 10 already specifies the semantics.
++<p>20.2.1 [operators] paragraph 10 already specifies the semantics.
+ That paragraph says that, if declarations of operator!=, operator&gt;,
+ operator&lt;=, and operator&gt;= appear without definitions, they are
+-defined as specified in 20.3.1 [operators]. There should be no user
++defined as specified in 20.2.1 [operators]. There should be no user
+ confusion, since that paragraph happens to immediately precede the
+ specification of <tt>pair</tt>.</p>
+
+@@ -14438,15 +13719,15 @@ specification of <tt>pair</tt>.</p>
+
+ <hr>
+ <h3><a name="297"></a>297. const_mem_fun_t&lt;&gt;::argument_type should be const T*</h3>
+-<p><b>Section:</b> 20.8.7 [logical.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.7 [logical.operations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The class templates <tt>const_mem_fun_t</tt> in 20.5.8, p8 and
+ <tt>const_mem_fun1_t</tt>
+-in 20.5.8, p9 derive from <tt>unary_function&lt;T*, S&gt;</tt>, and
++in 20.5.8, p9 derive from <tt>unary_function&lt;T*, S></tt>, and
+ <tt>binary_function&lt;T*,
+-A, S&gt;</tt>, respectively. Consequently, their <tt>argument_type</tt>, and
++A, S></tt>, respectively. Consequently, their <tt>argument_type</tt>, and
+ <tt>first_argument_type</tt>
+ members, respectively, are both defined to be <tt>T*</tt> (non-const).
+ However, their function call member operator takes a <tt>const T*</tt>
+@@ -14456,31 +13737,31 @@ example below derived from existing code fails to compile due to the
+ discrepancy:
+ </p>
+
+-<p><tt>template &lt;class T&gt;</tt>
+-<br><tt>void foo (typename T::argument_type arg)&nbsp;&nbsp; // #1</tt>
+-<br><tt>{</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp; typename T::result_type (T::*pf) (typename
++<p><tt>template &lt;class T></tt>
++<br/><tt>void foo (typename T::argument_type arg)&nbsp;&nbsp; // #1</tt>
++<br/><tt>{</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp; typename T::result_type (T::*pf) (typename
+ T::argument_type)
+ const =&nbsp;&nbsp; // #2</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &amp;T::operator();</tt>
+-<br><tt>}</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &amp;T::operator();</tt>
++<br/><tt>}</tt>
+ </p>
+
+ <p><tt>struct X { /* ... */ };</tt></p>
+
+ <p><tt>int main ()</tt>
+-<br><tt>{</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp; const X x;</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp; foo&lt;std::const_mem_fun_t&lt;void, X&gt;
+-&gt;(&amp;x);&nbsp;&nbsp;
++<br/><tt>{</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp; const X x;</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp; foo&lt;std::const_mem_fun_t&lt;void, X>
++>(&amp;x);&nbsp;&nbsp;
+ // #3</tt>
+-<br><tt>}</tt>
++<br/><tt>}</tt>
+ </p>
+
+ <p>#1 <tt>foo()</tt> takes a plain unqualified <tt>X*</tt> as an argument
+-<br>#2 the type of the pointer is incompatible with the type of the member
++<br/>#2 the type of the pointer is incompatible with the type of the member
+ function
+-<br>#3 the address of a constant being passed to a function taking a non-const
++<br/>#3 the address of a constant being passed to a function taking a non-const
+ <tt>X*</tt>
+ </p>
+
+@@ -14489,25 +13770,25 @@ function
+ <p>Replace the top portion of the definition of the class template
+ const_mem_fun_t in 20.5.8, p8
+ </p>
+-<p><tt>template &lt;class S, class T&gt; class const_mem_fun_t</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
+-unary_function&lt;T*, S&gt; {</tt>
++<p><tt>template &lt;class S, class T> class const_mem_fun_t</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
++unary_function&lt;T*, S> {</tt>
+ </p>
+ <p>with</p>
+-<p><tt>template &lt;class S, class T&gt; class const_mem_fun_t</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
+-unary_function&lt;<b>const</b> T*, S&gt; {</tt>
++<p><tt>template &lt;class S, class T> class const_mem_fun_t</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
++unary_function&lt;<b>const</b> T*, S> {</tt>
+ </p>
+ <p>Also replace the top portion of the definition of the class template
+ const_mem_fun1_t in 20.5.8, p9</p>
+-<p><tt>template &lt;class S, class T, class A&gt; class const_mem_fun1_t</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
+-binary_function&lt;T*, A, S&gt; {</tt>
++<p><tt>template &lt;class S, class T, class A> class const_mem_fun1_t</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
++binary_function&lt;T*, A, S> {</tt>
+ </p>
+ <p>with</p>
+-<p><tt>template &lt;class S, class T, class A&gt; class const_mem_fun1_t</tt>
+-<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
+-binary_function&lt;<b>const</b> T*, A, S&gt; {</tt>
++<p><tt>template &lt;class S, class T, class A> class const_mem_fun1_t</tt>
++<br/><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; : public
++binary_function&lt;<b>const</b> T*, A, S> {</tt>
+ </p>
+
+
+@@ -14521,9 +13802,9 @@ and the argument type itself, are not the same.</p>
+
+ <hr>
+ <h3><a name="298"></a>298. ::operator delete[] requirement incorrect/insufficient</h3>
+-<p><b>Section:</b> 18.6.1.2 [new.delete.array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> John A. Pedretti <b>Opened:</b> 2001-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.6.1.2 [new.delete.array] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> John A. Pedretti <b>Opened:</b> 2001-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The default behavior of <tt>operator delete[]</tt> described in 18.5.1.2, p12 -
+@@ -14549,7 +13830,7 @@ For a null value of <i><tt>ptr</tt></i> , does nothing.
+ Any other value of <i><tt>ptr</tt></i> shall be a value returned
+ earlier by a call to the default <tt>operator new[](std::size_t)</tt>.
+ [Footnote: The value must not have been invalidated by an intervening
+-call to <tt>operator delete[](void*)</tt> (17.6.3.9 [res.on.arguments]).
++call to <tt>operator delete[](void*)</tt> (17.6.4.9 [res.on.arguments]).
+ --- end footnote]
+ For such a non-null value of <i><tt>ptr</tt></i> , reclaims storage
+ allocated by the earlier call to the default <tt>operator new[]</tt>.
+@@ -14571,13 +13852,13 @@ or <tt>operator delete(<i>ptr</i>, std::nothrow)</tt> respectively.
+
+ <hr>
+ <h3><a name="300"></a>300. list::merge() specification incomplete</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> John Pedretti <b>Opened:</b> 2001-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> John Pedretti <b>Opened:</b> 2001-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The "Effects" clause for list::merge() (23.3.4.4 [list.ops], p23)
++The &quot;Effects&quot; clause for list::merge() (23.3.5.5 [list.ops], p23)
+ appears to be incomplete: it doesn't cover the case where the argument
+ list is identical to *this (i.e., this == &amp;x). The requirement in the
+ note in p24 (below) is that x be empty after the merge which is surely
+@@ -14586,7 +13867,7 @@ unintended in this case.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 23.3.4.4 [list.ops], replace paragraps 23-25 with:</p>
++<p>In 23.3.5.5 [list.ops], replace paragraps 23-25 with:</p>
+ <blockquote>
+ <p>
+ 23 Effects: if (&amp;x == this) does nothing; otherwise, merges the two
+@@ -14615,14 +13896,14 @@ effects.
+ </blockquote>
+
+ <p><i>[Copenhagen: The original proposed resolution did not fix all of
+-the problems in 23.3.4.4 [list.ops], p22-25. Three different
++the problems in 23.3.5.5 [list.ops], p22-25. Three different
+ paragraphs (23, 24, 25) describe the effects of <tt>merge</tt>.
+ Changing p23, without changing the other two, appears to introduce
+ contradictions. Additionally, "merges the argument list into the
+ list" is excessively vague.]</i></p>
+
+
+-<p><i>[Post-Curaçao: Robert Klarer provided new wording.]</i></p>
++<p><i>[Post-Cura&ccedil;ao: Robert Klarer provided new wording.]</i></p>
+
+
+
+@@ -14632,10 +13913,10 @@ list" is excessively vague.]</i></p>
+
+ <hr>
+ <h3><a name="301"></a>301. basic_string template ctor effects clause omits allocator argument</h3>
+-<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.require">issues</a> in [string.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-01-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The effects clause for the basic_string template ctor in 21.3.1, p15
+@@ -14670,14 +13951,14 @@ a mistake.
+
+ <hr>
+ <h3><a name="303"></a>303. Bitset input operator underspecified</h3>
+-<p><b>Section:</b> 20.5.4 [bitset.operators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-02-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6.4 [bitset.operators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-02-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 23.3.5.3, we are told that <tt>bitset</tt>'s input operator
+-"Extracts up to <i>N</i> (single-byte) characters from
+-<i>is</i>.", where <i>is</i> is a stream of type
++&quot;Extracts up to <i>N</i> (single-byte) characters from
++<i>is</i>.&quot;, where <i>is</i> is a stream of type
+ <tt>basic_istream&lt;charT, traits&gt;</tt>.
+ </p>
+
+@@ -14789,10 +14070,10 @@ consequence of the design choice.</p>
+
+ <hr>
+ <h3><a name="305"></a>305. Default behavior of codecvt&lt;wchar_t, char, mbstate_t&gt;::length()</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-01-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-01-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>22.2.1.5/3 introduces codecvt in part with:</p>
+
+@@ -14824,7 +14105,7 @@ that this is not what was intended and is a defect.
+
+ <p>Discussion from the -lib reflector:
+
+-<br>This proposal would have the effect of making the semantics of
++<br/>This proposal would have the effect of making the semantics of
+ all of the virtual functions in <tt>codecvt&lt;wchar_t, char,
+ mbstate_t&gt;</tt> implementation specified. Is that what we want, or
+ do we want to mandate specific behavior for the base class virtuals
+@@ -14906,8 +14187,8 @@ single external character), but this would rule out important
+ encodings that are in common use: it would rule out JIS, for
+ example, and it would rule out a fixed-width encoding of UCS-4.</p>
+
+-<p><i>[Curaçao: fixed rationale typo at the request of Ichiro Koshida;
+-"shift-JIS" changed to "JIS".]</i></p>
++<p><i>[Cura&ccedil;ao: fixed rationale typo at the request of Ichiro Koshida;
++&quot;shift-JIS&quot; changed to &quot;JIS&quot;.]</i></p>
+
+
+
+@@ -14917,22 +14198,22 @@ example, and it would rule out a fixed-width encoding of UCS-4.</p>
+
+ <hr>
+ <h3><a name="306"></a>306. offsetof macro and non-POD types</h3>
+-<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2001-02-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.types">issues</a> in [support.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2001-02-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Spliced together from reflector messages c++std-lib-8294 and -8295:</p>
+
+-<p>18.1, paragraph 5, reads: "The macro <tt>offsetof</tt>
++<p>18.1, paragraph 5, reads: &quot;The macro <tt>offsetof</tt>
+ accepts a restricted set of <i>type</i> arguments in this
+ International Standard. <i>type</i> shall be a POD structure or a POD
+ union (clause 9). The result of applying the offsetof macro to a field
+ that is a static data member or a function member is
+-undefined."</p>
++undefined.&quot;</p>
+
+-<p>For the POD requirement, it doesn't say "no diagnostic
+-required" or "undefined behavior". I read 1.4 [intro.compliance], paragraph 1, to mean that a diagnostic is required.
++<p>For the POD requirement, it doesn't say &quot;no diagnostic
++required&quot; or &quot;undefined behavior&quot;. I read 1.4 [intro.compliance], paragraph 1, to mean that a diagnostic is required.
+ It's not clear whether this requirement was intended. While it's
+ possible to provide such a diagnostic, the extra complication doesn't
+ seem to add any value.
+@@ -14940,8 +14221,8 @@ seem to add any value.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 18.1, paragraph 5, to "If <i>type</i> is not a POD
+-structure or a POD union the results are undefined."</p>
++<p>Change 18.1, paragraph 5, to &quot;If <i>type</i> is not a POD
++structure or a POD union the results are undefined.&quot;</p>
+
+ <p><i>[Copenhagen: straw poll was 7-4 in favor. It was generally
+ agreed that requiring a diagnostic was inadvertent, but some LWG
+@@ -14955,16 +14236,16 @@ possible.]</i></p>
+
+ <hr>
+ <h3><a name="307"></a>307. Lack of reference typedefs in container adaptors</h3>
+-<p><b>Section:</b> 23.3.4 [list] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-03-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5 [list] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>From reflector message c++std-lib-8330. See also lib-8317.</p>
+
+ <p>
+-The standard is currently inconsistent in 23.3.4.2 [list.capacity]
+-paragraph 1 and 23.3.4.3 [list.modifiers] paragraph 1.
++The standard is currently inconsistent in 23.3.5.3 [list.capacity]
++paragraph 1 and 23.3.5.4 [list.modifiers] paragraph 1.
+ 23.2.3.3/1, for example, says:
+ </p>
+
+@@ -14990,7 +14271,7 @@ container's reference type.</p>
+
+ <p>
+ I propose 3. This does not preclude option 2 if we choose to do it
+-later (see issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#96">96</a>); the issues are independent. Option
++later (see issue <a href="lwg-closed.html#96">96</a>); the issues are independent. Option
+ 3 offers a small step towards support for proxied containers. This
+ small step fixes a current contradiction, is easy for vendors to
+ implement, is already implemented in at least one popular lib, and
+@@ -15007,7 +14288,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>Change 23.2.3.1/1 from:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class queue {
+ public:
+@@ -15033,7 +14315,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>to:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class queue {
+ public:
+@@ -15062,7 +14345,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>Change 23.2.3.2/1 from:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = vector&lt;T&gt;,
+ class Compare = less&lt;typename Container::value_type&gt; &gt;
+ class priority_queue {
+@@ -15094,7 +14378,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>to:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = vector&lt;T&gt;,
+ class Compare = less&lt;typename Container::value_type&gt; &gt;
+ class priority_queue {
+@@ -15128,7 +14413,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>And change 23.2.3.3/1 from:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class stack {
+ public:
+@@ -15172,7 +14458,8 @@ priority_queue and stack. Change return types of "value_type&amp;" to
+
+ <p>to:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class stack {
+ public:
+@@ -15227,10 +14514,10 @@ and it was deliberately not adopted. Nevertheless, the LWG believes
+
+ <hr>
+ <h3><a name="308"></a>308. Table 82 mentions unrelated headers</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 82 in section 27 mentions the header &lt;cstdlib&gt; for String
+@@ -15259,10 +14546,10 @@ section 27.9 [file.streams], including 27.9.2 [c.files].]</i></p>
+
+ <hr>
+ <h3><a name="310"></a>310. Is errno a macro?</h3>
+-<p><b>Section:</b> 17.6.1.2 [headers], 19.4 [errno] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2001-03-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#headers">issues</a> in [headers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.1.2 [headers], 19.4 [errno] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2001-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#headers">issues</a> in [headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Exactly how should errno be declared in a conforming C++ header?
+@@ -15299,8 +14586,8 @@ section 27.9 [file.streams], including 27.9.2 [c.files].]</i></p>
+
+ <p>Two acceptable fixes:</p>
+ <ul>
+- <li><p>errno must be a macro. This is trivially satisfied by adding<br>
+- &nbsp;&nbsp;#define errno (::std::errno)<br>
++ <li><p>errno must be a macro. This is trivially satisfied by adding<br/>
++ &nbsp;&nbsp;#define errno (::std::errno)<br/>
+ to the headers if errno is not already a macro. You then always
+ write errno without any scope qualification, and it always expands
+ to a correct reference. Since it is always a macro, you know to
+@@ -15352,7 +14639,7 @@ not a name is a macro; it must explicitly specify exactly which names
+ are required to be macros. The only one that really works is for it
+ to be a macro.</p>
+
+-<p><i>[Curaçao: additional rationale added.]</i></p>
++<p><i>[Cura&ccedil;ao: additional rationale added.]</i></p>
+
+
+
+@@ -15362,15 +14649,16 @@ to be a macro.</p>
+
+ <hr>
+ <h3><a name="311"></a>311. Incorrect wording in basic_ostream class synopsis</h3>
+-<p><b>Section:</b> 27.7.2.1 [ostream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-03-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream">issues</a> in [ostream].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.1 [ostream] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream">issues</a> in [ostream].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>In 27.7.2.1 [ostream], the synopsis of class basic_ostream says:</p>
++<p>In 27.7.3.1 [ostream], the synopsis of class basic_ostream says:</p>
+
+-<pre> // partial specializationss
++<pre>
++ // partial specializationss
+ template&lt;class traits&gt;
+ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,traits&gt;&amp;,
+ const char * );
+@@ -15385,14 +14673,14 @@ to be a macro.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In the synopsis in 27.7.2.1 [ostream], remove the
++<p>In the synopsis in 27.7.3.1 [ostream], remove the
+ <i>// partial specializationss</i> comment. Also remove the same
+ comment (correctly spelled, but still incorrect) from the synopsis in
+-27.7.2.6.4 [ostream.inserters.character].
++27.7.3.6.4 [ostream.inserters.character].
+ </p>
+
+ <p><i>[
+-Pre-Redmond: added 27.7.2.6.4 [ostream.inserters.character] because of Martin's
++Pre-Redmond: added 27.7.3.6.4 [ostream.inserters.character] because of Martin's
+ comment in c++std-lib-8939.
+ ]</i></p>
+
+@@ -15404,14 +14692,14 @@ comment in c++std-lib-8939.
+
+ <hr>
+ <h3><a name="312"></a>312. Table 27 is missing headers</h3>
+-<p><b>Section:</b> 20 [utilities] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utilities">issues</a> in [utilities].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20 [utilities] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-03-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utilities">issues</a> in [utilities].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Table 27 in section 20 lists the header &lt;memory&gt; (only) for
+ Memory (lib.memory) but neglects to mention the headers
+-&lt;cstdlib&gt; and &lt;cstring&gt; that are discussed in 20.7.6 [meta.rel].</p>
++&lt;cstdlib&gt; and &lt;cstring&gt; that are discussed in 20.10.6 [meta.rel].</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -15424,13 +14712,13 @@ as &lt;memory&gt;.</p>
+
+ <hr>
+ <h3><a name="315"></a>315. Bad "range" in list::unique complexity</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-05-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-05-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-23.3.4.4 [list.ops], Para 21 describes the complexity of
++23.3.5.5 [list.ops], Para 21 describes the complexity of
+ list::unique as: "If the range (last - first) is not empty, exactly
+ (last - first) -1 applications of the corresponding predicate,
+ otherwise no applications of the predicate)".
+@@ -15451,11 +14739,11 @@ Change the "range" from (last - first) to [first, last).
+
+ <hr>
+ <h3><a name="316"></a>316. Vague text in Table 69</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Table 69 says this about a_uniq.insert(t):</p>
+
+@@ -15484,10 +14772,10 @@ takes place...
+
+ <hr>
+ <h3><a name="317"></a>317. Instantiation vs. specialization of facets</h3>
+-<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#localization">issues</a> in [localization].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#localization">issues</a> in [localization].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The localization section of the standard refers to specializations of
+@@ -15550,14 +14838,15 @@ change.</p>
+
+ <hr>
+ <h3><a name="318"></a>318. Misleading comment in definition of numpunct_byname</h3>
+-<p><b>Section:</b> 22.4.3.2 [locale.numpunct.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.3.2 [locale.numpunct.byname] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-05-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The definition of the numpunct_byname template contains the following
+ comment:</p>
+
+-<pre> namespace std {
++<pre>
++ namespace std {
+ template &lt;class charT&gt;
+ class numpunct_byname : public numpunct&lt;charT&gt; {
+ // this class is specialized for char and wchar_t.
+@@ -15571,17 +14860,17 @@ template at all, but simply provide the primary template.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Remove the comment from the text in 22.2.3.2 and from the proposed
+-resolution of library issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#228">228</a>.</p>
++resolution of library issue <a href="lwg-defects.html#228">228</a>.</p>
+
+
+
+
+ <hr>
+ <h3><a name="319"></a>319. Storage allocation wording confuses "Required behavior", "Requires"</h3>
+-<p><b>Section:</b> 18.6.1.1 [new.delete.single], 18.6.1.2 [new.delete.array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2001-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.6.1.1 [new.delete.single], 18.6.1.2 [new.delete.array] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2001-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.single">issues</a> in [new.delete.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The standard specifies 17.5.1.4 [structure.specifications] that "Required
+ behavior" elements describe "the semantics of a function definition
+@@ -15626,13 +14915,13 @@ should be specified as "Requires".</p>
+
+ <hr>
+ <h3><a name="320"></a>320. list::assign overspecified</h3>
+-<p><b>Section:</b> 23.3.4.1 [list.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.cons">issues</a> in [list.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.2 [list.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.cons">issues</a> in [list.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Section 23.3.4.1 [list.cons], paragraphs 6-8 specify that list assign (both forms) have
++Section 23.3.5.2 [list.cons], paragraphs 6-8 specify that list assign (both forms) have
+ the "effects" of a call to erase followed by a call to insert.
+ </p>
+
+@@ -15658,12 +14947,13 @@ Metrowerks and SGI recycle nodes, Dinkumware and Rogue Wave don't.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 23.3.4.1 [list.cons]/7 from:</p>
++<p>Change 23.3.5.2 [list.cons]/7 from:</p>
+
+ <blockquote>
+ <p>Effects:</p>
+
+-<pre> erase(begin(), end());
++<pre>
++ erase(begin(), end());
+ insert(begin(), first, last);
+ </pre>
+ </blockquote>
+@@ -15676,7 +14966,8 @@ Metrowerks and SGI recycle nodes, Dinkumware and Rogue Wave don't.
+
+ <p>In 23.2.3 [sequence.reqmts], in Table 67 (sequence requirements),
+ add two new rows:</p>
+-<pre> a.assign(i,j) void pre: i,j are not iterators into a.
++<pre>
++ a.assign(i,j) void pre: i,j are not iterators into a.
+ Replaces elements in a with a copy
+ of [i, j).
+
+@@ -15685,11 +14976,12 @@ add two new rows:</p>
+ of t.
+ </pre>
+
+-<p>Change 23.3.4.1 [list.cons]/8 from:</p>
++<p>Change 23.3.5.2 [list.cons]/8 from:</p>
+
+ <blockquote>
+ <p>Effects:</p>
+-<pre> erase(begin(), end());
++<pre>
++ erase(begin(), end());
+ insert(begin(), n, t);
+ </pre>
+ </blockquote>
+@@ -15710,9 +15002,9 @@ temporary. Howard provided wording.
+ ]</i></p>
+
+
+-<p><i>[Curaçao: Made editorial improvement in wording; changed
+-"Replaces elements in a with copies of elements in [i, j)."
+-with "Replaces the elements of a with a copy of [i, j)."
++<p><i>[Cura&ccedil;ao: Made editorial improvement in wording; changed
++&quot;Replaces elements in a with copies of elements in [i, j).&quot;
++with &quot;Replaces the elements of a with a copy of [i, j).&quot;
+ Changes not deemed serious enough to requre rereview.]</i></p>
+
+
+@@ -15723,10 +15015,11 @@ Changes not deemed serious enough to requre rereview.]</i></p>
+
+ <hr>
+ <h3><a name="321"></a>321. Typo in num_get</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Kevin Djang <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Kevin Djang <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 22.2.2.1.2 at p7 states that "A length specifier is added to
+@@ -15753,10 +15046,11 @@ to be "A length modifier is added ..."
+
+ <hr>
+ <h3><a name="322"></a>322. iterator and const_iterator should have the same value type</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2001-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It's widely assumed that, if X is a container,
+@@ -15769,7 +15063,7 @@ iterator_traits&lt;X::const_iterator&gt;::value_type should be "const
+ X::value_type".
+ </p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#279">279</a>.</p>
++<p>Related issue: <a href="lwg-closed.html#279">279</a>.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -15799,10 +15093,11 @@ requires that iterator_traits&lt;const int*&gt;::value_type is int.
+
+ <hr>
+ <h3><a name="324"></a>324. Do output iterators have value types?</h3>
+-<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-06-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2001-06-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#output.iterators">active issues</a> in [output.iterators].</p>
++<p><b>View all other</b> <a href="lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>Table 73 suggests that output iterators have value types. It
+@@ -15884,28 +15179,32 @@ output iterator.
+ <p>Table 73, change</p>
+
+ <blockquote>
+-<pre>*a = t
++<pre>
++*a = t
+ </pre>
+ </blockquote>
+
+ <p>to</p>
+
+ <blockquote>
+-<pre>*r = o
++<pre>
++*r = o
+ </pre>
+ </blockquote>
+
+ <p>and change</p>
+
+ <blockquote>
+-<pre>*r++ = t
++<pre>
++*r++ = t
+ </pre>
+ </blockquote>
+
+ <p>to</p>
+
+ <blockquote>
+-<pre>*r++ = o
++<pre>
++*r++ = o
+ </pre>
+ </blockquote>
+
+@@ -15932,10 +15231,10 @@ decision.</p>
+
+ <hr>
+ <h3><a name="325"></a>325. Misleading text in moneypunct&lt;&gt;::do_grouping</h3>
+-<p><b>Section:</b> 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.moneypunct.virtuals">issues</a> in [locale.moneypunct.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.moneypunct.virtuals">issues</a> in [locale.moneypunct.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The Returns clause in 22.2.6.3.2, p3 says about
+ moneypunct&lt;charT&gt;::do_grouping()
+@@ -15997,11 +15296,11 @@ integers, not ASCII characters.
+
+ <hr>
+ <h3><a name="327"></a>327. Typo in time_get facet in table 52</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Tiki Wan <b>Opened:</b> 2001-07-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#447">447</a></p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Tiki Wan <b>Opened:</b> 2001-07-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#447">447</a></p>
+ <p><b>Discussion:</b></p>
+ <p>The <tt>wchar_t</tt> versions of <tt>time_get</tt> and
+ <tt>time_get_byname</tt> are listed incorrectly in table 52,
+@@ -16014,11 +15313,13 @@ InputIterator, since these are input facets.</p>
+ <p>
+ In table 52, required instantiations, in
+ 22.3.1.1.1 [locale.category], change</p>
+-<pre> time_get&lt;wchar_t, OutputIterator&gt;
++<pre>
++ time_get&lt;wchar_t, OutputIterator&gt;
+ time_get_byname&lt;wchar_t, OutputIterator&gt;
+ </pre>
+ <p>to</p>
+-<pre> time_get&lt;wchar_t, InputIterator&gt;
++<pre>
++ time_get&lt;wchar_t, InputIterator&gt;
+ time_get_byname&lt;wchar_t, InputIterator&gt;
+ </pre>
+
+@@ -16032,9 +15333,9 @@ a typo, wchart instead of wchar_t.]</i></p>
+
+ <hr>
+ <h3><a name="328"></a>328. Bad sprintf format modifier in money_put&lt;&gt;::do_put()</h3>
+-<p><b>Section:</b> 22.4.6.2.2 [locale.money.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.6.2.2 [locale.money.put.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-07-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>The sprintf format string , "%.01f" (that's the digit one), in the
+ description of the do_put() member functions of the money_put facet in
+@@ -16056,18 +15357,19 @@ modifier.</p>
+
+ <hr>
+ <h3><a name="329"></a>329. vector capacity, reserve and reallocation</h3>
+-<p><b>Section:</b> 23.4.1.2 [vector.capacity], 23.4.1.4 [vector.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2001-07-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity], 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2001-07-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is an apparent contradiction about which circumstances can cause
+-a reallocation of a vector in Section 23.4.1.2 [vector.capacity] and
+-section 23.4.1.4 [vector.modifiers].
++a reallocation of a vector in Section 23.3.6.3 [vector.capacity] and
++section 23.3.6.5 [vector.modifiers].
+ </p>
+
+-<p>23.4.1.2 [vector.capacity],p5 says:</p>
++<p>23.3.6.3 [vector.capacity],p5 says:</p>
+ <blockquote><p>
+ Notes: Reallocation invalidates all the references, pointers, and iterators
+ referring to the elements in the sequence. It is guaranteed that no
+@@ -16078,7 +15380,8 @@ greater than the size specified in the most recent call to reserve().
+
+ <p>Which implies if I do</p>
+
+-<pre> std::vector&lt;int&gt; vec;
++<pre>
++ std::vector&lt;int&gt; vec;
+ vec.reserve(23);
+ vec.reserve(0);
+ vec.insert(vec.end(),1);
+@@ -16087,7 +15390,7 @@ greater than the size specified in the most recent call to reserve().
+ <p>then the implementation may reallocate the vector for the insert,
+ as the size specified in the previous call to reserve was zero.</p>
+
+-<p>However, the previous paragraphs (23.4.1.2 [vector.capacity], p1-2) state:</p>
++<p>However, the previous paragraphs (23.3.6.3 [vector.capacity], p1-2) state:</p>
+ <blockquote>
+ <p>
+ (capacity) Returns: The total number of elements the vector
+@@ -16103,7 +15406,7 @@ of capacity() otherwise...
+ <p>
+ This implies that vec.capacity() is still 23, and so the insert()
+ should not require a reallocation, as vec.size() is 0. This is backed
+-up by 23.4.1.4 [vector.modifiers], p1:
++up by 23.3.6.5 [vector.modifiers], p1:
+ </p>
+ <blockquote><p>
+ (insert) Notes: Causes reallocation if the new size is greater than the old
+@@ -16118,7 +15421,7 @@ than the old capacity, I think the intent is clear.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change the wording of 23.4.1.2 [vector.capacity] paragraph 5 to:</p>
++<p>Change the wording of 23.3.6.3 [vector.capacity] paragraph 5 to:</p>
+
+ <blockquote><p>
+ Notes: Reallocation invalidates all the references, pointers, and
+@@ -16151,19 +15454,20 @@ reallocation guarantees was inadvertant.</p>
+
+ <hr>
+ <h3><a name="331"></a>331. bad declaration of destructor for ios_base::failure</h3>
+-<p><b>Section:</b> 27.5.2.1.1 [ios::failure] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-With the change in 17.6.4.12 [res.on.exception.handling] to state
++With the change in 17.6.5.12 [res.on.exception.handling] to state
+ "An implementation may strengthen the exception-specification for a
+ non-virtual function by removing listed exceptions."
+-(issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#119">119</a>)
++(issue <a href="lwg-defects.html#119">119</a>)
+ and the following declaration of ~failure() in ios_base::failure
+ </p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ class ios_base::failure : public exception {
+ public:
+ ...
+@@ -16174,7 +15478,8 @@ and the following declaration of ~failure() in ios_base::failure
+ </pre>
+ <p>the class failure cannot be implemented since in 18.7.1 [type.info] the destructor of class exception has an empty
+ exception specification:</p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ class exception {
+ public:
+ ...
+@@ -16201,11 +15506,11 @@ of other classes derived from <tt>exception</tt> are handled.</p>
+
+ <hr>
+ <h3><a name="333"></a>333. does endl imply synchronization with the device?</h3>
+-<p><b>Section:</b> 27.7.2.8 [ostream.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.8 [ostream.manip] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> PremAnand M. Rao <b>Opened:</b> 2001-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>A footnote in 27.7.2.8 [ostream.manip] states:</p>
++<p>A footnote in 27.7.3.8 [ostream.manip] states:</p>
+ <blockquote><p>
+ [Footnote: The effect of executing cout &lt;&lt; endl is to insert a
+ newline character in the output sequence controlled by cout, then
+@@ -16232,7 +15537,7 @@ the behavior one way or the other.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Remove footnote 300 from section 27.7.2.8 [ostream.manip].</p>
++<p>Remove footnote 300 from section 27.7.3.8 [ostream.manip].</p>
+
+
+ <p><b>Rationale:</b></p>
+@@ -16250,10 +15555,10 @@ does.</p>
+
+ <hr>
+ <h3><a name="334"></a>334. map::operator[] specification forces inefficient implementation</h3>
+-<p><b>Section:</b> 23.6.1.2 [map.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrea Griffini <b>Opened:</b> 2001-09-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map.access">issues</a> in [map.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.4.4.3 [map.access] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrea Griffini <b>Opened:</b> 2001-09-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.access">issues</a> in [map.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current standard describes map::operator[] using a
+@@ -16266,7 +15571,8 @@ require all those temporary copies.
+ </p>
+
+ <p>Currently map::operator[] behaviour is specified as: </p>
+-<pre> Returns:
++<pre>
++ Returns:
+ (*((insert(make_pair(x, T()))).first)).second.
+ </pre>
+
+@@ -16293,7 +15599,8 @@ construction for each type).
+ </p>
+
+ <p>A simple (half) solution would be replacing the description with:</p>
+-<pre> Returns:
++<pre>
++ Returns:
+ (*((insert(value_type(x, T()))).first)).second.
+ </pre>
+
+@@ -16333,7 +15640,7 @@ non-conforming.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Replace 23.6.1.2 [map.access] paragraph 1 with
++Replace 23.4.4.3 [map.access] paragraph 1 with
+ </p>
+ <blockquote>
+ <p>
+@@ -16352,7 +15659,7 @@ value_type(x, T()) into the map.
+ wording. We may also wish to have a blanket statement somewhere in
+ clause 17 saying that we do not intend the semantics of sample code
+ fragments to be interpreted as specifing exactly how many copies are
+-made. See issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#98">98</a> for a similar problem.]</i></p>
++made. See issue <a href="lwg-defects.html#98">98</a> for a similar problem.]</i></p>
+
+
+
+@@ -16373,15 +15680,16 @@ we are no longer defining <tt>operator[]</tt> in terms of
+
+ <hr>
+ <h3><a name="335"></a>335. minor issue with char_traits, table 37</h3>
+-<p><b>Section:</b> 21.2.1 [char.traits.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-09-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.2.1 [char.traits.require] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 37, in 21.2.1 [char.traits.require], descibes char_traits::assign
+ as:
+ </p>
+-<pre> X::assign(c,d) assigns c = d.
++<pre>
++ X::assign(c,d) assigns c = d.
+ </pre>
+
+ <p>And para 1 says:</p>
+@@ -16398,7 +15706,8 @@ assign, at least), 'c' is intended to be a reference type.
+
+ <p>I did a quick survey of the four implementations I happened to have
+ lying around, and sure enough they all have signatures:</p>
+-<pre> assign( charT&amp;, const charT&amp; );
++<pre>
++ assign( charT&amp;, const charT&amp; );
+ </pre>
+
+ <p>(or the equivalent). It's also described this way in Nico's book.
+@@ -16414,7 +15723,8 @@ and char_traits&lt;wchar_t&gt; in 21.1.3.2...)
+ </p></blockquote>
+
+ <p>and change the description of assign in the table to:</p>
+-<pre> X::assign(r,d) assigns r = d
++<pre>
++ X::assign(r,d) assigns r = d
+ </pre>
+
+
+@@ -16423,11 +15733,11 @@ and char_traits&lt;wchar_t&gt; in 21.1.3.2...)
+
+ <hr>
+ <h3><a name="336"></a>336. Clause 17 lack of references to deprecated headers</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-09-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-09-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>From c++std-edit-873:</p>
+
+@@ -16458,9 +15768,9 @@ library (though a deprecated one).</p>
+ <li>17.5.2.3 [objects.within.classes] Private members/1/(2 places)</li>
+ <li>17.6 [requirements] Library-wide requirements/1</li>
+ <li>17.6.1.2 [headers] Headers/4</li>
+-<li>17.6.3.6 [replacement.functions] Replacement functions/1</li>
+-<li>17.6.4.4 [global.functions] Global or non-member functions/2</li>
+-<li>17.6.4.10 [protection.within.classes] Protection within classes/1</li>
++<li>17.6.4.6 [replacement.functions] Replacement functions/1</li>
++<li>17.6.5.4 [global.functions] Global or non-member functions/2</li>
++<li>17.6.5.10 [protection.within.classes] Protection within classes/1</li>
+ </ul>
+
+
+@@ -16471,10 +15781,10 @@ library (though a deprecated one).</p>
+
+ <hr>
+ <h3><a name="337"></a>337. replace_copy_if's template parameter should be InputIterator</h3>
+-<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-09-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.5 [alg.replace] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2001-09-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.replace">issues</a> in [alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>From c++std-edit-876:</p>
+
+@@ -16495,15 +15805,15 @@ parameter name conveys real normative meaning.
+
+ <hr>
+ <h3><a name="338"></a>338. is whitespace allowed between `-' and a digit?</h3>
+-<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4 [locale.categories] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.categories">issues</a> in [locale.categories].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ From Stage 2 processing in 22.4.2.1.2 [facet.num.get.virtuals], p8 and 9 (the
+ original text or the text corrected by the proposed resolution of
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#221">221</a>) it seems clear that no whitespace is allowed
++issue <a href="lwg-defects.html#221">221</a>) it seems clear that no whitespace is allowed
+ within a number, but 22.4.3.1 [locale.numpunct], p2, which gives the
+ format for integer and floating point values, says that whitespace is
+ optional between a plusminus and a sign.
+@@ -16514,7 +15824,7 @@ The text needs to be clarified to either consistently allow or
+ disallow whitespace between a plusminus and a sign. It might be
+ worthwhile to consider the fact that the C library stdio facility does
+ not permit whitespace embedded in numbers and neither does the C or
+-C++ core language (the syntax of integer-literals is given in 2.14.2 [lex.icon], that of floating-point-literals in 2.14.4 [lex.fcon] of the C++ standard).
++C++ core language (the syntax of integer-literals is given in 2.13.2 [lex.icon], that of floating-point-literals in 2.13.4 [lex.fcon] of the C++ standard).
+ </p>
+
+
+@@ -16530,7 +15840,8 @@ value, <tt>whitespace</tt> is as determined by the facet
+ <tt>numpunct&lt;charT&gt;</tt> members. Integer values have the
+ format:
+ </p>
+-<pre> integer ::= [sign] units
++<pre>
++ integer ::= [sign] units
+ sign ::= plusminus [whitespace]
+ plusminus ::= '+' | '-'
+ units ::= digits [thousands-sep units]
+@@ -16546,7 +15857,8 @@ value, and <tt>thousands-sep</tt> and <tt>decimal-point</tt> are the
+ results of corresponding <tt>numpunct&lt;charT&gt;</tt> members.
+ Integer values have the format:
+ </p>
+-<pre> integer ::= [sign] units
++<pre>
++ integer ::= [sign] units
+ sign ::= plusminus
+ plusminus ::= '+' | '-'
+ units ::= digits [thousands-sep units]
+@@ -16568,10 +15880,10 @@ resolution removes all mention of "whitespace" from that format.</p>
+
+ <hr>
+ <h3><a name="339"></a>339. definition of bitmask type restricted to clause 27</h3>
+-<p><b>Section:</b> 22.4.1 [category.ctype], 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#category.ctype">issues</a> in [category.ctype].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1 [category.ctype], 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#category.ctype">issues</a> in [category.ctype].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The ctype_category::mask type is declared to be an enum in 22.4.1 [category.ctype] with p1 then stating that it is a bitmask type, most
+@@ -16585,7 +15897,7 @@ clause 27, making the reference in 22.2.1 somewhat dubious.
+ <blockquote><p>
+ Several types defined in clause 27 are bitmask types. Each bitmask type
+ can be implemented as an enumerated type that overloads certain operators,
+- as an integer type, or as a bitset (20.5 [template.bitset]).
++ as an integer type, or as a bitset (20.6 [template.bitset]).
+ </p></blockquote>
+ <p>to read</p>
+ <blockquote><p>
+@@ -16604,7 +15916,8 @@ following (note, in particluar, the cross-reference to 17.3.2.1.2 in
+
+ <blockquote>
+ <p>22.2.1 The ctype category [lib.category.ctype]</p>
+-<pre>namespace std {
++<pre>
++namespace std {
+ class ctype_base {
+ public:
+ typedef <b><i>T</i></b> mask;
+@@ -16628,7 +15941,7 @@ following (note, in particluar, the cross-reference to 17.3.2.1.2 in
+ <p>The type <tt>mask</tt> is a bitmask type (17.5.2.1.3 [bitmask.types]).</p>
+ </blockquote>
+
+-<p><i>[Curaçao: The LWG notes that T above should be bold-italics to be
++<p><i>[Cura&ccedil;ao: The LWG notes that T above should be bold-italics to be
+ consistent with the rest of the standard.]</i></p>
+
+
+@@ -16641,10 +15954,10 @@ consistent with the rest of the standard.]</i></p>
+
+ <hr>
+ <h3><a name="340"></a>340. interpretation of <tt>has_facet&lt;Facet&gt;(loc)</tt></h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It's unclear whether 22.1.1.1.1, p3 says that
+@@ -16713,23 +16026,25 @@ complete list of the ones we need.</p>
+
+ <hr>
+ <h3><a name="341"></a>341. Vector reallocation and swap</h3>
+-<p><b>Section:</b> 23.4.1.2 [vector.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2001-09-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2001-09-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It is a common idiom to reduce the capacity of a vector by swapping it with
+ an empty one:</p>
+-<pre> std::vector&lt;SomeType&gt; vec;
++<pre>
++ std::vector&lt;SomeType&gt; vec;
+ // fill vec with data
+ std::vector&lt;SomeType&gt;().swap(vec);
+ // vec is now empty, with minimal capacity
+ </pre>
+
+-<p>However, the wording of 23.4.1.2 [vector.capacity]paragraph 5 prevents
++<p>However, the wording of 23.3.6.3 [vector.capacity]paragraph 5 prevents
+ the capacity of a vector being reduced, following a call to
+ reserve(). This invalidates the idiom, as swap() is thus prevented
+-from reducing the capacity. The proposed wording for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#329">329</a> does not affect this. Consequently, the example above
++from reducing the capacity. The proposed wording for issue <a href="lwg-defects.html#329">329</a> does not affect this. Consequently, the example above
+ requires the temporary to be expanded to cater for the contents of
+ vec, and the contents be copied across. This is a linear-time
+ operation.</p>
+@@ -16759,9 +16074,10 @@ referred to one vector now refer to the other, and vice-versa.</li>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add a new paragraph after 23.4.1.2 [vector.capacity] paragraph 5:</p>
++<p>Add a new paragraph after 23.3.6.3 [vector.capacity] paragraph 5:</p>
+ <blockquote>
+-<pre> void swap(vector&lt;T,Allocator&gt;&amp; x);
++<pre>
++ void swap(vector&lt;T,Allocator&gt;&amp; x);
+ </pre>
+ <p><b>Effects:</b> Exchanges the contents and capacity() of <tt>*this</tt>
+ with that of <tt>x</tt>.</p>
+@@ -16787,21 +16103,275 @@ the two vectors, including their reallocation guarantees.
+
+
+ <hr>
++<h3><a name="343"></a>343. Unspecified library header dependencies</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The synopses of the C++ library headers clearly show which names are
++required to be defined in each header. Since in order to implement the
++classes and templates defined in these headers declarations of other
++templates (but not necessarily their definitions) are typically
++necessary the standard in 17.4.4, p1 permits library implementers to
++include any headers needed to implement the definitions in each header.
++</p>
++
++<p>
++For instance, although it is not explicitly specified in the synopsis of
++<tt>&lt;string&gt;</tt>, at the point of definition of the <tt>std::basic_string</tt> template
++the declaration of the <tt>std::allocator</tt> template must be in scope. All
++current implementations simply include <tt>&lt;memory&gt;</tt> from within <tt>&lt;string&gt;</tt>,
++either directly or indirectly, to bring the declaration of
++<tt>std::allocator</tt> into scope.
++</p>
++
++<p>
++Additionally, however, some implementation also include <tt>&lt;istream&gt;</tt> and
++<tt>&lt;ostream&gt;</tt> at the top of <tt>&lt;string&gt;</tt> to bring the declarations of
++<tt>std::basic_istream</tt> and <tt>std::basic_ostream</tt> into scope (which are needed
++in order to implement the string inserter and extractor operators
++(21.3.7.9 [lib.string.io])). Other implementations only include
++<tt>&lt;iosfwd&gt;</tt>, since strictly speaking, only the declarations and not the
++full definitions are necessary.
++</p>
++
++<p>
++Obviously, it is possible to implement <tt>&lt;string&gt;</tt> without actually
++providing the full definitions of all the templates <tt>std::basic_string</tt>
++uses (<tt>std::allocator</tt>, <tt>std::basic_istream</tt>, and <tt>std::basic_ostream</tt>).
++Furthermore, not only is it possible, doing so is likely to have a
++positive effect on compile-time efficiency.
++</p>
++
++<p>
++But while it may seem perfectly reasonable to expect a program that uses
++the <tt>std::basic_string</tt> insertion and extraction operators to also
++explicitly include <tt>&lt;istream&gt;</tt> or <tt>&lt;ostream&gt;</tt>, respectively, it doesn't seem
++reasonable to also expect it to explicitly include <tt>&lt;memory&gt;</tt>. Since
++what's reasonable and what isn't is highly subjective one would expect
++the standard to specify what can and what cannot be assumed.
++Unfortunately, that isn't the case.
++</p>
++
++<p>The examples below demonstrate the issue.</p>
++
++<p>Example 1:</p>
++
++<p>It is not clear whether the following program is complete:</p>
++
++<pre>
++#include &lt;string&gt;
++
++extern std::basic_ostream&lt;char&gt; &amp;strm;
++
++int main () {
++ strm &lt;&lt; std::string ("Hello, World!\n");
++}
++</pre>
++
++<p>or whether one must explicitly include <tt>&lt;memory&gt;</tt> or
++<tt>&lt;ostream&gt;</tt> (or both) in addition to <tt>&lt;string&gt;</tt> in order for
++the program to compile.</p>
++
++
++<p>Example 2:</p>
++
++<p>Similarly, it is unclear whether the following program is complete:</p>
++
++<pre>
++#include &lt;istream&gt;
++
++extern std::basic_iostream&lt;char&gt; &amp;strm;
++
++int main () {
++ strm &lt;&lt; "Hello, World!\n";
++}
++</pre>
++
++<p>
++or whether one needs to explicitly include <tt>&lt;ostream&gt;</tt>, and
++perhaps even other headers containing the definitions of other
++required templates:</p>
++
++<pre>
++#include &lt;ios&gt;
++#include &lt;istream&gt;
++#include &lt;ostream&gt;
++#include &lt;streambuf&gt;
++
++extern std::basic_iostream&lt;char&gt; &amp;strm;
++
++int main () {
++ strm &lt;&lt; "Hello, World!\n";
++}
++</pre>
++
++<p>Example 3:</p>
++
++<p>Likewise, it seems unclear whether the program below is complete:</p>
++<pre>
++#include &lt;iterator&gt;
++
++bool foo (std::istream_iterator&lt;int&gt; a, std::istream_iterator&lt;int&gt; b)
++{
++ return a == b;
++}
++
++int main () { }
++</pre>
++
++<p>or whether one should be required to include <tt>&lt;istream&gt;</tt>.</p>
++
++<p>There are many more examples that demonstrate this lack of a
++requirement. I believe that in a good number of cases it would be
++unreasonable to require that a program explicitly include all the
++headers necessary for a particular template to be specialized, but I
++think that there are cases such as some of those above where it would
++be desirable to allow implementations to include only as much as
++necessary and not more.</p>
++
++<p><i>[
++post Bellevue:
++]</i></p>
++
++
++<blockquote><p>
++Position taken in prior reviews is that the idea of a table of header
++dependencies is a good one. Our view is that a full paper is needed to
++do justice to this, and we've made that recommendation to the issue
++author.
++</p></blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Resolved. Handled by LWG <a href="lwg-defects.html#1178">1178</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++For every C++ library header, supply a minimum set of other C++ library
++headers that are required to be included by that header. The proposed
++list is below (C++ headers for C Library Facilities, table 12 in
++17.4.1.2, p3, are omitted):
++</p>
++
++<pre>
+++------------+--------------------+
++| C++ header |required to include |
+++============+====================+
++|&lt;algorithm&gt; | |
+++------------+--------------------+
++|&lt;bitset&gt; | |
+++------------+--------------------+
++|&lt;complex&gt; | |
+++------------+--------------------+
++|&lt;deque&gt; |&lt;memory&gt; |
+++------------+--------------------+
++|&lt;exception&gt; | |
+++------------+--------------------+
++|&lt;fstream&gt; |&lt;ios&gt; |
+++------------+--------------------+
++|&lt;functional&gt;| |
+++------------+--------------------+
++|&lt;iomanip&gt; |&lt;ios&gt; |
+++------------+--------------------+
++|&lt;ios&gt; |&lt;streambuf&gt; |
+++------------+--------------------+
++|&lt;iosfwd&gt; | |
+++------------+--------------------+
++|&lt;iostream&gt; |&lt;istream&gt;, &lt;ostream&gt;|
+++------------+--------------------+
++|&lt;istream&gt; |&lt;ios&gt; |
+++------------+--------------------+
++|&lt;iterator&gt; | |
+++------------+--------------------+
++|&lt;limits&gt; | |
+++------------+--------------------+
++|&lt;list&gt; |&lt;memory&gt; |
+++------------+--------------------+
++|&lt;locale&gt; | |
+++------------+--------------------+
++|&lt;map&gt; |&lt;memory&gt; |
+++------------+--------------------+
++|&lt;memory&gt; | |
+++------------+--------------------+
++|&lt;new&gt; |&lt;exception&gt; |
+++------------+--------------------+
++|&lt;numeric&gt; | |
+++------------+--------------------+
++|&lt;ostream&gt; |&lt;ios&gt; |
+++------------+--------------------+
++|&lt;queue&gt; |&lt;deque&gt; |
+++------------+--------------------+
++|&lt;set&gt; |&lt;memory&gt; |
+++------------+--------------------+
++|&lt;sstream&gt; |&lt;ios&gt;, &lt;string&gt; |
+++------------+--------------------+
++|&lt;stack&gt; |&lt;deque&gt; |
+++------------+--------------------+
++|&lt;stdexcept&gt; | |
+++------------+--------------------+
++|&lt;streambuf&gt; |&lt;ios&gt; |
+++------------+--------------------+
++|&lt;string&gt; |&lt;memory&gt; |
+++------------+--------------------+
++|&lt;strstream&gt; | |
+++------------+--------------------+
++|&lt;typeinfo&gt; |&lt;exception&gt; |
+++------------+--------------------+
++|&lt;utility&gt; | |
+++------------+--------------------+
++|&lt;valarray&gt; | |
+++------------+--------------------+
++|&lt;vector&gt; |&lt;memory&gt; |
+++------------+--------------------+
++</pre>
++
++
++<p><b>Rationale:</b></p>
++<p>The portability problem is real. A program that works correctly on
++one implementation might fail on another, because of different header
++dependencies. This problem was understood before the standard was
++completed, and it was a conscious design choice.</p>
++<p>One possible way to deal with this, as a library extension, would
++be an <tt>&lt;all&gt;</tt> header.</p>
++
++<p>
++Hinnant: It's time we dealt with this issue for C++0X. Reopened.
++</p>
++
++
++
++
++
++
++
++<hr>
+ <h3><a name="345"></a>345. type tm in &lt;cwchar&gt;</h3>
+-<p><b>Section:</b> 21.7 [c.strings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Clark Nelson <b>Opened:</b> 2001-10-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.strings">issues</a> in [c.strings].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.8 [c.strings] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Clark Nelson <b>Opened:</b> 2001-10-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.strings">active issues</a> in [c.strings].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.strings">issues</a> in [c.strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ C99, and presumably amendment 1 to C90, specify that &lt;wchar.h&gt;
+-declares struct tm as an incomplete type. However, table 48 in 21.7 [c.strings] does not mention the type tm as being declared in
++declares struct tm as an incomplete type. However, table 48 in 21.8 [c.strings] does not mention the type tm as being declared in
+ &lt;cwchar&gt;. Is this omission intentional or accidental?
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In section 21.7 [c.strings], add "tm" to table 48.</p>
++<p>In section 21.8 [c.strings], add "tm" to table 48.</p>
+
+
+
+@@ -16809,10 +16379,10 @@ declares struct tm as an incomplete type. However, table 48 in 21.7 [c.strings]
+
+ <hr>
+ <h3><a name="346"></a>346. Some iterator member functions should be const</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jeremy Siek <b>Opened:</b> 2001-10-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jeremy Siek <b>Opened:</b> 2001-10-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Iterator member functions and operators that do not change the state
+ of the iterator should be defined as const member functions or as
+@@ -16832,23 +16402,27 @@ make this more explicit and also fix a couple problems.</p>
+ "In the following sections, a and b denote values of type const X...".</p>
+
+ <p>In Table 73, change</p>
+-<pre> a-&gt;m U&amp; ...
++<pre>
++ a-&gt;m U&amp; ...
+ </pre>
+
+ <p>to</p>
+
+-<pre> a-&gt;m const U&amp; ...
++<pre>
++ a-&gt;m const U&amp; ...
+ r-&gt;m U&amp; ...
+ </pre>
+
+ <p>In Table 73 expression column, change</p>
+
+-<pre> *a = t
++<pre>
++ *a = t
+ </pre>
+
+ <p>to</p>
+
+-<pre> *r = t
++<pre>
++ *r = t
+ </pre>
+
+ <p><i>[Redmond: The container requirements should be reviewed to see if
+@@ -16862,10 +16436,10 @@ the same problem appears there.]</i></p>
+
+ <hr>
+ <h3><a name="347"></a>347. locale::category and bitmask requirements</h3>
+-<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger, Nathan Myers <b>Opened:</b> 2001-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.category">issues</a> in [locale.category].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.1 [locale.category] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger, Nathan Myers <b>Opened:</b> 2001-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.category">issues</a> in [locale.category].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 22.3.1.1.1 [locale.category] paragraph 1, the category members
+@@ -16893,7 +16467,8 @@ changes beyond resolving the DR.</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>Replace the first two paragraphs of 22.3.1.1 [locale.types] with:</p>
+ <blockquote>
+-<pre> typedef int category;
++<pre>
++ typedef int category;
+ </pre>
+
+ <p>Valid category values include the <tt>locale</tt> member bitmask
+@@ -16903,7 +16478,8 @@ represents a single locale category. In addition, <tt>locale</tt> member
+ bitmask constant <tt>none</tt> is defined as zero and represents no
+ category. And locale member bitmask constant <tt>all</tt> is defined such that
+ the expression</p>
+-<pre> (collate | ctype | monetary | numeric | time | messages | all) == all
++<pre>
++ (collate | ctype | monetary | numeric | time | messages | all) == all
+ </pre>
+ <p>
+ is <tt>true</tt>, and represents the union of all categories. Further
+@@ -16921,7 +16497,7 @@ in turn, identifies a set of locale facets, including at least those
+ shown in Table 51:
+ </p>
+ </blockquote>
+-<p><i>[Curaçao: need input from locale experts.]</i></p>
++<p><i>[Cura&ccedil;ao: need input from locale experts.]</i></p>
+
+
+
+@@ -16937,7 +16513,7 @@ shown in Table 51:
+ extra locale categories.</p>
+
+ <blockquote>
+-<p><b>Option 2:</b> <br>
++<p><b>Option 2:</b> <br/>
+ Replace the first paragraph of 22.3.1.1 [locale.types] with:</p>
+ <blockquote>
+ <p>
+@@ -16965,12 +16541,13 @@ of the other enumerated values; implementations may add extra categories.]
+
+ <hr>
+ <h3><a name="349"></a>349. Minor typographical error in ostream_iterator</h3>
+-<p><b>Section:</b> 24.6.2 [ostream.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-10-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.6.2 [ostream.iterator] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2001-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>24.5.2 [lib.ostream.iterator] states:</p>
+-<pre> [...]
++<pre>
++ [...]
+
+ private:
+ // basic_ostream&lt;charT,traits&gt;* out_stream; exposition only
+@@ -16993,10 +16570,10 @@ In 24.6.2 [ostream.iterator], replace <tt>const char* delim</tt> with
+
+ <hr>
+ <h3><a name="352"></a>352. missing fpos requirements</h3>
+-<p><b>Section:</b> 21.2.2 [char.traits.typedefs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-12-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits.typedefs">issues</a> in [char.traits.typedefs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.2.2 [char.traits.typedefs] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-12-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits.typedefs">issues</a> in [char.traits.typedefs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <i>(1)</i>
+@@ -17050,10 +16627,10 @@ be considered NAD.</p>
+
+ <hr>
+ <h3><a name="353"></a>353. <tt>std::pair</tt> missing template assignment</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-12-02 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2001-12-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The class template <tt>std::pair</tt> defines a template ctor (20.2.2, p4) but
+@@ -17071,14 +16648,16 @@ instead of just a straight assignment.
+ <p>
+ Add the following declaration to the definition of <tt>std::pair</tt>:
+ </p>
+-<pre> template&lt;class U, class V&gt;
++<pre>
++ template&lt;class U, class V&gt;
+ pair&amp; operator=(const pair&lt;U, V&gt; &amp;p);
+ </pre>
+ <p>
+ And also add a paragraph describing the effects of the function template to the
+ end of 20.2.2:
+ </p>
+-<pre> template&lt;class U, class V&gt;
++<pre>
++ template&lt;class U, class V&gt;
+ pair&amp; operator=(const pair&lt;U, V&gt; &amp;p);
+ </pre>
+ <p>
+@@ -17087,7 +16666,7 @@ end of 20.2.2:
+ <b>Returns</b>: <tt>*this</tt>
+ </p>
+
+-<p><i>[Curaçao: There is no indication this is was anything other than
++<p><i>[Cura&ccedil;ao: There is no indication this is was anything other than
+ a design decision, and thus NAD.&nbsp; May be appropriate for a future
+ standard.]</i></p>
+
+@@ -17105,11 +16684,11 @@ and thus moved from NAD Future to <del>NAD Editorial</del><ins>Resolved</ins>.
+
+ <hr>
+ <h3><a name="354"></a>354. Associative container lower/upper bound requirements</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Hans Aberg <b>Opened:</b> 2001-12-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Hans Aberg <b>Opened:</b> 2001-12-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Discussions in the thread "Associative container lower/upper bound
+@@ -17161,7 +16740,7 @@ key greater than k, or a.end() if such an element is not found.
+ </p>
+ </blockquote>
+
+-<p><i>[Curaçao: LWG reviewed PR.]</i></p>
++<p><i>[Cura&ccedil;ao: LWG reviewed PR.]</i></p>
+
+
+
+@@ -17172,20 +16751,20 @@ key greater than k, or a.end() if such an element is not found.
+
+ <hr>
+ <h3><a name="355"></a>355. Operational semantics for a.back()</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Yaroslav Mironov <b>Opened:</b> 2002-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Yaroslav Mironov <b>Opened:</b> 2002-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>Table 68 "Optional Sequence Operations" in 23.1.1/12
+-specifies operational semantics for "a.back()" as
+-"*--a.end()", which may be ill-formed <i>[because calling
++<p>Table 68 &quot;Optional Sequence Operations&quot; in 23.1.1/12
++specifies operational semantics for &quot;a.back()&quot; as
++&quot;*--a.end()&quot;, which may be ill-formed <i>[because calling
+ operator-- on a temporary (the return) of a built-in type is
+ ill-formed]</i>, provided a.end() returns a simple pointer rvalue
+ (this is almost always the case for std::vector::end(), for
+ example). Thus, the specification is not only incorrect, it
+-demonstrates a dangerous construct: "--a.end()" may
++demonstrates a dangerous construct: &quot;--a.end()&quot; may
+ successfully compile and run as intended, but after changing the type
+ of the container or the mode of compilation it may produce
+ compile-time error. </p>
+@@ -17193,38 +16772,42 @@ compile-time error. </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change the specification in table 68 "Optional Sequence
+-Operations" in 23.1.1/12 for "a.back()" from</p>
++<p>Change the specification in table 68 &quot;Optional Sequence
++Operations&quot; in 23.1.1/12 for &quot;a.back()&quot; from</p>
+
+
+-<blockquote><pre>*--a.end()
++<blockquote><pre>
++*--a.end()
+ </pre></blockquote>
+
+ <p>to</p>
+
+-<blockquote><pre> { iterator tmp = a.end(); --tmp; return *tmp; }
++<blockquote><pre>
++ { iterator tmp = a.end(); --tmp; return *tmp; }
+ </pre></blockquote>
+
+ <p>and the specification for "a.pop_back()" from</p>
+
+-<blockquote><pre>a.erase(--a.end())
++<blockquote><pre>
++a.erase(--a.end())
+ </pre></blockquote>
+
+ <p>to</p>
+
+-<blockquote><pre> { iterator tmp = a.end(); --tmp; a.erase(tmp); }
++<blockquote><pre>
++ { iterator tmp = a.end(); --tmp; a.erase(tmp); }
+ </pre></blockquote>
+
+-<p><i>[Curaçao: LWG changed PR from "{ X::iterator tmp =
+-a.end(); return *--tmp; }" to "*a.rbegin()", and from
+-"{ X::iterator tmp = a.end(); a.erase(--tmp); }" to
+-"a.erase(rbegin())".]</i></p>
++<p><i>[Cura&ccedil;ao: LWG changed PR from &quot;{ X::iterator tmp =
++a.end(); return *--tmp; }&quot; to &quot;*a.rbegin()&quot;, and from
++&quot;{ X::iterator tmp = a.end(); a.erase(--tmp); }&quot; to
++&quot;a.erase(rbegin())&quot;.]</i></p>
+
+
+-<p><i>[There is a second possible defect; table 68 "Optional
+-Sequence Operations" in the "Operational Semantics"
+-column uses operations present only in the "Reversible
+-Container" requirements, yet there is no stated dependency
++<p><i>[There is a second possible defect; table 68 &quot;Optional
++Sequence Operations&quot; in the &quot;Operational Semantics&quot;
++column uses operations present only in the &quot;Reversible
++Container&quot; requirements, yet there is no stated dependency
+ between these separate requirements tables. Ask in Santa Cruz if the
+ LWG would like a new issue opened.]</i></p>
+
+@@ -17254,10 +16837,11 @@ LWG would like a new issue opened.]</i></p>
+
+ <hr>
+ <h3><a name="358"></a>358. interpreting <tt>thousands_sep</tt> after a <tt>decimal_point</tt></h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I don't think <tt>thousands_sep</tt> is being treated correctly after
+@@ -17314,13 +16898,14 @@ Change the first sentence of 22.2.2.1.2, p9 from
+
+ <hr>
+ <h3><a name="359"></a>359. num_put&lt;&gt;::do_put (..., bool) undocumented</h3>
+-<p><b>Section:</b> 22.4.2.2.1 [facet.num.put.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.2.2.1 [facet.num.put.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>22.2.2.2.1, p1:</p>
+
+- <pre> iter_type put (iter_type out, ios_base&amp; str, char_type fill,
++ <pre>
++ iter_type put (iter_type out, ios_base&amp; str, char_type fill,
+ bool val) const;
+ ...
+
+@@ -17331,7 +16916,8 @@ Change the first sentence of 22.2.2.1.2, p9 from
+ however, 22.2.2.2.2, p23:</p>
+
+ <blockquote>
+-<pre>iter_type put (iter_type out, ios_base&amp; str, char_type fill,
++<pre>
++iter_type put (iter_type out, ios_base&amp; str, char_type fill,
+ bool val) const;
+ </pre>
+
+@@ -17339,7 +16925,8 @@ however, 22.2.2.2.2, p23:</p>
+ <p>Effects: If (str.flags() &amp; ios_base::boolalpha) == 0 then do
+ out = do_put(out, str, fill, (int)val)
+ Otherwise do</p>
+-<pre> string_type s =
++<pre>
++ string_type s =
+ val ? use_facet&lt;ctype&lt;charT&gt; &gt;(loc).truename()
+ : use_facet&lt;ctype&lt;charT&gt; &gt;(loc).falsename();
+ </pre>
+@@ -17389,7 +16976,8 @@ In 22.4.2.2.2 [facet.num.put.virtuals], p23, make the following changes
+ ios_base::boolalpha) == 0</tt> then
+ <tt>do_put (out, str, fill, (long)val)</tt>
+ Otherwise the function obtains a string <tt>s</tt> as if by</p>
+-<pre> string_type s =
++<pre>
++ string_type s =
+ val ? use_facet&lt;ctype&lt;charT&gt; &gt;(loc).truename()
+ : use_facet&lt;ctype&lt;charT&gt; &gt;(loc).falsename();
+ </pre>
+@@ -17410,10 +16998,10 @@ be a requirement of gratuitous inefficiency.
+
+ <hr>
+ <h3><a name="360"></a>360. locale mandates inefficient implementation</h3>
+-<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale">issues</a> in [locale].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.1 [locale] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale">issues</a> in [locale].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.1.1, p7 (copied below) allows iostream formatters and extractors
+@@ -17460,19 +17048,20 @@ prevents locale from being implemented efficiently.
+
+ <hr>
+ <h3><a name="362"></a>362. bind1st/bind2nd type safety</h3>
+-<p><b>Section:</b> D.11 [depr.lib.binders] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andrew Demkin <b>Opened:</b> 2002-04-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [depr.lib.binders] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andrew Demkin <b>Opened:</b> 2002-04-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The definition of bind1st() (D.11 [depr.lib.binders]) can result in
++The definition of bind1st() (X [depr.lib.binders]) can result in
+ the construction of an unsafe binding between incompatible pointer
+ types. For example, given a function whose first parameter type is
+ 'pointer to T', it's possible without error to bind an argument of
+ type 'pointer to U' when U does not derive from T:
+ </p>
+-<pre> foo(T*, int);
++<pre>
++ foo(T*, int);
+
+ struct T {};
+ struct U {};
+@@ -17490,20 +17079,21 @@ The definition of bind1st() includes a functional-style conversion to
+ map its argument to the expected argument type of the bound function
+ (see below):
+ </p>
+-<pre> typename Operation::first_argument_type(x)
++<pre>
++ typename Operation::first_argument_type(x)
+ </pre>
+
+ <p>
+-A functional-style conversion (D.11 [depr.lib.binders]) is defined to be
+-semantically equivalent to an explicit cast expression (D.11 [depr.lib.binders]), which may (according to 5.4, paragraph 5) be interpreted
++A functional-style conversion (X [depr.lib.binders]) is defined to be
++semantically equivalent to an explicit cast expression (X [depr.lib.binders]), which may (according to 5.4, paragraph 5) be interpreted
+ as a reinterpret_cast, thus masking the error.
+ </p>
+
+-<p>The problem and proposed change also apply to D.11 [depr.lib.binders].</p>
++<p>The problem and proposed change also apply to X [depr.lib.binders].</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Add this sentence to the end of D.11 [depr.lib.binders]/1:
++<p>Add this sentence to the end of X [depr.lib.binders]/1:
+ "Binders <tt>bind1st</tt> and <tt>bind2nd</tt> are deprecated in
+ favor of <tt>std::tr1::bind</tt>."</p>
+
+@@ -17522,10 +17112,10 @@ as a reinterpret_cast, thus masking the error.
+
+ <hr>
+ <h3><a name="363"></a>363. Missing exception specification in 27.4.2.1.1</h3>
+-<p><b>Section:</b> 27.5.2.1.1 [ios::failure] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown and Marc Paterno <b>Opened:</b> 2002-05-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.3.1.1 [ios::failure] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown and Marc Paterno <b>Opened:</b> 2002-05-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios::failure">issues</a> in [ios::failure].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The destructor of ios_base::failure should have an empty throw
+@@ -17536,7 +17126,8 @@ declared in this way.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change the destructor to</p>
+-<pre> virtual ~failure() throw();
++<pre>
++ virtual ~failure() throw();
+ </pre>
+
+
+@@ -17549,13 +17140,13 @@ declared in this way.
+
+ <hr>
+ <h3><a name="364"></a>364. Inconsistent wording in 27.5.2.4.2</h3>
+-<p><b>Section:</b> 27.6.2.4.2 [streambuf.virt.buffer] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#streambuf.virt.buffer">issues</a> in [streambuf.virt.buffer].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.6.3.4.2 [streambuf.virt.buffer] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#streambuf.virt.buffer">issues</a> in [streambuf.virt.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-27.6.2.4.2 [streambuf.virt.buffer] paragraph 1 is inconsistent with the Effects
++27.6.3.4.2 [streambuf.virt.buffer] paragraph 1 is inconsistent with the Effects
+ clause for seekoff.
+ </p>
+
+@@ -17595,10 +17186,10 @@ for each class derived from basic_streambuf in this clause
+
+ <hr>
+ <h3><a name="365"></a>365. Lack of const-qualification in clause 27</h3>
+-<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#input.output">issues</a> in [input.output].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27 [input.output] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown, Marc Paterno <b>Opened:</b> 2002-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#input.output">issues</a> in [input.output].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Some stream and streambuf member functions are declared non-const,
+@@ -17610,24 +17201,26 @@ document N1360 for details and rationale.
+ <p>The list of member functions under discussion: <tt>in_avail</tt>,
+ <tt>showmanyc</tt>, <tt>tellg</tt>, <tt>tellp</tt>, <tt>is_open</tt>.</p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#73">73</a></p>
++<p>Related issue: <a href="lwg-closed.html#73">73</a></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 27.8.1.5, 27.8.1.7, 27.8.1.8, 27.8.1.10, 27.8.1.11, and 27.8.1.13</p>
+ <p>Replace</p>
+-<pre> bool is_open();
++<pre>
++ bool is_open();
+ </pre>
+ <p>with</p>
+-<pre> bool is_open() const;
++<pre>
++ bool is_open() const;
+ </pre>
+
+
+ <p><b>Rationale:</b></p>
+ <p>Of the changes proposed in N1360, the only one that is safe is
+ changing the filestreams' is_open to const. The LWG believed that
+-this was NAD the first time it considered this issue (issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#73">73</a>), but now thinks otherwise. The corresponding streambuf
++this was NAD the first time it considered this issue (issue <a href="lwg-closed.html#73">73</a>), but now thinks otherwise. The corresponding streambuf
+ member function, after all,is already const.</p>
+
+ <p>The other proposed changes are less safe, because some streambuf
+@@ -17648,10 +17241,10 @@ way by providing both overloads; this would be a conforming extension.</p>
+
+ <hr>
+ <h3><a name="369"></a>369. io stream objects and static ctors</h3>
+-<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ruslan Abdikeev <b>Opened:</b> 2002-07-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ruslan Abdikeev <b>Opened:</b> 2002-07-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Is it safe to use standard iostream objects from constructors of
+@@ -17742,7 +17335,7 @@ initialized non-local objects defined later in that translation unit.
+ <p>
+ The original proposed resolution unconditionally required
+ implementations to define an ios_base::Init object of some
+-implementation-defined name in the header &lt;iostream&gt;. That's an
++implementation-defined name in the header &lt;iostream>. That's an
+ overspecification. First, defining the object may be unnecessary
+ and even detrimental to performance if an implementation can
+ guarantee that the 8 standard iostream objects will be initialized
+@@ -17760,15 +17353,17 @@ do to ensure that stream objects are constructed during startup.</p>
+
+ <hr>
+ <h3><a name="370"></a>370. Minor error in basic_istream::get</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-07-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-07-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Defect report for description of basic_istream::get (section 27.7.1.3 [istream.unformatted]), paragraph 15. The description for the get function
++<p>Defect report for description of basic_istream::get (section 27.7.2.3 [istream.unformatted]), paragraph 15. The description for the get function
+ with the following signature:</p>
+
+-<pre> basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp;
++<pre>
++ basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp;
+ sb);
+ </pre>
+
+@@ -17788,11 +17383,11 @@ with the following signature:</p>
+ <p><b>Proposed resolution:</b></p>
+ <p>Change the <b>Effects</b> paragraph to:</p>
+ <blockquote><p>
+- Effects: Calls get(sb,this-&gt;widen('\n'))
++ Effects: Calls get(sb,this->widen('\n'))
+ </p></blockquote>
+
+ <p><i>[Pre-Oxford: Minor correction from Howard: replaced 'widen'
+- with 'this-&gt;widen'.]</i></p>
++ with 'this->widen'.]</i></p>
+
+
+
+@@ -17804,10 +17399,11 @@ with the following signature:</p>
+
+ <hr>
+ <h3><a name="371"></a>371. Stability of multiset and multimap member functions</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Frank Compagner <b>Opened:</b> 2002-07-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Frank Compagner <b>Opened:</b> 2002-07-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The requirements for multiset and multimap containers (23.1
+@@ -17825,7 +17421,8 @@ following 'idiom' that removes elements based on a certain predicate
+ function.
+ </p>
+
+-<pre> multimap&lt;int, int&gt; m;
++<pre>
++ multimap&lt;int, int&gt; m;
+ multimap&lt;int, int&gt;::iterator i = m.begin();
+ while (i != m.end()) {
+ if (pred(i))
+@@ -17860,7 +17457,7 @@ be hard to track down by users. This would also make the need for an
+ erase_if() member function that much greater.
+ </p>
+
+-<p>This issue is somewhat related to LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>.</p>
++<p>This issue is somewhat related to LWG issue <a href="lwg-defects.html#130">130</a>.</p>
+
+
+
+@@ -17897,24 +17494,24 @@ wording.]</i></p>
+
+ <hr>
+ <h3><a name="373"></a>373. Are basic_istream and basic_ostream to use (exceptions()&amp;badbit) != 0 ?</h3>
+-<p><b>Section:</b> 27.7.1.2.1 [istream.formatted.reqmts], 27.7.2.6.1 [ostream.formatted.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Keith Baker <b>Opened:</b> 2002-07-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.reqmts">issues</a> in [istream.formatted.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.1 [istream.formatted.reqmts], 27.7.3.6.1 [ostream.formatted.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Keith Baker <b>Opened:</b> 2002-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.reqmts">issues</a> in [istream.formatted.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-In 27.7.1.2.1 [istream.formatted.reqmts] and 27.7.2.6.1 [ostream.formatted.reqmts]
++In 27.7.2.2.1 [istream.formatted.reqmts] and 27.7.3.6.1 [ostream.formatted.reqmts]
+ (exception()&amp;badbit) != 0 is used in testing for rethrow, yet
+ exception() is the constructor to class std::exception in 18.7.1 [type.info] that has no return type. Should member function
+-exceptions() found in 27.5.4 [ios] be used instead?
++exceptions() found in 27.5.5 [ios] be used instead?
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 27.7.1.2.1 [istream.formatted.reqmts] and 27.7.2.6.1 [ostream.formatted.reqmts], change
++In 27.7.2.2.1 [istream.formatted.reqmts] and 27.7.3.6.1 [ostream.formatted.reqmts], change
+ "(exception()&amp;badbit) != 0" to "(exceptions()&amp;badbit) != 0".
+ </p>
+
+@@ -17928,13 +17525,13 @@ In 27.7.1.2.1 [istream.formatted.reqmts] and 27.7.2.6.1 [ostream.formatted.reqmt
+
+ <hr>
+ <h3><a name="375"></a>375. basic_ios should be ios_base in 27.7.1.3</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Section 27.8.1.4 [stringbuf.virtuals]: Table 90, Table 91, and paragraph
++In Section 27.8.2.4 [stringbuf.virtuals]: Table 90, Table 91, and paragraph
+ 14 all contain references to "basic_ios::" which should be
+ "ios_base::".
+ </p>
+@@ -17954,13 +17551,13 @@ paragraph 14 to "ios_base".
+
+ <hr>
+ <h3><a name="376"></a>376. basic_streambuf semantics</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2002-08-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Section 27.8.1.4 [stringbuf.virtuals], Table 90, the implication is that
++In Section 27.8.2.4 [stringbuf.virtuals], Table 90, the implication is that
+ the four conditions should be mutually exclusive, but they are not.
+ The first two cases, as written, are subcases of the third.</p>
+
+@@ -18004,28 +17601,30 @@ are both true, but case 3 is false.
+
+ <hr>
+ <h3><a name="379"></a>379. nonsensical ctype::do_widen() requirement</h3>
+-<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.1.2 [locale.ctype.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.virtuals">issues</a> in [locale.ctype.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The last sentence in 22.2.1.1.2, p11 below doesn't seem to make sense.
+ </p>
+-<pre> charT do_widen (char c) const;
++<pre>
++ charT do_widen (char c) const;
+
+ -11- Effects: Applies the simplest reasonable transformation from
+ a char value or sequence of char values to the corresponding
+ charT value or values. The only characters for which unique
+ transformations are required are those in the basic source
+ character set (2.2). For any named ctype category with a
+- ctype&lt;charT&gt; facet ctw and valid ctype_base::mask value
++ ctype&lt;charT> facet ctw and valid ctype_base::mask value
+ M (is(M, c) || !ctw.is(M, do_widen(c))) is true.
+ </pre>
+ <p>
+ Shouldn't the last sentence instead read
+ </p>
+-<pre> For any named ctype category with a ctype&lt;char&gt; facet ctc
++<pre>
++ For any named ctype category with a ctype&lt;char> facet ctc
+ and valid ctype_base::mask value M
+ (ctc.is(M, c) || !is(M, do_widen(c))) is true.
+ </pre>
+@@ -18041,7 +17640,8 @@ footnote 224.)
+ Replace the last sentence of 22.4.1.1.2 [locale.ctype.virtuals], p11 with the
+ following text:
+ </p>
+-<pre> For any named ctype category with a ctype&lt;char&gt; facet ctc
++<pre>
++ For any named ctype category with a ctype&lt;char> facet ctc
+ and valid ctype_base::mask value M,
+ (ctc.is(M, c) || !is(M, do_widen(c))) is true.
+ </pre>
+@@ -18060,10 +17660,10 @@ following text:
+
+ <hr>
+ <h3><a name="380"></a>380. typos in codecvt tables 53 and 54</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Tables 53 and 54 in 22.4.1.5 [locale.codecvt.byname] are both titled "convert
+@@ -18098,10 +17698,10 @@ elements was needed to terminate a sequence given the value of state."
+
+ <hr>
+ <h3><a name="381"></a>381. detection of invalid mbstate_t in codecvt</h3>
+-<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.5 [locale.codecvt.byname] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2002-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.byname">issues</a> in [locale.codecvt.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ All but one codecvt member functions that take a state_type argument
+@@ -18125,13 +17725,15 @@ cases, I propose the following:
+ Add a new paragraph before 22.2.1.5.2, p5, and after the function
+ declaration below
+ </p>
+-<pre> result do_unshift(stateT&amp; state,
++<pre>
++ result do_unshift(stateT&amp; state,
+ externT* to, externT* to_limit, externT*&amp; to_next) const;
+ </pre>
+ <p>
+ as follows:
+ </p>
+-<pre> Requires: (to &lt;= to_end) well defined and true; state initialized,
++<pre>
++ Requires: (to &lt;= to_end) well defined and true; state initialized,
+ if at the beginning of a sequence, or else equal to the result of
+ converting the preceding characters in the sequence.
+ </pre>
+@@ -18139,12 +17741,14 @@ as follows:
+ and change the text in Table 54, row 4, the <b>error</b> row, under
+ the heading Meaning, from
+ </p>
+-<pre> state has invalid value
++<pre>
++ state has invalid value
+ </pre>
+ <p>
+ to
+ </p>
+-<pre> an unspecified error has occurred
++<pre>
++ an unspecified error has occurred
+ </pre>
+
+
+@@ -18162,10 +17766,10 @@ values, or that choose to detect any other kind of error, may return
+
+ <hr>
+ <h3><a name="383"></a>383. Bidirectional iterator assertion typo</h3>
+-<p><b>Section:</b> 24.2.6 [bidirectional.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> ysapir (submitted via comp.std.c++) <b>Opened:</b> 2002-10-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.2.6 [bidirectional.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> ysapir (submitted via comp.std.c++) <b>Opened:</b> 2002-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bidirectional.iterators">issues</a> in [bidirectional.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Following a discussion on the boost list regarding end iterators and
+@@ -18178,8 +17782,8 @@ with that discussion.
+ I have checked this newsgroup, as well as attempted a search of the
+ Active/Defect/Closed Issues List on the site for the words "s is
+ derefer" so I believe this has not been proposed before. Furthermore,
+-the "Lists by Index" mentions only DR <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a> on section
+-24.1.4, and DR <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a> is not related to this issue.
++the "Lists by Index" mentions only DR <a href="lwg-closed.html#299">299</a> on section
++24.1.4, and DR <a href="lwg-closed.html#299">299</a> is not related to this issue.
+ </p>
+
+ <p>
+@@ -18187,7 +17791,8 @@ The standard makes the following assertion on bidirectional iterators,
+ in section 24.1.4 [lib.bidirectional.iterators], Table 75:
+ </p>
+
+-<pre> operational assertion/note
++<pre>
++ operational assertion/note
+ expression return type semantics pre/post-condition
+
+ --r X&amp; pre: there exists s such
+@@ -18199,7 +17804,7 @@ expression return type semantics pre/post-condition
+ </pre>
+
+ <p>
+-(See <a href="http://aspn.activestate.com/ASPN/Mail/Message/boost/1395763">http://aspn.activestate.com/ASPN/Mail/Message/boost/1395763</a>.)
++(See <a href="http://lists.boost.org/Archives/boost/2002/10/37636.php">http://lists.boost.org/Archives/boost/2002/10/37636.php</a>.)
+ </p>
+
+ <p>
+@@ -18231,10 +17836,10 @@ Change the guarantee to "postcondition: r is dereferenceable."
+
+ <hr>
+ <h3><a name="384"></a>384. equal_range has unimplementable runtime complexity</h3>
+-<p><b>Section:</b> 25.4.3.3 [equal.range] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Hans Bos <b>Opened:</b> 2002-10-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#equal.range">issues</a> in [equal.range].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.3.3 [equal.range] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Hans Bos <b>Opened:</b> 2002-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#equal.range">issues</a> in [equal.range].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 25.4.3.3 [equal.range]
+@@ -18245,7 +17850,8 @@ comparisons are allowed for equal_range.
+ <p>It is not possible to implement equal_range with these constraints.</p>
+
+ <p>In a range of one element as in:</p>
+-<pre> int x = 1;
++<pre>
++ int x = 1;
+ equal_range(&amp;x, &amp;x + 1, 1)
+ </pre>
+
+@@ -18255,7 +17861,8 @@ comparisons are allowed for equal_range.
+
+ <p>I have checked a few libraries and they all use the same (nonconforming)
+ algorithm for equal_range that has a complexity of</p>
+-<pre> 2* log(distance(first, last)) + 2.
++<pre>
++ 2* log(distance(first, last)) + 2.
+ </pre>
+ <p>I guess this is the algorithm that the standard assumes for equal_range.</p>
+
+@@ -18303,9 +17910,9 @@ to <tt>2*log<sub>2</sub>(last - first) + <i>O</i>(1)</tt>.</p>
+
+ <hr>
+ <h3><a name="386"></a>386. Reverse iterator's operator[] has impossible return type</h3>
+-<p><b>Section:</b> 24.5.1.3.11 [reverse.iter.op-=] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.1.3.11 [reverse.iter.op-=] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2002-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In 24.5.1.3.11 [reverse.iter.op-=], <tt>reverse_iterator&lt;&gt;::operator[]</tt>
+ is specified as having a return type of <tt>reverse_iterator::reference</tt>,
+@@ -18319,7 +17926,7 @@ which is the same as <tt>iterator_traits&lt;Iterator&gt;::reference</tt>.
+ to <tt>Iterator</tt>'s value type. The return type specified for
+ reverse_iterator's operator[] would thus appear to be impossible.</p>
+
+-<p>With the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#299">299</a>, the type of
++<p>With the resolution of issue <a href="lwg-closed.html#299">299</a>, the type of
+ <tt>a[n]</tt> will continue to be required (for random access
+ iterators) to be convertible to the value type, and also <tt>a[n] =
+ t</tt> will be a valid expression. Implementations of
+@@ -18336,14 +17943,16 @@ which is the same as <tt>iterator_traits&lt;Iterator&gt;::reference</tt>.
+ <p>In 24.5.1.2 [reverse.iter.requirements] change:</p>
+
+ <blockquote>
+-<pre>reference operator[](difference_type n) const;
++<pre>
++reference operator[](difference_type n) const;
+ </pre>
+ </blockquote>
+
+ <p>to:</p>
+
+ <blockquote>
+-<pre><b><i>unspecified</i></b> operator[](difference_type n) const; // see 24.2.7 [random.access.iterators]
++<pre>
++<b><i>unspecified</i></b> operator[](difference_type n) const; // see 24.2.7 [random.access.iterators]
+ </pre>
+ </blockquote>
+
+@@ -18365,25 +17974,27 @@ Comments from Dave Abrahams: IMO we should resolve 386 by just saying
+
+
+ <hr>
+-<h3><a name="387"></a>387. std::complex over-encapsulated</h3>
+-<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="387"></a>387. <tt>std::complex</tt> over-encapsulated</h3>
++<p><b>Section:</b> 26.4 [complex.numbers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#complex.numbers">active issues</a> in [complex.numbers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.numbers">issues</a> in [complex.numbers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The absence of explicit description of std::complex&lt;T&gt; layout
++The absence of explicit description of <tt>std::complex&lt;T&gt;</tt> layout
+ makes it imposible to reuse existing software developed in traditional
+ languages like Fortran or C with unambigous and commonly accepted
+ layout assumptions. There ought to be a way for practitioners to
+-predict with confidence the layout of std::complex&lt;T&gt; whenever T
++predict with confidence the layout of <tt>std::complex&lt;T&gt;</tt> whenever <tt>T</tt>
+ is a numerical datatype. The absence of ways to access individual
+-parts of a std::complex&lt;T&gt; object as lvalues unduly promotes
++parts of a <tt>std::complex&lt;T&gt;</tt> object as lvalues unduly promotes
+ severe pessimizations. For example, the only way to change,
+ independently, the real and imaginary parts is to write something like
+ </p>
+
+-<pre>complex&lt;T&gt; z;
++<pre>
++complex&lt;T&gt; z;
+ // ...
+ // set the real part to r
+ z = complex&lt;T&gt;(r, z.imag());
+@@ -18398,7 +18009,7 @@ is, in effect, just a pair of numbers with no particular invariant to
+ maintain. Existing practice in numerical computations has it that a
+ complex number datatype is usually represented by Cartesian
+ coordinates. Therefore the over-encapsulation put in the specification
+-of std::complex&lt;&gt; is not justified.
++of <tt>std::complex&lt;&gt;</tt> is not justified.
+ </p>
+
+
+@@ -18406,28 +18017,28 @@ of std::complex&lt;&gt; is not justified.
+ <p><b>Proposed resolution:</b></p>
+ <p>Add the following requirements to 26.4 [complex.numbers] as 26.3/4:</p>
+ <blockquote>
+-<p>If z is an lvalue expression of type cv std::complex&lt;T&gt; then</p>
++<p>If <tt>z</tt> is an lvalue expression of type <i>cv</i> <tt>std::complex&lt;T&gt;</tt> then</p>
+
+ <ul>
+-<li>the expression reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)
++<li>the expression <tt>reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)</tt>
+ is well-formed; and</li>
+-<li>reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)[0]designates the
+-real part of z; and</li>
+-<li>reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)[1]designates the
+-imaginary part of z.</li>
++<li><tt>reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)[0]</tt> designates the
++real part of <tt>z</tt>; and</li>
++<li><tt>reinterpret_cast&lt;cv T(&amp;)[2]&gt;(z)[1]</tt> designates the
++imaginary part of <tt>z</tt>.</li>
+ </ul>
+
+ <p>
+-Moreover, if a is an expression of pointer type cv complex&lt;T&gt;*
+-and the expression a[i] is well-defined for an integer expression
+-i then:
++Moreover, if <tt>a</tt> is an expression of pointer type <i>cv</i> <tt>complex&lt;T&gt;*</tt>
++and the expression <tt>a[i]</tt> is well-defined for an integer expression
++<tt>i</tt> then:
+ </p>
+
+ <ul>
+-<li>reinterpret_cast&lt;cv T*&gt;(a)[2*i] designates the real
+-part of a[i]; and</li>
+-<li>reinterpret_cast&lt;cv T*&gt;(a)[2*i+1] designates the
+-imaginary part of a[i].</li>
++<li><tt>reinterpret_cast&lt;cv T*&gt;(a)[2*i]</tt> designates the real
++part of <tt>a[i]</tt>; and</li>
++<li><tt>reinterpret_cast&lt;cv T*&gt;(a)[2*i+1]</tt> designates the
++imaginary part of <tt>a[i]</tt>.</li>
+ </ul>
+ </blockquote>
+
+@@ -18436,7 +18047,8 @@ In 26.4.2 [complex] and 26.4.3 [complex.special] add the following member functi
+ (changing <tt>T</tt> to concrete types as appropriate for the specializations).
+ </p>
+
+-<blockquote><pre>void real(T);
++<blockquote><pre>
++void real(T);
+ void imag(T);
+ </pre></blockquote>
+
+@@ -18445,33 +18057,37 @@ Add to 26.4.4 [complex.members]
+ </p>
+
+ <blockquote>
+-<pre>T real() const;
++<pre>
++T real() const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> the value of the real component
+-</blockquote>
+-<pre>void real(T val);
++</p></blockquote>
++<pre>
++void real(T val);
+ </pre>
+-<blockquote>
+-Assigns val to the real component.
+-</blockquote>
+-<pre>T imag() const;
++<blockquote><p>
++Assigns <tt>val</tt> to the real component.
++</p></blockquote>
++<pre>
++T imag() const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> the value of the imaginary component
+-</blockquote>
+-<pre>void imag(T val);
++</p></blockquote>
++<pre>
++void imag(T val);
+ </pre>
+-<blockquote>
+-Assigns val to the imaginary component.
+-</blockquote>
++<blockquote><p>
++Assigns <tt>val</tt> to the imaginary component.
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[Kona: The layout guarantee is absolutely necessary for C
+ compatibility. However, there was disagreement about the other part
+ of this proposal: retrieving elements of the complex number as
+- lvalues. An alternative: continue to have real() and imag() return
+- rvalues, but add set_real() and set_imag(). Straw poll: return
++ lvalues. An alternative: continue to have <tt>real()</tt> and <tt>imag()</tt> return
++ rvalues, but add <tt>set_real()</tt> and <tt>set_imag()</tt>. Straw poll: return
+ lvalues - 2, add setter functions - 5. Related issue: do we want
+ reinterpret_cast as the interface for converting a complex to an
+ array of two reals, or do we want to provide a more explicit way of
+@@ -18487,28 +18103,28 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Second half of proposed wording replaced and moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Pre-Sophia Antipolis, Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Added the members to 26.4.3 [complex.special] and changed from Ready to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post-Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from WP back to Ready so that the "and 26.4.3 [complex.special]" in the proposed
+ resolution can be officially applied.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -18523,14 +18139,15 @@ existing implementations already have the layout proposed here.</p>
+
+ <hr>
+ <h3><a name="389"></a>389. Const overload of valarray::operator[] returns by value</h3>
+-<p><b>Section:</b> 26.6.2.3 [valarray.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#77">77</a></p>
++<p><b>Section:</b> 26.6.2.4 [valarray.access] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2002-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.access">issues</a> in [valarray.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#77">77</a></p>
+ <p><b>Discussion:</b></p>
+ <p>Consider the following program:</p>
+-<pre> #include &lt;iostream&gt;
++<pre>
++ #include &lt;iostream&gt;
+ #include &lt;ostream&gt;
+ #include &lt;vector&gt;
+ #include &lt;valarray&gt;
+@@ -18571,11 +18188,13 @@ should not return a const T&amp;.</p>
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In the class synopsis in 26.6.2 [template.valarray], and in
+-26.6.2.3 [valarray.access] just above paragraph 1, change</p>
+-<pre> T operator[](size_t const);
++26.6.2.4 [valarray.access] just above paragraph 1, change</p>
++<pre>
++ T operator[](size_t const);
+ </pre>
+ <p>to</p>
+-<pre> const T&amp; operator[](size_t const);
++<pre>
++ const T&amp; operator[](size_t const);
+ </pre>
+
+ <p><i>[Kona: fixed a minor typo: put semicolon at the end of the line
+@@ -18597,9 +18216,9 @@ impact on allowable optimizations.</p>
+
+ <hr>
+ <h3><a name="391"></a>391. non-member functions specified as const</h3>
+-<p><b>Section:</b> 22.3.3.2 [conversions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2002-12-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.3.2 [conversions] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2002-12-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The specifications of toupper and tolower both specify the functions as
+@@ -18620,10 +18239,11 @@ const in the header file synopsis in section 22.3 [locales].
+
+ <hr>
+ <h3><a name="395"></a>395. inconsistencies in the definitions of rand() and random_shuffle()</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2003-01-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2003-01-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 26.8 [c.math], the C++ standard refers to the C standard for the
+@@ -18674,10 +18294,10 @@ implementation is permitted to use <tt>rand</tt>.]
+
+ <hr>
+ <h3><a name="396"></a>396. what are characters zero and one</h3>
+-<p><b>Section:</b> 20.5.1 [bitset.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6.1 [bitset.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 23.3.5.1, p6 [lib.bitset.cons] talks about a generic character
+@@ -18686,17 +18306,19 @@ that means for charT other than char and wchar_t. And even for
+ those two types, the values 0 and 1 are not actually what is
+ intended -- the values '0' and '1' are. This, along with the
+ converse problem in the description of to_string() in 23.3.5.2,
+-p33, looks like a defect remotely related to DR 303.
++p33, looks like a defect remotely related to DR <a href="lwg-defects.html#303">303</a>.
+ </p>
+ <p>
+-http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#303
++http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303
+ </p>
+- <pre>23.3.5.1:
++ <pre>
++23.3.5.1:
+ -6- An element of the constructed string has value zero if the
+ corresponding character in str, beginning at position pos,
+ is 0. Otherwise, the element has the value one.
+ </pre>
+- <pre>23.3.5.2:
++ <pre>
++23.3.5.2:
+ -33- Effects: Constructs a string object of the appropriate
+ type and initializes it to a string of length N characters.
+ Each character is determined by the value of its
+@@ -18719,13 +18341,13 @@ Sophia Antipolis:
+ <blockquote>
+ <p>
+ We note that <tt>bitset</tt> has been moved from section 23 to section 20, by
+-another issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#842">842</a>) previously resolved at this meeting.
++another issue (<a href="lwg-defects.html#842">842</a>) previously resolved at this meeting.
+ </p>
+ <p>
+ Disposition: move to ready.
+ </p>
+ <p>
+-We request that Howard submit a separate issue regarding the three to_string overloads.
++We request that Howard submit a separate issue regarding the three <tt>to_string</tt> overloads.
+ </p>
+ </blockquote>
+
+@@ -18733,8 +18355,9 @@ We request that Howard submit a separate issue regarding the three to_string ove
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Change the constructor's function declaration immediately before
+-20.5.1 [bitset.cons] p3 to:</p>
+-<pre> template &lt;class charT, class traits, class Allocator&gt;
++20.6.1 [bitset.cons] p3 to:</p>
++<pre>
++ template &lt;class charT, class traits, class Allocator&gt;
+ explicit
+ bitset(const basic_string&lt;charT, traits, Allocator&gt;&amp; str,
+ typename basic_string&lt;charT, traits, Allocator&gt;::size_type pos = 0,
+@@ -18742,7 +18365,7 @@ We request that Howard submit a separate issue regarding the three to_string ove
+ basic_string&lt;charT, traits, Allocator&gt;::npos,
+ charT zero = charT('0'), charT one = charT('1'))
+ </pre>
+-<p>Change the first two sentences of 20.5.1 [bitset.cons] p6 to: "An
++<p>Change the first two sentences of 20.6.1 [bitset.cons] p6 to: "An
+ element of the constructed string has value 0 if the corresponding
+ character in <i>str</i>, beginning at position <i>pos</i>,
+ is <i>zero</i>. Otherwise, the element has the value 1.</p>
+@@ -18755,17 +18378,19 @@ is <i>zero</i>. Otherwise, the element has the value 1.</p>
+ </p>
+
+ <p>Change the declaration of the <tt>to_string</tt> member function
+- immediately before 20.5.2 [bitset.members] p33 to:</p>
+-<pre> template &lt;class charT, class traits, class Allocator&gt;
++ immediately before 20.6.2 [bitset.members] p33 to:</p>
++<pre>
++ template &lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT, traits, Allocator&gt;
+ to_string(charT zero = charT('0'), charT one = charT('1')) const;
+ </pre>
+-<p>Change the last sentence of 20.5.2 [bitset.members] p33 to: "Bit
++<p>Change the last sentence of 20.6.2 [bitset.members] p33 to: "Bit
+ value 0 becomes the character <tt><i>zero</i></tt>, bit value 1 becomes the
+ character <tt><i>one</i></tt>.</p>
+-<p>Change 20.5.4 [bitset.operators] p8 to:</p>
++<p>Change 20.6.4 [bitset.operators] p8 to:</p>
+ <p><b>Returns</b>:</p>
+-<pre> os &lt;&lt; x.template to_string&lt;charT,traits,allocator&lt;charT&gt; &gt;(
++<pre>
++ os &lt;&lt; x.template to_string&lt;charT,traits,allocator&lt;charT&gt; &gt;(
+ use_facet&lt;ctype&lt;charT&gt; &gt;(<i>os</i>.getloc()).widen('0'),
+ use_facet&lt;ctype&lt;charT&gt; &gt;(<i>os</i>.getloc()).widen('1'));
+ </pre>
+@@ -18781,7 +18406,7 @@ is <i>zero</i>. Otherwise, the element has the value 1.</p>
+ resolution allows those users who care about this issue to get it
+ right.</p>
+ <p>We fix the inserter to use the new arguments. Note that we already
+- fixed the analogous problem with the extractor in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#303">303</a>.</p>
++ fixed the analogous problem with the extractor in issue <a href="lwg-defects.html#303">303</a>.</p>
+
+
+
+@@ -18790,35 +18415,36 @@ post Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We are happy with the resolution as proposed, and we move this to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-The proposed wording neglects the 3 newer to_string overloads.
+-</blockquote>
++<blockquote><p>
++The proposed wording neglects the 3 newer <tt>to_string</tt> overloads.
++</p></blockquote>
+
+
+
+
+ <hr>
+ <h3><a name="400"></a>400. redundant type cast in lib.allocator.members</h3>
+-<p><b>Section:</b> 20.9.5.1 [allocator.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.9.5.1 [allocator.members] allocator members, contains
++20.7.9.1 [allocator.members] allocator members, contains
+ the following 3 lines:
+ </p>
+
+-<pre> 12 Returns: new((void *) p) T( val)
++<pre>
++ 12 Returns: new((void *) p) T( val)
+ void destroy(pointer p);
+ 13 Returns: ((T*) p)-&gt;~T()
+ </pre>
+@@ -18842,17 +18468,19 @@ Replace "((T*) p)" with "p".
+
+ <hr>
+ <h3><a name="401"></a>401. incorrect type casts in table 32 in lib.allocator.requirements</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I think that in par2 of [default.con.req] the last two
+ lines of table 32 contain two incorrect type casts. The lines are ...
+ </p>
+
+-<pre> a.construct(p,t) Effect: new((void*)p) T(t)
++<pre>
++ a.construct(p,t) Effect: new((void*)p) T(t)
+ a.destroy(p) Effect: ((T*)p)?-&gt;~T()
+ </pre>
+
+@@ -18861,7 +18489,8 @@ lines of table 32 contain two incorrect type casts. The lines are ...
+ from table 31:
+ </p>
+
+-<pre> alloc&lt;T&gt; a ;// an allocator for T
++<pre>
++ alloc&lt;T&gt; a ;// an allocator for T
+ alloc&lt;T&gt;::pointer p ;// random access iterator
+ // (may be different from T*)
+ alloc&lt;T&gt;::reference r = *p;// T&amp;
+@@ -18925,29 +18554,32 @@ issue to Ready status to be voted into the WP at Kona.
+
+ <hr>
+ <h3><a name="402"></a>402. wrong new expression in [some_]allocator::construct</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements], 20.9.5.1 [allocator.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Markus Mauhart <b>Opened:</b> 2003-02-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This applies to the new expression that is contained in both par12 of
+-20.9.5.1 [allocator.members] and in par2 (table 32) of [default.con.req].
++20.7.9.1 [allocator.members] and in par2 (table 32) of [default.con.req].
+ I think this new expression is wrong, involving unintended side
+ effects.
+ </p>
+
+
+-<p>20.9.5.1 [allocator.members] contains the following 3 lines:</p>
++<p>20.7.9.1 [allocator.members] contains the following 3 lines:</p>
+
+-<pre> 11 Returns: the largest value N for which the call allocate(N,0) might succeed.
++<pre>
++ 11 Returns: the largest value N for which the call allocate(N,0) might succeed.
+ void construct(pointer p, const_reference val);
+ 12 Returns: new((void *) p) T( val)
+ </pre>
+
+
+ <p> [default.con.req] in table 32 has the following line:</p>
+-<pre> a.construct(p,t) Effect: new((void*)p) T(t)
++<pre>
++ a.construct(p,t) Effect: new((void*)p) T(t)
+ </pre>
+
+ <p>
+@@ -18955,7 +18587,8 @@ effects.
+ especially from table 31:
+ </p>
+
+-<pre> alloc&lt;T&gt; a ;// an allocator for T
++<pre>
++ alloc&lt;T&gt; a ;// an allocator for T
+ alloc&lt;T&gt;::pointer p ;// random access iterator
+ // (may be different from T*)
+ alloc&lt;T&gt;::reference r = *p;// T&amp;
+@@ -18991,10 +18624,10 @@ Replace "new" with "::new" in both cases.
+
+ <hr>
+ <h3><a name="403"></a>403. basic_string::swap should not throw exceptions</h3>
+-<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2003-03-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::swap">issues</a> in [string::swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2003-03-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::swap">issues</a> in [string::swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -19059,9 +18692,10 @@ Throws: Shall not throw exceptions.
+
+ <hr>
+ <h3><a name="404"></a>404. May a replacement allocation function be declared inline?</h3>
+-<p><b>Section:</b> 17.6.3.6 [replacement.functions], 18.6.1 [new.delete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-04-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.6 [replacement.functions], 18.6.1 [new.delete] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-04-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#replacement.functions">issues</a> in [replacement.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The eight basic dynamic memory allocation functions (single-object
+@@ -19073,7 +18707,7 @@ in preference to the implementation's definition.
+
+ <p>
+ Three different parts of the standard mention requirements on
+-replacement functions: 17.6.3.6 [replacement.functions], 18.6.1.1 [new.delete.single]
++replacement functions: 17.6.4.6 [replacement.functions], 18.6.1.1 [new.delete.single]
+ and 18.6.1.2 [new.delete.array], and 3.7.3 [basic.stc.auto].
+ </p>
+
+@@ -19091,7 +18725,7 @@ and 18.6.1.2 [new.delete.array], and 3.7.3 [basic.stc.auto].
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new sentence to the end of 17.6.3.6 [replacement.functions] paragraph 3:
++Add a new sentence to the end of 17.6.4.6 [replacement.functions] paragraph 3:
+ "The program's definitions shall not be specified as <tt>inline</tt>.
+ No diagnostic is required."
+ </p>
+@@ -19116,10 +18750,10 @@ believed to be of limited value.
+
+ <hr>
+ <h3><a name="405"></a>405. qsort and POD</h3>
+-<p><b>Section:</b> 25.5 [alg.c.library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2003-04-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.c.library">issues</a> in [alg.c.library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.5 [alg.c.library] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ray Lischner <b>Opened:</b> 2003-04-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.c.library">issues</a> in [alg.c.library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 25.5 [alg.c.library] describes bsearch and qsort, from the C
+@@ -19148,10 +18782,11 @@ type."
+
+ <hr>
+ <h3><a name="406"></a>406. vector::insert(s) exception safety</h3>
+-<p><b>Section:</b> 23.4.1.4 [vector.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2003-04-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2003-04-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is a possible defect in the standard: the standard text was
+@@ -19165,7 +18800,7 @@ existing implementation.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Replace 23.4.1.4 [vector.modifiers] paragraph 1 with:</p>
++<p>Replace 23.3.6.5 [vector.modifiers] paragraph 1 with:</p>
+ <blockquote><p>
+ 1- Notes: Causes reallocation if the new size is greater than the
+ old capacity. If no reallocation happens, all the iterators and
+@@ -19184,10 +18819,10 @@ existing implementation.
+
+ <hr>
+ <h3><a name="407"></a>407. Can singular iterators be destroyed?</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Clause X [iterator.concepts], paragraph 5, says that the only expression
+@@ -19212,10 +18847,10 @@ of a non-singular value to an iterator that holds a singular value."
+
+ <hr>
+ <h3><a name="409"></a>409. Closing an fstream should clear error state</h3>
+-<p><b>Section:</b> 27.9.1.9 [ifstream.members], 27.9.1.13 [ofstream.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.9 [ifstream.members], 27.9.1.13 [ofstream.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nathan Myers <b>Opened:</b> 2003-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ifstream.members">issues</a> in [ifstream.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A strict reading of 27.9.1 [fstreams] shows that opening or
+@@ -19226,7 +18861,7 @@ the EOF bit in the stream's error state is still set. This is
+ counterintuitive.
+ </p>
+ <p>
+-The LWG considered this issue once before, as issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#22">22</a>,
++The LWG considered this issue once before, as issue <a href="lwg-defects.html#22">22</a>,
+ and put in a footnote to clarify that the strict reading was indeed
+ correct. We did that because we believed the standard was
+ unambiguous and consistent, and that we should not make architectural
+@@ -19240,37 +18875,37 @@ language, those considerations no longer apply.
+ <p>Change 27.9.1.9 [ifstream.members], para. 3 from:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode|in). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)].
++Calls rdbuf()->open(s,mode|in). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)].
+ </p></blockquote>
+
+ <p>to:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode|in). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)), else calls clear().
++Calls rdbuf()->open(s,mode|in). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)), else calls clear().
+ </p></blockquote>
+
+ <p>Change 27.9.1.13 [ofstream.members], para. 3 from:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode|out). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)).
++Calls rdbuf()->open(s,mode|out). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)).
+ </p></blockquote>
+
+ <p>to:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode|out). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)), else calls clear().
++Calls rdbuf()->open(s,mode|out). If that function returns a null pointer, calls setstate(failbit) (which may throw ios_base::failure [Footnote: (lib.iostate.flags)), else calls clear().
+ </p></blockquote>
+
+ <p>Change 27.9.1.17 [fstream.members], para. 3 from:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode), If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure). (lib.iostate.flags) )
++Calls rdbuf()->open(s,mode), If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure). (lib.iostate.flags) )
+ </p></blockquote>
+
+ <p>to:</p>
+
+ <blockquote><p>
+-Calls rdbuf()-&gt;open(s,mode), If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure). (lib.iostate.flags) ), else calls clear().
++Calls rdbuf()->open(s,mode), If that function returns a null pointer, calls setstate(failbit), (which may throw ios_base::failure). (lib.iostate.flags) ), else calls clear().
+ </p></blockquote>
+
+
+@@ -19295,69 +18930,79 @@ flags.]</i></p>
+
+ <hr>
+ <h3><a name="410"></a>410. Missing semantics for stack and queue comparison operators</h3>
+-<p><b>Section:</b> 23.3.4.1 [list.cons], 23.3.4.3 [list.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Hans Bos <b>Opened:</b> 2003-06-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.cons">issues</a> in [list.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.5.2 [list.cons], 23.3.5.4 [list.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Hans Bos <b>Opened:</b> 2003-06-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.cons">issues</a> in [list.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Sections 23.3.4.1 [list.cons] and 23.3.4.3 [list.modifiers] list
++Sections 23.3.5.2 [list.cons] and 23.3.5.4 [list.modifiers] list
+ comparison operators (==, !=, &lt;, &lt;=, &gt;, =&gt;) for queue and
+-stack. Only the semantics for queue::operator== (23.3.4.1 [list.cons] par2) and queue::operator&lt; (23.3.4.1 [list.cons]
++stack. Only the semantics for queue::operator== (23.3.5.2 [list.cons] par2) and queue::operator&lt; (23.3.5.2 [list.cons]
+ par3) are defined.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Add the following new paragraphs after 23.3.4.1 [list.cons]
++<p>Add the following new paragraphs after 23.3.5.2 [list.cons]
+ paragraph 3:</p>
+
+ <blockquote>
+
+-<pre> operator!=
++<pre>
++ operator!=
+ </pre>
+ <p>Returns: <tt>x.c != y.c</tt></p>
+
+-<pre> operator&gt;
++<pre>
++ operator&gt;
+ </pre>
+ <p>Returns: <tt>x.c &gt; y.c</tt></p>
+
+-<pre> operator&lt;=
++<pre>
++ operator&lt;=
+ </pre>
+ <p>Returns: <tt>x.c &lt;= y.c</tt></p>
+
+-<pre> operator&gt;=
++<pre>
++ operator&gt;=
+ </pre>
+ <p>Returns: <tt>x.c &gt;= y.c</tt></p>
+
+ </blockquote>
+
+-<p>Add the following paragraphs at the end of 23.3.4.3 [list.modifiers]:</p>
++<p>Add the following paragraphs at the end of 23.3.5.4 [list.modifiers]:</p>
+
+ <blockquote>
+
+-<pre> operator==
++<pre>
++ operator==
+ </pre>
+ <p>Returns: <tt>x.c == y.c</tt></p>
+
+-<pre> operator&lt;
++<pre>
++ operator&lt;
+ </pre>
+ <p>Returns: <tt>x.c &lt; y.c</tt></p>
+
+-<pre> operator!=
++<pre>
++ operator!=
+ </pre>
+ <p>Returns: <tt>x.c != y.c</tt></p>
+
+-<pre> operator&gt;
++<pre>
++ operator&gt;
+ </pre>
+ <p>Returns: <tt>x.c &gt; y.c</tt></p>
+
+-<pre> operator&lt;=
++<pre>
++ operator&lt;=
+ </pre>
+ <p>Returns: <tt>x.c &lt;= y.c</tt></p>
+
+-<pre> operator&gt;=
++<pre>
++ operator&gt;=
+ </pre>
+ <p>Returns: <tt>x.c &gt;= y.c</tt></p>
+
+@@ -19379,10 +19024,10 @@ supposed to do, but we ought to spell it out.</p>
+
+ <hr>
+ <h3><a name="411"></a>411. Wrong names of set member functions</h3>
+-<p><b>Section:</b> 25.4.5 [alg.set.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2003-07-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.set.operations">issues</a> in [alg.set.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.5 [alg.set.operations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Frey <b>Opened:</b> 2003-07-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.set.operations">issues</a> in [alg.set.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 25.4.5 [alg.set.operations] paragraph 1 reads:
+@@ -19407,14 +19052,14 @@ set_intersection(), not union() and intersection().
+
+ <hr>
+ <h3><a name="412"></a>412. Typo in 27.4.4.3</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-07-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#429">429</a></p>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-07-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#429">429</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The Effects clause in 27.5.4.3 [iostate.flags] paragraph 5 says that the
++The Effects clause in 27.5.5.4 [iostate.flags] paragraph 5 says that the
+ function only throws if the respective bits are already set prior to
+ the function call. That's obviously not the intent. The typo ought to
+ be corrected and the text reworded as: "If (<i>state</i> &amp;
+@@ -19424,7 +19069,7 @@ exceptions()) == 0, returns. ..."
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 27.5.4.3 [iostate.flags] paragraph 5, replace "If (rdstate() &amp;
++In 27.5.5.4 [iostate.flags] paragraph 5, replace "If (rdstate() &amp;
+ exceptions()) == 0" with "If ((state | (rdbuf() ? goodbit : badbit))
+ &amp; exceptions()) == 0".
+ </p>
+@@ -19443,10 +19088,10 @@ exceptions()) == 0" with "If ((state | (rdbuf() ? goodbit : badbit))
+
+ <hr>
+ <h3><a name="413"></a>413. Proposed resolution to LDR#64 still wrong</h3>
+-<p><b>Section:</b> 27.7.1.2.3 [istream::extractors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2003-07-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.3 [istream::extractors] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2003-07-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::extractors">issues</a> in [istream::extractors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The second sentence of the proposed resolution says:
+@@ -19466,7 +19111,7 @@ basic_istream (*this) and inserting into sb. I can't really tell if
+ <p><i>[
+ Sydney: Definitely a real issue. We are, indeed, extracting characters
+ from an istream and not from sb. The problem was there in the FDIS and
+-wasn't fixed by issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#64">64</a>. Probably what was intended was
++wasn't fixed by issue <a href="lwg-defects.html#64">64</a>. Probably what was intended was
+ to have *this instead of sb. We're talking about the exception flag
+ state of a basic_istream object, and there's only one basic_istream
+ object in this discussion, so that would be a consistent
+@@ -19501,16 +19146,18 @@ then the caught exception is rethrown.
+
+ <hr>
+ <h3><a name="414"></a>414. Which iterators are invalidated by v.erase()?</h3>
+-<p><b>Section:</b> 23.4.1.4 [vector.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-08-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-08-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Consider the following code fragment:
+ </p>
+ <blockquote>
+-<pre>int A[8] = { 1,3,5,7,9,8,4,2 };
++<pre>
++int A[8] = { 1,3,5,7,9,8,4,2 };
+ std::vector&lt;int&gt; v(A, A+8);
+
+ std::vector&lt;int&gt;::iterator i1 = v.begin() + 3;
+@@ -19556,7 +19203,7 @@ techniques.)
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 23.4.1.4 [vector.modifiers] paragraph 3, change "Invalidates all the
++In 23.3.6.5 [vector.modifiers] paragraph 3, change "Invalidates all the
+ iterators and references after the point of the erase" to
+ "Invalidates iterators and references at or after the point of the
+ erase".
+@@ -19576,9 +19223,9 @@ erase".
+
+ <hr>
+ <h3><a name="415"></a>415. behavior of std::ws</h3>
+-<p><b>Section:</b> 27.7.1.4 [istream.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.4 [istream.manip] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to 27.6.1.4, the ws() manipulator is not required to construct
+@@ -19594,7 +19241,7 @@ doesn't affect the stream's gcount).
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 27.7.1.4 [istream.manip], immediately before the first sentence
++Add to 27.7.2.4 [istream.manip], immediately before the first sentence
+ of paragraph 1, the following text:
+ </p>
+
+@@ -19615,9 +19262,9 @@ of paragraph 1, the following text:
+
+ <hr>
+ <h3><a name="416"></a>416. definitions of XXX_MIN and XXX_MAX macros in climits</h3>
+-<p><b>Section:</b> 18.3.2 [c.limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.3 [c.limits] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -19628,12 +19275,12 @@ is true depends on the #defintion of the LONG_MAX macro, specifically
+ its type. This issue is about the fact that the type of these macros
+ is not actually required to be the same as the the type each respective
+ limit.
+-<br>
++<br/>
+
+ Section 18.2.2 of the C++ Standard does not specify the exact types of
+-the XXX_MIN and XXX_MAX macros #defined in the &lt;climits&gt; and &lt;limits.h&gt;
++the XXX_MIN and XXX_MAX macros #defined in the &lt;climits> and &lt;limits.h>
+ headers such as INT_MAX and LONG_MAX and instead defers to the C standard.
+-<br>
++<br/>
+
+ Section 5.2.4.2.1, p1 of the C standard specifies that "The values [of
+ these constants] shall be replaced by constant expressions suitable for use
+@@ -19641,15 +19288,15 @@ in #if preprocessing directives. Moreover, except for CHAR_BIT and MB_LEN_MAX,
+ the following shall be replaced by expressions that have the same type as
+ would an expression that is an object of the corresponding type converted
+ according to the integer promotions."
+-<br>
++<br/>
+
+ The "corresponding type converted according to the integer promotions" for
+ LONG_MAX is, according to 6.4.4.1, p5 of the C standard, the type of long
+ converted to the first of the following set of types that can represent it:
+ int, long int, long long int. So on an implementation where (sizeof(long)
+ == sizeof(int)) this type is actually int, while on an implementation where
+-(sizeof(long) &gt; sizeof(int)) holds this type will be long.
+-<br>
++(sizeof(long) > sizeof(int)) holds this type will be long.
++<br/>
+
+ This is not an issue in C since the type of the macro cannot be detected
+ by any conforming C program, but it presents a portability problem in C++
+@@ -19670,7 +19317,7 @@ where the actual type is easily detectable by overload resolution.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 18.3.2 [c.limits], paragraph 2:
++Change 18.3.3 [c.limits], paragraph 2:
+ </p>
+
+ <blockquote><p>
+@@ -19684,32 +19331,35 @@ to match the type to which they refer.<i>--end note</i>]</ins>
+
+
+ <hr>
+-<h3><a name="419"></a>419. istream extractors not setting failbit if eofbit is already set</h3>
+-<p><b>Section:</b> 27.7.1.1.3 [istream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="419"></a>419. istream extractors not setting <tt>failbit</tt> if <tt>eofbit</tt> is already set</h3>
++<p><b>Section:</b> 27.7.2.1.3 [istream::sentry] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+-27.7.1.1.3 [istream::sentry], p2 says that istream::sentry ctor prepares for input if is.good()
+-is true. p4 then goes on to say that the ctor sets the sentry::ok_ member to
+-true if the stream state is good after any preparation. 27.7.1.2.1 [istream.formatted.reqmts], p1 then
++27.7.2.1.3 [istream::sentry], p2 says that <tt>istream::sentry</tt> ctor prepares for input if <tt>is.good()</tt>
++is true. p4 then goes on to say that the ctor sets the <tt>sentry::ok_</tt> member to
++true if the stream state is good after any preparation. 27.7.2.2.1 [istream.formatted.reqmts], p1 then
+ says that a formatted input function endeavors to obtain the requested input
+-if the sentry's operator bool() returns true.
++if the sentry's <tt>operator bool()</tt> returns true.
+
+-Given these requirements, no formatted extractor should ever set failbit if
+-the initial stream rdstate() == eofbit. That is contrary to the behavior of
++Given these requirements, no formatted extractor should ever set <tt>failbit</tt> if
++the initial stream <tt>rdstate() == eofbit</tt>. That is contrary to the behavior of
+ all implementations I tested. The program below prints out
+-
++</p>
++<blockquote><pre>
+ eof = 1, fail = 0
+ eof = 1, fail = 1
+-
++</pre></blockquote>
++<p>
+ on all of them.
+ </p>
+ <pre>
+-#include &lt;sstream&gt;
+-#include &lt;cstdio&gt;
++
++#include &lt;sstream>
++#include &lt;cstdio>
+
+ int main()
+ {
+@@ -19717,12 +19367,12 @@ int main()
+
+ int i = 0;
+
+- strm &gt;&gt; i;
++ strm >> i;
+
+ std::printf ("eof = %d, fail = %d\n",
+ !!strm.eof (), !!strm.fail ());
+
+- strm &gt;&gt; i;
++ strm >> i;
+
+ std::printf ("eof = %d, fail = %d\n",
+ !!strm.eof (), !!strm.fail ());
+@@ -19730,43 +19380,43 @@ int main()
+
+ </pre>
+ <p>
+-<br>
++<br/>
+
+ Comments from Jerry Schwarz (c++std-lib-11373):
+-<br>
++<br/>
+
+ Jerry Schwarz wrote:
+-<br>
++<br/>
+
+ I don't know where (if anywhere) it says it in the standard, but the
+-formatted extractors are supposed to set failbit if they don't extract
++formatted extractors are supposed to set <tt>failbit</tt> if they don't extract
+ any characters. If they didn't then simple loops like
+-<br>
++<br/>
+
+-while (cin &gt;&gt; x);
+-<br>
++while (cin >> x);
++<br/>
+
+ would loop forever.
+-<br>
++<br/>
+
+ Further comments from Martin Sebor:
+-<br>
++<br/>
+
+ The question is which part of the extraction should prevent this from happening
+-by setting failbit when eofbit is already set. It could either be the sentry
++by setting <tt>failbit</tt> when <tt>eofbit</tt> is already set. It could either be the sentry
+ object or the extractor. It seems that most implementations have chosen to
+-set failbit in the sentry [...] so that's the text that will need to be
++set <tt>failbit</tt> in the sentry [...] so that's the text that will need to be
+ corrected.
+
+ </p>
+ <p>
+-Pre Berlin: This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a>. If the sentry
++Pre Berlin: This issue is related to <a href="lwg-closed.html#342">342</a>. If the sentry
+ sets <tt>failbit</tt> when it finds <tt>eofbit</tt> already set, then
+ you can never seek away from the end of stream.
+ </p>
+-<p>Kona: Possibly NAD. If eofbit is set then good() will return false. We
++<p>Kona: Possibly NAD. If <tt>eofbit</tt> is set then <tt>good()</tt> will return false. We
+ then set <i>ok</i> to false. We believe that the sentry's
+- constructor should always set failbit when <i>ok</i> is false, and
++ constructor should always set <tt>failbit</tt> when <i>ok</i> is false, and
+ we also think the standard already says that. Possibly it could be
+ clearer.</p>
+
+@@ -19776,15 +19426,15 @@ you can never seek away from the end of stream.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 27.7.1.1.3 [istream::sentry], p2 to:
++Change 27.7.2.1.3 [istream::sentry], p2 to:
+ </p>
+
+ <blockquote>
+@@ -19803,19 +19453,19 @@ Otherwise</ins> prepares for formatted or unformatted input. ...
+
+ <hr>
+ <h3><a name="420"></a>420. is std::FILE a complete type?</h3>
+-<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fstreams">issues</a> in [fstreams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fstreams">issues</a> in [fstreams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 7.19.1, p2, of C99 requires that the FILE type only be declared in
+-&lt;stdio.h&gt;. None of the (implementation-defined) members of the
++&lt;stdio.h>. None of the (implementation-defined) members of the
+ struct is mentioned anywhere for obvious reasons.
+ </p>
+
+ <p>
+-C++ says in 27.8.1, p2 that FILE is a type that's defined in &lt;cstdio&gt;. Is
++C++ says in 27.8.1, p2 that FILE is a type that's defined in &lt;cstdio>. Is
+ it really the intent that FILE be a complete type or is an implementation
+ allowed to just declare it without providing a full definition?
+ </p>
+@@ -19837,10 +19487,10 @@ allowed to just declare it without providing a full definition?
+
+ <hr>
+ <h3><a name="422"></a>422. explicit specializations of member functions of class templates</h3>
+-<p><b>Section:</b> 17.6.3.3 [reserved.names] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.3 [reserved.names] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reserved.names">issues</a> in [reserved.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It has been suggested that 17.4.3.1, p1 may or may not allow programs to
+@@ -19857,7 +19507,7 @@ the program) by relying on the "as if" rule.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+- Add the following sentence to 17.6.3.3 [reserved.names], p1:
++ Add the following sentence to 17.6.4.3 [reserved.names], p1:
+ </p>
+
+ <blockquote><p>
+@@ -19905,9 +19555,10 @@ use the right wording.]</i></p>
+
+ <hr>
+ <h3><a name="425"></a>425. return value of std::get_temporary_buffer</h3>
+-<p><b>Section:</b> 20.9.7 [temporary.buffer] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.7.11 [temporary.buffer] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#temporary.buffer">issues</a> in [temporary.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard is not clear about the requirements on the value returned from
+@@ -19920,7 +19571,7 @@ is when the argument is less than 0.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 20.7.3 [meta.help] paragraph 2 from "...or a pair of 0
++<p>Change 20.10.3 [meta.help] paragraph 2 from "...or a pair of 0
+ values if no storage can be obtained" to "...or a pair of 0 values if
+ no storage can be obtained or if <i>n</i> &lt;= 0."</p>
+ <p><i>[Kona: Matt provided wording]</i></p>
+@@ -19931,26 +19582,26 @@ no storage can be obtained or if <i>n</i> &lt;= 0."</p>
+
+ <hr>
+ <h3><a name="426"></a>426. search_n(), fill_n(), and generate_n() with negative n</h3>
+-<p><b>Section:</b> 25.2.13 [alg.search], 25.3.6 [alg.fill], 25.3.7 [alg.generate] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.search">issues</a> in [alg.search].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.2.13 [alg.search], 25.3.6 [alg.fill], 25.3.7 [alg.generate] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.search">issues</a> in [alg.search].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The complexity requirements for these function templates are incorrect
+ (or don't even make sense) for negative n:</p>
+
+ <p>25.1.9, p7 (search_n):
+-<br>
++<br/>
+ Complexity: At most (last1 - first1) * count applications
+ of the corresponding predicate.</p>
+
+ <p>25.2.5, p3 (fill_n):
+-<br>
++<br/>
+ Complexity: Exactly last - first (or n) assignments.</p>
+
+ <p>25.2.6, p3 (generate_n):
+-<br>
++<br/>
+ Complexity: Exactly last - first (or n) assignments.</p>
+
+ <p>
+@@ -20010,15 +19661,16 @@ or 0 otherwise) assignments.
+
+
+ <hr>
+-<h3><a name="427"></a>427. stage 2 and rationale of DR 221</h3>
+-<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="427"></a>427. Stage 2 and rationale of DR 221</h3>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The requirements specified in Stage 2 and reiterated in the rationale
+-of DR 221 (and echoed again in DR 303) specify that num_get&lt;charT&gt;::
++of DR 221 (and echoed again in DR 303) specify that num_get&lt;charT>::
+ do_get() compares characters on the stream against the widened elements
+ of "012...abc...ABCX+-"
+ </p>
+@@ -20031,7 +19683,7 @@ character type to be equality comparable (the char_traits template must
+ be used to perform tests for equality). Hence, the num_get template cannot
+ be implemented to support any arbitrary character type. The num_get template
+ must either make the assumption that the character type is equality-comparable
+-(as some popular implementations do), or it may use char_traits&lt;charT&gt; to do
++(as some popular implementations do), or it may use char_traits&lt;charT> to do
+ the comparisons (some other popular implementations do that). This diversity
+ of approaches makes it difficult to write portable programs that attempt to
+ instantiate the num_get template on user-defined types.
+@@ -20046,7 +19698,7 @@ instantiate the num_get template on user-defined types.
+ and traits is in order. The LWG considered and rejected the
+ possibility of changing numeric facets to use narrowing instead of
+ widening. This may be a good idea for other reasons (see issue
+- <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#459">459</a>), but it doesn't solve the problem raised by this
++ <a href="lwg-closed.html#459">459</a>), but it doesn't solve the problem raised by this
+ issue. Whether we use widen or narrow the <tt>num_get</tt> facet
+ still has no idea which traits class the user wants to use for
+ the comparison, because only streams, not facets, are passed traits
+@@ -20106,11 +19758,11 @@ Daniel volunteered to provide wording.
+ ]</i></p>
+
+
+-<blockquote>
+-Leave as Open. Alisdair and/or Tom will provide wording based on discussions.
++<blockquote><p>
++Leave as Open. Alisdair and&#47;or Tom will provide wording based on discussions.
+ We want to clearly state that streams and locales work just on <tt>char</tt>
+ and <tt>wchar_t</tt> (except where otherwise specified).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-06 Tom updated the proposed wording.
+@@ -20130,12 +19782,12 @@ The original proposed wording is preserved here:
+ Change 22.3.1.1.1 [locale.category]/6:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] A template formal parameter with name <tt>C</tt> represents the set of all possible
+ specializations on a <ins><tt>char</tt> or <tt>wchar_t</tt></ins> parameter<del> that satisfies
+ the requirements for a character on which any of the iostream components
+ can be instantiated</del>. [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20143,13 +19795,313 @@ can be instantiated</del>. [..]
+ Add the following sentence to the end of 22.4.2 [category.numeric]/2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] These specializations refer to [..], and also for the <tt>ctype&lt;&gt;</tt> facet to
+ perform character classification. <ins>Implementations are encouraged
+ but not required to use the <tt>char_traits&lt;charT&gt;</tt> functions for all
+ comparisons and assignments of characters of type <tt>charT</tt> that do
+ not belong to the set of required specializations.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Change 22.4.2.1.2 [facet.num.get.virtuals]/3:
++</p>
++
++<blockquote>
++<p>
++Stage 2: If <tt>in==end</tt> then stage 2 terminates. Otherwise a <tt>charT</tt> is taken
++from <tt>in</tt> and local variables are initialized as if by
++</p>
++
++<blockquote><pre>
++char_type ct = *in;
++<ins>using tr = char_traits&lt;char_type&gt;;
++const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct);</ins>
++char c = src[<del>find(atoms, atoms + sizeof(src) - 1, ct) - atoms</del>
++ <ins>pos ? pos - atoms : sizeof(src) - 1</ins>];
++if (<ins>tr::eq(ct, </ins><del>ct == </del>use_facet&lt;numpunct&lt;charT&gt;(loc).decimal_point()<ins>)</ins>)
++ c = '.';
++bool discard =
++ <ins>tr::eq(ct, </ins><del>ct == </del>use_facet&lt;numpunct&lt;charT&gt;(loc).thousands_sep()<ins>)</ins>
++ &amp;&amp; use_facet&lt;numpunct&lt;charT&gt; &gt;(loc).grouping().length() != 0;
++</pre></blockquote>
++
++<p>
++where the values <tt>src</tt> and <tt>atoms</tt> are defined as if by: [..]
++</p>
+ </blockquote>
++
++<p>
++[Remark of the author: I considered to replace the initialization
++"<tt>char_type ct = *in;</tt>"
++by the sequence "<tt>char_type ct; tr::assign(ct, *in);</tt>", but decided
++against it, because
++it is a copy-initialization context, not an assignment]
++</p>
++</li>
++
++<li>
++<p>
++Add the following sentence to the end of 22.4.5 [category.time]/1:
++</p>
++
++<blockquote><p>
++[..] Their members use [..] , to determine formatting details.
++<ins>Implementations are encouraged but not required to use the
++<tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
++of characters of type <tt>charT</tt> that do
++not belong to the set of required specializations.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4:
++</p>
++
++<ul>
++<li>
++<del>The next element of <tt>fmt</tt> is equal to <tt>'%'</tt></del> <ins>For the next element <tt>c</tt>
++of <tt>fmt char_traits&lt;char_type&gt;::eq(c, use_facet&lt;ctype&lt;char_type&gt;&gt;(f.getloc()).widen('%')) == true</tt></ins>,
++[..]
++</li>
++</ul>
++</li>
++
++<li>
++<p>
++Add the following sentence to the end of 22.4.6 [category.monetary]/2:
++</p>
++
++<blockquote><p>
++Their members use [..] to determine formatting details.
++<ins>Implementations are encouraged but not required to use the
++<tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
++of characters of type <tt>charT</tt> that do
++not belong to the set of required specializations.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Change 22.4.6.1.2 [locale.money.get.virtuals]/4:
++</p>
++
++<blockquote>
++<p>
++[..] The value <tt>units</tt> is produced as if by:
++</p>
++
++<blockquote><pre>
++for (int i = 0; i &lt; n; ++i)
++ buf2[i] = src[<ins>char_traits&lt;charT&gt;::</ins>find(atoms, <del>atoms+</del>sizeof(src), buf1[i]) - atoms];
++buf2[n] = 0;
++sscanf(buf2, "%Lf", &amp;units);
++</pre></blockquote>
++</blockquote>
++</li>
++
++<li>
++<p>
++Change 22.4.6.2.2 [locale.money.put.virtuals]/1:
++</p>
++
++<blockquote><p>
++[..] for character buffers <tt>buf1</tt> and <tt>buf2</tt>. If <ins>for</ins> the first
++character <ins><tt>c</tt></ins>
++in <tt>digits</tt> or <tt>buf2</tt> <del>is equal to
++<tt>ct.widen('-')</tt></del><ins><tt>char_traits&lt;charT&gt;::eq(c,
++ct.widen('-')) == true</tt></ins>, [..]
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Add a footnote to the first sentence of 27.7.2.2.2 [istream.formatted.arithmetic]/1:
++</p>
++
++<blockquote>
++<p>
++As in the case of the inserters, these extractors depend on the locale's
++<tt>num_get&lt;&gt;</tt> (22.4.2.1) object to perform parsing the input stream
++data.<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Add a footnote to the second sentence of 27.7.3.6.2 [ostream.inserters.arithmetic]/1:
++</p>
++
++<blockquote>
++<p>
++<i>Effects:</i> The classes <tt>num_get&lt;&gt;</tt> and
++<tt>num_put&lt;&gt;</tt> handle locale-dependent numeric formatting and
++parsing. These inserter functions use the imbued locale value to perform
++numeric formatting.<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/4:
++</p>
++
++<blockquote>
++<p>
++<i>Returns:</i> An object of unspecified type such that if in is an object of type
++<tt>basic_istream&lt;charT, traits&gt;</tt> then the expression <tt>in &gt;&gt; get_money(mon, intl)</tt>
++behaves as if it called <tt>f(in, mon, intl)</tt>, where the function <tt>f</tt> is defined
++as:<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/5:
++</p>
++
++<blockquote>
++<p>
++<i>Returns:</i> An object of unspecified type such that if <tt>out</tt> is an object of type
++<tt>basic_ostream&lt;charT, traits&gt;</tt> then the expression <tt>out &lt;&lt; put_money(mon, intl)</tt>
++behaves as a formatted input function that calls <tt>f(out, mon, intl)</tt>, where the
++function <tt>f</tt> is defined as:<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++13) Add a footnote after the first sentence of 27.7.5 [ext.manip]/8:
++</p>
++
++<blockquote>
++<p>
++<i>Returns:</i> An object of unspecified type such that if <tt>in</tt> is an
++object of type b<tt>asic_istream&lt;charT, traits&gt;</tt> then the expression
++<tt>in &gt;&gt;get_time(tmb, fmt)</tt> behaves as if it called <tt>f(in, tmb, fmt)</tt>,
++where the function <tt>f</tt> is defined as:<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/10:
++</p>
++
++<blockquote>
++<p>
++Returns: An object of unspecified type such that if <tt>out</tt> is an object of type
++<tt>basic_ostream&lt;charT, traits&gt;</tt> then the expression <tt>out &lt;&lt;put_time(tmb, fmt)</tt>
++behaves as if it called <tt>f(out, tmb, fmt)</tt>, where the function <tt>f</tt> is defined
++as:<ins><sup>(footnote)</sup></ins> [..]
++</p>
++
++<p>
++<ins>
++<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
++<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
++results.
++</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++</blockquote>
++</blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote>
++<p>
++Moved to Ready with only two of the bullets. The original wording is preserved
++here:
++</p>
++
++<blockquote class="note">
++<ol>
++<li>
++<p>
++Change 22.3.1.1.1 [locale.category]/6:
++</p>
++
++<blockquote><p>
++[..] A template formal parameter with name <tt>C</tt> represents
++the set
++<del>of all possible specializations on a</del>
++<ins>of types containing <tt>char</tt>, <tt>wchar_t</tt>,
++and any other implementation-defined character type
++</ins>
++<del> parameter</del>
++that satisfies
++the requirements for a character on which any of the iostream components
++can be instantiated. [..]
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Add the following sentence to the end of 22.4.2 [category.numeric]/2:
++</p>
++
++<blockquote><p>
++[..] These specializations refer to [..], and also for the <tt>ctype&lt;&gt;</tt> facet to
++perform character classification. <ins>[<i>Note:</i> Implementations are encouraged
++but not required to use the <tt>char_traits&lt;charT&gt;</tt> functions for all
++comparisons and assignments of characters of type <tt>charT</tt> that do
++not belong to the set of required specializations - <i>end note</i>].</ins>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20163,7 +20115,8 @@ Stage 2: If <tt>in==end</tt> then stage 2 terminates. Otherwise a <tt>charT</tt>
+ from <tt>in</tt> and local variables are initialized as if by
+ </p>
+
+-<blockquote><pre>char_type ct = *in;
++<blockquote><pre>
++char_type ct = *in;
+ <ins>using tr = char_traits&lt;char_type&gt;;
+ const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct);</ins>
+ char c = src[<del>find(atoms, atoms + sizeof(src) - 1, ct) - atoms</del>
+@@ -20194,311 +20147,13 @@ it is a copy-initialization context, not an assignment]
+ Add the following sentence to the end of 22.4.5 [category.time]/1:
+ </p>
+
+-<blockquote>
+-[..] Their members use [..] , to determine formatting details.
+-<ins>Implementations are encouraged but not required to use the
+-<tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
+-of characters of type <tt>charT</tt> that do
+-not belong to the set of required specializations.</ins>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4:
+-</p>
+-
+-<ul>
+-<li>
+-<del>The next element of <tt>fmt</tt> is equal to <tt>'%'</tt></del> <ins>For the next element <tt>c</tt>
+-of <tt>fmt char_traits&lt;char_type&gt;::eq(c, use_facet&lt;ctype&lt;char_type&gt;&gt;(f.getloc()).widen('%')) == true</tt></ins>,
+-[..]
+-</li>
+-</ul>
+-</li>
+-
+-<li>
+-<p>
+-Add the following sentence to the end of 22.4.6 [category.monetary]/2:
+-</p>
+-
+-<blockquote>
+-Their members use [..] to determine formatting details.
+-<ins>Implementations are encouraged but not required to use the
+-<tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
+-of characters of type <tt>charT</tt> that do
+-not belong to the set of required specializations.</ins>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 22.4.6.1.2 [locale.money.get.virtuals]/4:
+-</p>
+-
+-<blockquote>
+-<p>
+-[..] The value <tt>units</tt> is produced as if by:
+-</p>
+-
+-<blockquote><pre>for (int i = 0; i &lt; n; ++i)
+- buf2[i] = src[<ins>char_traits&lt;charT&gt;::</ins>find(atoms, <del>atoms+</del>sizeof(src), buf1[i]) - atoms];
+-buf2[n] = 0;
+-sscanf(buf2, "%Lf", &amp;units);
+-</pre></blockquote>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 22.4.6.2.2 [locale.money.put.virtuals]/1:
+-</p>
+-
+-<blockquote>
+-[..] for character buffers <tt>buf1</tt> and <tt>buf2</tt>. If <ins>for</ins> the first
+-character <ins><tt>c</tt></ins>
+-in <tt>digits</tt> or <tt>buf2</tt> <del>is equal to
+-<tt>ct.widen('-')</tt></del><ins><tt>char_traits&lt;charT&gt;::eq(c,
+-ct.widen('-')) == true</tt></ins>, [..]
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1:
+-</p>
+-
+-<blockquote>
+-<p>
+-As in the case of the inserters, these extractors depend on the locale's
+-<tt>num_get&lt;&gt;</tt> (22.4.2.1) object to perform parsing the input stream
+-data.<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1:
+-</p>
+-
+-<blockquote>
+-<p>
+-<i>Effects:</i> The classes <tt>num_get&lt;&gt;</tt> and
+-<tt>num_put&lt;&gt;</tt> handle locale-dependent numeric formatting and
+-parsing. These inserter functions use the imbued locale value to perform
+-numeric formatting.<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/4:
+-</p>
+-
+-<blockquote>
+-<p>
+-<i>Returns:</i> An object of unspecified type such that if in is an object of type
+-<tt>basic_istream&lt;charT, traits&gt;</tt> then the expression <tt>in &gt;&gt; get_money(mon, intl)</tt>
+-behaves as if it called <tt>f(in, mon, intl)</tt>, where the function <tt>f</tt> is defined
+-as:<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/5:
+-</p>
+-
+-<blockquote>
+-<p>
+-<i>Returns:</i> An object of unspecified type such that if <tt>out</tt> is an object of type
+-<tt>basic_ostream&lt;charT, traits&gt;</tt> then the expression <tt>out &lt;&lt; put_money(mon, intl)</tt>
+-behaves as a formatted input function that calls <tt>f(out, mon, intl)</tt>, where the
+-function <tt>f</tt> is defined as:<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-13) Add a footnote after the first sentence of 27.7.4 [ext.manip]/8:
+-</p>
+-
+-<blockquote>
+-<p>
+-<i>Returns:</i> An object of unspecified type such that if <tt>in</tt> is an
+-object of type b<tt>asic_istream&lt;charT, traits&gt;</tt> then the expression
+-<tt>in &gt;&gt;get_time(tmb, fmt)</tt> behaves as if it called <tt>f(in, tmb, fmt)</tt>,
+-where the function <tt>f</tt> is defined as:<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the input stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/10:
+-</p>
+-
+-<blockquote>
+-<p>
+-Returns: An object of unspecified type such that if <tt>out</tt> is an object of type
+-<tt>basic_ostream&lt;charT, traits&gt;</tt> then the expression <tt>out &lt;&lt;put_time(tmb, fmt)</tt>
+-behaves as if it called <tt>f(out, tmb, fmt)</tt>, where the function <tt>f</tt> is defined
+-as:<ins><sup>(footnote)</sup></ins> [..]
+-</p>
+-
+-<p>
+-<ins>
+-<sup>footnote)</sup> If the traits of the output stream has different semantics for <tt>lt()</tt>,
+-<tt>eq()</tt>, and <tt>assign()</tt> than <tt>char_traits&lt;char_type&gt;</tt>, this may give surprising
+-results.
+-</ins>
+-</p>
+-</blockquote>
+-</li>
+-</ol>
+-
+-</blockquote>
+-</blockquote>
+-
+-<p><i>[
+-2010 Pittsburgh:
+-]</i></p>
+-
+-
+-<blockquote>
+-<p>
+-Moved to Ready with only two of the bullets. The original wording is preserved
+-here:
+-</p>
+-
+-<blockquote class="note">
+-<ol>
+-<li>
+-<p>
+-Change 22.3.1.1.1 [locale.category]/6:
+-</p>
+-
+-<blockquote>
+-[..] A template formal parameter with name <tt>C</tt> represents
+-the set
+-<del>of all possible specializations on a</del>
+-<ins>of types containing <tt>char</tt>, <tt>wchar_t</tt>,
+-and any other implementation-defined character type
+-</ins>
+-<del> parameter</del>
+-that satisfies
+-the requirements for a character on which any of the iostream components
+-can be instantiated. [..]
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Add the following sentence to the end of 22.4.2 [category.numeric]/2:
+-</p>
+-
+-<blockquote>
+-[..] These specializations refer to [..], and also for the <tt>ctype&lt;&gt;</tt> facet to
+-perform character classification. <ins>[<i>Note:</i> Implementations are encouraged
+-but not required to use the <tt>char_traits&lt;charT&gt;</tt> functions for all
+-comparisons and assignments of characters of type <tt>charT</tt> that do
+-not belong to the set of required specializations - <i>end note</i>].</ins>
+-</blockquote>
+-</li>
+-
+-<li>
+-<p>
+-Change 22.4.2.1.2 [facet.num.get.virtuals]/3:
+-</p>
+-
+-<blockquote>
+-<p>
+-Stage 2: If <tt>in==end</tt> then stage 2 terminates. Otherwise a <tt>charT</tt> is taken
+-from <tt>in</tt> and local variables are initialized as if by
+-</p>
+-
+-<blockquote><pre>char_type ct = *in;
+-<ins>using tr = char_traits&lt;char_type&gt;;
+-const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct);</ins>
+-char c = src[<del>find(atoms, atoms + sizeof(src) - 1, ct) - atoms</del>
+- <ins>pos ? pos - atoms : sizeof(src) - 1</ins>];
+-if (<ins>tr::eq(ct, </ins><del>ct == </del>use_facet&lt;numpunct&lt;charT&gt;(loc).decimal_point()<ins>)</ins>)
+- c = '.';
+-bool discard =
+- <ins>tr::eq(ct, </ins><del>ct == </del>use_facet&lt;numpunct&lt;charT&gt;(loc).thousands_sep()<ins>)</ins>
+- &amp;&amp; use_facet&lt;numpunct&lt;charT&gt; &gt;(loc).grouping().length() != 0;
+-</pre></blockquote>
+-
+-<p>
+-where the values <tt>src</tt> and <tt>atoms</tt> are defined as if by: [..]
+-</p>
+-</blockquote>
+-
+-<p>
+-[Remark of the author: I considered to replace the initialization
+-"<tt>char_type ct = *in;</tt>"
+-by the sequence "<tt>char_type ct; tr::assign(ct, *in);</tt>", but decided
+-against it, because
+-it is a copy-initialization context, not an assignment]
+-</p>
+-</li>
+-
+-<li>
+-<p>
+-Add the following sentence to the end of 22.4.5 [category.time]/1:
+-</p>
+-
+-<blockquote>
++<blockquote><p>
+ [..] Their members use [..] , to determine formatting details.
+ <ins>[<i>Note:</i> Implementations are encouraged but not required to use the
+ <tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
+ of characters of type <tt>charT</tt> that do
+ not belong to the set of required specializations - <i>end note</i>].</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20520,13 +20175,13 @@ of <tt>fmt char_traits&lt;char_type&gt;::eq(c, use_facet&lt;ctype&lt;char_type&g
+ Add the following sentence to the end of 22.4.6 [category.monetary]/2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Their members use [..] to determine formatting details.
+ <ins>[<i>Note:</i> Implementations are encouraged but not required to use the
+ <tt>char_traits&lt;charT&gt;</tt> functions for all comparisons and assignments
+ of characters of type <tt>charT</tt> that do
+ not belong to the set of required specializations - <i>end note</i>].</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20539,7 +20194,8 @@ Change 22.4.6.1.2 [locale.money.get.virtuals]/4:
+ [..] The value <tt>units</tt> is produced as if by:
+ </p>
+
+-<blockquote><pre>for (int i = 0; i &lt; n; ++i)
++<blockquote><pre>
++for (int i = 0; i &lt; n; ++i)
+ buf2[i] = src[<ins>char_traits&lt;charT&gt;::</ins>find(atoms, <del>atoms+</del>sizeof(src), buf1[i]) - atoms];
+ buf2[n] = 0;
+ sscanf(buf2, "%Lf", &amp;units);
+@@ -20552,13 +20208,13 @@ sscanf(buf2, "%Lf", &amp;units);
+ Change 22.4.6.2.2 [locale.money.put.virtuals]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] for character buffers <tt>buf1</tt> and <tt>buf2</tt>. If <ins>for</ins> the first
+ character <ins><tt>c</tt></ins>
+ in <tt>digits</tt> or <tt>buf2</tt> <del>is equal to
+ <tt>ct.widen('-')</tt></del><ins><tt>char_traits&lt;charT&gt;::eq(c,
+ ct.widen('-')) == true</tt></ins>, [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20566,7 +20222,7 @@ ct.widen('-')) == true</tt></ins>, [..]
+ Add a new paragraph after the
+ first paragraph of 27.2.2 [iostreams.limits.pos]/1:
+ </p>
+-<blockquote>
++<blockquote><p>
+ In the classes of clause 27,
+ a template formal parameter with name <tt>charT</tt> represents
+ one of
+@@ -20576,12 +20232,12 @@ and any other implementation-defined character type
+ that satisfies
+ the requirements for a character on which any of the iostream components
+ can be instantiated.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1:
++Add a footnote to the first sentence of 27.7.2.2.2 [istream.formatted.arithmetic]/1:
+ </p>
+
+ <blockquote>
+@@ -20603,7 +20259,7 @@ results.
+
+ <li>
+ <p>
+-Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1:
++Add a footnote to the second sentence of 27.7.3.6.2 [ostream.inserters.arithmetic]/1:
+ </p>
+
+ <blockquote>
+@@ -20627,7 +20283,7 @@ results.
+
+ <li>
+ <p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/4:
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/4:
+ </p>
+
+ <blockquote>
+@@ -20650,7 +20306,7 @@ results.
+
+ <li>
+ <p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/5:
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/5:
+ </p>
+
+ <blockquote>
+@@ -20673,7 +20329,7 @@ results.
+
+ <li>
+ <p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/8:
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/8:
+ </p>
+
+ <blockquote>
+@@ -20696,7 +20352,7 @@ results.
+
+ <li>
+ <p>
+-Add a footnote after the first sentence of 27.7.4 [ext.manip]/10:
++Add a footnote after the first sentence of 27.7.5 [ext.manip]/10:
+ </p>
+
+ <blockquote>
+@@ -20729,7 +20385,7 @@ results.
+ Change 22.3.1.1.1 [locale.category]/6:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] A template formal parameter with name <tt>C</tt> represents
+ the set
+ <del>of all possible specializations on a</del>
+@@ -20740,7 +20396,7 @@ and any other implementation-defined character type
+ that satisfies
+ the requirements for a character on which any of the iostream components
+ can be instantiated. [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -20748,7 +20404,7 @@ can be instantiated. [..]
+ Add a new paragraph after the
+ first paragraph of 27.2.2 [iostreams.limits.pos]/1:
+ </p>
+-<blockquote>
++<blockquote><p>
+ In the classes of clause 27,
+ a template formal parameter with name <tt>charT</tt> represents
+ one of
+@@ -20758,7 +20414,7 @@ and any other implementation-defined character type
+ that satisfies
+ the requirements for a character on which any of the iostream components
+ can be instantiated.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ </ol>
+@@ -20768,10 +20424,10 @@ can be instantiated.
+
+ <hr>
+ <h3><a name="428"></a>428. string::erase(iterator) validity</h3>
+-<p><b>Section:</b> 21.4.6.5 [string::erase] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::erase">issues</a> in [string::erase].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.6.5 [string::erase] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::erase">issues</a> in [string::erase].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 23.1.1, p3 along with Table 67 specify as a prerequisite for a.erase(q)
+@@ -20805,10 +20461,10 @@ which is most likely not the intent.
+
+
+ <hr>
+-<h3><a name="430"></a>430. valarray subset operations</h3>
+-<p><b>Section:</b> 26.6.2.4 [valarray.sub] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="430"></a>430. <tt>valarray</tt> subset operations</h3>
++<p><b>Section:</b> 26.6.2.5 [valarray.sub] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard fails to specify the behavior of valarray::operator[](slice)
+@@ -20828,11 +20484,11 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Please note that the standard also fails to specify the behavior of
+ slice_array and gslice_array in the valid case. Bill Plauger will
+-endeavor to provide revised wording for slice_array and gslice_array.
+-</blockquote>
++endeavor to provide revised wording for <tt>slice_array</tt> and <tt>gslice_array</tt>.
++</p></blockquote>
+
+ <p><i>[
+ post-Bellevue: Bill provided wording.
+@@ -20855,10 +20511,10 @@ Move to Ready.
+ ]</i></p>
+
+
+-<blockquote>
+-The resolution to LWG issue 430 has not been applied --- there have been
++<blockquote><p>
++The resolution to LWG issue <a href="lwg-defects.html#430">430</a> has not been applied &mdash; there have been
+ changes to the underlying text, and the resolution needs to be reworked.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-09 Matt updated wording.
+@@ -20874,7 +20530,7 @@ changes to the underlying text, and the resolution needs to be reworked.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Replace 26.6.2.4 [valarray.sub], with the following:
++Replace 26.6.2.5 [valarray.sub], with the following:
+ </p>
+
+ <blockquote>
+@@ -20890,7 +20546,8 @@ selective replacement (slicing) of the controlled sequence. In each case
+ the selected element(s) must exist.
+ </p>
+
+-<pre>valarray&lt;T&gt; operator[](slice slicearr) const;
++<pre>
++valarray&lt;T&gt; operator[](slice slicearr) const;
+ </pre>
+
+ <blockquote>
+@@ -20900,7 +20557,8 @@ containing those elements of the controlled sequence designated by
+ <tt>slicearr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ valarray&lt;char&gt; v1("ABCDE", 5);
+ v0[slice(2, 5, 3)] = v1;
+ // v0 == valarray&lt;char&gt;("abAdeBghCjkDmnEp", 16)
+@@ -20910,7 +20568,8 @@ v0[slice(2, 5, 3)] = v1;
+ </p>
+ </blockquote>
+
+-<pre>valarray&lt;T&gt; operator[](slice slicearr);
++<pre>
++valarray&lt;T&gt; operator[](slice slicearr);
+ </pre>
+
+ <blockquote>
+@@ -20919,7 +20578,8 @@ This function selects those elements of the controlled sequence
+ designated by <tt>slicearr</tt>. [<i>Example</i>:
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ valarray&lt;char&gt; v1("ABCDE", 5);
+ v0[slice(2, 5, 3)] = v1;
+ // v0 == valarray&lt;char&gt;("abAdeBghCjkDmnEp", 16)
+@@ -20929,7 +20589,8 @@ v0[slice(2, 5, 3)] = v1;
+ </p>
+ </blockquote>
+
+-<pre>valarray&lt;T&gt; operator[](const gslice&amp; gslicearr) const;
++<pre>
++valarray&lt;T&gt; operator[](const gslice&amp; gslicearr) const;
+ </pre>
+
+ <blockquote>
+@@ -20939,7 +20600,8 @@ containing those elements of the controlled sequence designated by
+ <tt>gslicearr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ const size_t lv[] = {2, 3};
+ const size_t dv[] = {7, 2};
+ const valarray&lt;size_t&gt; len(lv, 2), str(dv, 2);
+@@ -20951,7 +20613,8 @@ const valarray&lt;size_t&gt; len(lv, 2), str(dv, 2);
+ </p>
+ </blockquote>
+
+-<pre>gslice_array&lt;T&gt; operator[](const gslice&amp; gslicearr);
++<pre>
++gslice_array&lt;T&gt; operator[](const gslice&amp; gslicearr);
+ </pre>
+
+ <blockquote>
+@@ -20960,7 +20623,8 @@ This function selects those elements of the controlled sequence
+ designated by <tt>gslicearr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ valarray&lt;char&gt; v1("ABCDEF", 6);
+ const size_t lv[] = {2, 3};
+ const size_t dv[] = {7, 2};
+@@ -20973,7 +20637,8 @@ v0[gslice(3, len, str)] = v1;
+ </p>
+ </blockquote>
+
+-<pre>valarray&lt;T&gt; operator[](const valarray&lt;bool&gt;&amp; boolarr) const;
++<pre>
++valarray&lt;T&gt; operator[](const valarray&lt;bool&gt;&amp; boolarr) const;
+ </pre>
+
+ <blockquote>
+@@ -20983,7 +20648,8 @@ containing those elements of the controlled sequence designated by
+ <tt>boolarr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ const bool vb[] = {false, false, true, true, false, true};
+ // v0[valarray&lt;bool&gt;(vb, 6)] returns
+ // valarray&lt;char&gt;("cdf", 3)
+@@ -20993,7 +20659,8 @@ const bool vb[] = {false, false, true, true, false, true};
+ </p>
+ </blockquote>
+
+-<pre>mask_array&lt;T&gt; operator[](const valarray&lt;bool&gt;&amp; boolarr);
++<pre>
++mask_array&lt;T&gt; operator[](const valarray&lt;bool&gt;&amp; boolarr);
+ </pre>
+
+ <blockquote>
+@@ -21002,7 +20669,8 @@ This function selects those elements of the controlled sequence
+ designated by <tt>boolarr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ valarray&lt;char&gt; v1("ABC", 3);
+ const bool vb[] = {false, false, true, true, false, true};
+ v0[valarray&lt;bool&gt;(vb, 6)] = v1;
+@@ -21013,7 +20681,8 @@ v0[valarray&lt;bool&gt;(vb, 6)] = v1;
+ </p>
+ </blockquote>
+
+-<pre>valarray&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp; indarr) const;
++<pre>
++valarray&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp; indarr) const;
+ </pre>
+
+ <blockquote>
+@@ -21023,7 +20692,8 @@ containing those elements of the controlled sequence designated by
+ <tt>indarr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ const size_t vi[] = {7, 5, 2, 3, 8};
+ // v0[valarray&lt;size_t&gt;(vi, 5)] returns
+ // valarray&lt;char&gt;("hfcdi", 5)
+@@ -21033,7 +20703,8 @@ const size_t vi[] = {7, 5, 2, 3, 8};
+ </p>
+ </blockquote>
+
+-<pre>indirect_array&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp; indarr);
++<pre>
++indirect_array&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp; indarr);
+ </pre>
+
+ <blockquote>
+@@ -21042,7 +20713,8 @@ This function selects those elements of the controlled sequence
+ designated by <tt>indarr</tt>. [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
++<blockquote><pre>
++valarray&lt;char&gt; v0("abcdefghijklmnop", 16);
+ valarray&lt;char&gt; v1("ABCDE", 5);
+ const size_t vi[] = {7, 5, 2, 3, 8};
+ v0[valarray&lt;size_t&gt;(vi, 5)] = v1;
+@@ -21061,12 +20733,13 @@ v0[valarray&lt;size_t&gt;(vi, 5)] = v1;
+
+ <hr>
+ <h3><a name="431"></a>431. Swapping containers with unequal allocators</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements], 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-09-20 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2003-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Clause 20.2.5 [allocator.requirements] paragraph 4 says that implementations
++<p>Clause 17.6.3.5 [allocator.requirements] paragraph 4 says that implementations
+ are permitted to supply containers that are unable to cope with
+ allocator instances and that container implementations may assume
+ that all instances of an allocator type compare equal. We gave
+@@ -21089,12 +20762,13 @@ v0[valarray&lt;size_t&gt;(vi, 5)] = v1;
+ <p>3. The operation swaps both the vectors' contents and their
+ allocators. This would be an O(1) operation. That is:</p>
+ <blockquote>
+- <pre> my_alloc a1(...);
++ <pre>
++ my_alloc a1(...);
+ my_alloc a2(...);
+ assert(a1 != a2);
+
+- vector&lt;int, my_alloc&gt; v1(a1);
+- vector&lt;int, my_alloc&gt; v2(a2);
++ vector&lt;int, my_alloc> v1(a1);
++ vector&lt;int, my_alloc> v2(a2);
+ assert(a1 == v1.get_allocator());
+ assert(a2 == v2.get_allocator());
+
+@@ -21131,7 +20805,7 @@ swap allocators, else it will perform a "slow swap" using copy construction and
+ 2009-04-28 Pablo adds:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Fixed in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a>.
+ I argued for marking this Tentatively-Ready right after Bellevue,
+@@ -21141,12 +20815,12 @@ would break in the presence of the RVO. (That breakage had nothing to do with
+ swap, but never-the-less). I addressed that breakage in in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2840.pdf">N2840</a>
+ (Summit) by means of a non-normative reference:
+-
+-<blockquote>
++</p>
++<blockquote><p>
+ [<i>Note:</i> in situations where the copy constructor for a container is elided,
+ this function is not called. The behavior in these cases is as if
+-<tt>select_on_container_copy_construction</tt> returned <tt>x</tt> — <i>end note</i>]
+-</blockquote>
++<tt>select_on_container_copy_construction</tt> returned <tt>x</tt> &mdash; <i>end note</i>]
++</p></blockquote>
+
+ </blockquote>
+
+@@ -21155,10 +20829,10 @@ this function is not called. The behavior in these cases is as if
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -21170,10 +20844,10 @@ this function is not called. The behavior in these cases is as if
+
+ <hr>
+ <h3><a name="432"></a>432. stringbuf::overflow() makes only one write position available</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Christian W Brock <b>Opened:</b> 2003-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Christian W Brock <b>Opened:</b> 2003-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>27.7.1.3 par 8 says:</p>
+ <blockquote><p>
+@@ -21265,7 +20939,7 @@ basic_stringbuf underlying character sequence. If the buffer is only
+ created in input mode, the underlying character sequence is equal to
+ the input sequence; otherwise, it is equal to the output sequence. In
+ case of an empty underlying character sequence, the function returns
+-basic_string&lt;charT,traits,Allocator&gt;().
++basic_string&lt;charT,traits,Allocator>().
+ </p>
+ </blockquote>
+
+@@ -21391,7 +21065,7 @@ newoff + off to the next pointer xnext .
+ <blockquote>
+ <p>
+ -12- _ If (newoff + off) &lt; 0, or if (newoff + off) refers to an
+-uninitialized character (as defined in 27.8.1.3 [stringbuf.members]
++uninitialized character (as defined in 27.8.2.3 [stringbuf.members]
+ paragraph 1), the positioning operation fails. Otherwise, the function
+ assigns xbeg + newoff + off to the next pointer xnext .
+ </p>
+@@ -21456,10 +21130,10 @@ initialized range.</p>
+
+ <hr>
+ <h3><a name="434"></a>434. bitset::to_string() hard to use</h3>
+-<p><b>Section:</b> 20.5.2 [bitset.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6.2 [bitset.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It has been pointed out a number of times that the bitset to_string() member
+@@ -21478,22 +21152,23 @@ interface (declarations only) of the class template bitset as well as to
+ section 23.3.5.2, immediately after p34, the Returns clause of the existing
+ to_string() member function template:</p>
+
+-<pre> template &lt;class charT, class traits&gt;
+- basic_string&lt;charT, traits, allocator&lt;charT&gt; &gt;
++<pre>
++ template &lt;class charT, class traits>
++ basic_string&lt;charT, traits, allocator&lt;charT> >
+ to_string () const;
+
+- -34.1- Returns: to_string&lt;charT, traits, allocator&lt;charT&gt; &gt;().
++ -34.1- Returns: to_string&lt;charT, traits, allocator&lt;charT> >().
+
+- template &lt;class charT&gt;
+- basic_string&lt;charT, char_traits&lt;charT&gt;, allocator&lt;charT&gt; &gt;
++ template &lt;class charT>
++ basic_string&lt;charT, char_traits&lt;charT>, allocator&lt;charT> >
+ to_string () const;
+
+- -34.2- Returns: to_string&lt;charT, char_traits&lt;charT&gt;, allocator&lt;charT&gt; &gt;().
++ -34.2- Returns: to_string&lt;charT, char_traits&lt;charT>, allocator&lt;charT> >().
+
+- basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;
++ basic_string&lt;char, char_traits&lt;char>, allocator&lt;char> >
+ to_string () const;
+
+- -34.3- Returns: to_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;().
++ -34.3- Returns: to_string&lt;char, char_traits&lt;char>, allocator&lt;char> >().
+ </pre>
+
+ <p><i>[Kona: the LWG agrees that this is an improvement over the
+@@ -21511,17 +21186,17 @@ to_string() member function template:</p>
+
+ <hr>
+ <h3><a name="435"></a>435. bug in DR 25</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-It has been pointed out that the proposed resolution in DR 25 may not be
+-quite up to snuff: <br>
++It has been pointed out that the proposed resolution in DR <a href="lwg-defects.html#25">25</a> may not be
++quite up to snuff: <br/>
+ http://gcc.gnu.org/ml/libstdc++/2003-09/msg00147.html
+-http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#25<br>
++http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#25<br/>
+ </p>
+
+ <p>
+@@ -21545,7 +21220,7 @@ iostreams where the operator does truncate).
+ <p>Change the text in 21.3.7.9, p4 from</p>
+ <blockquote><p>
+ If bool(k) is true, inserts characters as if by calling
+- os.rdbuf()-&gt;sputn(str.data(), n), padding as described in stage 3
++ os.rdbuf()->sputn(str.data(), n), padding as described in stage 3
+ of lib.facet.num.put.virtuals, where n is the larger of os.width()
+ and str.size();
+ </p></blockquote>
+@@ -21554,7 +21229,7 @@ iostreams where the operator does truncate).
+ If bool(k) is true, determines padding as described in
+ lib.facet.num.put.virtuals, and then inserts the resulting
+ sequence of characters <tt>seq</tt> as if by calling
+- <tt>os.rdbuf()-&gt;sputn(seq, n)</tt>, where <tt>n</tt> is the larger of
++ <tt>os.rdbuf()->sputn(seq, n)</tt>, where <tt>n</tt> is the larger of
+ <tt>os.width()</tt> and <tt>str.size()</tt>;
+ </p></blockquote>
+
+@@ -21575,14 +21250,14 @@ iostreams where the operator does truncate).
+
+ <hr>
+ <h3><a name="436"></a>436. are cv-qualified facet types valid facets?</h3>
+-<p><b>Section:</b> 22.3.1.1.2 [locale.facet] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.3.1.1.2 [locale.facet] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2003-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Is "const std::ctype&lt;char&gt;" a valid template argument to has_facet, use_facet,
++Is "const std::ctype&lt;char>" a valid template argument to has_facet, use_facet,
+ and the locale template ctor? And if so, does it designate the same Facet as
+-the non-const "std::ctype&lt;char&gt;?" What about "volatile std::ctype&lt;char&gt;?"
++the non-const "std::ctype&lt;char>?" What about "volatile std::ctype&lt;char>?"
+ Different implementations behave differently: some fail to compile, others
+ accept such types but behave inconsistently.
+ </p>
+@@ -21609,30 +21284,34 @@ text.]</i></p>
+
+ <hr>
+ <h3><a name="438"></a>438. Ambiguity in the "do the right thing" clause</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2003-10-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2003-10-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>Section 23.2.3 [sequence.reqmts], paragraphs 9-11, fixed up the problem
+ noticed with statements like:</p>
+-<pre>vector&lt;int&gt; v(10, 1);
++<pre>
++vector&lt;int&gt; v(10, 1);
+ </pre>
+
+ <p>The intent of the above statement was to construct with:</p>
+-<pre>vector(size_type, const value_type&amp;);
++<pre>
++vector(size_type, const value_type&amp;);
+ </pre>
+
+ <p>but early implementations failed to compile as they bound to:</p>
+-<pre>template &lt;class InputIterator&gt;
++<pre>
++template &lt;class InputIterator&gt;
+ vector(InputIterator f, InputIterator l);
+ </pre>
+ <p>instead.</p>
+
+ <p>Paragraphs 9-11 say that if InputIterator is an integral type, then the
+ member template constructor will have the same effect as:</p>
+-<pre>vector&lt;static_cast&lt;size_type&gt;(f), static_cast&lt;value_type&gt;(l));
++<pre>
++vector&lt;static_cast&lt;size_type&gt;(f), static_cast&lt;value_type&gt;(l));
+ </pre>
+ <p>(and similarly for the other member template functions of sequences).</p>
+
+@@ -21644,7 +21323,8 @@ member template constructor will have the same effect as:</p>
+
+ <p>This might look something like:</p>
+ <blockquote>
+-<pre>template &lt;class T&gt;
++<pre>
++template &lt;class T&gt;
+ struct vector
+ {
+ typedef unsigned size_type;
+@@ -21686,7 +21366,8 @@ every call with the member template, detect the type of InputIterator,
+ and then redirect to the correct logic. Something like:
+ </p>
+ <blockquote>
+-<pre>template &lt;class T&gt;
++<pre>
++template &lt;class T&gt;
+ template &lt;class I&gt;
+ vector&lt;T&gt;::vector(I f, I l)
+ {
+@@ -21715,7 +21396,8 @@ vector&lt;T&gt;::choose_init(I f, I l, int2type&lt;true&gt;)
+
+ <p>Both of these solutions solve the case the standard specifically
+ mentions:</p>
+-<pre>vector&lt;int&gt; v(10, 1); // ok, vector size 10, initialized to 1
++<pre>
++vector&lt;int&gt; v(10, 1); // ok, vector size 10, initialized to 1
+ </pre>
+
+ <p>
+@@ -21723,7 +21405,8 @@ However, (and here is the problem), the two solutions have different
+ behavior in some cases where the value_type of the sequence is not an
+ integral type. For example consider:
+ </p>
+-<blockquote><pre> pair&lt;char, char&gt; p('a', 'b');
++<blockquote><pre>
++ pair&lt;char, char&gt; p('a', 'b');
+ vector&lt;vector&lt;pair&lt;char, char&gt; &gt; &gt; d('a', 'b');
+ </pre></blockquote>
+ <p>
+@@ -21731,7 +21414,8 @@ The second line of this snippet is likely an error. Solution A catches
+ the error and refuses to compile. The reason is that there is no
+ specialization of the member template constructor that looks like:
+ </p>
+-<pre>template &lt;&gt;
++<pre>
++template &lt;&gt;
+ template &lt;&gt;
+ vector&lt;vector&lt;pair&lt;char, char&gt; &gt; &gt;::vector(char, char) { ... }
+ </pre>
+@@ -21748,7 +21432,8 @@ unsigned integral type and used to size the outer vector. 'b' is
+ static casted to the inner vector using it's explicit constructor:
+ </p>
+
+-<pre>explicit vector(size_type n);
++<pre>
++explicit vector(size_type n);
+ </pre>
+
+ <p>
+@@ -21765,7 +21450,8 @@ explicit qualifier on the inner vector has been thwarted at any rate.
+ The standard is not clear whether the expression:
+ </p>
+
+-<pre> vector&lt;vector&lt;pair&lt;char, char&gt; &gt; &gt; d('a', 'b');
++<pre>
++ vector&lt;vector&lt;pair&lt;char, char&gt; &gt; &gt; d('a', 'b');
+ </pre>
+
+ <p>
+@@ -21800,7 +21486,8 @@ the expression above would be to change "static_cast" in paragraphs
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class T, class U&gt;
++<pre>
++template &lt;class T, class U&gt;
+ inline
+ T implicit_cast(const U&amp; u)
+ {
+@@ -21820,22 +21507,25 @@ T implicit_cast(const U&amp; u)
+ <ul>
+ <li>
+ <p>If the constructor</p>
+- <pre> template &lt;class InputIterator&gt;
++ <pre>
++ template &lt;class InputIterator&gt;
+ X(InputIterator f, InputIterator l,
+ const allocator_type&amp; a = allocator_type())
+ </pre>
+ <p>is called with a type InputIterator that does not qualify as
+ an input iterator, then the constructor will behave as if the
+ overloaded constructor:</p>
+- <pre> X(size_type, const value_type&amp; = value_type(),
++ <pre>
++ X(size_type, const value_type&amp; = value_type(),
+ const allocator_type&amp; = allocator_type())
+ </pre>
+- <p>were called instead, with the arguments static_cast&lt;size_type&gt;(f), l and a, respectively.</p>
++ <p>were called instead, with the arguments static_cast&lt;size_type>(f), l and a, respectively.</p>
+ </li>
+
+ <li>
+ <p>If the member functions of the forms:</p>
+- <pre> template &lt;class InputIterator&gt; // such as insert()
++ <pre>
++ template &lt;class InputIterator&gt; // such as insert()
+ rt fx1(iterator p, InputIterator f, InputIterator l);
+
+ template &lt;class InputIterator&gt; // such as append(), assign()
+@@ -21847,7 +21537,8 @@ T implicit_cast(const U&amp; u)
+ <p>are called with a type InputIterator that does not qualify as
+ an input iterator, then these functions will behave as if the
+ overloaded member functions:</p>
+- <pre> rt fx1(iterator, size_type, const value_type&amp;);
++ <pre>
++ rt fx1(iterator, size_type, const value_type&amp;);
+
+ rt fx2(size_type, const value_type&amp;);
+
+@@ -21891,7 +21582,7 @@ Redmond.
+
+ <p><i>[Redmond: one very small change in wording: the first argument
+ is cast to size_t. This fixes the problem of something like
+- <tt>vector&lt;vector&lt;int&gt; &gt;(5, 5)</tt>, where int is not
++ <tt>vector&lt;vector&lt;int> >(5, 5)</tt>, where int is not
+ implicitly convertible to the value type.]</i></p>
+
+
+@@ -21900,7 +21591,8 @@ Redmond.
+ <p><b>Rationale:</b></p>
+ <p>The proposed resolution fixes:</p>
+
+-<pre> vector&lt;int&gt; v(10, 1);
++<pre>
++ vector&lt;int&gt; v(10, 1);
+ </pre>
+
+ <p>
+@@ -21910,7 +21602,8 @@ if).</p>
+
+ <p>The proposed resolution breaks:</p>
+
+-<pre> vector&lt;vector&lt;T&gt; &gt; v(10, 1);
++<pre>
++ vector&lt;vector&lt;T&gt; &gt; v(10, 1);
+ </pre>
+
+ <p>
+@@ -21922,7 +21615,8 @@ The proposed resolution leaves the behavior of the following code
+ unspecified.
+ </p>
+
+-<pre> struct A
++<pre>
++ struct A
+ {
+ operator int () const {return 10;}
+ };
+@@ -21949,21 +21643,21 @@ implicitly convertible to B.
+
+ <hr>
+ <h3><a name="441"></a>441. Is fpos::state const?</h3>
+-<p><b>Section:</b> 27.5.3 [fpos] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fpos">issues</a> in [fpos].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.4 [fpos] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fpos">issues</a> in [fpos].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In section 27.5.3.1 [fpos.members] fpos&lt;stateT&gt;::state() is declared
+-non const, but in section 27.5.3 [fpos] it is declared const.
++In section 27.5.4.1 [fpos.members] fpos&lt;stateT>::state() is declared
++non const, but in section 27.5.4 [fpos] it is declared const.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In section 27.5.3.1 [fpos.members], change the declaration of
+-<tt>fpos&lt;stateT&gt;::state()</tt> to const.
++In section 27.5.4.1 [fpos.members], change the declaration of
++<tt>fpos&lt;stateT>::state()</tt> to const.
+ </p>
+
+
+@@ -21972,14 +21666,14 @@ In section 27.5.3.1 [fpos.members], change the declaration of
+
+ <hr>
+ <h3><a name="442"></a>442. sentry::operator bool() inconsistent signature</h3>
+-<p><b>Section:</b> 27.7.2.4 [ostream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.4 [ostream::sentry] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream::sentry">issues</a> in [ostream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In section 27.7.2.4 [ostream::sentry] paragraph 4, in description part
+-basic_ostream&lt;charT, traits&gt;::sentry::operator bool() is declared
++In section 27.7.3.4 [ostream::sentry] paragraph 4, in description part
++basic_ostream&lt;charT, traits>::sentry::operator bool() is declared
+ as non const, but in section 27.6.2.3, in synopsis it is declared
+ const.
+ </p>
+@@ -21987,7 +21681,7 @@ const.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In section 27.7.2.4 [ostream::sentry] paragraph 4, change the declaration
++In section 27.7.3.4 [ostream::sentry] paragraph 4, change the declaration
+ of <tt>sentry::operator bool()</tt> to const.
+ </p>
+
+@@ -21997,14 +21691,14 @@ of <tt>sentry::operator bool()</tt> to const.
+
+ <hr>
+ <h3><a name="443"></a>443. filebuf::close() inconsistent use of EOF</h3>
+-<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In section 27.9.1.4 [filebuf.members] par6, in effects description of
+-basic_filebuf&lt;charT, traits&gt;::close(), overflow(EOF) is used twice;
++basic_filebuf&lt;charT, traits>::close(), overflow(EOF) is used twice;
+ should be overflow(traits::eof()).
+ </p>
+
+@@ -22020,14 +21714,14 @@ Change overflow(EOF) to overflow(traits::eof()).
+
+ <hr>
+ <h3><a name="444"></a>444. Bad use of casts in fstream</h3>
+-<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fstreams">issues</a> in [fstreams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Vincent Leloup <b>Opened:</b> 2003-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fstreams">issues</a> in [fstreams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 27.9.1.9 [ifstream.members] p1, 27.9.1.13 [ofstream.members] p1, 27.9.1.17 [fstream.members] p1 seems have same problem as exposed in LWG issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#252">252</a>.
++<a href="lwg-defects.html#252">252</a>.
+ </p>
+
+
+@@ -22041,22 +21735,22 @@ Change overflow(EOF) to overflow(traits::eof()).
+
+ <p>Change 27.8.1.7/1 from:</p>
+ <blockquote><p>
+- Returns: (basic_filebuf&lt;charT,traits&gt;*)&amp;sb.
++ Returns: (basic_filebuf&lt;charT,traits>*)&amp;sb.
+ </p></blockquote>
+
+ <p>to:</p>
+ <blockquote><p>
+- Returns: const_cast&lt;basic_filebuf&lt;charT,traits&gt;*&gt;(&amp;sb).
++ Returns: const_cast&lt;basic_filebuf&lt;charT,traits>*>(&amp;sb).
+ </p></blockquote>
+
+ <p>Change 27.8.1.10/1 from:</p>
+ <blockquote><p>
+- Returns: (basic_filebuf&lt;charT,traits&gt;*)&amp;sb.
++ Returns: (basic_filebuf&lt;charT,traits>*)&amp;sb.
+ </p></blockquote>
+
+ <p>to:</p>
+ <blockquote><p>
+- Returns: const_cast&lt;basic_filebuf&lt;charT,traits&gt;*&gt;(&amp;sb).
++ Returns: const_cast&lt;basic_filebuf&lt;charT,traits>*>(&amp;sb).
+ </p></blockquote>
+
+ <p>Change 27.8.1.13/1 from:</p>
+@@ -22066,7 +21760,7 @@ Change overflow(EOF) to overflow(traits::eof()).
+
+ <p>to:</p>
+ <blockquote><p>
+- Returns: const_cast&lt;basic_filebuf&lt;charT,traits&gt;*&gt;(&amp;sb).
++ Returns: const_cast&lt;basic_filebuf&lt;charT,traits>*>(&amp;sb).
+ </p></blockquote>
+
+
+@@ -22078,10 +21772,10 @@ Change overflow(EOF) to overflow(traits::eof()).
+
+ <hr>
+ <h3><a name="445"></a>445. iterator_traits::reference unspecified for some iterator categories</h3>
+-<p><b>Section:</b> 24.4.1 [iterator.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2003-12-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.traits">issues</a> in [iterator.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.4.1 [iterator.traits] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2003-12-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.traits">issues</a> in [iterator.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The standard places no restrictions at all on the reference type
+@@ -22116,7 +21810,8 @@ and V is its value_type
+ </ul>
+
+ <p>A mutable forward iterator ought to satisfy, for x of type V:</p>
+- <pre> { R r = *a; r = x; } is equivalent to *a = x;
++ <pre>
++ { R r = *a; r = x; } is equivalent to *a = x;
+ </pre>
+
+ <p>
+@@ -22187,7 +21882,8 @@ category, respectively.
+
+ <blockquote><p>
+ In addition, the types</p>
+-<pre>iterator_traits&lt;Iterator&gt;::reference
++<pre>
++iterator_traits&lt;Iterator&gt;::reference
+ iterator_traits&lt;Iterator&gt;::pointer
+ </pre>
+ <p>must be defined as the iterator's reference and pointer types, that
+@@ -22199,7 +21895,8 @@ respectively.</p>
+
+ <blockquote><p>
+ In the case of an output iterator, the types</p>
+-<pre>iterator_traits&lt;Iterator&gt;::difference_type
++<pre>
++iterator_traits&lt;Iterator&gt;::difference_type
+ iterator_traits&lt;Iterator&gt;::value_type
+ </pre>
+ <p>are both defined as <tt>void</tt>.</p>
+@@ -22208,7 +21905,8 @@ iterator_traits&lt;Iterator&gt;::value_type
+ <p>to:</p>
+ <blockquote><p>
+ In the case of an output iterator, the types</p>
+-<pre>iterator_traits&lt;Iterator&gt;::difference_type
++<pre>
++iterator_traits&lt;Iterator&gt;::difference_type
+ iterator_traits&lt;Iterator&gt;::value_type
+ iterator_traits&lt;Iterator&gt;::reference
+ iterator_traits&lt;Iterator&gt;::pointer
+@@ -22218,12 +21916,14 @@ iterator_traits&lt;Iterator&gt;::pointer
+
+ <p>In 24.6.3 [istreambuf.iterator], change:</p>
+ <blockquote>
+-<pre>typename traits::off_type, charT*, charT&amp;&gt;
++<pre>
++typename traits::off_type, charT*, charT&amp;&gt;
+ </pre>
+ </blockquote>
+ <p>to:</p>
+ <blockquote>
+-<pre>typename traits::off_type, charT*, charT&gt;
++<pre>
++typename traits::off_type, charT*, charT&gt;
+ </pre>
+ </blockquote>
+
+@@ -22244,10 +21944,10 @@ needed to be changed.
+
+ <hr>
+ <h3><a name="448"></a>448. Random Access Iterators over abstract classes</h3>
+-<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 76, the random access iterator requirement table, says that the
+@@ -22268,10 +21968,10 @@ Change the return type to "convertible to T const&amp;".
+
+ <hr>
+ <h3><a name="449"></a>449. Library Issue 306 Goes Too Far</h3>
+-<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2004-01-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.types">issues</a> in [support.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2004-01-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Original text:</p>
+ <blockquote><p>
+@@ -22310,12 +22010,13 @@ undefined."
+
+ <hr>
+ <h3><a name="453"></a>453. basic_stringbuf::seekoff need not always fail for an empty stream</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<pre> pos_type basic_stringbuf::seekoff(off_type, ios_base::seekdir,
++<pre>
++ pos_type basic_stringbuf::seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode);
+ </pre>
+ <p>
+@@ -22353,10 +22054,10 @@ is nonzero, the positioning operation fails.
+
+ <hr>
+ <h3><a name="455"></a>455. cerr::tie() and wcerr::tie() are overspecified</h3>
+-<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Both cerr::tie() and wcerr::tie() are obliged to be null at program
+@@ -22372,7 +22073,7 @@ permitted if not required. Same for wcerr::tie().
+ <p>Add to the description of cerr:</p>
+ <blockquote><p>
+ After the object cerr is initialized, cerr.tie() returns &amp;cout.
+-Its state is otherwise the same as required for basic_ios&lt;char&gt;::init
++Its state is otherwise the same as required for basic_ios&lt;char>::init
+ (lib.basic.ios.cons).
+ </p></blockquote>
+
+@@ -22380,7 +22081,7 @@ Its state is otherwise the same as required for basic_ios&lt;char&gt;::init
+
+ <blockquote><p>
+ After the object wcerr is initialized, wcerr.tie() returns &amp;wcout.
+-Its state is otherwise the same as required for basic_ios&lt;wchar_t&gt;::init
++Its state is otherwise the same as required for basic_ios&lt;wchar_t>::init
+ (lib.basic.ios.cons).
+ </p></blockquote>
+
+@@ -22395,10 +22096,10 @@ Its state is otherwise the same as required for basic_ios&lt;wchar_t&gt;::init
+
+ <hr>
+ <h3><a name="456"></a>456. Traditional C header files are overspecified</h3>
+-<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#headers">issues</a> in [headers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#headers">issues</a> in [headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>The C++ Standard effectively requires that the traditional C headers
+@@ -22503,7 +22204,7 @@ using-declarations (7.3.3 [namespace.udecl]).</ins>
+ </p></blockquote>
+
+ <p>
+-Change D.7 [depr.c.headers], para. 2-3:
++Change D.5 [depr.c.headers], para. 2-3:
+ </p>
+
+ <blockquote>
+@@ -22535,10 +22236,10 @@ names within the namespace <tt>std</tt>.</ins> <i>-- end example</i>]
+
+ <hr>
+ <h3><a name="457"></a>457. bitset constructor: incorrect number of initialized bits</h3>
+-<p><b>Section:</b> 20.5.1 [bitset.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dag Henriksson <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6.1 [bitset.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dag Henriksson <b>Opened:</b> 2004-01-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The constructor from unsigned long says it initializes "the first M
+@@ -22555,7 +22256,7 @@ guaranteed to have any corresponding bit values in val.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 20.5.1 [bitset.cons] paragraph 2, change "M is the smaller of
++<p>In 20.6.1 [bitset.cons] paragraph 2, change "M is the smaller of
+ N and the value CHAR_BIT * sizeof (unsigned long). (249)" to
+ "<tt>M</tt> is the smaller of <tt>N</tt> and the number of bits in
+ the value representation (section 3.9 [basic.types]) of <tt>unsigned
+@@ -22568,10 +22269,10 @@ guaranteed to have any corresponding bit values in val.
+
+ <hr>
+ <h3><a name="460"></a>460. Default modes missing from basic_fstream member specifications</h3>
+-<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ben Hutchings <b>Opened:</b> 2004-04-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#fstreams">issues</a> in [fstreams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1 [fstreams] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ben Hutchings <b>Opened:</b> 2004-04-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#fstreams">issues</a> in [fstreams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The second parameters of the non-default constructor and of the open
+@@ -22586,17 +22287,21 @@ that it is intended to be callable with one argument.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>In 27.9.1.15 [fstream.cons], change</p>
+-<pre> explicit basic_fstream(const char* s, ios_base::openmode mode);
++<pre>
++ explicit basic_fstream(const char* s, ios_base::openmode mode);
+ </pre>
+ <p>to</p>
+-<pre> explicit basic_fstream(const char* s,
++<pre>
++ explicit basic_fstream(const char* s,
+ ios_base::openmode mode = ios_base::in|ios_base::out);
+ </pre>
+ <p>In 27.9.1.17 [fstream.members], change</p>
+-<pre> void open(const char*s, ios_base::openmode mode);
++<pre>
++ void open(const char*s, ios_base::openmode mode);
+ </pre>
+ <p>to</p>
+-<pre> void open(const char*s,
++<pre>
++ void open(const char*s,
+ ios_base::openmode mode = ios_base::in|ios_base::out);
+ </pre>
+
+@@ -22606,9 +22311,9 @@ that it is intended to be callable with one argument.
+
+ <hr>
+ <h3><a name="461"></a>461. time_get hard or impossible to implement</h3>
+-<p><b>Section:</b> 22.4.5.1.2 [locale.time.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-03-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.5.1.2 [locale.time.get.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bill Plauger <b>Opened:</b> 2004-03-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Template time_get currently contains difficult, if not impossible,
+@@ -22648,7 +22353,8 @@ and maximum latitude, we can permit an implementation to parse whatever
+ <p><b>Proposed resolution:</b></p>
+
+ <p><b>In the description:</b></p>
+-<pre>iter_type do_get_time(iter_type s, iter_type end, ios_base&amp; str,
++<pre>
++iter_type do_get_time(iter_type s, iter_type end, ios_base&amp; str,
+ ios_base::iostate&amp; err, tm* t) const;
+ </pre>
+
+@@ -22665,29 +22371,32 @@ encounters an error or end of sequence.
+
+
+ <p>Change</p>
+-<pre>iter_type do_get_date(iter_type s, iter_type end, ios_base&amp; str,
++<pre>
++iter_type do_get_date(iter_type s, iter_type end, ios_base&amp; str,
+ ios_base::iostate&amp; err, tm* t) const;
+
+ 4 Effects: Reads characters starting at s until it has extracted those
+ struct tm members, and remaining format characters, used by
+-time_put&lt;&gt;::put to produce the format specified by 'x', or until it
++time_put&lt;>::put to produce the format specified by 'x', or until it
+ encounters an error.
+ </pre>
+
+ <p>to</p>
+-<pre>iter_type do_get_date(iter_type s, iter_type end, ios_base&amp; str,
++<pre>
++iter_type do_get_date(iter_type s, iter_type end, ios_base&amp; str,
+ ios_base::iostate&amp; err, tm* t) const;
+ </pre>
+
+ <p>
+ 4 Effects: Reads characters starting at s until it has extracted those
+ struct tm members, and remaining format characters, used by
+-time_put&lt;&gt;::put to produce one of the following formats, or until it
++time_put&lt;>::put to produce one of the following formats, or until it
+ encounters an error. The format depends on the value returned by
+ date_order() as follows:
+ </p>
+
+-<pre> date_order() format
++<pre>
++ date_order() format
+
+ no_order "%m/%d/%y"
+ dmy "%d/%m/%y"
+@@ -22711,17 +22420,17 @@ An implementation may also accept additional implementation-defined formats.
+
+ <hr>
+ <h3><a name="464"></a>464. Suggestion for new member functions in standard containers</h3>
+-<p><b>Section:</b> 23.4.1 [vector], 23.6.1 [map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2004-05-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector], 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2004-05-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>To add slightly more convenience to vector&lt;T&gt; and map&lt;Key,T&gt; we should consider to add</p>
++<p>To add slightly more convenience to vector&lt;T> and map&lt;Key,T> we should consider to add</p>
+ <ol>
+-<li> add vector&lt;T&gt;::data() member (const and non-const version)
++<li> add vector&lt;T>::data() member (const and non-const version)
+ semantics: if( empty() ) return 0; else return buffer_;</li>
+-<li> add map&lt;Key,T&gt;::at( const Key&amp; k ) member (const and non-const version)
++<li> add map&lt;Key,T>::at( const Key&amp; k ) member (const and non-const version)
+ <i>semantics</i>: iterator i = find( k ); if( i != end() ) return *i; else throw range_error();</li>
+ </ol>
+
+@@ -22729,7 +22438,7 @@ semantics: if( empty() ) return 0; else return buffer_;</li>
+
+ <ul>
+ <li>To obtain a pointer to the vector's buffer, one must use either operator[]() (which can give undefined behavior for empty vectors) or at() (which will then throw if the vector is empty). </li>
+-<li>tr1::array&lt;T,sz&gt; already has a data() member</li>
++<li>tr1::array&lt;T,sz> already has a data() member</li>
+ <li>e cannot use operator[]() when T is not DefaultDonstructible</li>
+ <li>Neither when the map is const.</li>
+ <li>when we want to make sure we don't add an element accidently</li>
+@@ -22739,17 +22448,19 @@ semantics: if( empty() ) return 0; else return buffer_;</li>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>In 23.4.1 [vector], add the following to the <tt>vector</tt>
++<p>In 23.3.6 [vector], add the following to the <tt>vector</tt>
+ synopsis after "element access" and before "modifiers":</p>
+-<pre> // <i>[lib.vector.data] data access</i>
++<pre>
++ // <i>[lib.vector.data] data access</i>
+ pointer data();
+ const_pointer data() const;
+ </pre>
+
+-<p>Add a new subsection of 23.4.1 [vector]:</p>
++<p>Add a new subsection of 23.3.6 [vector]:</p>
+ <blockquote>
+ <p>23.2.4.x <tt>vector</tt> data access</p>
+-<pre> pointer data();
++<pre>
++ pointer data();
+ const_pointer data() const;
+ </pre>
+ <p><b>Returns:</b> A pointer such that [data(), data() + size()) is a valid
+@@ -22758,15 +22469,17 @@ semantics: if( empty() ) return 0; else return buffer_;</li>
+ <p><b>Throws:</b> Nothing.</p>
+ </blockquote>
+
+-<p>In 23.6.1 [map], add the following to the <tt>map</tt>
++<p>In 23.4.4 [map], add the following to the <tt>map</tt>
+ synopsis immediately after the line for operator[]:</p>
+-<pre> T&amp; at(const key_type&amp; x);
++<pre>
++ T&amp; at(const key_type&amp; x);
+ const T&amp; at(const key_type&amp; x) const;
+ </pre>
+
+-<p>Add the following to 23.6.1.2 [map.access]:</p>
++<p>Add the following to 23.4.4.3 [map.access]:</p>
+ <blockquote>
+-<pre> T&amp; at(const key_type&amp; x);
++<pre>
++ T&amp; at(const key_type&amp; x);
+ const T&amp; at(const key_type&amp; x) const;
+ </pre>
+
+@@ -22789,28 +22502,28 @@ synopsis immediately after the line for operator[]:</p>
+
+
+ <hr>
+-<h3><a name="465"></a>465. Contents of &lt;ciso646&gt;</h3>
+-<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2004-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#headers">issues</a> in [headers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="465"></a>465. Contents of &lt;ciso646></h3>
++<p><b>Section:</b> 17.6.1.2 [headers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve Clamage <b>Opened:</b> 2004-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#headers">issues</a> in [headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>C header &lt;iso646.h&gt; defines macros for some operators, such as
++<p>C header &lt;iso646.h> defines macros for some operators, such as
+ not_eq for !=.</p>
+
+ <p>Section 17.6.1.2 [headers] "Headers" says that except as noted in
+-clauses 18 through 27, the &lt;cname&gt; C++ header contents are the same
+-as the C header &lt;name.h&gt;. In particular, table 12 lists
+-&lt;ciso646&gt; as a C++ header.</p>
++clauses 18 through 27, the &lt;cname> C++ header contents are the same
++as the C header &lt;name.h>. In particular, table 12 lists
++&lt;ciso646> as a C++ header.</p>
+
+-<p>I don't find any other mention of &lt;ciso646&gt;, or any mention of
+-&lt;iso646.h&gt;, in clauses 17 thorough 27. That implies that the
+-contents of &lt;ciso646&gt; are the same as C header &lt;iso646.h&gt;.</p>
++<p>I don't find any other mention of &lt;ciso646>, or any mention of
++&lt;iso646.h>, in clauses 17 thorough 27. That implies that the
++contents of &lt;ciso646> are the same as C header &lt;iso646.h>.</p>
+
+ <p>Annex C (informative, not normative) in [diff.header.iso646.h] C.2.2.2
+-"Header &lt;iso646.h&gt;" says that the alternative tokens are not
+-defined as macros in &lt;ciso646&gt;, but does not mention the contents
+-of &lt;iso646.h&gt;.</p>
++"Header &lt;iso646.h>" says that the alternative tokens are not
++defined as macros in &lt;ciso646>, but does not mention the contents
++of &lt;iso646.h>.</p>
+
+ <p>I don't find any normative text to support C.2.2.2.</p>
+
+@@ -22823,8 +22536,8 @@ of &lt;iso646.h&gt;.</p>
+ <blockquote>
+ <p>Identifiers that are keywords or operators in C++ shall not be defined
+ as macros in C++ standard library headers.
+-[Footnote:In particular, including the standard header &lt;iso646.h&gt;
+-or &lt;ciso646&gt; has no effect. </p>
++[Footnote:In particular, including the standard header &lt;iso646.h>
++or &lt;ciso646> has no effect. </p>
+ </blockquote>
+
+ <p><i>[post-Redmond: Steve provided wording.]</i></p>
+@@ -22837,19 +22550,19 @@ or &lt;ciso646&gt; has no effect. </p>
+
+ <hr>
+ <h3><a name="467"></a>467. char_traits::lt(), compare(), and memcmp()</h3>
+-<p><b>Section:</b> 21.2.3.1 [char.traits.specializations.char] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.2.3.1 [char.traits.specializations.char] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+ Table 37 describes the requirements on Traits::compare() in terms of
+-those on Traits::lt(). 21.1.3.1, p6 requires char_traits&lt;char&gt;::lt()
++those on Traits::lt(). 21.1.3.1, p6 requires char_traits&lt;char>::lt()
+ to yield the same result as operator&lt;(char, char).
+ </p>
+
+ <p>
+-Most, if not all, implementations of char_traits&lt;char&gt;::compare()
++Most, if not all, implementations of char_traits&lt;char>::compare()
+ call memcmp() for efficiency. However, the C standard requires both
+ memcmp() and strcmp() to interpret characters under comparison as
+ unsigned, regardless of the signedness of char. As a result, all
+@@ -22888,10 +22601,10 @@ imposed by Table 37 on compare() when char is signed.
+
+ <hr>
+ <h3><a name="468"></a>468. unexpected consequences of ios_base::operator void*()</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>The program below is required to compile but when run it typically
+@@ -22899,8 +22612,9 @@ produces unexpected results due to the user-defined conversion from
+ std::cout or any object derived from basic_ios to void*.
+ </p>
+
+-<pre> #include &lt;cassert&gt;
+- #include &lt;iostream&gt;
++<pre>
++ #include &lt;cassert>
++ #include &lt;iostream>
+
+ int main ()
+ {
+@@ -22913,7 +22627,7 @@ std::cout or any object derived from basic_ios to void*.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Replace std::basic_ios&lt;charT, traits&gt;::operator void*() with another
++Replace std::basic_ios&lt;charT, traits>::operator void*() with another
+ conversion operator to some unspecified type that is guaranteed not
+ to be convertible to any other type except for bool (a pointer-to-member
+ might be one such suitable type). In addition, make it clear that the
+@@ -22922,16 +22636,20 @@ the value need not be valid.
+ </p>
+
+ <p>Specifically, change in [lib.ios] the signature of</p>
+-<pre> operator void*() const;
++<pre>
++ operator void*() const;
+ </pre>
+ <p>to</p>
+-<pre> operator unspecified-bool-type() const;
++<pre>
++ operator unspecified-bool-type() const;
+ </pre>
+ <p>and change [lib.iostate.flags], p1 from</p>
+-<pre> operator void*() const;
++<pre>
++ operator void*() const;
+ </pre>
+ <p>to</p>
+-<pre>operator unspecified-bool-type() const;
++<pre>
++operator unspecified-bool-type() const;
+
+ -1- Returns: if fail() then a value that will evaluate false in a
+ boolean context; otherwise a value that will evaluate true in a
+@@ -22960,14 +22678,14 @@ the value need not be valid.
+
+ <hr>
+ <h3><a name="469"></a>469. vector&lt;bool&gt; ill-formed relational operators</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-The overloads of relational operators for vector&lt;bool&gt; specified
++The overloads of relational operators for vector&lt;bool> specified
+ in [lib.vector.bool] are redundant (they are semantically identical
+ to those provided for the vector primary template) and may even be
+ diagnosed as ill-formed (refer to Daveed Vandevoorde's explanation
+@@ -22979,21 +22697,22 @@ in c++std-lib-13647).
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Remove all overloads of overloads of relational operators for
+-vector&lt;bool&gt; from [lib.vector.bool].
++vector&lt;bool> from [lib.vector.bool].
+ </p>
+
+
+
+
+ <hr>
+-<h3><a name="471"></a>471. result of what() implementation-defined</h3>
+-<p><b>Section:</b> 18.8.1 [exception] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="471"></a>471. result of <tt>what()</tt> implementation-defined</h3>
++<p><b>Section:</b> 18.8.1 [exception] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>[lib.exception] specifies the following:</p>
+-<pre> exception (const exception&amp;) throw();
++<pre>
++ exception (const exception&amp;) throw();
+ exception&amp; operator= (const exception&amp;) throw();
+
+ -4- Effects: Copies an exception object.
+@@ -23068,10 +22787,10 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The issue was pulled from Ready. It needs to make clear that only homogenous copying
+ is intended to be supported, not coping from a derived to a base.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -23082,12 +22801,12 @@ Batavia (2009-05):
+ Howard supplied the following replacement wording
+ for paragraph 7 of the proposed resolution:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <ins>-7- <i>Postcondition:</i> <tt>what()</tt> shall return the same NTBS
+ as would be obtained by using <tt>static_cast</tt>
+ to cast the rhs to the same types as the lhs
+ and then calling <tt>what()</tt> on that possibly sliced object.</ins>
+-</blockquote>
++</p></blockquote>
+ <p>
+ Pete asks what "the same NTBS" means.
+ </p>
+@@ -23098,9 +22817,9 @@ Pete asks what "the same NTBS" means.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Further discussion in the thread starting with c++std-lib-24512.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-09-24 Niels provided updated wording:
+@@ -23119,7 +22838,7 @@ satisfy the proposed resolution, including MSVC 2008 SP1, Apache
+ stdcxx-4.2.1, GCC 4.1.2, GCC 4.3.2, and CodeGear C++ 6.13.
+ </p>
+ <p>
+-The proposed resolution was updated with help from Daniel Krügler;
++The proposed resolution was updated with help from Daniel Kr&uuml;gler;
+ the update aims to clarify that the proposed postcondition only
+ applies to homogeneous copying.
+ </p>
+@@ -23130,9 +22849,9 @@ applies to homogeneous copying.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready after inserting "publicly accessible" in two places.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -23188,16 +22907,16 @@ are implementation-defined.</del>
+
+
+ <hr>
+-<h3><a name="473"></a>473. underspecified ctype calls</h3>
+-<p><b>Section:</b> 22.4.1.1 [locale.ctype] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="473"></a>473. underspecified <tt>ctype</tt> calls</h3>
++<p><b>Section:</b> 22.4.1.1 [locale.ctype] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Most ctype member functions come in two forms: one that operates
++Most <tt>ctype</tt> member functions come in two forms: one that operates
+ on a single character at a time and another form that operates
+ on a range of characters. Both forms are typically described by
+-a single Effects and/or Returns clause.
++a single Effects and&#47;or Returns clause.
+ </p>
+ <p>
+ The Returns clause of each of the single-character non-virtual forms
+@@ -23231,9 +22950,9 @@ the virtual function of the alternate form that has not been
+ overriden.
+ </p>
+ <p>
+-Thus, it might be possible for, say, ctype::widen(c) to return one
+-value, while for ctype::widen(&amp;c, &amp;c + 1, &amp;wc) to set
+-wc to another value. This is almost certainly not intended. Both
++Thus, it might be possible for, say, <tt>ctype::widen(c)</tt> to return one
++value, while for <tt>ctype::widen(&amp;c, &amp;c + 1, &amp;wc)</tt> to set
++<tt>wc</tt> to another value. This is almost certainly not intended. Both
+ forms of every function should be required to return the same result
+ for the same character, otherwise the same program using an
+ implementation that calls one form of the functions will behave
+@@ -23254,11 +22973,11 @@ of the function in turn calls the other form.
+ </p>
+ <p>
+ Lillehammer: Part of this isn't a real problem. We already talk about
+-caching. 22.1.1/6 But part is a real problem. ctype virtuals may call
++caching. 22.1.1&#47;6 But part is a real problem. <tt>ctype</tt> virtuals may call
+ each other, so users don't know which ones to override to avoid avoid
+ infinite loops.</p>
+
+-<p>This is a problem for all facet virtuals, not just ctype virtuals,
++<p>This is a problem for all facet virtuals, not just <tt>ctype</tt> virtuals,
+ so we probably want a blanket statement in clause 22 for all
+ facets. The LWG is leaning toward a blanket prohibition, that a
+ facet's virtuals may never call each other. We might want to do that
+@@ -23275,9 +22994,9 @@ provide wording.</p>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -23286,10 +23005,10 @@ Move to Ready.
+ Add paragraph 3 to 22.4 [locale.categories]:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ -3- Within this clause it is unspecified if one virtual function calls another
+ virtual function.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+
+
+@@ -23305,16 +23024,16 @@ override both virtual functions, not just one.
+
+ <hr>
+ <h3><a name="474"></a>474. confusing Footnote 297</h3>
+-<p><b>Section:</b> 27.7.2.6.4 [ostream.inserters.character] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.inserters.character">issues</a> in [ostream.inserters.character].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.6.4 [ostream.inserters.character] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2004-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.inserters.character">issues</a> in [ostream.inserters.character].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+ I think Footnote 297 is confused. The paragraph it applies to seems
+ quite clear in that widen() is only called if the object is not a char
+-stream (i.e., not basic_ostream&lt;char&gt;), so it's irrelevant what the
++stream (i.e., not basic_ostream&lt;char>), so it's irrelevant what the
+ value of widen(c) is otherwise.
+ </p>
+
+@@ -23329,10 +23048,10 @@ I propose to strike the Footnote.
+
+ <hr>
+ <h3><a name="475"></a>475. May the function object passed to for_each modify the elements of the iterated sequence?</h3>
+-<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stephan T. Lavavej, Jaakko Jarvi <b>Opened:</b> 2004-07-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stephan T. Lavavej, Jaakko Jarvi <b>Opened:</b> 2004-07-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It is not clear whether the function object passed to for_each is allowed to
+@@ -23413,23 +23132,24 @@ passed to it.
+
+
+ <hr>
+-<h3><a name="478"></a>478. Should forward iterator requirements table have a line for r-&gt;m?</h3>
+-<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#477">477</a></p>
++<h3><a name="478"></a>478. Should forward iterator requirements table have a line for r->m?</h3>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2004-07-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#477">477</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The Forward Iterator requirements table contains the following:
+ </p>
+-<pre> expression return type operational precondition
++<pre>
++ expression return type operational precondition
+ semantics
+ ========== ================== =========== ==========================
+- a-&gt;m U&amp; if X is mutable, (*a).m pre: (*a).m is well-defined.
++ a->m U&amp; if X is mutable, (*a).m pre: (*a).m is well-defined.
+ otherwise const U&amp;
+
+- r-&gt;m U&amp; (*r).m pre: (*r).m is well-defined.
++ r->m U&amp; (*r).m pre: (*r).m is well-defined.
+ </pre>
+
+ <p>The second line may be unnecessary. Paragraph 11 of
+@@ -23450,12 +23170,12 @@ current requirements allow iterators to make many of the operations
+ specified using the identifiers a and b invalid for non-const
+ iterators.</p>
+
+-<p>Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#477">477</a></p>
++<p>Related issue: <a href="lwg-closed.html#477">477</a></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Remove the "r-&gt;m" line from the Forward Iterator requirements
++<p>Remove the "r->m" line from the Forward Iterator requirements
+ table. Change</p>
+ <blockquote><p>
+ "const X"
+@@ -23483,17 +23203,17 @@ This is a defect because it constrains an lvalue to returning a modifiable lvalu
+
+ <hr>
+ <h3><a name="482"></a>482. Swapping pairs</h3>
+-<p><b>Section:</b> 20.3.5 [pairs], 20.4 [tuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2004-09-14 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs], 20.4 [tuple] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2004-09-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>(Based on recent comp.std.c++ discussion)</p>
+
+ <p>Pair (and tuple) should specialize std::swap to work in terms of
+ std::swap on their components. For example, there's no obvious reason
+-why swapping two objects of type pair&lt;vector&lt;int&gt;,
+-list&lt;double&gt; &gt; should not take O(1).</p>
++why swapping two objects of type pair&lt;vector&lt;int>,
++list&lt;double> > should not take O(1).</p>
+
+ <p><i>[Lillehammer: We agree it should be swappable. Howard will
+ provide wording.]</i></p>
+@@ -23501,7 +23221,7 @@ list&lt;double&gt; &gt; should not take O(1).</p>
+
+ <p><i>[
+ Post Oxford: We got <tt>swap</tt> for <tt>pair</tt> but accidently
+-missed <tt>tuple</tt>. <tt>tuple::swap</tt> is being tracked by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#522">522</a>.
++missed <tt>tuple</tt>. <tt>tuple::swap</tt> is being tracked by <a href="lwg-defects.html#522">522</a>.
+ ]</i></p>
+
+
+@@ -23524,10 +23244,219 @@ Recommend <del>NAD</del><ins>Resolved</ins>, fixed by
+
+
+ <hr>
++<h3><a name="485"></a>485. output iterator insufficiently constrained</h3>
++<p><b>Section:</b> 24.2.4 [output.iterators] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2004-10-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#output.iterators">active issues</a> in [output.iterators].</p>
++<p><b>View all other</b> <a href="lwg-index.html#output.iterators">issues</a> in [output.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The note on 24.1.2 Output iterators insufficiently limits what can be
++performed on output iterators. While it requires that each iterator is
++progressed through only once and that each iterator is written to only
++once, it does not require the following things:</p>
++
++<p>Note: Here it is assumed that <tt>x</tt> is an output iterator of type <tt>X</tt> which
++has not yet been assigned to.</p>
++
++<p>a) That each value of the output iterator is written to:
++The standard allows:
++<tt>++x; ++x; ++x;</tt>
++</p>
++
++<p>
++b) That assignments to the output iterator are made in order
++<tt>X a(x); ++a; *a=1; *x=2;</tt> is allowed
++</p>
++
++<p>
++c) Chains of output iterators cannot be constructed:
++<tt>X a(x); ++a; X b(a); ++b; X c(b); ++c;</tt> is allowed, and under the current
++wording (I believe) <tt>x,a,b,c</tt> could be written to in any order.
++</p>
++
++<p>I do not believe this was the intension of the standard?</p>
++<p><i>[Lillehammer: Real issue. There are lots of constraints we
++ intended but didn't specify. Should be solved as part of iterator
++ redesign.]</i></p>
++
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Bill provided wording according to consensus.
++</p></blockquote>
++
++<p><i>[
++2009-07-21 Alisdair requests change from Review to Open. See thread starting
++with c++std-lib-24459 for discussion.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Modified wording. Set to Review.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Move to Ready after looking at again in a larger group in Santa Cruz.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by N3066.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change Table 101 &mdash; Output iterator requirements in 24.2.4 [output.iterators]:
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 101 &mdash; Output iterator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational semantics</th>
++<th>Assertion/note pre-/post-condition</th>
++</tr>
++
++<tr>
++<td>
++<tt>X(a)</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<tt>a = t</tt> is equivalent to <tt>X(a) = t</tt>. note: a destructor is assumed.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X u(a);</tt><br/>
++<tt>X u = a;</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>*r = o</tt>
++</td>
++<td>
++result is not used
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<ins>
++Post: <tt>r</tt> is not required to be dereferenceable. <tt>r</tt> is incrementable.
++</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>++r</tt>
++</td>
++<td>
++<tt>X&amp;</tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++<tt>&amp;r == &amp;++r</tt>
++<ins>
++Post: <tt>r</tt> is dereferenceable, unless otherwise specified. <tt>r</tt> is not required to be incrementable.
++</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>r++</tt>
++</td>
++<td>
++convertible to <tt>const X&amp;</tt>
++</td>
++<td>
++<tt>{X tmp = r;<br/>++r;<br/>return tmp;}</tt>
++</td>
++<td>
++<ins>
++Post: <tt>r</tt> is dereferenceable, unless otherwise specified. <tt>r</tt> is not required to be incrementable.
++</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>*r++ = o;</tt>
++</td>
++<td>
++result is not used
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++
++
++
++
++<hr>
+ <h3><a name="488"></a>488. rotate throws away useful information</h3>
+-<p><b>Section:</b> 25.3.11 [alg.rotate] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2004-11-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.11 [alg.rotate] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2004-11-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.rotate">issues</a> in [alg.rotate].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ rotate takes 3 iterators: first, middle and last which point into a
+@@ -23541,7 +23470,8 @@ In many use cases of rotate, the client needs to know where the
+ subrange [first, middle) starts after the rotate is performed. This
+ might look like:
+ </p>
+-<pre> rotate(first, middle, last);
++<pre>
++ rotate(first, middle, last);
+ Iterator i = advance(first, distance(middle, last));
+ </pre>
+
+@@ -23551,7 +23481,8 @@ start of the subrange [first, middle) has linear complexity. However,
+ it is not difficult for rotate to return this information with
+ negligible additional computation expense. So the client could code:
+ </p>
+-<pre> Iterator i = rotate(first, middle, last);
++<pre>
++ Iterator i = rotate(first, middle, last);
+ </pre>
+
+ <p>
+@@ -23560,7 +23491,7 @@ and the resulting program becomes significantly more efficient.
+
+ <p>
+ While the backwards compatibility hit with this change is not zero, it
+-is very small (similar to that of lwg <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#130">130</a>), and there is
++is very small (similar to that of lwg <a href="lwg-defects.html#130">130</a>), and there is
+ a significant benefit to the change.
+ </p>
+
+@@ -23569,14 +23500,16 @@ a significant benefit to the change.
+ <p><b>Proposed resolution:</b></p>
+ <p>In 25 [algorithms] p2, change:</p>
+
+-<blockquote><pre> template&lt;class ForwardIterator&gt;
++<blockquote><pre>
++ template&lt;class ForwardIterator>
+ <del>void</del> <ins>ForwardIterator</ins> rotate(ForwardIterator first, ForwardIterator middle,
+ ForwardIterator last);
+ </pre></blockquote>
+
+ <p>In 25.3.11 [alg.rotate], change:</p>
+
+-<blockquote><pre> template&lt;class ForwardIterator&gt;
++<blockquote><pre>
++ template&lt;class ForwardIterator>
+ <del>void</del> <ins>ForwardIterator</ins> rotate(ForwardIterator first, ForwardIterator middle,
+ ForwardIterator last);
+ </pre></blockquote>
+@@ -23611,10 +23544,10 @@ Toronto: moved to Ready.
+
+ <hr>
+ <h3><a name="495"></a>495. Clause 22 template parameter requirements</h3>
+-<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2005-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#localization">issues</a> in [localization].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22 [localization] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2005-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#localization">issues</a> in [localization].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>It appears that there are no requirements specified for many of the
+ template parameters in clause 22. It looks like this issue has never
+@@ -23687,16 +23620,17 @@ requirements of charT (described in 21 [strings]).
+
+ <hr>
+ <h3><a name="496"></a>496. Illegal use of "T" in vector&lt;bool&gt;</h3>
+-<p><b>Section:</b> 23.4.1 [vector] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> richard@ex-parrot.com <b>Opened:</b> 2005-02-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector">issues</a> in [vector].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6 [vector] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> richard@ex-parrot.com <b>Opened:</b> 2005-02-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector">issues</a> in [vector].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In the synopsis of the std::vector&lt;bool&gt; specialisation in 23.4.1 [vector],
++In the synopsis of the std::vector&lt;bool> specialisation in 23.3.6 [vector],
+ the non-template assign() function has the signature</p>
+
+-<pre> void assign( size_type n, const T&amp; t );
++<pre>
++ void assign( size_type n, const T&amp; t );
+ </pre>
+
+ <p>The type, T, is not defined in this context.</p>
+@@ -23711,18 +23645,18 @@ the non-template assign() function has the signature</p>
+
+ <hr>
+ <h3><a name="497"></a>497. meaning of numeric_limits::traps for floating point types</h3>
+-<p><b>Section:</b> 18.3.1.2 [numeric.limits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-03-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2.4 [numeric.limits.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-03-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>18.2.1.2, p59 says this much about the traps member of numeric_limits:</p>
+
+ <blockquote>
+-<p>static const bool traps;<br>
++<p>static const bool traps;<br/>
+ -59- true if trapping is implemented for the type.204)
+-<br>
++<br/>
+ Footnote 204: Required by LIA-1.
+ </p>
+ </blockquote>
+@@ -23774,9 +23708,10 @@ at runtime.
+
+ <hr>
+ <h3><a name="498"></a>498. Requirements for partition() and stable_partition() too strong</h3>
+-<p><b>Section:</b> 25.3.13 [alg.partitions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Sean Parent, Joe Gottman <b>Opened:</b> 2005-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25.3.13 [alg.partitions] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Sean Parent, Joe Gottman <b>Opened:</b> 2005-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.partitions">issues</a> in [alg.partitions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Problem:
+@@ -23805,10 +23740,11 @@ Proposed resolution:
+ Add the following signature to:
+ </p>
+ <p>
+-Header <tt>&lt;algorithm&gt;</tt> synopsis [algorithms.syn]<br>
++Header <tt>&lt;algorithm&gt;</tt> synopsis [algorithms.syn]<br/>
+ p3 Partitions 25.3.13 [alg.partitions]
+ </p>
+-<blockquote><pre> template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred&gt;
++<blockquote><pre>
++ template&lt;ForwardIterator Iter, Predicate&lt;auto, Iter::value_type&gt; Pred&gt;
+ requires ShuffleIterator&lt;Iter&gt;
+ &amp;&amp; CopyConstructible&lt;Pred&gt;
+ Iter partition(Iter first, Iter last, Pred pred);
+@@ -23867,13 +23803,15 @@ Move to Ready.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Change 25.2.12 from </p>
+-<blockquote><pre>template&lt;class BidirectionalIterator, class Predicate&gt;
++<blockquote><pre>
++template&lt;class BidirectionalIterator, class Predicate&gt;
+ BidirectionalIterator partition(BidirectionalIterato r first,
+ BidirectionalIterator last,
+ Predicate pred);
+ </pre></blockquote>
+ <p>to </p>
+-<blockquote><pre>template&lt;class ForwardIterator, class Predicate&gt;
++<blockquote><pre>
++template&lt;class ForwardIterator, class Predicate&gt;
+ ForwardIterator partition(ForwardIterator first,
+ ForwardIterator last,
+ Predicate pred);
+@@ -23918,10 +23856,10 @@ to work for ForwardIterator a minor embarrassment.
+
+ <hr>
+ <h3><a name="505"></a>505. Result_type in random distribution requirements</h3>
+-<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req">issues</a> in [rand.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.1 [rand.req], TR1 5.1.1 [tr.rand.req] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req">issues</a> in [rand.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 17: Random distribution requirements
+@@ -23944,8 +23882,8 @@ for all distributions and should therefore be indicated as such via a new secon
+ row to this table 17:
+ </p>
+ <table border="1" cellpadding="5">
+-<tbody><tr><td>X::result_type</td><td>T</td><td>---</td><td>compile-time</td></tr>
+-</tbody></table>
++<tr><td>X::result_type</td><td>T</td><td>---</td><td>compile-time</td></tr>
++</table>
+
+ <p><i>[
+ Berlin: Voted to WP. N1932 adopts the proposed resolution: see Table 5 row 1.
+@@ -23959,20 +23897,22 @@ Berlin: Voted to WP. N1932 adopts the proposed resolution: see Table 5 row 1.
+
+ <hr>
+ <h3><a name="507"></a>507. Missing requirement for variate_generator::operator()</h3>
+-<p><b>Section:</b> 26.5 [rand], TR1 5.1.3 [tr.rand.var] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5 [rand], TR1 5.1.3 [tr.rand.var] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Paragraph 11 of [tr.rand.var] equires that the member template
+ </p>
+-<blockquote><pre>template&lt;class T&gt; result_type operator() (T value);
++<blockquote><pre>
++template&lt;class T&gt; result_type operator() (T value);
+ </pre></blockquote>
+ <p>
+ return
+ </p>
+-<blockquote><pre>distribution()(e, value)
++<blockquote><pre>
++distribution()(e, value)
+ </pre></blockquote>
+ <p>
+ However, not all distributions have an operator() with a corresponding signature.
+@@ -24001,24 +23941,26 @@ Precondition: <tt>distribution().operator()(e,value)</tt> is well-formed.
+
+ <hr>
+ <h3><a name="508"></a>508. Bad parameters for ranlux64_base_01</h3>
+-<p><b>Section:</b> 26.5.5 [rand.predef], TR1 5.1.5 [tr.rand.predef] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.5 [rand.predef], TR1 5.1.5 [tr.rand.predef] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.predef">issues</a> in [rand.predef].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The fifth of these engines with predefined parameters, ranlux64_base_01,
+ appears to have an unintentional error for which there is a simple correction.
+ The two pre-defined subtract_with_carry_01 engines are given as:
+ </p>
+-<blockquote><pre>typedef subtract_with_carry_01&lt;float, 24, 10, 24&gt; ranlux_base_01;
++<blockquote><pre>
++typedef subtract_with_carry_01&lt;float, 24, 10, 24&gt; ranlux_base_01;
+ typedef subtract_with_carry_01&lt;double, 48, 10, 24&gt; ranlux64_base_01;
+ </pre></blockquote>
+ <p>
+ We demonstrate below that ranlux64_base_01 fails to meet the intent of the
+ random number generation proposal, but that the simple correction to
+ </p>
+-<blockquote><pre>typedef subtract_with_carry_01&lt;double, 48, 5, 12&gt; ranlux64_base_01;
++<blockquote><pre>
++typedef subtract_with_carry_01&lt;double, 48, 5, 12&gt; ranlux64_base_01;
+ </pre></blockquote>
+ <p>
+ does meet the intent of defining well-known good parameterizations.
+@@ -24057,7 +23999,8 @@ to deliver 48 random bits at a time rather than 24.
+ <p>
+ To achieve this intended behavior, the correct template parameteriztion would be:
+ </p>
+-<blockquote><pre>typedef subtract_with_carry_01&lt;double, 48, 5, 12&gt; ranlux64_base_01;
++<blockquote><pre>
++typedef subtract_with_carry_01&lt;double, 48, 5, 12&gt; ranlux64_base_01;
+ </pre></blockquote>
+ <p>
+ The sequence of mantissa bits delivered by this is isomorphic (treating each
+@@ -24085,11 +24028,11 @@ just above paragraph 5.
+
+ <hr>
+ <h3><a name="518"></a>518. Are insert and erase stable for unordered_multiset and unordered_multimap?</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req], TR1 6.3.1 [tr.unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req], TR1 6.3.1 [tr.unord.req] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Issue 371 deals with stability of multiset/multimap under insert and erase
+@@ -24154,10 +24097,11 @@ preserves the relative ordering of equivalent elements.</ins></p>
+
+ <hr>
+ <h3><a name="519"></a>519. Data() undocumented</h3>
+-<p><b>Section:</b> 23.3.1 [array], TR1 6.2.2 [tr.array.array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.2 [array], TR1 6.2.2 [tr.array.array] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>array&lt;&gt;::data()</tt> is present in the class synopsis, but not documented.
+@@ -24168,7 +24112,8 @@ preserves the relative ordering of equivalent elements.</ins></p>
+ <p>
+ Add a new section, after 6.2.2.3:
+ </p>
+-<blockquote><pre>T* data()
++<blockquote><pre>
++T* data()
+ const T* data() const;
+ </pre></blockquote>
+ <p>
+@@ -24188,9 +24133,9 @@ of <tt>data()</tt> is unspecified.
+
+ <hr>
+ <h3><a name="520"></a>520. Result_of and pointers to data members</h3>
+-<p><b>Section:</b> 20.8.10.1 [func.bind], TR1 3.6 [tr.func.bind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.10 [func.bind], TR1 3.6 [tr.func.bind] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the original proposal for binders, the return type of bind() when
+@@ -24213,7 +24158,9 @@ Pete and Peter will provide wording.
+ <p>
+ In 20.5.4 [lib.func.ret] ([tr.func.ret]) p3 add the following bullet after bullet 2:
+ </p>
+-<ol start="3">
++<ol>
++<li>[&hellip;]</li>
++<li>[&hellip;]</li>
+ <li>If <tt>F</tt> is a member data pointer type <tt>R T::*</tt>, <tt>type</tt>
+ shall be <tt><i>cv</i> R&amp;</tt> when <tt>T1</tt> is <tt><i>cv</i> U1&amp;</tt>,
+ <tt>R</tt> otherwise.</li>
+@@ -24231,10 +24178,10 @@ Peter provided wording.
+
+ <hr>
+ <h3><a name="521"></a>521. Garbled requirements for argument_type in reference_wrapper</h3>
+-<p><b>Section:</b> 20.8.4 [refwrap], TR1 2.1.2 [tr.util.refwrp.refwrp] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#refwrap">issues</a> in [refwrap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.4 [refwrap], TR1 2.1.2 [tr.util.refwrp.refwrp] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap">issues</a> in [refwrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 2.1.2/3, second bullet item currently says that reference_wrapper&lt;T&gt; is
+@@ -24303,10 +24250,10 @@ function's cv-qualifiers); the type <tt>T1</tt> is <tt><i>cv</i> T0*</tt></ins>
+
+ <hr>
+ <h3><a name="522"></a>522. Tuple doesn't define swap</h3>
+-<p><b>Section:</b> 20.4 [tuple], TR1 6.1 [tr.tuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Andy Koenig <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple">issues</a> in [tuple].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.4 [tuple], TR1 6.1 [tr.tuple] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Andy Koenig <b>Opened:</b> 2005-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple">issues</a> in [tuple].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Tuple doesn't define swap(). It should.
+@@ -24337,7 +24284,8 @@ Bellevue: Alisdair provided wording.
+ Add these signatures to 20.4 [tuple]
+ </p>
+
+-<blockquote><pre>template &lt;class... Types&gt;
++<blockquote><pre>
++template &lt;class... Types&gt;
+ void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y);
+ template &lt;class... Types&gt;
+ void swap(tuple&lt;Types...&gt;&amp;&amp; x, tuple&lt;Types...&gt;&amp; y);
+@@ -24349,7 +24297,8 @@ template &lt;class... Types&gt;
+ Add this signature to 20.4.2 [tuple.tuple]
+ </p>
+
+-<blockquote><pre>void swap(tuple&amp;&amp;);
++<blockquote><pre>
++void swap(tuple&amp;&amp;);
+ </pre></blockquote>
+
+ <p>
+@@ -24361,7 +24310,8 @@ Add the following two sections to the end of the tuple clauses
+ 20.3.1.7 tuple swap [tuple.swap]
+ </p>
+
+-<pre>void swap(tuple&amp;&amp; rhs);
++<pre>
++void swap(tuple&amp;&amp; rhs);
+ </pre>
+
+ <blockquote>
+@@ -24382,7 +24332,8 @@ exception.
+ 20.3.1.8 tuple specialized algorithms [tuple.special]
+ </p>
+
+-<pre>template &lt;class... Types&gt;
++<pre>
++template &lt;class... Types&gt;
+ void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y);
+ template &lt;class... Types&gt;
+ void swap(tuple&lt;Types...&gt;&amp;&amp; x, tuple&lt;Types...&gt;&amp; y);
+@@ -24404,10 +24355,11 @@ template &lt;class... Types&gt;
+
+ <hr>
+ <h3><a name="524"></a>524. regex named character classes and case-insensitivity don't mix</h3>
+-<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2005-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re">issues</a> in [re].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28 [re] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2005-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re">active issues</a> in [re].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re">issues</a> in [re].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This defect is also being discussed on the Boost developers list. The
+@@ -24482,10 +24434,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="525"></a>525. type traits definitions not clear</h3>
+-<p><b>Section:</b> 20.7.4 [meta.unary], TR1 4.5 [tr.meta.unary] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2005-07-11 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.10.4 [meta.unary], TR1 4.5 [tr.meta.unary] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2005-07-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It is not completely clear how the primary type traits deal with
+@@ -24502,29 +24454,29 @@ Berlin: Howard to provide wording.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Wording provided in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2028.html">N2028</a>.
+-A
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2157.html">revision (N2157)</a>
++A <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2157.html">revision (N2157)</a>
+ provides more detail for motivation.
+ </p>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2157.html">revision (N2157)</a>
+ in the WP.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="527"></a>527. tr1::bind has lost its Throws clause</h3>
+-<p><b>Section:</b> 20.8.10.1.2 [func.bind.bind], TR1 3.6.3 [tr.func.bind.bind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2005-10-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="527"></a>527. <tt>tr1::bind</tt> has lost its Throws clause</h3>
++<p><b>Section:</b> 20.9.10.3 [func.bind.bind], TR1 3.6.3 [tr.func.bind.bind] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2005-10-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The original bind proposal gives the guarantee that tr1::bind(f, t1, ..., tN) does not throw when the copy constructors of f, t1, ..., tN don't.
++The original bind proposal gives the guarantee that <tt>tr1::bind(f, t1, ..., tN)</tt>
++does not throw when the copy constructors of <tt>f, t1, ..., tN</tt> don't.
+ </p>
+
+ <p>
+@@ -24583,22 +24535,22 @@ throws an exception.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.8.10.1.2 [func.bind.bind], add a new paragraph after p2:
++In 20.9.10.3 [func.bind.bind], add a new paragraph after p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> Nothing unless the copy constructor of <tt>F</tt> or of one of the types
+ in the <tt>BoundArgs...</tt> pack expansion throws an exception.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-In 20.8.10.1.2 [func.bind.bind], add a new paragraph after p4:
++In 20.9.10.3 [func.bind.bind], add a new paragraph after p4:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> Nothing unless the copy constructor of <tt>F</tt> or of one of the types
+ in the <tt>BoundArgs...</tt> pack expansion throws an exception.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -24607,16 +24559,17 @@ in the <tt>BoundArgs...</tt> pack expansion throws an exception.
+
+ <hr>
+ <h3><a name="530"></a>530. Must elements of a string be contiguous?</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2005-11-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2005-11-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#69">69</a>, which was incorporated into C++03, mandated
++<p>Issue <a href="lwg-defects.html#69">69</a>, which was incorporated into C++03, mandated
+ that the elements of a vector must be stored in contiguous memory.
+ Should the same also apply to <tt>basic_string</tt>?</p>
+
+-<p>We almost require contiguity already. Clause 23.6.4 [multiset]
++<p>We almost require contiguity already. Clause 23.4.7 [multiset]
+ defines <tt>operator[]</tt> as <tt>data()[pos]</tt>. What's missing
+ is a similar guarantee if we access the string's elements via the
+ iterator interface.</p>
+@@ -24660,10 +24613,11 @@ more design choices.
+
+ <hr>
+ <h3><a name="531"></a>531. array forms of unformatted input functions</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-11-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-11-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The array forms of unformatted input functions don't seem to have well-defined
+@@ -24736,10 +24690,10 @@ writing to out of bounds memory when <tt>n == 0</tt>. Martin provided fix.
+
+ <hr>
+ <h3><a name="533"></a>533. typo in 2.2.3.10/1</h3>
+-<p><b>Section:</b> 20.9.10.2.11 [util.smartptr.getdeleter], TR1 2.2.3.10 [tr.util.smartptr.getdeleter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2005-11-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.10 [util.smartptr.getdeleter], TR1 2.2.3.10 [tr.util.smartptr.getdeleter] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2005-11-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I'm seeing something that looks like a typo. The Return of <tt>get_deleter</tt>
+@@ -24767,10 +24721,11 @@ If <tt><del>*this</del> <ins>p</ins></tt> <i>owns</i> a deleter <tt>d</tt>...
+
+ <hr>
+ <h3><a name="534"></a>534. Missing basic_string members</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2005-11-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2005-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ OK, we all know std::basic_string is bloated and already has way too
+@@ -24823,7 +24778,8 @@ added to vector, or at() member added to the maps.
+ <p>
+ Add the following members to definition of class template basic_string, 21.3p7
+ </p>
+-<blockquote><pre>void pop_back ()
++<blockquote><pre>
++void pop_back ()
+
+ const charT &amp; front() const
+ charT &amp; front()
+@@ -24839,7 +24795,8 @@ Add the following paragraphs to basic_string description
+ 21.3.4p5
+ </p>
+ <blockquote>
+-<pre>const charT &amp; front() const
++<pre>
++const charT &amp; front() const
+ charT &amp; front()
+ </pre>
+ <p>
+@@ -24854,7 +24811,8 @@ charT &amp; front()
+ 21.3.4p6
+ </p>
+ <blockquote>
+-<pre>const charT &amp; back() const
++<pre>
++const charT &amp; back() const
+ charT &amp; back()
+ </pre>
+ <p>
+@@ -24869,7 +24827,8 @@ charT &amp; back()
+ 21.3.5.5p10
+ </p>
+ <blockquote>
+-<pre>void pop_back ()
++<pre>
++void pop_back ()
+ </pre>
+ <p>
+ <i>Precondition:</i> <tt>!empty()</tt>
+@@ -24883,7 +24842,8 @@ charT &amp; back()
+ Update Table 71: (optional sequence operations)
+ Add basic_string to the list of containers for the following operations.
+ </p>
+-<blockquote><pre>a.front()
++<blockquote><pre>
++a.front()
+ a.back()
+ a.push_back()
+ a.pop_back()
+@@ -24901,10 +24861,10 @@ Berlin: Has support. Alisdair provided wording.
+
+ <hr>
+ <h3><a name="535"></a>535. std::string::swap specification poorly worded</h3>
+-<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2005-12-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::swap">issues</a> in [string::swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.6.8 [string::swap] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2005-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::swap">issues</a> in [string::swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ std::string::swap currently says for effects and postcondition:
+@@ -24948,23 +24908,26 @@ characters that <del>were</del> <ins>was</ins> in <tt><i>s</i></tt>,
+
+ <hr>
+ <h3><a name="537"></a>537. Typos in the signatures in 27.6.1.3/42-43 and 27.6.2.4</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2006-02-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the most recent working draft, I'm still seeing:
+ </p>
+
+-<blockquote><pre>seekg(off_type&amp; off, ios_base::seekdir dir)
++<blockquote><pre>
++seekg(off_type&amp; off, ios_base::seekdir dir)
+ </pre></blockquote>
+
+ <p>
+ and
+ </p>
+
+-<blockquote><pre>seekp(pos_type&amp; pos)
++<blockquote><pre>
++seekp(pos_type&amp; pos)
+
+ seekp(off_type&amp; off, ios_base::seekdir dir)
+ </pre></blockquote>
+@@ -24979,21 +24942,24 @@ that is, by reference off and pos arguments.
+ After 27.6.1.3p42 change:
+ </p>
+
+-<blockquote><pre>basic_istream&lt;charT,traits&gt;&amp; seekg(off_type<del>&amp;</del> <i>off</i>, ios_base::seekdir <i>dir</i>);
++<blockquote><pre>
++basic_istream&lt;charT,traits&gt;&amp; seekg(off_type<del>&amp;</del> <i>off</i>, ios_base::seekdir <i>dir</i>);
+ </pre></blockquote>
+
+ <p>
+ After 27.6.2.4p1 change:
+ </p>
+
+-<blockquote><pre>basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type<del>&amp;</del> <i>pos</i>);
++<blockquote><pre>
++basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type<del>&amp;</del> <i>pos</i>);
+ </pre></blockquote>
+
+ <p>
+ After 27.6.2.4p3 change:
+ </p>
+
+-<blockquote><pre>basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type<del>&amp;</del> <i>off</i>, ios_base::seekdir <i>dir</i>);
++<blockquote><pre>
++basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type<del>&amp;</del> <i>off</i>, ios_base::seekdir <i>dir</i>);
+ </pre></blockquote>
+
+
+@@ -25002,10 +24968,10 @@ After 27.6.2.4p3 change:
+
+ <hr>
+ <h3><a name="538"></a>538. 241 again: Does unique_copy() require CopyConstructible and Assignable?</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I believe I botched the resolution of
+@@ -25037,7 +25003,8 @@ and that one can assign from <tt>*<i>first</i></tt> to <tt>*<i>result</i></tt>.
+ This latter requirement does not necessarily imply that you can:
+ </p>
+
+-<blockquote><pre>*<i>first</i> = *<i>first</i>;
++<blockquote><pre>
++*<i>first</i> = *<i>first</i>;
+ </pre></blockquote>
+
+
+@@ -25059,14 +25026,14 @@ Otherwise CopyConstructible is not required.
+
+
+ <hr>
+-<h3><a name="539"></a>539. partial_sum and adjacent_difference should mention requirements</h3>
+-<p><b>Section:</b> 26.7.3 [partial.sum] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Marc Schoolderman <b>Opened:</b> 2006-02-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="539"></a>539. <tt>partial_sum</tt> and <tt>adjacent_difference</tt> should mention requirements</h3>
++<p><b>Section:</b> 26.7.4 [partial.sum] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Marc Schoolderman <b>Opened:</b> 2006-02-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-There are some problems in the definition of partial_sum and
+-adjacent_difference in 26.4 [lib.numeric.ops]
++There are some problems in the definition of <tt>partial_sum</tt> and
++<tt>adjacent_difference</tt> in 26.4 [lib.numeric.ops]
+ </p>
+
+ <p>
+@@ -25079,7 +25046,8 @@ specifies the effects clause as;
+ Assigns to every element referred to by iterator <tt>i</tt> in the range
+ <tt>[result,result + (last - first))</tt> a value correspondingly equal to
+ </p>
+-<blockquote><pre>((...(* first + *( first + 1)) + ...) + *( first + ( i - result )))
++<blockquote><pre>
++((...(* first + *( first + 1)) + ...) + *( first + ( i - result )))
+ </pre></blockquote>
+ </blockquote>
+
+@@ -25089,7 +25057,8 @@ logical to expect that:
+ </p>
+
+
+-<blockquote><pre>char i_array[4] = { 100, 100, 100, 100 };
++<blockquote><pre>
++char i_array[4] = { 100, 100, 100, 100 };
+ int o_array[4];
+
+ std::partial_sum(i_array, i_array+4, o_array);
+@@ -25099,7 +25068,8 @@ std::partial_sum(i_array, i_array+4, o_array);
+ Is equivalent to
+ </p>
+
+-<blockquote><pre>int o_array[4] = { 100, 100+100, 100+100+100, 100+100+100+100 };
++<blockquote><pre>
++int o_array[4] = { 100, 100+100, 100+100+100, 100+100+100+100 };
+ </pre></blockquote>
+
+ <p>
+@@ -25119,7 +25089,8 @@ The issue becomes more noticeable when the result of the expression <tt>*i +
+ <tt>value_type</tt>. In a contrived example:
+ </p>
+
+-<blockquote><pre>enum not_int { x = 1, y = 2 };
++<blockquote><pre>
++enum not_int { x = 1, y = 2 };
+ ...
+ not_int e_array[4] = { x, x, y, y };
+ std::partial_sum(e_array, e_array+4, o_array);
+@@ -25181,7 +25152,8 @@ In both cases, the semantics should probably be clarified.
+ all implementations seem to perform operations in the 'result' type:
+ </p>
+
+-<blockquote><pre>unsigned char i_array[4] = { 4, 3, 2, 1 };
++<blockquote><pre>
++unsigned char i_array[4] = { 4, 3, 2, 1 };
+ int o_array[4];
+
+ std::adjacent_difference(i_array, i_array+4, o_array);
+@@ -25213,24 +25185,24 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The intent of the algorithms is to perform their calculations using the type of the input iterator.
+ Proposed wording provided.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We did not agree that the proposed resolution was correct. For example,
+ when the arguments are types <tt>(float*, float*, double*)</tt>, the
+ highest-quality solution would use double as the type of the
+ accumulator. If the intent of the wording is to require that the type of
+ the accumulator must be the <tt>input_iterator</tt>'s <tt>value_type</tt>, the wording
+ should specify it.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair adds:
+@@ -25242,7 +25214,8 @@ should specify it.
+ Now that we have the facility, the 'best' accumulator type could probably be
+ deduced as:
+ </p>
+-<blockquote><pre>std::common_type&lt;InIter::value_type, OutIter::reference&gt;::type
++<blockquote><pre>
++std::common_type&lt;InIter::value_type, OutIter::reference&gt;::type
+ </pre></blockquote>
+ <p>
+ This type would then have additional requirements of constructability and
+@@ -25264,11 +25237,11 @@ clearer indication of preferred direction.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution isn't quite right. For example, "the type of
+-*first" should be changed to "iterator::value_type" or similar. Daniel
++<tt>*first</tt>" should be changed to "<tt>iterator::value_type</tt>" or similar. Daniel
+ volunteered to correct the wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-29 Daniel corrected wording.
+@@ -25280,9 +25253,9 @@ volunteered to correct the wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -25293,7 +25266,7 @@ Move to Ready.
+ <ol>
+ <li>
+ <p>
+-Change 26.7.3 [partial.sum]/1 as indicated:
++Change 26.7.4 [partial.sum]/1 as indicated:
+ </p>
+
+ <blockquote>
+@@ -25325,33 +25298,33 @@ binary_op(binary_op(...,
+
+ <li>
+ <p>
+-Change 26.7.3 [partial.sum]/3 as indicated:
++Change 26.7.4 [partial.sum]/3 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Complexity:</i> Exactly <tt><ins>max(</ins>(last - first) - 1<ins>, 0)</ins></tt>
+ applications
+ of <tt><del>binary_op</del></tt><ins>the binary operation</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 26.7.3 [partial.sum]/4 as indicated:
++Change 26.7.4 [partial.sum]/4 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <ins><tt>VT</tt> shall be constructible from the type of <tt>*first</tt>, the result of
+ <tt>acc + *i</tt> or <tt>binary_op(acc, *i)</tt> shall be implicitly convertible to <tt>VT</tt>, and
+ the result of the expression <tt>acc</tt> shall be writable to the <tt>result</tt>
+ output iterator.</ins> In the ranges <tt>[first,last]</tt> and
+ <tt>[result,result + (last - first)]</tt> [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 26.7.4 [adjacent.difference]/1 as indicated:
++Change 26.7.5 [adjacent.difference]/1 as indicated:
+ </p>
+
+ <blockquote>
+@@ -25388,10 +25361,10 @@ result gets the value of *first.</del>
+
+ <li>
+ <p>
+-Change 26.7.4 [adjacent.difference]/2 as indicated:
++Change 26.7.5 [adjacent.difference]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <ins><tt>VT</tt> shall be <tt>MoveAssignable</tt> ([moveassignable])
+ and shall be
+ constructible from the type of <tt>*first</tt>. The result
+@@ -25399,19 +25372,19 @@ of the expression <tt>acc</tt> and the result of the expression <tt>val - acc</t
+ <tt>binary_op(val, acc)</tt>
+ shall be writable to the <tt>result</tt> output iterator.</ins> In the ranges
+ <tt>[first,last]</tt> [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 26.7.4 [adjacent.difference]/5 as indicated:
++Change 26.7.5 [adjacent.difference]/5 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Complexity:</i> Exactly <tt><ins>max(</ins>(last - first) - 1<ins>, 0)</ins></tt>
+ applications
+ of <del><tt>binary_op</tt></del><ins>the binary operation</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -25424,10 +25397,10 @@ of <del><tt>binary_op</tt></del><ins>the binary operation</ins>.
+
+ <hr>
+ <h3><a name="540"></a>540. shared_ptr&lt;void&gt;::operator*()</h3>
+-<p><b>Section:</b> 20.9.10.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I'm trying to reconcile the note in tr.util.smartptr.shared.obs, p6
+@@ -25482,10 +25455,11 @@ definition) of the function shall be well-formed.</ins>
+
+ <hr>
+ <h3><a name="541"></a>541. shared_ptr template assignment and void</h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared], TR1 2.2.3 [tr.util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared], TR1 2.2.3 [tr.util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Is the void specialization of the template assignment operator taking
+@@ -25494,7 +25468,8 @@ a shared_ptr&lt;void&gt; as an argument supposed be well-formed?
+ <p>
+ I.e., is this snippet well-formed:
+ </p>
+-<blockquote><pre>shared_ptr&lt;void&gt; p;
++<blockquote><pre>
++shared_ptr&lt;void&gt; p;
+ p.operator=&lt;void&gt;(p);
+ </pre></blockquote>
+
+@@ -25516,7 +25491,8 @@ though in a small test case (below) I can reproduce the error with
+ it as well.
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ struct A { T&amp; operator*() { return *(T*)0; } };
+
+ template &lt;class T&gt;
+@@ -25540,7 +25516,8 @@ int main ()
+ <p>
+ In [lib.memory] change:
+ </p>
+-<blockquote><pre>template&lt;class X&gt; class auto_ptr;
++<blockquote><pre>
++template&lt;class X&gt; class auto_ptr;
+ <ins>template&lt;&gt; class auto_ptr&lt;void&gt;;</ins>
+ </pre></blockquote>
+
+@@ -25548,7 +25525,8 @@ In [lib.memory] change:
+ In [lib.auto.ptr]/2 add the following before the last closing brace:
+ </p>
+
+-<blockquote><pre>template&lt;&gt; class auto_ptr&lt;void&gt;
++<blockquote><pre>
++template&lt;&gt; class auto_ptr&lt;void&gt;
+ {
+ public:
+ typedef void element_type;
+@@ -25562,10 +25540,10 @@ public:
+
+ <hr>
+ <h3><a name="542"></a>542. shared_ptr observers</h3>
+-<p><b>Section:</b> 20.9.10.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2005-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Peter Dimov wrote:
+@@ -25602,7 +25580,7 @@ capture the intent.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.10.2.5 [util.smartptr.shared.obs] p12:
++Change 20.8.2.2.5 [util.smartptr.shared.obs] p12:
+ </p>
+ <blockquote><p>
+ [<i>Note:</i> <tt>use_count()</tt> is not necessarily efficient. <del>Use only for
+@@ -25610,7 +25588,7 @@ debugging and testing purposes, not for production code.</del> --<i>end note</i>
+ </p></blockquote>
+
+ <p>
+-Change 20.9.10.3.5 [util.smartptr.weak.obs] p3:
++Change 20.8.2.3.5 [util.smartptr.weak.obs] p3:
+ </p>
+ <blockquote><p>
+ [<i>Note:</i> <tt>use_count()</tt> is not necessarily efficient. <del>Use only for
+@@ -25623,9 +25601,9 @@ debugging and testing purposes, not for production code.</del> --<i>end note</i>
+
+ <hr>
+ <h3><a name="543"></a>543. valarray slice default constructor</h3>
+-<p><b>Section:</b> 26.6.4 [class.slice] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2005-11-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.4 [class.slice] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2005-11-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ If one explicitly constructs a slice or glice with the default
+@@ -25640,7 +25618,8 @@ could be interpreted two ways:
+ <p>
+ Here is a bit of code to illustrate:
+ </p>
+-<blockquote><pre>#include &lt;iostream&gt;
++<blockquote><pre>
++#include &lt;iostream&gt;
+ #include &lt;valarray&gt;
+
+ int main()
+@@ -25655,7 +25634,8 @@ int main()
+ Is the behavior undefined? Or should the output be:
+ </p>
+
+-<blockquote><pre>v[slice()].size() = 0
++<blockquote><pre>
++v[slice()].size() = 0
+ </pre></blockquote>
+
+ <p>
+@@ -25665,11 +25645,11 @@ There is a similar question and wording for gslice at 26.3.6.1p1.
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p><i>[Martin suggests removing the second sentence in 26.6.4.1 [cons.slice] as well.]</i></p>
++<p><i>[Martin suggests removing the second sentence in 26.6.4.2 [cons.slice] as well.]</i></p>
+
+
+ <p>
+-Change 26.6.4.1 [cons.slice]:
++Change 26.6.4.2 [cons.slice]:
+ </p>
+
+ <blockquote><p>
+@@ -25681,7 +25661,7 @@ takes a start, length, and stride parameter.
+ </p></blockquote>
+
+ <p>
+-Change 26.6.6.1 [gslice.cons]:
++Change 26.6.6.2 [gslice.cons]:
+ </p>
+
+ <blockquote><p>
+@@ -25699,10 +25679,10 @@ lengths, and strides, as explained in the previous section.
+
+ <hr>
+ <h3><a name="545"></a>545. When is a deleter deleted?</h3>
+-<p><b>Section:</b> 20.9.10.2.11 [util.smartptr.getdeleter], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.10 [util.smartptr.getdeleter], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2006-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The description of ~shared_ptr doesn't say when the shared_ptr's deleter, if
+@@ -25717,7 +25697,7 @@ instances). We should say which it is.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add after the first sentence of 20.9.10.2.11 [util.smartptr.getdeleter]/1:
++Add after the first sentence of 20.8.2.2.10 [util.smartptr.getdeleter]/1:
+ </p>
+ <blockquote>
+ <p>
+@@ -25736,11 +25716,12 @@ This can happen if the implementation doesn't destroy the deleter until all
+
+
+ <hr>
+-<h3><a name="550"></a>550. What should the return type of pow(float,int) be?</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="550"></a>550. What should the return type of <tt>pow(float,int)</tt> be?</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Assuming we adopt the
+@@ -25748,16 +25729,18 @@ Assuming we adopt the
+ compatibility package from C99</a> what should be the return type of the
+ following signature be:
+ </p>
+-<blockquote><pre>? pow(float, int);
++<blockquote><pre>
++? pow(float, int);
+ </pre></blockquote>
+ <p>
+ C++03 says that the return type should be <tt>float</tt>.
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">
+-TR1</a> and C90/99 say the return type should be <tt>double</tt>. This can put
++TR1</a> and C90&#47;99 say the return type should be <tt>double</tt>. This can put
+ clients into a situation where C++03 provides answers that are not as high
+-quality as C90/C99/TR1. For example:
++quality as C90&#47;C99&#47;TR1. For example:
+ </p>
+-<blockquote><pre>#include &lt;math.h&gt;
++<blockquote><pre>
++#include &lt;math.h&gt;
+
+ int main()
+ {
+@@ -25766,17 +25749,19 @@ int main()
+ }
+ </pre></blockquote>
+ <p>
+-Assuming an IEEE 32 bit float and IEEE 64 bit double, C90/C99/TR1 all suggest:
++Assuming an IEEE 32 bit float and IEEE 64 bit double, C90&#47;C99&#47;TR1 all suggest:
+ </p>
+
+-<blockquote><pre>y = 4329326534736.390625
++<blockquote><pre>
++y = 4329326534736.390625
+ </pre></blockquote>
+
+ <p>
+-which is exactly right. While C++98/C++03 demands:
++which is exactly right. While C++98&#47;C++03 demands:
+ </p>
+
+-<blockquote><pre>y = 4329326510080.
++<blockquote><pre>
++y = 4329326510080.
+ </pre></blockquote>
+
+ <p>
+@@ -25792,17 +25777,15 @@ Fortran, C and TR1 and make the return type of <tt>pow(float,int)</tt> be
+ <p><i>[
+ Kona (2007): Other functions that are affected by this issue include
+ <tt>ldexp</tt>, <tt>scalbln</tt>, and <tt>scalbn</tt>. We also believe that there is a typo in
+-26.7/10: <tt>float nexttoward(float, long double);</tt> [sic] should be <tt>float
++26.7&#47;10: <tt>float nexttoward(float, long double);</tt> [sic] should be <tt>float
+ nexttoward(float, float);</tt> Proposed Disposition: Review (the proposed
+ resolution appears above, rather than below, the heading "Proposed
+ resolution")
+ ]</i></p>
+
+
+-<p><i>[
+-</i></p><p><i>
+-Howard, post Kona:
+-</i></p><i>
++<p><i>[Howard, post Kona:]</i></p>
++
+ <blockquote>
+ <p>
+ Unfortunately I strongly disagree with a part of the resolution
+@@ -25821,7 +25804,8 @@ For similar reasons, I do not believe that the second <tt>long double</tt> param
+ correct signature is:
+ </p>
+ <blockquote>
+-<pre>float nexttoward(float, long double);
++<pre>
++float nexttoward(float, long double);
+ </pre>
+ </blockquote>
+ <p>
+@@ -25833,21 +25817,19 @@ route (with <tt>pow</tt> only) and C99 took another (with many math functions in
+ The proposed resolution basically says: C++98 got it wrong and C99 got it right; let's go with C99.
+ </p>
+ </blockquote>
+-]</i><p></p>
+-
+
+ <p><i>[
+ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This signature was not picked up from C99. Instead, if one types
+-pow(2.0f,2), the promotion rules will invoke "double pow(double,
++<tt>pow(2.0f,2)</tt>, the promotion rules will invoke "double pow(double,
+ double)", which generally gives special treatment for integral
+ exponents, preserving full accuracy of the result. New proposed
+ wording provided.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -25859,7 +25841,8 @@ Change 26.8 [c.math] p10:
+ <p>
+ The added signatures are:
+ </p>
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ <del>float pow(float, int);</del>
+ ...
+ <del>double pow(double, int);</del>
+@@ -25875,9 +25858,9 @@ The added signatures are:
+
+ <hr>
+ <h3><a name="551"></a>551. &lt;ccomplex&gt;</h3>
+-<p><b>Section:</b> X [cmplxh], TR1 8.3 [tr.c99.cmplxh] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [cmplxh], TR1 8.3 [tr.c99.cmplxh] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Previously xxx.h was parsable by C++. But in the case of C99's &lt;complex.h&gt;
+@@ -25936,10 +25919,10 @@ note</i>]</ins>
+
+ <hr>
+ <h3><a name="552"></a>552. random_shuffle and its generator</h3>
+-<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-01-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-01-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ ...is specified to shuffle its range by calling swap but not how
+@@ -25977,11 +25960,11 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+
+ <hr>
+-<h3><a name="556"></a>556. is Compare a BinaryPredicate?</h3>
+-<p><b>Section:</b> 25.4 [alg.sorting] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.sorting">issues</a> in [alg.sorting].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="556"></a>556. Is <tt>Compare</tt> a <tt>BinaryPredicate</tt>?</h3>
++<p><b>Section:</b> 25.4 [alg.sorting] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.sorting">issues</a> in [alg.sorting].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 25, p8 we allow BinaryPredicates to return a type that's convertible
+@@ -26027,28 +26010,28 @@ destroyed.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review once wording received. Stefanus to send proposed wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review once wording received. Stefanus to send proposed wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-24 Stefanus supplied wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review once wording received. Stefanus to send proposed wording.
+ Old proposed wording here:
+-<blockquote>
++</p><blockquote>
+ <p>
+ I think we could fix this by rewording 25.3, p2 to read somthing like:
+ </p>
+@@ -26076,7 +26059,8 @@ Howard expresses concern that the current direction of the proposed
+ wording outlaws expressions such as:
+ </p>
+
+-<blockquote><pre>if (!comp(x, y))
++<blockquote><pre>
++if (!comp(x, y))
+ </pre></blockquote>
+
+ <p>
+@@ -26092,7 +26076,7 @@ The previous wording is saved here:
+ <p>
+ Change 25.4 [alg.sorting] p2:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>Compare</tt> is used as a function object<ins>. The return value of
+ the function call operator applied to an object of type Compare, when
+ converted to type bool, yields true if the first argument of the
+@@ -26101,7 +26085,7 @@ is less than the second, and <tt>false</tt> otherwise. <tt>Compare
+ comp</tt> is used throughout for algorithms assuming an ordering
+ relation. It is assumed that <tt>comp</tt> will not apply any
+ non-constant function through the dereferenced iterator.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -26162,8 +26146,8 @@ non-constant function through the dereferenced iterators.
+ Change 25.4 [alg.sorting]/2 as indicated:
+ </p>
+
+-<blockquote>
+-2 <tt>Compare</tt> is <del>used as</del> a function object <ins>type (20.8 [function.objects]). The return value of the function call operation
++<blockquote><p>
++2 <tt>Compare</tt> is <del>used as</del> a function object <ins>type (20.9 [function.objects]). The return value of the function call operation
+ applied to an object of type <tt>Compare</tt>, when contextually converted to
+ type <tt>bool</tt> (4 [conv]), yields <tt>true</tt> if the first
+ argument of the call</ins><del> which returns <tt>true</tt> if the first
+@@ -26171,7 +26155,7 @@ argument</del> is less than the second, and <tt>false</tt> otherwise.
+ <tt>Compare comp</tt> is used throughout for algorithms assuming an ordering
+ relation. It is assumed that <tt>comp</tt> will not apply any non-constant
+ function through the dereferenced iterator.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ </ol>
+@@ -26183,14 +26167,14 @@ function through the dereferenced iterator.
+
+ <hr>
+ <h3><a name="559"></a>559. numeric_limits&lt;const T&gt;</h3>
+-<p><b>Section:</b> 18.3.1 [limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#limits">issues</a> in [limits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2 [limits] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#limits">issues</a> in [limits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+-18.3.1 [limits], p2 requires implementations to provide specializations of the
++18.3.2 [limits], p2 requires implementations to provide specializations of the
+ <code>numeric_limits</code> template for each scalar type. While this
+ could be interepreted to include cv-qualified forms of such types such
+ an interepretation is not reflected in the synopsis of the
+@@ -26225,6 +26209,7 @@ following:
+ </p>
+
+ <pre>
++
+ template &lt;class T&gt; class numeric_limits&lt;const T&gt;;
+ template &lt;class T&gt; class numeric_limits&lt;volatile T&gt;;
+ template &lt;class T&gt; class numeric_limits&lt;const volatile T&gt;;
+@@ -26233,7 +26218,7 @@ template &lt;class T&gt; class numeric_limits&lt;const volatile T&gt;;
+
+ <p>
+
+-Add a new paragraph to the end of 18.3.1.1 [numeric.limits], with the following
++Add a new paragraph to the end of 18.3.2.3 [numeric.limits], with the following
+ text:
+
+ </p>
+@@ -26258,15 +26243,16 @@ automatically.
+
+ <hr>
+ <h3><a name="561"></a>561. inserter overly generic</h3>
+-<p><b>Section:</b> 24.5.2.6.5 [inserter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-02-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.2.6.5 [inserter] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2006-02-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The declaration of <tt>std::inserter</tt> is:
+ </p>
+
+-<blockquote><pre>template &lt;class Container, class Iterator&gt;
++<blockquote><pre>
++template &lt;class Container, class Iterator&gt;
+ insert_iterator&lt;Container&gt;
+ inserter(Container&amp; x, Iterator i);
+ </pre></blockquote>
+@@ -26284,7 +26270,8 @@ one has in a signature, the opportunity for a mistaken binding grows geometrical
+ It would be much better if <tt>inserter</tt> had the following signature instead:
+ </p>
+
+-<blockquote><pre>template &lt;class Container&gt;
++<blockquote><pre>
++template &lt;class Container&gt;
+ insert_iterator&lt;Container&gt;
+ inserter(Container&amp; x, typename Container::iterator i);
+ </pre></blockquote>
+@@ -26304,7 +26291,8 @@ types need not be anything closely related to containers or iterators.
+ This can adversely impact well written code. Consider:
+ </p>
+
+-<blockquote><pre>#include &lt;iterator&gt;
++<blockquote><pre>
++#include &lt;iterator&gt;
+ #include &lt;string&gt;
+
+ namespace my
+@@ -26345,7 +26333,8 @@ To make matters a little more insidious, the above example works today if you
+ simply change the first argument to an rvalue:
+ </p>
+
+-<blockquote><pre> inserter(my::my_type(), c);
++<blockquote><pre>
++ inserter(my::my_type(), c);
+ </pre></blockquote>
+
+ <p>
+@@ -26374,7 +26363,8 @@ Change 24.2:
+ <blockquote><p>
+ <b>24.2 Header</b> <tt>&lt;iterator&gt;</tt> <b>synopsis</b>
+ </p>
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ template &lt;class Container<del>, class Iterator</del>&gt;
+ insert_iterator&lt;Container&gt; inserter(Container&amp; x, <del>Iterator</del> <ins>typename Container::iterator</ins> i);
+ ...
+@@ -26387,7 +26377,8 @@ Change 24.4.2.5:
+
+ <blockquote><p>
+ <b>24.4.2.5 Class template</b> <tt>insert_iterator</tt></p>
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ template &lt;class Container<del>, class Iterator</del>&gt;
+ insert_iterator&lt;Container&gt; inserter(Container&amp; x, <del>Iterator</del> <ins>typename Container::iterator</ins> i);
+ ...
+@@ -26402,7 +26393,8 @@ Change 24.4.2.6.5:
+ <p>
+ <b>24.4.2.6.5</b> <tt>inserter</tt>
+ </p>
+-<pre>template &lt;class Container<del>, class Inserter</del>&gt;
++<pre>
++template &lt;class Container<del>, class Inserter</del>&gt;
+ insert_iterator&lt;Container&gt; inserter(Container&amp; x, <del>Inserter</del> <ins>typename Container::iterator</ins> i);
+ </pre>
+ <blockquote><p>
+@@ -26423,10 +26415,10 @@ Proposed Disposition: Ready
+
+ <hr>
+ <h3><a name="562"></a>562. stringbuf ctor inefficient</h3>
+-<p><b>Section:</b> 27.8 [string.streams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.streams">issues</a> in [string.streams].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8 [string.streams] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.streams">issues</a> in [string.streams].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -26449,7 +26441,8 @@ Change 27.7.1.1, p3 of the Working Draft, N1804, as follows:
+
+ </p>
+
+-<blockquote><pre>explicit basic_stringbuf(const basic_string&lt;charT,traits,Allocator&gt;&amp; <i>s<del>tr</del></i>,
++<blockquote><pre>
++explicit basic_stringbuf(const basic_string&lt;charT,traits,Allocator&gt;&amp; <i>s<del>tr</del></i>,
+ ios_base::openmode <i>which</i> = ios_base::in | ios_base::out);
+ </pre>
+
+@@ -26518,10 +26511,10 @@ Kona (2007) Moved to Ready.
+
+ <hr>
+ <h3><a name="563"></a>563. stringbuf seeking from end</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to Table 92 (unchanged by issue 432), when <code>(way ==
+@@ -26575,11 +26568,11 @@ Kona (2007) Moved to Ready.
+
+
+ <hr>
+-<h3><a name="564"></a>564. stringbuf seekpos underspecified</h3>
+-<p><b>Section:</b> 27.8.1.4 [stringbuf.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="564"></a>564. <tt>stringbuf</tt> seekpos underspecified</h3>
++<p><b>Section:</b> 27.8.2.4 [stringbuf.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#stringbuf.virtuals">issues</a> in [stringbuf.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The effects of the <code>seekpos()</code> member function of
+@@ -26594,9 +26587,9 @@ is described.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -26647,10 +26640,10 @@ plugs the hole by specifying <tt>seekpos()</tt> in terms of <tt>seekoff()</tt>.
+
+
+ <hr>
+-<h3><a name="565"></a>565. xsputn inefficient</h3>
+-<p><b>Section:</b> 27.6.2.4.5 [streambuf.virt.put] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="565"></a>565. <tt>xsputn</tt> inefficient</h3>
++<p><b>Section:</b> 27.6.3.4.5 [streambuf.virt.put] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -26683,9 +26676,9 @@ required to cause a call to <tt>overflow()</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -26730,10 +26723,11 @@ proposed wording doesn't accomplish that. Proposed Disposition: Open
+
+ <hr>
+ <h3><a name="566"></a>566. array forms of unformatted input function undefined for zero-element arrays</h3>
+-<p><b>Section:</b> 27.7.1.3 [istream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -26802,10 +26796,10 @@ location of the array.
+
+ <hr>
+ <h3><a name="567"></a>567. streambuf inserter and extractor should be unformatted</h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-02-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -26869,17 +26863,17 @@ Kona (2007): Proposed Disposition: Ready
+
+ <hr>
+ <h3><a name="574"></a>574. DR 369 Contradicts Text</h3>
+-<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2006-04-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.4 [iostream.objects] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2006-04-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.objects">issues</a> in [iostream.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ lib.iostream.objects requires that the standard stream objects are never
+ destroyed, and it requires that they be destroyed.
+ </p>
+ <p>
+-DR 369 adds words to say that we really mean for ios_base::Init objects to force
++DR 369 adds words to say that we really mean for <tt>ios_base::Init</tt> objects to force
+ construction of standard stream objects. It ends, though, with the phrase "these
+ stream objects shall be destroyed after the destruction of dynamically ...".
+ However, the rule for destruction is stated in the standard: "The objects are
+@@ -26898,7 +26892,7 @@ Change 27.4 [iostream.objects]/1:
+ some time prior to or during the first time an object of class
+ <tt>ios_base::Init</tt> is constructed, and in any case before the body of main
+ begins execution.<sup>290)</sup> The objects are not destroyed during program
+-execution.<sup>291)</sup> If a translation unit includes <tt>&lt;iostream&amp;t;</tt> or explicitly
++execution.<sup>291)</sup> If a translation unit includes <tt>&lt;iostream&gt;</tt> or explicitly
+ constructs an <tt>ios_base::Init</tt> object, these stream objects shall be
+ constructed before dynamic initialization of non-local objects defined
+ later in that translation unit<del>, and these stream objects shall be
+@@ -26921,10 +26915,10 @@ Disposition: Review
+
+ <hr>
+ <h3><a name="575"></a>575. the specification of ~shared_ptr is MT-unfriendly, makes implementation assumptions</h3>
+-<p><b>Section:</b> 20.9.10.2.2 [util.smartptr.shared.dest], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2006-04-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.dest">issues</a> in [util.smartptr.shared.dest].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.2 [util.smartptr.shared.dest], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2006-04-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.dest">issues</a> in [util.smartptr.shared.dest].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ [tr.util.smartptr.shared.dest] says in its second bullet:
+@@ -26961,7 +26955,8 @@ of shared_ptr's state, this would lead to other undesirable consequences WRT
+ multiple threads. For example,
+ </p>
+
+-<blockquote><pre>p1 = p2;
++<blockquote><pre>
++p1 = p2;
+ </pre></blockquote>
+
+ <p>
+@@ -27000,17 +26995,18 @@ after <tt>*this</tt> is destroyed. <i>--end note</i>]
+
+ <hr>
+ <h3><a name="576"></a>576. find_first_of is overconstrained</h3>
+-<p><b>Section:</b> 25.2.7 [alg.find.first.of] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2006-04-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.find.first.of">issues</a> in [alg.find.first.of].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.2.7 [alg.find.first.of] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2006-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.find.first.of">issues</a> in [alg.find.first.of].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 25.1.4 Find First [lib.alg.find.first], the two iterator type parameters to
+ find_first_of are specified to require Forward Iterators, as follows:
+ </p>
+
+-<blockquote><pre>template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
+ ForwardIterator1
+ find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
+ ForwardIterator2 first2, ForwardIterator2 last2);
+@@ -27034,7 +27030,8 @@ Iterator or a true reference.
+ Change the declarations of <tt>find_first_of</tt> to:
+ </p>
+
+-<blockquote><pre>template&lt;class <del>ForwardIterator1</del><ins>InputIterator1</ins>, class ForwardIterator2&gt;
++<blockquote><pre>
++template&lt;class <del>ForwardIterator1</del><ins>InputIterator1</ins>, class ForwardIterator2&gt;
+ <del>ForwardIterator1</del><ins>InputIterator1</ins>
+ find_first_of(<del>ForwardIterator1</del><ins>InputIterator1</ins> first1, <del>ForwardIterator1</del><ins>InputIterator1</ins> last1,
+ ForwardIterator2 first2, ForwardIterator2 last2);
+@@ -27053,9 +27050,9 @@ template&lt;class <del>ForwardIterator1</del><ins>InputIterator1</ins>, class Fo
+
+ <hr>
+ <h3><a name="577"></a>577. upper_bound(first, last, ...) cannot return last</h3>
+-<p><b>Section:</b> 25.4.3.2 [upper.bound] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2006-05-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.3.2 [upper.bound] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2006-05-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ ISO/IEC 14882:2003 says:
+@@ -27103,10 +27100,10 @@ conditions hold: <tt>!(value &lt; *j)</tt> or <tt><i>comp</i>(<i>value</i>, *j)
+
+ <hr>
+ <h3><a name="578"></a>578. purpose of hint to allocator::allocate()</h3>
+-<p><b>Section:</b> 20.9.5.1 [allocator.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -27162,10 +27159,10 @@ adjacent element is often a good choice to pass for this argument.</del>
+
+ <hr>
+ <h3><a name="581"></a>581. <code>flush()</code> not unformatted function</h3>
+-<p><b>Section:</b> 27.7.2.7 [ostream.unformatted] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.3.7 [ostream.unformatted] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.unformatted">issues</a> in [ostream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -27176,7 +27173,7 @@ That has at least two in my opinion problematic consequences:
+ </p>
+ <p>
+
+-First, <code>flush()</code> now calls <code>rdbuf()-&gt;pubsync()</code>
++First, <code>flush()</code> now calls <code>rdbuf()->pubsync()</code>
+ unconditionally, without regard to the state of the stream. I can't
+ think of any reason why <code>flush()</code> should behave differently
+ from the vast majority of stream functions in this respect.
+@@ -27206,7 +27203,7 @@ Effects: <ins>Behaves as an unformatted output function (as described
+ in 27.6.2.6, paragraph 1). </ins>If <code>rdbuf()</code> is not a null
+ pointer, <ins>constructs a sentry object. If this object returns
+ <code>true</code> when converted to a value of type bool the function
+-</ins>calls <code>rdbuf()-&gt;pubsync()</code>. If that function returns
++</ins>calls <code>rdbuf()->pubsync()</code>. If that function returns
+ -1 calls <code>setstate(badbit)</code> (which may throw
+ <code>ios_base::failure</code> (27.4.4.3)). <ins>Otherwise, if the
+ sentry object returns <code>false</code>, does nothing.</ins><del>Does
+@@ -27226,10 +27223,10 @@ Kona (2007): Proposed Disposition: Ready
+
+ <hr>
+ <h3><a name="586"></a>586. string inserter not a formatted function</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -27285,7 +27282,7 @@ traits&gt;::sentry k (os)</code>. If <code>bool(k)</code> is
+ this object returns <code>true</code> when converted to a value of
+ type <code>bool</code>, determines padding as described in
+ 22.2.2.2.2</ins>, then inserts the resulting sequence of characters
+-<code><i>seq</i></code> as if by calling <code>os.rdbuf()-&gt;sputn(seq ,
++<code><i>seq</i></code> as if by calling <code>os.rdbuf()->sputn(seq ,
+ n)</code>, where <code><i>n</i></code> is the larger of
+ <code>os.width()</code> and <code>str.size()</code>; then calls
+ <code>os.width(0)</code>. <del>If the call to sputn fails, calls
+@@ -27309,11 +27306,12 @@ indicates a failure.
+
+ <hr>
+ <h3><a name="589"></a>589. Requirements on iterators of member template functions of containers</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2006-08-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#536">536</a></p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2006-08-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#536">536</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There appears to be no requirements on the InputIterators used in sequences in 23.1.1 in
+@@ -27369,10 +27367,10 @@ easy to fix this up as a safety net and as a clear statement of intent.
+
+ <hr>
+ <h3><a name="593"></a>593. __STDC_CONSTANT_MACROS</h3>
+-<p><b>Section:</b> 18.4 [cstdint], TR1 8.22 [tr.c99.cstdint] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2006-08-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cstdint">issues</a> in [cstdint].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.4 [cstdint], TR1 8.22 [tr.c99.cstdint] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2006-08-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cstdint">issues</a> in [cstdint].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Clause 18.3 of the current Working Paper (N2009) deals with the new C++ headers
+@@ -27411,20 +27409,20 @@ particular, the symbols __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS
+
+
+ <hr>
+-<h3><a name="594"></a>594. Disadvantages of defining Swappable in terms of CopyConstructible and Assignable</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="594"></a>594. Disadvantages of defining <tt>Swappable</tt> in terms of <tt>CopyConstructible</tt> and <tt>Assignable</tt></h3>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-It seems undesirable to define the Swappable requirement in terms of
+-CopyConstructible and Assignable requirements. And likewise, once the
+-MoveConstructible and MoveAssignable requirements (N1860) have made it
+-into the Working Draft, it seems undesirable to define the Swappable
++It seems undesirable to define the <tt>Swappable</tt> requirement in terms of
++<tt>CopyConstructible</tt> and <tt>Assignable</tt> requirements. And likewise, once the
++<tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> requirements (N1860) have made it
++into the Working Draft, it seems undesirable to define the <tt>Swappable</tt>
+ requirement in terms of those requirements. Instead, it appears
+-preferable to have the Swappable requirement defined exclusively in
++preferable to have the <tt>Swappable</tt> requirement defined exclusively in
+ terms of the existence of an appropriate swap function.
+ </p>
+
+@@ -27513,7 +27511,8 @@ that the following code fragment will correctly swap two objects of a
+ type T, if and only if T is Swappable:
+ </p>
+
+-<pre> using std::swap;
++<pre>
++ using std::swap;
+ swap(t, u); // t and u are of type T.
+ </pre>
+
+@@ -27534,28 +27533,28 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
+-Recommend NAD. Solved by
++<blockquote><p>
++Recommend <del>NAD</del><ins>Resolved</ins>. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2774.pdf">N2774</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Open. Waiting for non-concepts draft.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-08 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-This issue is very closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>.
+-</blockquote>
++<blockquote><p>
++This issue is very closely related to <a href="lwg-defects.html#742">742</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-03 Sean Hunt adds:
+@@ -27585,9 +27584,9 @@ limiting the non-ADL overload set to std::swap might be required.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD Editorial. Rationale added.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -27628,17 +27627,18 @@ within the namespace std, and has the semantics described in Table 33.
+
+
+ <hr>
+-<h3><a name="595"></a>595. TR1/C++0x: fabs(complex&lt;T&gt;) redundant / wrongly specified</h3>
+-<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stefan Große Pawig <b>Opened:</b> 2006-09-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="595"></a>595. TR1&#47;C++0x: <tt>fabs(complex&lt;T&gt;)</tt> redundant &#47; wrongly specified</h3>
++<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stefan Gro&szlig;e Pawig <b>Opened:</b> 2006-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ TR1 introduced, in the C compatibility chapter, the function
+-fabs(complex&lt;T&gt;):
++<tt>fabs(complex&lt;T&gt;)</tt>:
+ </p>
+-<blockquote><pre>----- SNIP -----
++<blockquote><pre>
++----- SNIP -----
+ 8.1.1 Synopsis [tr.c99.cmplx.syn]
+
+ namespace std {
+@@ -27667,7 +27667,8 @@ But in C99 (ISO/IEC 9899:1999 as well as the 9899:TC2 draft document
+ n1124), the referenced subclause reads
+ </p>
+
+-<blockquote><pre>----- SNIP -----
++<blockquote><pre>
++----- SNIP -----
+ 7.3.8.1 The cabs functions
+
+ Synopsis
+@@ -27699,9 +27700,9 @@ document n2009.pdf).
+ So either the return value of fabs() is specified wrongly, or fabs()
+ does not behave the same as C99's cabs*().
+ </p>
+-
++<p>
+ <b>Possible Resolutions</b>
+-
++</p>
+ <p>
+ This depends on the intention behind the introduction of fabs().
+ </p>
+@@ -27718,14 +27719,16 @@ is really needed, since complex&lt;T&gt; supports construction and
+ assignment from real valued arguments. There is no difference
+ in observable behaviour between
+ </p>
+-<blockquote><pre> complex&lt;double&gt; x, y;
++<blockquote><pre>
++ complex&lt;double&gt; x, y;
+ y = fabs(x);
+ complex&lt;double&gt; z(fabs(x));
+ </pre></blockquote>
+ <p>
+ and
+ </p>
+-<blockquote><pre> complex&lt;double&gt; x, y;
++<blockquote><pre>
++ complex&lt;double&gt; x, y;
+ y = abs(x);
+ complex&lt;double&gt; z(abs(x));
+ </pre></blockquote>
+@@ -27741,9 +27744,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
+-Bill believes that abs() is a suitable overload. We should remove fabs().
+-</blockquote>
++<blockquote><p>
++Bill believes that <tt>abs()</tt> is a suitable overload. We should remove <tt>fabs()</tt>.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -27752,7 +27755,8 @@ Bill believes that abs() is a suitable overload. We should remove fabs().
+ Change the synopsis in 26.4.1 [complex.syn]:
+ </p>
+
+-<blockquote><pre><del>template&lt;class T&gt; complex&lt;T&gt; fabs(const complex&lt;T&gt;&amp;);</del>
++<blockquote><pre>
++<del>template&lt;class T&gt; complex&lt;T&gt; fabs(const complex&lt;T&gt;&amp;);</del>
+ </pre></blockquote>
+
+ <p>
+@@ -27760,7 +27764,8 @@ Remove 26.4.7 [complex.value.ops], p7:
+ </p>
+
+ <blockquote>
+-<pre><del>template&lt;class T&gt; complex&lt;T&gt; fabs(const complex&lt;T&gt;&amp; <i>x</i>);</del>
++<pre>
++<del>template&lt;class T&gt; complex&lt;T&gt; fabs(const complex&lt;T&gt;&amp; <i>x</i>);</del>
+ </pre>
+ <blockquote>
+ <p>
+@@ -27782,15 +27787,16 @@ Proposed Disposition: Ready
+
+ <hr>
+ <h3><a name="596"></a>596. 27.8.1.3 Table 112 omits "a+" and "a+b" modes</h3>
+-<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2006-09-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.4 [filebuf.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2006-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#filebuf.members">issues</a> in [filebuf.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In testing 27.9.1.4 [filebuf.members], Table 112 (in the latest N2009 draft), we invoke
+ </p>
+-<blockquote><pre> ostr.open("somename", ios_base::out | ios_base::in | ios_base::app)
++<blockquote><pre>
++ ostr.open("somename", ios_base::out | ios_base::in | ios_base::app)
+ </pre></blockquote>
+ <p>
+ and we expect the open to fail, because out|in|app is not listed in
+@@ -27840,7 +27846,7 @@ Add to the table "File open modes" in 27.9.1.4 [filebuf.members]:
+ <blockquote>
+ <table border="1">
+ <caption> File open modes</caption>
+-<tbody><tr>
++<tr>
+ <th colspan="5"><tt>ios_base</tt> Flag combination</th>
+ <th><tt>stdio</tt> equivalent</th>
+ </tr>
+@@ -27896,15 +27902,15 @@ Add to the table "File open modes" in 27.9.1.4 [filebuf.members]:
+ </tr>
+ <tr>
+ <td><tt>+</tt></td> <td><tt>+</tt></td> <td><tt>+</tt></td> <td><tt>+</tt></td> <td>&nbsp;</td> <td><tt>"w+b"</tt></td>
+-</tr><tr>
++</tr>
++<tr>
+ <td><ins><tt>+</tt></ins></td> <td><ins><tt>+</tt></ins></td> <td><ins><tt>+</tt></ins></td> <td>&nbsp;</td> <td><ins><tt>+</tt></ins></td> <td><ins><tt>"a+b"</tt></ins></td>
+ </tr>
+ <tr>
+ <td><ins><tt>+</tt></ins></td> <td><ins><tt>+</tt></ins></td> <td>&nbsp;</td> <td>&nbsp;</td> <td><ins><tt>+</tt></ins></td> <td><ins><tt>"a+b"</tt></ins></td>
+ </tr>
+
+-
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -27919,10 +27925,10 @@ Kona (2007) Added proposed wording and moved to Review.
+
+ <hr>
+ <h3><a name="598"></a>598. Decimal: Conversion to integral should truncate, not round.</h3>
+-<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.2 [trdec.types.types] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types.types">issues</a> in [trdec.types.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -27934,7 +27940,8 @@ I would like to
+ ask, what where the reason for the decision to
+ define the semantics of the integral conversion of the decimal types, namely
+ </p>
+-<pre>"operator long long() const;
++<pre>
++"operator long long() const;
+
+ Returns: Returns the result of the
+ conversion of *this to the type long long, as if
+@@ -27997,9 +28004,9 @@ Change the <b>Returns:</b> clause in 3.2.4.4 to:
+
+ <hr>
+ <h3><a name="599"></a>599. Decimal: Say "octets" instead of "bytes."</h3>
+-<p><b>Section:</b> TRDecimal 3.1 [trdec.types.encodings] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.1 [trdec.types.encodings] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Daniel writes in a private email:
+@@ -28009,7 +28016,8 @@ Daniel writes in a private email:
+ <p>
+ - 3.1 'Decimal type encodings' says in its note:
+ </p>
+-<pre>"this implies that
++<pre>
++"this implies that
+ sizeof(std::decimal::decimal32) == 4,
+ sizeof(std::decimal::decimal64) == 8, and
+ sizeof(std::decimal::decimal128) == 16."
+@@ -28055,9 +28063,9 @@ decimal128 is a <em>decimal128</em> number, which is encoded in 16 consecutive <
+
+ <hr>
+ <h3><a name="600"></a>600. Decimal: Wrong parameters for wcstod* functions</h3>
+-<p><b>Section:</b> TRDecimal 3.9 [trdec.types.cwchar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.9 [trdec.types.cwchar] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Daniel writes:
+@@ -28073,7 +28081,8 @@ wcstod128 functions ([the parameters have type pointer-to-] char instead of wcha
+ <p>
+ Change "3.9.1 Additions to <code>&lt;cwchar&gt;</code> synopsis" to:
+ </p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ namespace decimal {
+ // 3.9.2 wcstod functions:
+ decimal32 wcstod32 (const <del>char</del> <ins>wchar_t</ins> * nptr, <del>char</del> <ins>wchar_t</ins> ** endptr);
+@@ -28088,9 +28097,9 @@ Change "3.9.1 Additions to <code>&lt;cwchar&gt;</code> synopsis" to:
+
+ <hr>
+ <h3><a name="601"></a>601. Decimal: numeric_limits typos</h3>
+-<p><b>Section:</b> TRDecimal 3.3 [trdec.types.limits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.3 [trdec.types.limits] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Daniel writes in a private email:
+@@ -28114,7 +28123,8 @@ max. exponent for decimal::decimal64).</li>
+ <p>
+ In "3.3 Additions to header <code>&lt;limits&gt;</code>" change numeric_limits&lt;decimal::decimal128&gt; as follows:
+ </p>
+-<pre> template&lt;&gt; class numeric_limits&lt;decimal::decimal128&gt; {
++<pre>
++ template&lt;&gt; class numeric_limits&lt;decimal::decimal128&gt; {
+ public:
+ static const bool is_specialized = true;
+
+@@ -28130,10 +28140,10 @@ In "3.3 Additions to header <code>&lt;limits&gt;</code>" change numeric_limits&l
+
+ <hr>
+ <h3><a name="602"></a>602. Decimal: "generic floating type" not defined.</h3>
+-<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Daniel Krugler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The document uses the term "generic floating types," but defines it nowhere.
+@@ -28159,10 +28169,10 @@ collectively described as the <i>basic floating types</i></ins>.
+
+ <hr>
+ <h3><a name="603"></a>603. Decimal: Trivially simplifying decimal classes.</h3>
+-<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>In c++std-lib-17198, Martin writes:</p>
+
+@@ -28182,7 +28192,8 @@ standard (e.g., std::complex).
+ <p>
+ Change "3.2.2 Class <code>decimal32</code>" as follows:
+ </p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ namespace decimal {
+ class decimal32 {
+ public:
+@@ -28196,7 +28207,8 @@ Change "3.2.2 Class <code>decimal32</code>" as follows:
+ <p>
+ Change "3.2.2.1 construct/copy/destroy" as follows:
+ </p>
+-<pre> decimal32();
++<pre>
++ decimal32();
+
+ Effects: Constructs an object of type decimal32 with the value 0;
+
+@@ -28213,7 +28225,8 @@ Change "3.2.2.1 construct/copy/destroy" as follows:
+ <p>
+ Change "3.2.3 Class <code>decimal64</code>" as follows:
+ </p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ namespace decimal {
+ class decimal64 {
+ public:
+@@ -28227,7 +28240,8 @@ Change "3.2.3 Class <code>decimal64</code>" as follows:
+ <p>
+ Change "3.2.3.1 construct/copy/destroy" as follows:
+ </p>
+-<pre> decimal64();
++<pre>
++ decimal64();
+
+ Effects: Constructs an object of type decimal64 with the value 0;
+
+@@ -28244,7 +28258,8 @@ Change "3.2.3.1 construct/copy/destroy" as follows:
+ <p>
+ Change "3.2.4 Class <code>decimal128</code>" as follows:
+ </p>
+-<pre> namespace std {
++<pre>
++ namespace std {
+ namespace decimal {
+ class decimal128 {
+ public:
+@@ -28258,7 +28273,8 @@ Change "3.2.4 Class <code>decimal128</code>" as follows:
+ <p>
+ Change "3.2.4.1 construct/copy/destroy" as follows:
+ </p>
+-<pre> decimal128();
++<pre>
++ decimal128();
+
+ Effects: Constructs an object of type decimal128 with the value 0;
+
+@@ -28278,10 +28294,10 @@ Change "3.2.4.1 construct/copy/destroy" as follows:
+
+ <hr>
+ <h3><a name="604"></a>604. Decimal: Storing a reference to a facet unsafe.</h3>
+-<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3 [trdec.types] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2006-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#trdec.types">issues</a> in [trdec.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In c++std-lib-17197, Martin writes:
+@@ -28322,24 +28338,27 @@ take a locale argument instead.
+ <p>
+ 1. Change the <code>extended_num_get</code> synopsis in 3.10.2 as follows:
+ </p>
+-<pre> extended_num_get(const <del>std::num_get&lt;charT, InputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
++<pre>
++ extended_num_get(const <del>std::num_get&lt;charT, InputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
+
+ /* ... */
+
+- <del>// <i>const std::num_get&lt;charT, InputIterator&gt; &amp; <b>base</b></i>; <i><b>exposition only</b></i></del>
++ <del>// <i>const std::num_get&lt;charT, InputIterator> &amp; <b>base</b></i>; <i><b>exposition only</b></i></del>
+ <ins>// <i>std::locale <b>baseloc</b></i>; <i><b>exposition only</b></i></ins>
+ </pre>
+ <p>
+ 2. Change the description of the above constructor in 3.10.2.1:
+ </p>
+-<pre> extended_num_get(const <del>std::num_get&lt;charT, InputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
++<pre>
++ extended_num_get(const <del>std::num_get&lt;charT, InputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
+
+ </pre>
+ <blockquote>
+ <p>
+ <b>Effects:</b> Constructs an <code>extended_num_get</code> facet as if by:
+ </p>
+-<pre> extended_num_get(const <del>std::num_get&lt;charT, InputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0)
++<pre>
++ extended_num_get(const <del>std::num_get&lt;charT, InputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0)
+ : facet(<i>refs</i>), <i>base<ins>loc</ins></i>(<i>b</i>)
+ { /* ... */ }
+
+@@ -28352,28 +28371,31 @@ take a locale argument instead.
+ 3. Change the <b>Returns:</b> clause for <code>do_get(iter_type, iter_type, ios_base &amp;, ios_base::iostate &amp;, bool &amp;) const</code>, <i>et al</i> to
+ </p>
+ <blockquote><p>
+-<b>Returns:</b> <code><del><i>base</i></del> <ins>std::use_facet&lt;std::num_get&lt;charT, InputIterator&gt; &gt;(<i>baseloc</i>)</ins>.get(<i>in</i>, <i>end</i>, <i>str</i>, <i>err</i>, <i>val</i>)</code>.
++<b>Returns:</b> <code><del><i>base</i></del> <ins>std::use_facet&lt;std::num_get&lt;charT, InputIterator> >(<i>baseloc</i>)</ins>.get(<i>in</i>, <i>end</i>, <i>str</i>, <i>err</i>, <i>val</i>)</code>.
+ </p></blockquote>
+ <p>
+ 4. Change the <code>extended_num_put</code> synopsis in 3.10.3 as follows:
+ </p>
+-<pre> extended_num_put(const <del>std::num_put&lt;charT, OutputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
++<pre>
++ extended_num_put(const <del>std::num_put&lt;charT, OutputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
+
+ /* ... */
+
+- <del>// <i>const std::num_put&lt;charT, OutputIterator&gt; &amp; <b>base</b></i>; <i><b>exposition only</b></i></del>
++ <del>// <i>const std::num_put&lt;charT, OutputIterator> &amp; <b>base</b></i>; <i><b>exposition only</b></i></del>
+ <ins>// <i>std::locale <b>baseloc</b></i>; <i><b>exposition only</b></i></ins>
+ </pre>
+ <p>
+ 5. Change the description of the above constructor in 3.10.3.1:
+ </p>
+-<pre> extended_num_put(const <del>std::num_put&lt;charT, OutputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
++<pre>
++ extended_num_put(const <del>std::num_put&lt;charT, OutputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0);
+ </pre>
+ <blockquote>
+ <p>
+ <b>Effects:</b> Constructs an <code>extended_num_put</code> facet as if by:
+ </p>
+-<pre> extended_num_put(const <del>std::num_put&lt;charT, OutputIterator&gt;</del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0)
++<pre>
++ extended_num_put(const <del>std::num_put&lt;charT, OutputIterator></del> <ins>std::locale</ins> &amp; <i>b</i>, size_t <i>refs</i> = 0)
+ : facet(<i>refs</i>), <i>base<ins>loc</ins></i>(<i>b</i>)
+ { /* ... */ }
+
+@@ -28386,7 +28408,7 @@ take a locale argument instead.
+ 6. Change the <b>Returns:</b> clause for <code>do_put(iter_type, ios_base &amp;, char_type, bool &amp;) const</code>, <i>et al</i> to
+ </p>
+ <blockquote><p>
+-<b>Returns:</b> <code><del><i>base</i></del> <ins>std::use_facet&lt;std::num_put&lt;charT, OutputIterator&gt; &gt;(<i>baseloc</i>)</ins>.put(<i>s</i>, <i>f</i>, <i>fill</i>, <i>val</i>)</code>.
++<b>Returns:</b> <code><del><i>base</i></del> <ins>std::use_facet&lt;std::num_put&lt;charT, OutputIterator> >(<i>baseloc</i>)</ins>.put(<i>s</i>, <i>f</i>, <i>fill</i>, <i>val</i>)</code>.
+ </p></blockquote>
+
+ <p><i>[
+@@ -28400,43 +28422,44 @@ Redmond: We would prefer to rename "extended" to "decimal".
+
+ <hr>
+ <h3><a name="605"></a>605. Decimal: &lt;decfloat.h&gt; doesn't live here anymore.</h3>
+-<p><b>Section:</b> TRDecimal 3.4 [trdec.types.cdecfloat] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#TRDec">TRDec</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2006-10-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#TRDec">TRDec</a> status.</p>
++<p><b>Section:</b> TRDecimal 3.4 [trdec.types.cdecfloat] <b>Status:</b> <a href="lwg-active.html#TRDec">TRDec</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2006-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#TRDec">TRDec</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Berlin, WG14 decided to drop the &lt;decfloat.h&gt; header. The contents of that header have been moved into &lt;float.h&gt;. For the sake of C compatibility, we should make corresponding changes.
++In Berlin, WG14 decided to drop the &lt;decfloat.h> header. The contents of that header have been moved into &lt;float.h>. For the sake of C compatibility, we should make corresponding changes.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-1. Change the heading of subclause 3.4, "Headers <code>&lt;cdecfloat&gt;</code> and <code>&lt;decfloat.h&gt;</code>" to "Additions to headers <code>&lt;cfloat&gt;</code> and <code>&lt;float.h&gt;</code>."
++1. Change the heading of subclause 3.4, "Headers <code>&lt;cdecfloat></code> and <code>&lt;decfloat.h></code>" to "Additions to headers <code>&lt;cfloat></code> and <code>&lt;float.h></code>."
+ </p>
+ <p>
+ 2. Change the text of subclause 3.4 as follows:
+ </p>
+ <blockquote>
+ <p>
+-<del>The standard C++ headers <code>&lt;cfloat&gt;</code> and <code>&lt;float.h&gt;</code> define characteristics of the floating-point types <code>float</code>, <code>double</code>, and <code>long double</code>. Their contents remain unchanged by this Technical Report.</del>
++<del>The standard C++ headers <code>&lt;cfloat></code> and <code>&lt;float.h></code> define characteristics of the floating-point types <code>float</code>, <code>double</code>, and <code>long double</code>. Their contents remain unchanged by this Technical Report.</del>
+ </p>
+ <p>
+-<del>Headers <code>&lt;cdecfloat&gt;</code> and <code>&lt;decfloat.h&gt;</code> define characteristics of the decimal floating-point types <code>decimal32</code>, <code>decimal64</code>, and <code>decimal128</code>. As well, <code>&lt;decfloat.h&gt;</code> defines the convenience typedefs <code>_Decimal32</code>, <code>_Decimal64</code>, and <code>_Decimal128</code>, for compatibilty with the C programming language.</del>
++<del>Headers <code>&lt;cdecfloat></code> and <code>&lt;decfloat.h></code> define characteristics of the decimal floating-point types <code>decimal32</code>, <code>decimal64</code>, and <code>decimal128</code>. As well, <code>&lt;decfloat.h></code> defines the convenience typedefs <code>_Decimal32</code>, <code>_Decimal64</code>, and <code>_Decimal128</code>, for compatibilty with the C programming language.</del>
+ </p>
+ <p>
+-<ins>The header <code>&lt;cfloat&gt;</code> is described in [tr.c99.cfloat]. The header <code>&lt;float.h&gt;</code> is described in [tr.c99.floath]. These headers are extended by this Technical Report to define characteristics of the decimal floating-point types <code>decimal32</code>, <code>decimal64</code>, and <code>decimal128</code>. As well, <code>&lt;float.h&gt;</code> is extended to define the convenience typedefs <code>_Decimal32</code>, <code>_Decimal64</code>, and <code>_Decimal128</code> for compatibility with the C programming language.</ins>
++<ins>The header <code>&lt;cfloat></code> is described in [tr.c99.cfloat]. The header <code>&lt;float.h></code> is described in [tr.c99.floath]. These headers are extended by this Technical Report to define characteristics of the decimal floating-point types <code>decimal32</code>, <code>decimal64</code>, and <code>decimal128</code>. As well, <code>&lt;float.h></code> is extended to define the convenience typedefs <code>_Decimal32</code>, <code>_Decimal64</code>, and <code>_Decimal128</code> for compatibility with the C programming language.</ins>
+ </p>
+ </blockquote>
+ <p>
+-3. Change the heading of subclause 3.4.1, "Header <code>&lt;cdecfloat&gt;</code> synopsis" to "Additions to header <code>&lt;cfloat&gt;</code> synopsis."
++3. Change the heading of subclause 3.4.1, "Header <code>&lt;cdecfloat></code> synopsis" to "Additions to header <code>&lt;cfloat></code> synopsis."
+ </p>
+ <p>
+-4. Change the heading of subclause 3.4.2, "Header <code>&lt;decfloat.h&gt;</code> synopsis" to "Additions to header <code>&lt;float.h&gt;</code> synopsis."
++4. Change the heading of subclause 3.4.2, "Header <code>&lt;decfloat.h></code> synopsis" to "Additions to header <code>&lt;float.h></code> synopsis."
+ </p>
+ <p>
+ 5. Change the contents of 3.4.2 as follows:
+ </p>
+-<pre> <del>#include &lt;cdecfloat&gt;</del>
++<pre>
++ <del>#include &lt;cdecfloat></del>
+
+ // <i>C-compatibility convenience typedefs:</i>
+
+@@ -28451,10 +28474,10 @@ In Berlin, WG14 decided to drop the &lt;decfloat.h&gt; header. The contents of
+
+ <hr>
+ <h3><a name="607"></a>607. Concern about short seed vectors</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Charles Karney <b>Opened:</b> 2006-10-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Charles Karney <b>Opened:</b> 2006-10-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Short seed vectors of 32-bit quantities all result in different states. However
+@@ -28462,7 +28485,8 @@ this is not true of seed vectors of 16-bit (or smaller) quantities. For example
+ these two seeds
+ </p>
+
+-<blockquote><pre>unsigned short seed = {1, 2, 3};
++<blockquote><pre>
++unsigned short seed = {1, 2, 3};
+ unsigned short seed = {1, 2, 3, 0};
+ </pre></blockquote>
+
+@@ -28470,7 +28494,8 @@ unsigned short seed = {1, 2, 3, 0};
+ both pack to
+ </p>
+
+-<blockquote><pre>unsigned seed = {0x20001, 0x3};
++<blockquote><pre>
++unsigned seed = {0x20001, 0x3};
+ </pre></blockquote>
+
+ <p>
+@@ -28502,10 +28527,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="608"></a>608. Unclear seed_seq construction details</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Charles Karney <b>Opened:</b> 2006-10-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Charles Karney <b>Opened:</b> 2006-10-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 26.4.7.1 [rand.util.seedseq] /6, the order of packing the inputs into b and the
+@@ -28537,16 +28562,17 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="609"></a>609. missing static const</h3>
+-<p><b>Section:</b> 26.5.4.2 [rand.adapt.ibits], TR1 5.1 [tr.rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Walter E. Brown <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.4.3 [rand.adapt.ibits], TR1 5.1 [tr.rand] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Walter E. Brown <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In preparing N2111, an error on my part resulted in the omission of the
+ following line from the template synopsis in the cited section:
+ </p>
+
+-<blockquote><pre>static const size_t word_size = w;
++<blockquote><pre>
++static const size_t word_size = w;
+ </pre></blockquote>
+
+ <p>
+@@ -28559,7 +28585,8 @@ following line from the template synopsis in the cited section:
+ Add the above declaration as the first line after the comment in [rand.adapt.ibits] p4:
+ </p>
+
+-<blockquote><pre>// engine characteristics
++<blockquote><pre>
++// engine characteristics
+ <ins>static const size_t word_size = w;</ins>
+ </pre></blockquote>
+
+@@ -28573,10 +28600,10 @@ and accept my apologies for the oversight.
+
+ <hr>
+ <h3><a name="610"></a>610. Suggested non-normative note for C++0x</h3>
+-<p><b>Section:</b> 20.8.14.2.1 [func.wrap.func.con], TR1 3.7.2.1 [tr.func.wrap.func.con] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Scott Meyers <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con], TR1 3.7.2.1 [tr.func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Scott Meyers <b>Opened:</b> 2006-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ My suggestion is that implementers of both tr1::function and its
+@@ -28609,7 +28636,8 @@ either an empty function object or a member pointer + an object pointer.
+ The function implementation in the upcoming Boost 1.34.0 uses the
+ "SFO", so that the function objects for typical bind expressions like
+ </p>
+-<blockquote><pre>bind(&amp;X::f, this, _1, _2, _3)
++<blockquote><pre>
++bind(&amp;X::f, this, _1, _2, _3)
+ </pre></blockquote>
+
+ <p>
+@@ -28645,15 +28673,15 @@ function pointer (a "bound member function").</ins>
+
+ <hr>
+ <h3><a name="611"></a>611. Standard library templates and incomplete types</h3>
+-<p><b>Section:</b> 17.6.3.8 [res.on.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nicola Musatti <b>Opened:</b> 2006-11-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.functions">issues</a> in [res.on.functions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.4.8 [res.on.functions] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nicola Musatti <b>Opened:</b> 2006-11-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.functions">issues</a> in [res.on.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the latest available draft standard
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2134.pdf">N2134</a>)
+-§ 17.4.3.6 [res.on.functions] states:
++&sect; 17.4.3.6 [res.on.functions] states:
+ </p>
+
+ <blockquote>
+@@ -28678,7 +28706,7 @@ instantiating a template component. </li>
+ </blockquote>
+
+ <p>
+-This is contradicted by § 20.6.6.2/2 [util.smartptr.shared] which
++This is contradicted by &sect; 20.6.6.2/2 [util.smartptr.shared] which
+ states:
+ </p>
+
+@@ -28695,7 +28723,7 @@ The template parameter <tt>T</tt> of <tt>shared_ptr</tt> may be an incomplete ty
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Modify the last bullet of § 17.4.3.6/2 [res.on.functions] to allow for
++Modify the last bullet of &sect; 17.4.3.6/2 [res.on.functions] to allow for
+ exceptions:
+ </p>
+
+@@ -28714,10 +28742,10 @@ component</ins>. </li>
+
+ <hr>
+ <h3><a name="612"></a>612. numeric_limits::is_modulo insufficiently defined</h3>
+-<p><b>Section:</b> 18.3.1.2 [numeric.limits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2006-11-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2.4 [numeric.limits.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Chris Jefferson <b>Opened:</b> 2006-11-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.limits.members">issues</a> in [numeric.limits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 18.2.1.2 55 states that "A type is modulo if it is possible to add two
+@@ -28750,7 +28778,7 @@ happens to b modulo? A: the standard already seems to require that.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Suggest 18.3.1.2 [numeric.limits.members], paragraph 57 is amended to:
++Suggest 18.3.2.4 [numeric.limits.members], paragraph 57 is amended to:
+ </p>
+
+ <blockquote><p>
+@@ -28769,13 +28797,13 @@ differs from the true value by an integer multiple of <tt>(max() - min() +
+
+ <hr>
+ <h3><a name="613"></a>613. max_digits10 missing from numeric_limits</h3>
+-<p><b>Section:</b> 18.3.1.5 [numeric.special] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-11-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.3.2.7 [numeric.special] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numeric.special">issues</a> in [numeric.special].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Section 18.3.1.5 [numeric.special] starts out by saying that "All members shall be provided
++Section 18.3.2.7 [numeric.special] starts out by saying that "All members shall be provided
+ for all specializations."
+ </p>
+ <p>
+@@ -28805,7 +28833,8 @@ For reference, here are the correct formulas from
+ <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf">N1822</a>:
+ </p>
+
+-<blockquote><pre>digits10 = floor((digits-1) * log10(2))
++<blockquote><pre>
++digits10 = floor((digits-1) * log10(2))
+ max_digits10 = ceil((1 + digits) * log10(2))
+ </pre></blockquote>
+
+@@ -28817,7 +28846,7 @@ We are also missing a statement regarding for what specializations this member h
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change and add after 18.3.1.2 [numeric.limits.members], p11:
++Change and add after 18.3.2.4 [numeric.limits.members], p11:
+ </p>
+
+ <blockquote>
+@@ -28834,10 +28863,11 @@ differ <del>by only one epsilon</del> are always differentiated.
+ </blockquote>
+
+ <p>
+-Change 18.3.1.5 [numeric.special], p2:
++Change 18.3.2.7 [numeric.special], p2:
+ </p>
+
+-<blockquote><pre>template&lt;&gt; class numeric_limits&lt;float&gt; {
++<blockquote><pre>
++template&lt;&gt; class numeric_limits&lt;float&gt; {
+ public:
+ static const bool is_specialized = true;
+ ...
+@@ -28847,10 +28877,11 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Change 18.3.1.5 [numeric.special], p3:
++Change 18.3.2.7 [numeric.special], p3:
+ </p>
+
+-<blockquote><pre>template&lt;&gt; class numeric_limits&lt;bool&gt; {
++<blockquote><pre>
++template&lt;&gt; class numeric_limits&lt;bool&gt; {
+ public:
+ static const bool is_specialized = true;
+ ...
+@@ -28867,17 +28898,18 @@ public:
+
+ <hr>
+ <h3><a name="616"></a>616. missing 'typename' in ctype_byname</h3>
+-<p><b>Section:</b> 22.4.1.2 [locale.ctype.byname] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.ctype.byname">issues</a> in [locale.ctype.byname].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.2 [locale.ctype.byname] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2006-12-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.ctype.byname">issues</a> in [locale.ctype.byname].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 22.2.1.2 defines the ctype_byname class template. It contains the
+ line
+ </p>
+
+-<blockquote><pre>typedef ctype&lt;charT&gt;::mask mask;
++<blockquote><pre>
++typedef ctype&lt;charT&gt;::mask mask;
+ </pre></blockquote>
+
+
+@@ -28887,7 +28919,8 @@ line
+ as this is a dependent type, it should obviously be
+ </p>
+
+-<blockquote><pre>typedef <ins>typename</ins> ctype&lt;charT&gt;::mask mask;
++<blockquote><pre>
++typedef <ins>typename</ins> ctype&lt;charT&gt;::mask mask;
+ </pre></blockquote>
+
+
+@@ -28896,9 +28929,9 @@ as this is a dependent type, it should obviously be
+
+ <hr>
+ <h3><a name="618"></a>618. valarray::cshift() effects on empty array</h3>
+-<p><b>Section:</b> 26.6.2.7 [valarray.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2007-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.2.8 [valarray.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2007-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I would respectfully request an issue be opened with the intention to
+@@ -28908,12 +28941,13 @@ clarify the wording for <tt>size() == 0</tt> for <tt>cshift</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 26.6.2.7 [valarray.members], paragraph 10:
++Change 26.6.2.8 [valarray.members], paragraph 10:
+ </p>
+
+ <blockquote>
+
+-<pre>valarray&lt;T&gt; cshift(int <i>n</i>) const;
++<pre>
++valarray&lt;T&gt; cshift(int <i>n</i>) const;
+ </pre>
+
+ <blockquote>
+@@ -28953,10 +28987,11 @@ Kona (2007) Changed proposed wording, added rationale and set to Review.
+
+ <hr>
+ <h3><a name="619"></a>619. Longjmp wording problem</h3>
+-<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2007-01-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2007-01-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The wording for <tt>longjmp</tt> is confusing.
+@@ -29008,10 +29043,10 @@ undefined behavior if replacing the <tt>setjmp</tt> and <tt>longjmp</tt> by
+
+ <hr>
+ <h3><a name="620"></a>620. valid uses of empty valarrays</h3>
+-<p><b>Section:</b> 26.6.2.1 [valarray.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.2.2 [valarray.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29036,7 +29071,7 @@ language.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+
+-Reword the <i>Effects</i> clause and <i>Footnote 280</i> as follows (26.6.2.1 [valarray.cons]):
++Reword the <i>Effects</i> clause and <i>Footnote 280</i> as follows (26.6.2.2 [valarray.cons]):
+
+ </p>
+ <blockquote>
+@@ -29077,10 +29112,10 @@ function.
+
+ <hr>
+ <h3><a name="621"></a>621. non-const copy assignment operators of helper arrays</h3>
+-<p><b>Section:</b> 26.6 [numarray] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numarray">issues</a> in [numarray].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6 [numarray] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numarray">issues</a> in [numarray].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29088,7 +29123,7 @@ The computed and "fill" assignment operators of <code>valarray</code>
+ helper array class templates (<code>slice_array</code>,
+ <code>gslice_array</code>, <code>mask_array</code>, and
+ <code>indirect_array</code>) are const member functions of each class
+-template (the latter by the resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#123">123</a>
++template (the latter by the resolution of <a href="lwg-defects.html#123">123</a>
+ since they have reference semantics and thus do not affect
+ the state of the object on which they are called. However, the copy
+ assignment operators of these class templates, which also have
+@@ -29135,40 +29170,44 @@ Specifically, make the following edits:
+ <p>
+
+ Change the signature in 26.6.5 [template.slice.array] and
+-26.6.5.1 [slice.arr.assign] as follows:
++26.6.5.2 [slice.arr.assign] as follows:
+
+ </p>
+ <blockquote><pre>
++
+ <code><ins>const</ins> slice_array&amp; operator= (const slice_array&amp;)<ins> const</ins>;</code>
+
+ </pre></blockquote>
+ <p>
+
+ Change the signature in 26.6.7 [template.gslice.array] and
+-26.6.7.1 [gslice.array.assign] as follows:
++26.6.7.2 [gslice.array.assign] as follows:
+
+ </p>
+ <blockquote><pre>
++
+ <code><ins>const</ins> gslice_array&amp; operator= (const gslice_array&amp;)<ins> const</ins>;</code>
+
+ </pre></blockquote>
+ <p>
+
+-Change the signature in 26.6.8 [template.mask.array] and 26.6.8.1 [mask.array.assign] as
++Change the signature in 26.6.8 [template.mask.array] and 26.6.8.2 [mask.array.assign] as
+ follows:
+
+ </p>
+ <blockquote><pre>
++
+ <code><ins>const</ins> mask_array&amp; operator= (const mask_array&amp;)<ins> const</ins>;</code>
+
+ </pre></blockquote>
+ <p>
+
+ Change the signature in 26.6.9 [template.indirect.array] and
+-26.6.9.1 [indirect.array.assign] as follows:
++26.6.9.2 [indirect.array.assign] as follows:
+
+ </p>
+ <blockquote><pre>
++
+ <code><ins>const</ins> indirect_array&amp; operator= (const indirect_array&amp;)<ins> const</ins>;</code>
+
+ </pre></blockquote>
+@@ -29184,9 +29223,9 @@ Kona (2007) Added const qualification to the return types and set to Ready.
+
+ <hr>
+ <h3><a name="622"></a>622. behavior of <code>filebuf</code> dtor and <code>close</code> on error</h3>
+-<p><b>Section:</b> 27.9.1.17 [fstream.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.17 [fstream.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29211,7 +29250,7 @@ dtor? Should the dtor catch and swallow it or should it propagate it
+ to the caller? The text doesn't seem to provide any guidance in this
+ regard other than the general restriction on throwing (but not
+ propagating) exceptions from destructors of library classes in
+-17.6.4.12 [res.on.exception.handling].
++17.6.5.12 [res.on.exception.handling].
+
+ </p>
+ <p>
+@@ -29259,7 +29298,7 @@ errors.
+ </p>
+
+ <p><i>[
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#418">418</a> for related issues.
++See <a href="lwg-closed.html#397">397</a> and <a href="lwg-closed.html#418">418</a> for related issues.
+ ]</i></p>
+
+
+@@ -29284,6 +29323,7 @@ Specifically, we propose to make the following edits in
+ </p>
+ <blockquote>
+ <pre>
++
+ <code>basic_filebuf&lt;charT,traits&gt;* close();</code>
+
+ </pre>
+@@ -29316,6 +29356,7 @@ And to make the following edits in 27.9.1.2 [filebuf.cons].
+ </p>
+ <blockquote>
+ <pre>
++
+ <code>virtual ~basic_filebuf();</code>
+
+ </pre>
+@@ -29326,7 +29367,7 @@ And to make the following edits in 27.9.1.2 [filebuf.cons].
+ <code>close()</code>. <ins>If an exception occurs during the
+ destruction of the object, including the call to <code>close()</code>,
+ the exception is caught but not rethrown (see
+-17.6.4.12 [res.on.exception.handling]).</ins>
++17.6.5.12 [res.on.exception.handling]).</ins>
+
+ </p>
+ </blockquote>
+@@ -29337,9 +29378,9 @@ the exception is caught but not rethrown (see
+
+ <hr>
+ <h3><a name="623"></a>623. <code>pubimbue</code> forbidden to call <code>imbue</code></h3>
+-<p><b>Section:</b> 27.2.1 [iostream.limits.imbue] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.2.1 [iostream.limits.imbue] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29381,9 +29422,10 @@ causes any instance of <code>basic_ios::imbue</code> or
+
+ <hr>
+ <h3><a name="624"></a>624. <code>valarray</code> assignment and arrays of unequal length</h3>
+-<p><b>Section:</b> 26.6.2.2 [valarray.assign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.6.2.3 [valarray.assign] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.assign">issues</a> in [valarray.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29396,7 +29438,7 @@ undefined behavior.
+ <p>
+
+ However, the generalized subscripting assignment operators overloaded
+-on <code>slice_array</code> et al (26.6.2.2 [valarray.assign]) don't have any
++on <code>slice_array</code> et al (26.6.2.3 [valarray.assign]) don't have any
+ such restriction, leading the reader to believe that the behavior of
+ these overloads is well defined regardless of the lengths of the
+ arguments.
+@@ -29408,7 +29450,8 @@ For example, based on the reading of the spec the behavior of the
+ snippet below can be expected to be well-defined:
+
+ </p>
+- <pre> const std::slice from_0_to_3 (0, 3, 1); // refers to elements 0, 1, 2
++ <pre>
++ const std::slice from_0_to_3 (0, 3, 1); // refers to elements 0, 1, 2
+ const std::valarray&lt;int&gt; a (1, 3); // a = { 1, 1, 1 }
+ std::valarray&lt;int&gt; b (2, 4); // b = { 2, 2, 2, 2 }
+
+@@ -29454,7 +29497,7 @@ the thread starting at c++std-lib-17786.
+ In order to reflect such views, the standard must specify that the
+ size of the array referred to by the argument of the assignment must
+ match the size of the array under assignment, for example by adding a
+-<i>Requires</i> clause to 26.6.2.2 [valarray.assign] as follows:
++<i>Requires</i> clause to 26.6.2.3 [valarray.assign] as follows:
+
+ </p>
+ <blockquote><p>
+@@ -29474,11 +29517,12 @@ to implement <code>valarray</code> efficiently.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Insert new paragraph into 26.6.2.2 [valarray.assign]:
++Insert new paragraph into 26.6.2.3 [valarray.assign]:
+ </p>
+
+ <blockquote>
+-<pre>valarray&lt;T&gt;&amp; operator=(const slice_array&lt;T&gt;&amp;);
++<pre>
++valarray&lt;T&gt;&amp; operator=(const slice_array&lt;T&gt;&amp;);
+ valarray&lt;T&gt;&amp; operator=(const gslice_array&lt;T&gt;&amp;);
+ valarray&lt;T&gt;&amp; operator=(const mask_array&lt;T&gt;&amp;);
+ valarray&lt;T&gt;&amp; operator=(const indirect_array&lt;T&gt;&amp;);
+@@ -29499,13 +29543,13 @@ These operators allow the results of a generalized subscripting operation to be
+
+
+ <hr>
+-<h3><a name="625"></a>625. mixed up <i>Effects</i> and <i>Returns</i> clauses</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#895">895</a></p>
++<h3><a name="625"></a>625. Mixed up <i>Effects</i> and <i>Returns</i> clauses</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#895">895</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29548,7 +29592,7 @@ with regards to the observable effects.
+ <p>
+ Here's an example of this problem that was precipitated by the change
+ from informative Notes to normative <i>Remark</i>s (presumably made to
+-address <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#424">424</a>):
++address <a href="lwg-closed.html#424">424</a>):
+ </p>
+
+ <p>
+@@ -29576,25 +29620,25 @@ introduction of <i>Remark</i>s:
+
+ <p>
+ <code> insert(size_type pos, string, size_type, size_type)</code> is
+-required to throw <code>out_of_range</code> if <code>pos &gt;
++required to throw <code>out_of_range</code> if <code>pos >
+ size()</code>.
+ </p>
+
+ <p>
+ <code>insert(size_type pos, string str)</code> is specified to return
+ <code>insert(pos, str, 0, npos)</code> by a <i>Returns</i> clause and
+-so its effects when <code>pos &gt; size()</code> are strictly speaking
++so its effects when <code>pos > size()</code> are strictly speaking
+ unspecified.
+-</p><p>
+-
+ </p>
++
++<p>
+ I believe a careful review of the current <i>Effects</i> and
+ <i>Returns</i> clauses is needed in order to identify all such
+ problematic cases. In addition, a review of the Working Paper should
+ be done to make sure that the newly introduced normative <i>Remark</i>
+ clauses do not impose any undesirable normative requirements in place
+ of the original informative <i>Notes</i>.
+-<p></p>
++</p>
+
+ <p><i>[
+ Batavia: Alan and Pete to work.
+@@ -29617,7 +29661,7 @@ Reopened.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Tom proposes we say that, unless specified otherwise,
+ it is always the caller's responsibility to verify that supplied arguments
+ meet the called function's requirements.
+@@ -29626,34 +29670,34 @@ If further semantics are specified
+ then it is up to the implementer to check those conditions.
+ Alan feels strongly that our current use of Requires in this context
+ is confusing, especially now that <tt>requires</tt> is a new keyword.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open. Martin will work on proposed wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to NAD Editorial, solved by revision to N3021.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -29674,16 +29718,17 @@ Solved by revision to N3021.
+
+ <hr>
+ <h3><a name="628"></a>628. Inconsistent definition of basic_regex constructor</h3>
+-<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-01-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex">issues</a> in [re.regex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex">issues</a> in [re.regex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 28.8 [re.regex] lists a constructor
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator&gt;
++<blockquote><pre>
++template&lt;class InputIterator&gt;
+ basic_regex(InputIterator first, InputIterator last,
+ flag_type f = regex_constants::ECMAScript);
+ </pre></blockquote>
+@@ -29699,7 +29744,8 @@ pair of <tt>ForwardIterator</tt>.
+ Change 28.8.2 [re.regex.construct]:
+ </p>
+
+-<blockquote><pre>template &lt;class <del>ForwardIterator</del> <ins>InputIterator</ins>&gt;
++<blockquote><pre>
++template &lt;class <del>ForwardIterator</del> <ins>InputIterator</ins>&gt;
+ basic_regex(<del>ForwardIterator</del> <ins>InputIterator</ins> first, <del>ForwardIterator</del> <ins>InputIterator</ins> last,
+ flag_type f = regex_constants::ECMAScript);
+ </pre></blockquote>
+@@ -29710,11 +29756,11 @@ Change 28.8.2 [re.regex.construct]:
+
+
+ <hr>
+-<h3><a name="629"></a>629. complex<t> insertion and locale dependence</t></h3>
+-<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2007-01-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="629"></a>629. <tt>complex&lt;T&gt;</tt> insertion and locale dependence</h3>
++<p><b>Section:</b> 26.4.6 [complex.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2007-01-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.ops">issues</a> in [complex.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ is there an issue opened for (0,3) as complex number with
+@@ -29724,12 +29770,12 @@ real complex number.
+ </p>
+
+ <p>
+-Further notes/ideas from the lib-reflector, messages 17982-17984:
++Further notes&#47;ideas from the lib-reflector, messages 17982-17984:
+ </p>
+
+ <blockquote>
+ <p>
+-Add additional entries in num_punct to cover the complex separator (French would be ';').
++Add additional entries in <tt>num_punct</tt> to cover the complex separator (French would be ';').
+ </p>
+ <p>
+ Insert a space before the comma, which should eliminate the ambiguity.
+@@ -29765,9 +29811,9 @@ Pre-Sophia Antipolis, Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Changed "showbase" to "showpoint" and changed from Ready to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post-Sophia Antipolis:
+@@ -29792,23 +29838,23 @@ I'm changing from WP back to Ready to pick up the "showbase" to "showpoint" chan
+ Add a footnote to 26.4.6 [complex.ops] p16:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [In a locale in which comma is being used as a decimal point character,
+ inserting <tt>showpoint</tt> into the output stream forces all outputs to show
+ an explicit decimal point character; then all inserted complex sequences
+ will extract unambiguously.]
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="630"></a>630. arrays of valarray</h3>
+-<p><b>Section:</b> 26.6.2.1 [valarray.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="630"></a>630. arrays of <tt>valarray</tt></h3>
++<p><b>Section:</b> 26.6.2.2 [valarray.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-01-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -29845,10 +29891,13 @@ required or guaranteed to have well-defined semantics for every type
+ <p>
+
+ I believe this problem was introduced by the adoption of the
+-resolution outlined in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1996/N0857.asc">N0857</a>,
++resolution outlined in <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1996/N0857.asc">N0857</a>,
+ <i>Assignment of valarrays</i>, from 1996. The copy assignment
+-operator of the original numerical array classes proposed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0280.pdf">N0280</a>,
+-as well as the one proposed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0308.asc">N0308</a>
++operator of the original numerical array classes proposed in <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0280.pdf">N0280</a>,
++as well as the one proposed in <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0308.asc">N0308</a>
+ (both from 1993), had well-defined semantics for arrays of unequal
+ size (the latter explicitly only when <code>*this</code> was empty;
+ assignment of non empty arrays of unequal size was a runtime error).
+@@ -29882,9 +29931,9 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ If no proposed wording by June meeting, this issue should be closed NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -29906,7 +29955,7 @@ Can be brought back on demand.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+
+-Change 26.6.2.2 [valarray.assign], p1 as follows:
++Change 26.6.2.3 [valarray.assign], p1 as follows:
+
+ </p>
+ <blockquote>
+@@ -29944,7 +29993,7 @@ text:
+ </blockquote>
+ <p>
+
+-Also add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:
++Also add the following paragraph to 26.6.2.3 [valarray.assign], immediately after p4:
+
+ </p>
+ <blockquote>
+@@ -29981,15 +30030,15 @@ which you can assign to a <tt>valarray</tt> of size 0, but not to any other
+
+ <hr>
+ <h3><a name="634"></a>634. <tt>allocator.address()</tt> doesn't work for types overloading <tt>operator&amp;</tt></h3>
+-<p><b>Section:</b> 20.9.5.1 [allocator.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-02-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#350">350</a></p>
++<p><b>Section:</b> 20.7.9.1 [allocator.members] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.members">issues</a> in [allocator.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#350">350</a></p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-20.9.5.1 [allocator.members] says:
++20.7.9.1 [allocator.members] says:
+ </p>
+ <blockquote>
+ <pre>pointer address(reference <i>x</i>) const;</pre>
+@@ -30001,7 +30050,7 @@ which you can assign to a <tt>valarray</tt> of size 0, but not to any other
+ </blockquote>
+
+ <p>
+-20.9.5.1 [allocator.members] defines <tt>CopyConstructible</tt> which currently not
++20.7.9.1 [allocator.members] defines <tt>CopyConstructible</tt> which currently not
+ only defines the semantics of copy construction, but also restricts what an overloaded
+ <tt>operator&amp;</tt> may do. I believe proposals are in the works (such as concepts
+ and rvalue reference) to decouple these two requirements. Indeed it is not evident
+@@ -30020,11 +30069,11 @@ yields a copy of the original proxy reference again.
+ <p>
+ On the other hand, some code truly needs the address of an object, and not a proxy
+ (typically for determining the identity of an object compared to a reference object).
+-<a href="http://www.boost.org/">boost</a> has long recognized this dilemma and solved it with
++<a href="http://www.boost.org">boost</a> has long recognized this dilemma and solved it with
+ <a href="http://www.boost.org/libs/utility/utility.htm#addressof"><tt>boost::addressof</tt></a>.
+ It appears to me that this would be useful functionality for the default allocator. Adopting
+ this definition for <tt>allocator::address</tt> would free the standard of requiring
+-anything special from types which overload <tt>operator&amp;</tt>. Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#580">580</a>
++anything special from types which overload <tt>operator&amp;</tt>. Issue <a href="lwg-closed.html#580">580</a>
+ is expected to make use of <tt>allocator::address</tt> mandatory for containers.
+ </p>
+
+@@ -30032,7 +30081,7 @@ is expected to make use of <tt>allocator::address</tt> mandatory for containers.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.5.1 [allocator.members]:
++Change 20.7.9.1 [allocator.members]:
+ </p>
+
+ <blockquote>
+@@ -30074,16 +30123,18 @@ issue to Ready status to be voted into the WP at Kona.
+
+ <hr>
+ <h3><a name="635"></a>635. domain of <tt>allocator::address</tt></h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-02-08 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-02-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The table of allocator requirements in 20.2.5 [allocator.requirements] describes
++The table of allocator requirements in 17.6.3.5 [allocator.requirements] describes
+ <tt>allocator::address</tt> as:
+ </p>
+-<blockquote><pre>a.address(r)
++<blockquote><pre>
++a.address(r)
+ a.address(s)
+ </pre></blockquote>
+ <p>
+@@ -30125,29 +30176,29 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Pablo recommends NAD Editorial, solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2768.pdf">N2768</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-04-28 Pablo adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Tentatively-ready NAD Editorial as fixed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2768.pdf">N2768</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Fixed by N2768.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-28 Reopened by Alisdair. No longer solved by concepts.
+@@ -30159,16 +30210,16 @@ Fixed by N2768.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.2.5 [allocator.requirements]:
++Change 17.6.3.5 [allocator.requirements]:
+ </p>
+
+ <blockquote>
+@@ -30199,15 +30250,17 @@ no resolution to this issue was recorded. Moved to Open.
+
+
+ <hr>
+-<h3><a name="638"></a>638. deque end invalidation during erase</h3>
+-<p><b>Section:</b> 23.3.2.3 [deque.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Steve LoBasso <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="638"></a>638. <tt>deque</tt> end invalidation during erase</h3>
++<p><b>Section:</b> 23.3.3.4 [deque.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Steve LoBasso <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.modifiers">issues</a> in [deque.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The standard states at 23.3.2.3 [deque.modifiers]/4:
++The standard states at 23.3.3.4 [deque.modifiers]/4:
+ </p>
+-<blockquote><pre>deque erase(...)
++<blockquote><pre>
++deque erase(...)
+ </pre>
+ <p>
+ <i>Effects:</i> ... An erase at either end of the deque invalidates only
+@@ -30228,7 +30281,8 @@ Any time the last element is erased, iterators to end are invalidated.
+ <p>
+ This would handle situations like:
+ </p>
+-<blockquote><pre>erase(begin(), end())
++<blockquote><pre>
++erase(begin(), end())
+ erase(end() - 1)
+ pop_back()
+ resize(n, ...) where n &lt; size()
+@@ -30241,21 +30295,22 @@ Post Kona, Steve LoBasso notes:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ My only issue with the proposed resolution is that it might not be clear
+ that <tt>pop_front()</tt> [where <tt>size() == 1</tt>] can invalidate past-the-end
+ iterators.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 23.3.2.3 [deque.modifiers], p4:
++Change 23.3.3.4 [deque.modifiers], p4:
+ </p>
+
+ <blockquote>
+-<pre>iterator erase(const_iterator position);
++<pre>
++iterator erase(const_iterator position);
+ iterator erase(const_iterator first, const_iterator last);
+ </pre>
+
+@@ -30283,31 +30338,32 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Note that there is existing code that relies on iterators not being
+ invalidated, but there are also existing implementations that do
+ invalidate iterators. Thus, such code is not portable in any case. There
+-is a pop_front() note, which should possibly be a separate issue. Mike
++is a <tt>pop_front()</tt> note, which should possibly be a separate issue. Mike
+ Spertus to evaluate and, if need be, file an issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+ <hr>
+-<h3><a name="640"></a>640. 27.6.2.5.2 does not handle (unsigned) long long</h3>
+-<p><b>Section:</b> 27.7.2.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="640"></a>640. 27.6.2.5.2 does not handle <tt>(unsigned) long long</tt></h3>
++<p><b>Section:</b> 27.7.3.6.2 [ostream.inserters.arithmetic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ostream.inserters.arithmetic">issues</a> in [ostream.inserters.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The arithmetic inserters are described in 27.7.2.6.2 [ostream.inserters.arithmetic].
++The arithmetic inserters are described in 27.7.3.6.2 [ostream.inserters.arithmetic].
+ Although the section starts with a listing of the inserters including
+ the new ones:
+ </p>
+
+-<blockquote><pre>operator&lt;&lt;(long long val );
++<blockquote><pre>
++operator&lt;&lt;(long long val );
+ operator&lt;&lt;(unsigned long long val );
+ </pre></blockquote>
+
+@@ -30329,15 +30385,15 @@ back.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 27.7.2.6.2 [ostream.inserters.arithmetic]/1 change the third sentence
++In 27.7.3.6.2 [ostream.inserters.arithmetic]/1 change the third sentence
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ When val is of type <tt>bool</tt>, <tt>long</tt>, <tt>unsigned
+ long</tt>, <ins>long long, unsigned long long,</ins> <tt>double</tt>,
+ <tt>long double</tt>, or <tt>const void*</tt>, the formatting conversion
+ occurs as if it performed the following code fragment:
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -30345,9 +30401,9 @@ occurs as if it performed the following code fragment:
+
+ <hr>
+ <h3><a name="643"></a>643. Impossible "as if" clauses</h3>
+-<p><b>Section:</b> 27.9.1.1 [filebuf], 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.9.1.1 [filebuf], 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current standard 14882:2003(E) as well as N2134 have the
+@@ -30364,7 +30420,8 @@ defects:
+ In order to support file I/O and multibyte/wide character conversion, conversions are performed using members of a
+ facet, referred to as <tt><i>a_codecvt</i></tt> in following sections, obtained "as if" by
+ </p>
+-<blockquote><pre>codecvt&lt;charT,char,typename traits::state_type&gt; <i>a_codecvt</i> =
++<blockquote><pre>
++codecvt&lt;charT,char,typename traits::state_type&gt; <i>a_codecvt</i> =
+ use_facet&lt;codecvt&lt;charT,char,typename traits::state_type&gt; &gt;(getloc());
+ </pre></blockquote>
+ </blockquote>
+@@ -30384,7 +30441,8 @@ A similar issue arises in 22.4.2.2.2 [facet.num.put.virtuals]/15 for <tt>num_pun
+ In 27.9.1.1 [filebuf]/5 change the "as if" code
+ </p>
+
+-<blockquote><pre><ins>const </ins>codecvt&lt;charT,char,typename traits::state_type&gt;<ins>&amp;</ins> <i>a_codecvt</i> =
++<blockquote><pre>
++<ins>const </ins>codecvt&lt;charT,char,typename traits::state_type&gt;<ins>&amp;</ins> <i>a_codecvt</i> =
+ use_facet&lt;codecvt&lt;charT,char,typename traits::state_type&gt; &gt;(getloc());
+ </pre></blockquote>
+
+@@ -30396,7 +30454,8 @@ In 22.4.2.2.2 [facet.num.put.virtuals]/15 (This is para 5 in N2134) change
+ <p>
+ A local variable <tt><i>punct</i></tt> is initialized via
+ </p>
+-<blockquote><pre><ins>const </ins>numpunct&lt;charT&gt;<ins>&amp;</ins> <i>punct</i> = use_facet&lt; numpunct&lt;charT&gt; &gt;(<i>str</i>.getloc() )<ins>;</ins>
++<blockquote><pre>
++<ins>const </ins>numpunct&lt;charT&gt;<ins>&amp;</ins> <i>punct</i> = use_facet&lt; numpunct&lt;charT&gt; &gt;(<i>str</i>.getloc() )<ins>;</ins>
+ </pre></blockquote>
+ </blockquote>
+
+@@ -30411,9 +30470,9 @@ A local variable <tt><i>punct</i></tt> is initialized via
+
+ <hr>
+ <h3><a name="646"></a>646. const incorrect match_result members</h3>
+-<p><b>Section:</b> 28.10.5 [re.results.form] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.10.5 [re.results.form] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 28.10.5 [re.results.form] (root and para 3) in N2134 defines the two function template
+@@ -30434,10 +30493,10 @@ in section 28.10.5 [re.results.form].
+
+ <hr>
+ <h3><a name="650"></a>650. regex_token_iterator and const correctness</h3>
+-<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Both the class definition of regex_token_iterator (28.12.2 [re.tokiter]/6) and the latter member specifications (28.12.2.2 [re.tokiter.comp]/1+2) declare both comparison operators as
+@@ -30452,7 +30511,8 @@ as well as in (28.12.2.3 [re.tokiter.deref]/1+2).
+ 1) In (28.12.2 [re.tokiter]/6) change the current declarations
+ </p>
+
+-<blockquote><pre>bool operator==(const regex_token_iterator&amp;) <ins>const</ins>;
++<blockquote><pre>
++bool operator==(const regex_token_iterator&amp;) <ins>const</ins>;
+ bool operator!=(const regex_token_iterator&amp;) <ins>const</ins>;
+ const value_type&amp; operator*() <ins>const</ins>;
+ const value_type* operator-&gt;() <ins>const</ins>;
+@@ -30462,7 +30522,8 @@ const value_type* operator-&gt;() <ins>const</ins>;
+ 2) In 28.12.2.2 [re.tokiter.comp] change the following declarations
+ </p>
+
+-<blockquote><pre>bool operator==(const regex_token_iterator&amp; right) <ins>const</ins>;
++<blockquote><pre>
++bool operator==(const regex_token_iterator&amp; right) <ins>const</ins>;
+ bool operator!=(const regex_token_iterator&amp; right) <ins>const</ins>;
+ </pre></blockquote>
+
+@@ -30470,7 +30531,8 @@ bool operator!=(const regex_token_iterator&amp; right) <ins>const</ins>;
+ 3) In 28.12.2.3 [re.tokiter.deref] change the following declarations
+ </p>
+
+-<blockquote><pre>const value_type&amp; operator*() <ins>const</ins>;
++<blockquote><pre>
++const value_type&amp; operator*() <ins>const</ins>;
+ const value_type* operator-&gt;() <ins>const</ins>;
+ </pre></blockquote>
+
+@@ -30487,10 +30549,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="651"></a>651. Missing preconditions for regex_token_iterator c'tors</h3>
+-<p><b>Section:</b> 28.12.2.1 [re.tokiter.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.tokiter.cnstr">issues</a> in [re.tokiter.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.12.2.1 [re.tokiter.cnstr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.tokiter.cnstr">issues</a> in [re.tokiter.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The text provided in 28.12.2.1 [re.tokiter.cnstr]/2+3 describes
+@@ -30536,9 +30598,9 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="652"></a>652. regex_iterator and const correctness</h3>
+-<p><b>Section:</b> 28.12.1 [re.regiter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.12.1 [re.regiter] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Both the class definition of regex_iterator (28.12.1 [re.regiter]/1) and the latter member specification (28.12.1.2 [re.regiter.comp]/1+2) declare both comparison operators as
+@@ -30553,7 +30615,8 @@ as well as in (28.12.1.3 [re.regiter.deref]/1+2).
+ 1) In (28.12.1 [re.regiter]/1) change the current declarations
+ </p>
+
+-<blockquote><pre>bool operator==(const regex_iterator&amp;) <ins>const</ins>;
++<blockquote><pre>
++bool operator==(const regex_iterator&amp;) <ins>const</ins>;
+ bool operator!=(const regex_iterator&amp;) <ins>const</ins>;
+ const value_type&amp; operator*() <ins>const</ins>;
+ const value_type* operator-&gt;() <ins>const</ins>;
+@@ -30563,7 +30626,8 @@ const value_type* operator-&gt;() <ins>const</ins>;
+ 2) In 28.12.1.3 [re.regiter.deref] change the following declarations
+ </p>
+
+-<blockquote><pre>const value_type&amp; operator*() <ins>const</ins>;
++<blockquote><pre>
++const value_type&amp; operator*() <ins>const</ins>;
+ const value_type* operator-&gt;() <ins>const</ins>;
+ </pre></blockquote>
+
+@@ -30571,7 +30635,8 @@ const value_type* operator-&gt;() <ins>const</ins>;
+ 3) In 28.12.1.2 [re.regiter.comp] change the following declarations
+ </p>
+
+-<blockquote><pre>bool operator==(const regex_iterator&amp; right) <ins>const</ins>;
++<blockquote><pre>
++bool operator==(const regex_iterator&amp; right) <ins>const</ins>;
+ bool operator!=(const regex_iterator&amp; right) <ins>const</ins>;
+ </pre></blockquote>
+
+@@ -30588,10 +30653,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="654"></a>654. Missing IO roundtrip for random number engines</h3>
+-<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 98 and para 5 in 26.5.1.4 [rand.req.eng] specify
+@@ -30623,7 +30688,8 @@ Proof: The following small program demonstrates the violation
+ of requirements (exception safety not fulfilled):
+ </p>
+
+-<blockquote><pre>#include &lt;cassert&gt;
++<blockquote><pre>
++#include &lt;cassert&gt;
+ #include &lt;ostream&gt;
+ #include &lt;iostream&gt;
+ #include &lt;iomanip&gt;
+@@ -30718,16 +30784,17 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="655"></a>655. Signature of generate_canonical not useful</h3>
+-<p><b>Section:</b> 26.5.7.2 [rand.util.canonical] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.canonical">issues</a> in [rand.util.canonical].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.2 [rand.util.canonical] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.canonical">issues</a> in [rand.util.canonical].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 26.5.2 [rand.synopsis] we have the declaration
+ </p>
+
+-<blockquote><pre>template&lt;class RealType, class UniformRandomNumberGenerator,
++<blockquote><pre>
++template&lt;class RealType, class UniformRandomNumberGenerator,
+ size_t bits&gt;
+ result_type generate_canonical(UniformRandomNumberGenerator&amp; g);
+ </pre></blockquote>
+@@ -30767,18 +30834,19 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="658"></a>658. Two unspecified function comparators in [function.objects]</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-03-19 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The header <tt>&lt;functional&gt;</tt> synopsis in 20.8 [function.objects]
++The header <tt>&lt;functional&gt;</tt> synopsis in 20.9 [function.objects]
+ contains the following two free comparison operator templates
+ for the <tt>function</tt> class template
+ </p>
+
+-<blockquote><pre>template&lt;class Function1, class Function2&gt;
++<blockquote><pre>
++template&lt;class Function1, class Function2&gt;
+ void operator==(const function&lt;Function1&gt;&amp;, const function&lt;Function2&gt;&amp;);
+ template&lt;class Function1, class Function2&gt;
+ void operator!=(const function&lt;Function1&gt;&amp;, const function&lt;Function2&gt;&amp;);
+@@ -30787,7 +30855,7 @@ void operator!=(const function&lt;Function1&gt;&amp;, const function&lt;Function
+ <p>
+ which are nowhere described. I assume that they are relicts before the
+ corresponding two private and undefined member templates in the function
+-template (see 20.8.14.2 [func.wrap.func] and [func.wrap.func.undef]) have been introduced. The original free
++template (see 20.9.12.2 [func.wrap.func] and [func.wrap.func.undef]) have been introduced. The original free
+ function templates should be removed, because using an undefined entity
+ would lead to an ODR violation of the user.
+ </p>
+@@ -30796,10 +30864,11 @@ would lead to an ODR violation of the user.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Remove the above mentioned two function templates from
+-the header <tt>&lt;functional&gt;</tt> synopsis (20.8 [function.objects])
++the header <tt>&lt;functional&gt;</tt> synopsis (20.9 [function.objects])
+ </p>
+
+-<blockquote><pre><del>template&lt;class Function1, class Function2&gt;
++<blockquote><pre>
++<del>template&lt;class Function1, class Function2&gt;
+ void operator==(const function&lt;Function1&gt;&amp;, const function&lt;Function2&gt;&amp;);
+ template&lt;class Function1, class Function2&gt;
+ void operator!=(const function&lt;Function1&gt;&amp;, const function&lt;Function2&gt;&amp;);</del>
+@@ -30807,34 +30876,35 @@ void operator!=(const function&lt;Function1&gt;&amp;, const function&lt;Function
+
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Fixed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2292.html">N2292</a>
+ Standard Library Applications for Deleted Functions.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="659"></a>659. istreambuf_iterator should have an operator-&gt;()</h3>
+-<p><b>Section:</b> 24.6.3 [istreambuf.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2007-03-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istreambuf.iterator">issues</a> in [istreambuf.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="659"></a>659. <tt>istreambuf_iterator</tt> should have an <tt>operator-&gt;()</tt></h3>
++<p><b>Section:</b> 24.6.3 [istreambuf.iterator] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2007-03-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istreambuf.iterator">issues</a> in [istreambuf.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Greg Herlihy has clearly demonstrated that a user defined input
+-iterator should have an operator-&gt;(), even if its
++iterator should have an <tt>operator-&gt;()</tt>, even if its
+ value type is a built-in type (comp.std.c++, "Re: Should any iterator
+-have an operator-&gt;() in C++0x?", March 2007). And as Howard
++have an <tt>operator-&gt;()</tt> in C++0x?", March 2007). And as Howard
+ Hinnant remarked in the same thread that the input iterator
+ <tt>istreambuf_iterator</tt> doesn't have one, this must be a
+ defect!
+ </p>
+ <p>
+ Based on Greg's example, the following code demonstrates the issue:
+-</p><pre> #include &lt;iostream&gt;
++</p><pre>
++ #include &lt;iostream&gt;
+ #include &lt;fstream&gt;
+ #include &lt;streambuf&gt;
+
+@@ -30848,15 +30918,14 @@ Based on Greg's example, the following code demonstrates the issue:
+ i-&gt;~C(); // ... so this should be supported!
+ }
+ </pre>
+-<p></p>
+ <p>
+-Of course, operator-&gt; is also needed when the value_type of
+-istreambuf_iterator is a class.
++Of course, <tt>operator-&gt;</tt> is also needed when the <tt>value_type</tt> of
++<tt>istreambuf_iterator</tt> is a class.
+ </p>
+ <p>
+-The operator-&gt; could be implemented in various ways. For instance,
++The <tt>operator-&gt;</tt> could be implemented in various ways. For instance,
+ by storing the current value inside the iterator, and returning its
+-address. Or by returning a proxy, like operator_arrow_proxy, from
++address. Or by returning a proxy, like <tt>operator_arrow_proxy</tt>, from
+ <a href="http://www.boost.org/boost/iterator/iterator_facade.hpp">http://www.boost.org/boost/iterator/iterator_facade.hpp</a>
+ </p>
+ <p>
+@@ -30883,7 +30952,7 @@ have <tt>istreambuf_iterator::pointer</tt> as return type, and this return type
+ may in fact be a proxy.
+ </p>
+ <p>
+-AFAIK, the resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#445">445</a> ("<tt>iterator_traits::reference</tt>
++AFAIK, the resolution of <a href="lwg-defects.html#445">445</a> ("<tt>iterator_traits::reference</tt>
+ unspecified for some iterator categories") implies that for any iterator
+ class <tt>Iter</tt>, the return type of <tt>operator-&gt;()</tt> is <tt>Iter::pointer</tt>, by
+ definition. I don't think <tt>Iter::pointer</tt> needs to be a raw pointer.
+@@ -30903,11 +30972,11 @@ is just: <tt>istreambuf_iterator</tt> should have an <tt>operator-&gt;()</tt>!
+ ]</i></p>
+
+
+-<blockquote>
+-Note that operator-&gt; is now a requirement in the <tt>InputIterator</tt> concept, so
++<blockquote><p>
++Note that <tt>operator-&gt;</tt> is now a requirement in the <tt>InputIterator</tt> concept, so
+ this issue cannot be ignored or existing valid programs will break when
+ compiled with an 0x library.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-29 Alisdair adds:
+@@ -30946,7 +31015,8 @@ In addition to the current proposal:
+ <p>
+ 24.6.3 [istreambuf.iterator]
+ </p>
+-<blockquote><pre>template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
++<blockquote><pre>
++template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
+ class istreambuf_iterator
+ : public iterator&lt;input_iterator_tag, charT,
+ typename traits::off_type, <del>charT*</del> <ins><i>unspecified</i></ins>, charT&gt; {
+@@ -30977,7 +31047,8 @@ Move to Ready.
+ Add to the synopsis in 24.6.3 [istreambuf.iterator]:
+ </p>
+
+-<blockquote><pre>charT operator*() const;
++<blockquote><pre>
++charT operator*() const;
+ <ins>pointer operator-&gt;() const;</ins>
+ istreambuf_iterator&lt;charT,traits&gt;&amp; operator++();
+ </pre></blockquote>
+@@ -30986,7 +31057,8 @@ istreambuf_iterator&lt;charT,traits&gt;&amp; operator++();
+ 24.6.3 [istreambuf.iterator]
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
++<blockquote><pre>
++template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
+ class istreambuf_iterator
+ : public iterator&lt;input_iterator_tag, charT,
+ typename traits::off_type, <del>charT*</del> <ins><i>unspecified</i></ins>, charT&gt; {
+@@ -31000,7 +31072,7 @@ Change 24.6.3 [istreambuf.iterator], p1:
+ The class template <tt>istreambuf_iterator</tt> reads successive
+ characters from the <tt>streambuf</tt> for which it was constructed.
+ <tt>operator*</tt> provides access to the current input character, if
+-any. <ins>[<i>Note:</i> <tt>operator-&gt;</tt> may return a proxy. —
++any. <ins>[<i>Note:</i> <tt>operator-&gt;</tt> may return a proxy. &mdash;
+ <i>end note</i>]</ins> Each time
+ <tt>operator++</tt> is evaluated, the iterator advances to the next
+ input character. If the end of stream is reached
+@@ -31019,31 +31091,29 @@ object suitable for use as an end-of-range.
+
+ <hr>
+ <h3><a name="660"></a>660. Missing Bitwise Operations</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-04-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-04-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>Section 20.8 [function.objects] provides <span id="st" name="st" class="st">function</span>
+-<span id="st" name="st" class="st">objects</span> for some unary and binary
++<p>Section 20.9 [function.objects] provides <em>function objects</em> for some unary and binary
+ operations, but others are missing. In a LWG reflector discussion, beginning
+ with c++std-lib-18078, pros and cons of adding some of the missing operations
+-were discussed. Bjarne Stroustrup commented "Why standardize what isn't used?
++were discussed. Bjarne Stroustrup commented &quot;Why standardize what isn't used?
+ Yes, I see the chicken and egg problems here, but it would be nice to see a
+-couple of genuine uses before making additions."</p>
++couple of genuine uses before making additions.&quot;</p>
+ <p>A number of libraries, including Rogue Wave, GNU, Adobe ASL, and Boost, have
+ already added these functions, either publicly or for internal use. For example,
+-Doug Gregor commented: "Boost will also add ... (|, &amp;, ^) in 1.35.0, because we
+-need those <span id="st" name="st" class="st">function</span>
+-<span id="st" name="st" class="st">objects</span> to represent various parallel
++Doug Gregor commented: &quot;Boost will also add ... (|, &amp;, ^) in 1.35.0, because we
++need those <em>function objects</em> to represent various parallel
+ collective operations (reductions, prefix reductions, etc.) in the new Message
+-Passing Interface (MPI) library."</p>
++Passing Interface (MPI) library.&quot;</p>
+ <p>Because the bitwise operators have the strongest use cases, the proposed
+ resolution is limited to them.</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>To 20.8 [function.objects], Function objects, paragraph 2, add to the header
++<p>To 20.9 [function.objects], Function objects, paragraph 2, add to the header
+ &lt;functional&gt; synopsis:</p>
+ <blockquote>
+ <pre>template &lt;class T&gt; struct bit_and;
+@@ -31080,13 +31150,13 @@ template &lt;class T&gt; struct bit_xor;</pre>
+
+ <hr>
+ <h3><a name="661"></a>661. New 27.6.1.2.2 changes make special extractions useless</h3>
+-<p><b>Section:</b> 27.7.1.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-04-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-04-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-To the more drastic changes of 27.7.1.2.2 [istream.formatted.arithmetic] in the current draft N2134 belong
++To the more drastic changes of 27.7.2.2.2 [istream.formatted.arithmetic] in the current draft N2134 belong
+ the explicit description of the extraction of the types short and int in
+ terms of as-if code fragments.
+ </p>
+@@ -31102,7 +31172,7 @@ beginning of the if-statement to be valid C++.
+ <li>
+ I would like to ask whether the omission of a similar explicit
+ extraction of unsigned short and unsigned int in terms of long -
+-compared to their corresponding new insertions, as described in 27.7.2.6.2 [ostream.inserters.arithmetic], is a deliberate decision or an
++compared to their corresponding new insertions, as described in 27.7.3.6.2 [ostream.inserters.arithmetic], is a deliberate decision or an
+ oversight.
+ </li>
+ </ol>
+@@ -31112,9 +31182,10 @@ oversight.
+ <ol>
+ <li>
+ <p>
+-In 27.7.1.2.2 [istream.formatted.arithmetic]/2 change the current as-if code fragment
++In 27.7.2.2.2 [istream.formatted.arithmetic]/2 change the current as-if code fragment
+ </p>
+-<blockquote><pre>typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
++<blockquote><pre>
++typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
+ iostate err = 0;
+ long lval;
+ use_facet&lt;numget&gt;(loc).get(*this, 0, *this, err, lval );
+@@ -31128,10 +31199,11 @@ setstate(err);
+ </pre></blockquote>
+
+ <p>
+-Similarily in 27.7.1.2.2 [istream.formatted.arithmetic]/3 change the current as-if fragment
++Similarily in 27.7.2.2.2 [istream.formatted.arithmetic]/3 change the current as-if fragment
+ </p>
+
+-<blockquote><pre>typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
++<blockquote><pre>
++typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
+ iostate err = 0;
+ long lval;
+ use_facet&lt;numget&gt;(loc).get(*this, 0, *this, err, lval );
+@@ -31165,10 +31237,10 @@ is deliberate.
+
+ <hr>
+ <h3><a name="664"></a>664. <tt>do_unshift</tt> for <tt>codecvt&lt;char, char, mbstate_t&gt;</tt></h3>
+-<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.1.4.2 [locale.codecvt.virtuals], para 7 says (regarding <tt>do_unshift</tt>):
+@@ -31220,10 +31292,10 @@ mbstate_t&gt;</tt> stores no characters.</del>
+
+ <hr>
+ <h3><a name="665"></a>665. <tt>do_unshift</tt> return value</h3>
+-<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.4.2 [locale.codecvt.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.codecvt.virtuals">issues</a> in [locale.codecvt.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.1.4.2 [locale.codecvt.virtuals], para 8 says:
+@@ -31269,10 +31341,10 @@ Change 22.4.1.4.2 [locale.codecvt.virtuals], p8:
+
+ <hr>
+ <h3><a name="666"></a>666. <tt>moneypunct::do_curr_symbol()</tt></h3>
+-<p><b>Section:</b> 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.moneypunct.virtuals">issues</a> in [locale.moneypunct.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.6.3.2 [locale.moneypunct.virtuals] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2007-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.moneypunct.virtuals">issues</a> in [locale.moneypunct.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 22.4.6.3.2 [locale.moneypunct.virtuals], para 4 footnote 257 says
+@@ -31317,11 +31389,11 @@ four characters long, usually three letters and a space.
+
+
+ <hr>
+-<h3><a name="671"></a>671. precision of hexfloat</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> John Salmon <b>Opened:</b> 2007-04-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="671"></a>671. precision of <tt>hexfloat</tt></h3>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> John Salmon <b>Opened:</b> 2007-04-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I am trying to understand how TR1 supports hex float (%a) output.
+@@ -31330,17 +31402,18 @@ I am trying to understand how TR1 supports hex float (%a) output.
+ As far as I can tell, it does so via the following:
+ </p>
+ <p>
+-8.15 Additions to header &lt;locale&gt; [tr.c99.locale]
++8.15 Additions to header <tt>&lt;locale&gt;</tt> [tr.c99.locale]
+ </p>
+ <p>
+ In subclause 22.4.2.2.2 [facet.num.put.virtuals], Table 58 Floating-point conversions, after
+-the line:
+-floatfield == ios_base::scientific %E
++the line:<br/>
++<tt>floatfield == ios_base::scientific %E</tt>
+ </p>
+ <p>
+ add the two lines:
+ </p>
+-<blockquote><pre>floatfield == ios_base::fixed | ios_base::scientific &amp;&amp; !uppercase %a
++<blockquote><pre>
++floatfield == ios_base::fixed | ios_base::scientific &amp;&amp; !uppercase %a
+ floatfield == ios_base::fixed | ios_base::scientific %A 2
+ </pre></blockquote>
+ <p>
+@@ -31354,14 +31427,14 @@ conversion specifier. end note]
+ Following the thread, in 22.4.2.2.2 [facet.num.put.virtuals], we find:
+ </p>
+ <p>
+-For conversion from a floating-point type, if (flags &amp; fixed) != 0 or
+-if str.precision() &gt; 0, then str.precision() is specified in the
++For conversion from a floating-point type, if <tt>(flags &amp; fixed) != 0</tt> or
++if <tt>str.precision() &gt; 0</tt>, then <tt>str.precision()</tt> is specified in the
+ conversion specification.
+ </p>
+ <p>
+-This would seem to imply that when floatfield == fixed|scientific, the
++This would seem to imply that when <tt>floatfield == fixed|scientific</tt>, the
+ precision of the conversion specifier is to be taken from
+-str.precision(). Is this really what's intended? I sincerely hope
++<tt>str.precision()</tt>. Is this really what's intended? I sincerely hope
+ that I'm either missing something or this is an oversight. Please
+ tell me that the committee did not intend to mandate that hex floats
+ (and doubles) should by default be printed as if by %.6a.
+@@ -31408,9 +31481,9 @@ Daniel and Robert have direction to write up wording for the "always %a" solutio
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31420,12 +31493,12 @@ Change 22.4.2.2.2 [facet.num.put.virtuals], Stage 1, under p5 (near the end
+ of Stage 1):
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For conversion from a floating-point type, <tt>str.precision()</tt> is specified
+ <ins>as precision</ins> in the conversion specification
+ <ins>if <tt>floatfield != (ios_base::fixed | ios_base::scientific)</tt>, else no
+ precision is specified</ins>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -31439,10 +31512,10 @@ Kona (2007): Robert volunteers to propose wording.
+
+ <hr>
+ <h3><a name="672"></a>672. Swappable requirements need updating</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current <tt>Swappable</tt> is:
+@@ -31451,7 +31524,7 @@ The current <tt>Swappable</tt> is:
+ <blockquote>
+ <table border="1">
+ <caption>Table 37: <tt>Swappable</tt> requirements <b>[swappable]</b></caption>
+-<tbody><tr><th>expression</th><th>return type</th><th>post-condition</th></tr>
++<tr><th>expression</th><th>return type</th><th>post-condition</th></tr>
+ <tr><td><tt>swap(s,t)</tt></td><td><tt>void</tt></td><td><tt>t</tt> has the value originally held by <tt>u</tt>, and <tt>u</tt> has the value originally
+ held by <tt>t</tt></td></tr>
+ <tr><td colspan="3">
+@@ -31470,7 +31543,7 @@ and has the semantics described in this table.
+ </li>
+ </ul>
+ </td></tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -31482,7 +31555,8 @@ require only <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>. This is a
+ Additionally we may want to support proxy references such that the following code is acceptable:
+ </p>
+
+-<blockquote><pre>namespace Mine {
++<blockquote><pre>
++namespace Mine {
+
+ template &lt;class T&gt;
+ struct proxy {...};
+@@ -31529,7 +31603,7 @@ between two different types for the case that one is binding to a user-defined <
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 20.2.1 [utility.arg.requirements]:
++Change 17.6.3.1 [utility.arg.requirements]:
+ </p>
+
+ <blockquote>
+@@ -31547,7 +31621,7 @@ rvalue of type <tt>T</tt>.
+
+ <table border="1">
+ <caption>Table 37: <tt>Swappable</tt> requirements <b>[swappable]</b></caption>
+-<tbody><tr><th>expression</th><th>return type</th><th>post-condition</th></tr>
++<tr><th>expression</th><th>return type</th><th>post-condition</th></tr>
+ <tr><td><tt>swap(s,t)</tt></td><td><tt>void</tt></td>
+ <td><tt>t</tt> has the value originally
+ held by <tt>u</tt>, and
+@@ -31573,7 +31647,7 @@ semantics described in this table.
+ </li>
+ </ul>
+ </td></tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -31583,7 +31657,7 @@ Kona (2007): We like the change to the <tt>Swappable</tt> requirements to use
+ move semantics. The issue relating to the support of proxies is
+ separable from the one relating to move semantics, and it's bigger than
+ just swap. We'd like to address only the move semantics changes under
+-this issue, and open a separated issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#742">742</a>) to handle proxies. Also, there
++this issue, and open a separated issue (<a href="lwg-defects.html#742">742</a>) to handle proxies. Also, there
+ may be a third issue, in that the current definition of <tt>Swappable</tt> does
+ not permit rvalues to be operands to a swap operation, and Howard's
+ proposed resolution would allow the right-most operand to be an rvalue,
+@@ -31598,17 +31672,17 @@ swap to be rvalues).
+
+ <hr>
+ <h3><a name="673"></a>673. <tt>unique_ptr</tt> update</h3>
+-<p><b>Section:</b> 20.9.9 [unique.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr">issues</a> in [unique.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.1 [unique.ptr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr">issues</a> in [unique.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Since the publication of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1856.html">N1856</a>
+ there have been a few small but significant advances which should be included into
+ <tt>unique_ptr</tt>. There exists a
+-<a href="http://home.twcny.rr.com/hinnant/cpp_extensions/unique_ptr.html">example implmenation</a>
++<a href="http://home.roadrunner.com/~hinnant/unique_ptr.hpp">example implementation</a>
+ for all of these changes.
+ </p>
+
+@@ -31618,9 +31692,8 @@ for all of these changes.
+ <p>
+ Even though <tt>unique_ptr&lt;void&gt;</tt> is not a valid use case (unlike for <tt>shared_ptr&lt;void&gt;</tt>),
+ unexpected cases to crop up which require the instantiation of the interface of <tt>unique_ptr&lt;void&gt;</tt>
+-even if it is never used. For example see
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#541">LWG 541</a> for how this accidently
+-happened to <tt>auto_ptr</tt>. I believe the most robust way to protect <tt>unique_ptr</tt> against this
++even if it is never used. For example see <a href="lwg-defects.html#541">541</a> for how this accidently happened to <tt>auto_ptr</tt>.
++I believe the most robust way to protect <tt>unique_ptr</tt> against this
+ type of failure is to augment the return type of <tt>unique_ptr&lt;T&gt;:operator*()</tt> with
+ <tt>add_lvalue_reference&lt;T&gt;::type</tt>. This means that given an instantiated <tt>unique_ptr&lt;void&gt;</tt>
+ the act of dereferencing it will simply return <tt>void</tt> instead of causing a compile time failure.
+@@ -31644,7 +31717,7 @@ for <tt>unique_ptr</tt> by having the deleter define the pointer type:
+ <tt>D::pointer</tt>. Furthermore this type can easily be defaulted to
+ <tt>T*</tt> should the deleter <tt>D</tt> choose not to define a pointer
+ type (example implementation
+-<a href="http://home.twcny.rr.com/hinnant/cpp_extensions/unique_ptr.html">here</a>).
++<a href="http://home.roadrunner.com/~hinnant/unique_ptr.hpp">here</a>).
+ This change has no run time overhead. It has no interface overhead on
+ authors of custom delter types. It simply allows (but not requires)
+ authors of custom deleter types to define a smart pointer for the
+@@ -31663,7 +31736,8 @@ This case is easy to check for with a <tt>static_assert</tt> assuring that the
+ deleter is not a pointer type in those constructors which do not accept deleters.
+ </p>
+
+-<blockquote><pre>unique_ptr&lt;A, void(*)(void*)&gt; p(new A); // error, no function given to delete the pointer!
++<blockquote><pre>
++unique_ptr&lt;A, void(*)(void*)&gt; p(new A); // error, no function given to delete the pointer!
+ </pre></blockquote>
+
+ </li>
+@@ -31686,7 +31760,8 @@ Post Kona: Howard adds example user code related to the first bullet:
+
+
+ <blockquote>
+-<pre>void legacy_code(void*, std::size_t);
++<pre>
++void legacy_code(void*, std::size_t);
+
+ void foo(std::size_t N)
+ {
+@@ -31702,7 +31777,8 @@ to disable with concepts. The only part of <tt>unique_ptr&lt;void&gt;</tt> we
+ want to disable (with concepts or by other means) are the two member functions:
+ </p>
+
+-<blockquote><pre>T&amp; operator*() const;
++<blockquote><pre>
++T&amp; operator*() const;
+ T* operator-&gt;() const;
+ </pre></blockquote>
+
+@@ -31711,7 +31787,7 @@ T* operator-&gt;() const;
+ <p><b>Proposed resolution:</b></p>
+
+ <p><i>[
+-I am grateful for the generous aid of Peter Dimov and Ion Gaztañaga in helping formulate and review
++I am grateful for the generous aid of Peter Dimov and Ion Gazta&ntilde;aga in helping formulate and review
+ the proposed resolutions below.
+ ]</i></p>
+
+@@ -31720,10 +31796,11 @@ the proposed resolutions below.
+ <li>
+
+ <p>
+-Change 20.9.9.2 [unique.ptr.single]:
++Change 20.8.1.2 [unique.ptr.single]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
++<blockquote><pre>
++template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
+ ...
+ <del>T&amp;</del> <ins>typename add_lvalue_reference&lt;T&gt;::type</ins> operator*() const;
+ ...
+@@ -31731,20 +31808,22 @@ Change 20.9.9.2 [unique.ptr.single]:
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.9.2.4 [unique.ptr.single.observers]:
++Change 20.8.1.2.4 [unique.ptr.single.observers]:
+ </p>
+
+-<blockquote><pre><del>T&amp;</del> <ins>typename add_lvalue_reference&lt;T&gt;::type</ins> operator*() const;
++<blockquote><pre>
++<del>T&amp;</del> <ins>typename add_lvalue_reference&lt;T&gt;::type</ins> operator*() const;
+ </pre></blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2 [unique.ptr.single]:
++Change 20.8.1.2 [unique.ptr.single]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
++<blockquote><pre>
++template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
+ public:
+ <ins>typedef <i>implementation (see description below)</i> pointer;</ins>
+ ...
+@@ -31773,10 +31852,11 @@ and <tt>CopyAssignable</tt>.
+ </p>
+
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]:
++Change 20.8.1.2.1 [unique.ptr.single.ctor]:
+ </p>
+
+-<blockquote><pre>unique_ptr(<del>T*</del> <ins>pointer</ins> p);
++<blockquote><pre>
++unique_ptr(<del>T*</del> <ins>pointer</ins> p);
+ ...
+ unique_ptr(<del>T*</del> <ins>pointer</ins> p, <i>implementation defined</i> d);
+ unique_ptr(<del>T*</del> <ins>pointer</ins> p, <i>implementation defined</i> d);
+@@ -31813,7 +31893,7 @@ internally stored deleter which was constructed from
+ </p>
+
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn]:
++Change 20.8.1.2.3 [unique.ptr.single.asgn]:
+ </p>
+
+ <blockquote>
+@@ -31826,30 +31906,31 @@ convertible to <del><tt>T*</tt></del> <ins>pointer</ins>.
+ </blockquote>
+
+ <p>
+-Change 20.9.9.2.4 [unique.ptr.single.observers]:
++Change 20.8.1.2.4 [unique.ptr.single.observers]:
+ </p>
+
+ <blockquote>
+-<pre><del>T*</del> <ins>pointer</ins> operator-&gt;() const;</pre>
+-...
++<pre><del>T*</del> <ins>pointer</ins> operator->() const;</pre>
++<p>...</p>
+ <pre><del>T*</del> <ins>pointer</ins> get() const;</pre>
+ </blockquote>
+
+ <p>
+-Change 20.9.9.2.5 [unique.ptr.single.modifiers]:
++Change 20.8.1.2.5 [unique.ptr.single.modifiers]:
+ </p>
+
+ <blockquote>
+ <pre><del>T*</del> <ins>pointer</ins> release();</pre>
+-...
++<p>...</p>
+ <pre>void reset(<del>T*</del> <ins>pointer</ins> p = <del>0</del> <ins>pointer()</ins>);</pre>
+ </blockquote>
+
+ <p>
+-Change 20.9.9.3 [unique.ptr.runtime]:
++Change 20.8.1.3 [unique.ptr.runtime]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt; {
++<blockquote><pre>
++template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt; {
+ public:
+ <ins>typedef <i>implementation</i> pointer;</ins>
+ ...
+@@ -31866,11 +31947,12 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.9.3.1 [unique.ptr.runtime.ctor]:
++Change 20.8.1.3.1 [unique.ptr.runtime.ctor]:
+ </p>
+
+ <blockquote>
+-<pre>unique_ptr(<del>T*</del> <ins>pointer</ins> p);
++<pre>
++unique_ptr(<del>T*</del> <ins>pointer</ins> p);
+ unique_ptr(<del>T*</del> <ins>pointer</ins> p, <i>implementation defined</i> d);
+ unique_ptr(<del>T*</del> <ins>pointer</ins> p, <i>implementation defined</i> d);
+ </pre>
+@@ -31885,11 +31967,12 @@ these members. <i>-- end note</i>]
+ </blockquote>
+
+ <p>
+-Change 20.9.9.3.3 [unique.ptr.runtime.modifiers]:
++Change 20.8.1.3.4 [unique.ptr.runtime.modifiers]:
+ </p>
+
+ <blockquote>
+-<pre>void reset(<del>T*</del> <ins>pointer</ins> p = <del>0</del> <ins>pointer()</ins>);
++<pre>
++void reset(<del>T*</del> <ins>pointer</ins> p = <del>0</del> <ins>pointer()</ins>);
+ </pre>
+
+ <p>
+@@ -31905,7 +31988,7 @@ templated overload. <i>-- end note</i>]
+ <li>
+
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]:
++Change 20.8.1.2.1 [unique.ptr.single.ctor]:
+ </p>
+
+ <blockquote>
+@@ -31939,10 +32022,11 @@ required)</ins>.
+
+ <hr>
+ <h3><a name="674"></a>674. <tt>shared_ptr</tt> interface changes for consistency with N1856</h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1856.html">N1856</a> does not propose
+@@ -31954,7 +32038,7 @@ and to interoperate with <tt>unique_ptr</tt> as it does with <tt>auto_ptr</tt>.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 20.9.10.2 [util.smartptr.shared] as follows:
++Change 20.8.2.2 [util.smartptr.shared] as follows:
+ </p>
+
+ <blockquote>
+@@ -31968,7 +32052,7 @@ template&lt;class Y, class D&gt; shared_ptr&amp; operator=(unique_ptr&lt;Y,D&gt;
+ </blockquote>
+
+ <p>
+-Change 20.9.10.2.1 [util.smartptr.shared.const] as follows:
++Change 20.8.2.2.1 [util.smartptr.shared.const] as follows:
+ </p>
+
+ <blockquote>
+@@ -31976,7 +32060,7 @@ Change 20.9.10.2.1 [util.smartptr.shared.const] as follows:
+ </blockquote>
+
+ <p>
+-Add to 20.9.10.2.1 [util.smartptr.shared.const]:
++Add to 20.8.2.2.1 [util.smartptr.shared.const]:
+ </p>
+
+ <blockquote>
+@@ -31997,7 +32081,7 @@ Add to 20.9.10.2.1 [util.smartptr.shared.const]:
+ </blockquote>
+
+ <p>
+-Change 20.9.10.2.3 [util.smartptr.shared.assign] as follows:
++Change 20.8.2.2.3 [util.smartptr.shared.assign] as follows:
+ </p>
+
+ <blockquote>
+@@ -32005,7 +32089,7 @@ Change 20.9.10.2.3 [util.smartptr.shared.assign] as follows:
+ </blockquote>
+
+ <p>
+-Add to 20.9.10.2.3 [util.smartptr.shared.assign]:
++Add to 20.8.2.2.3 [util.smartptr.shared.assign]:
+ </p>
+
+ <blockquote>
+@@ -32025,7 +32109,7 @@ Add to 20.9.10.2.3 [util.smartptr.shared.assign]:
+
+
+ <p><i>[
+-Kona (2007): We may need to open an issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#743">743</a>) to deal with the question of
++Kona (2007): We may need to open an issue (<a href="lwg-defects.html#743">743</a>) to deal with the question of
+ whether <tt>shared_ptr</tt> needs an rvalue <tt>swap</tt>.
+ ]</i></p>
+
+@@ -32035,10 +32119,11 @@ whether <tt>shared_ptr</tt> needs an rvalue <tt>swap</tt>.
+
+ <hr>
+ <h3><a name="675"></a>675. Move assignment of containers</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ James Hopkin pointed out to me that if <tt>vector&lt;T&gt;</tt> move assignment is O(1)
+@@ -32047,7 +32132,8 @@ the wrong semantics under move assignment when the source is not truly an rvalue
+ moved-from lvalue (destructors could run late).
+ </p>
+
+-<blockquote><pre><tt>vector&lt;shared_ptr&lt;ostream&gt;&gt;</tt> v1;
++<blockquote><pre>
++<tt>vector&lt;shared_ptr&lt;ostream&gt;&gt;</tt> v1;
+ <tt>vector&lt;shared_ptr&lt;ostream&gt;&gt;</tt> v2;
+ ...
+ v1 = v2; // #1
+@@ -32086,7 +32172,7 @@ Change 23.2 [container.requirements]:
+ <blockquote>
+ <table border="1">
+ <caption>Table 89: Container requirements</caption>
+-<tbody><tr>
++<tr>
+ <th>expression</th><th>return type</th><th>operational semantics</th>
+ <th>assertion/note pre/post-condition</th><th>complexity</th>
+ </tr>
+@@ -32099,7 +32185,7 @@ before this construction
+ </td>
+ <td><del>(Note C)</del> <ins>linear</ins></td>
+ </tr>
+-</tbody></table>
++</table>
+
+ <p>
+ Notes: the algorithms <tt>swap()</tt>, <tt>equal()</tt> and
+@@ -32144,10 +32230,10 @@ post Sophia Antipolis Howard updated proposed wording:
+
+ <hr>
+ <h3><a name="676"></a>676. Moving the unordered containers</h3>
+-<p><b>Section:</b> 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord">issues</a> in [unord].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Move semantics are missing from the <tt>unordered</tt> containers. The proposed
+@@ -32179,9 +32265,9 @@ on getting the unordered containers "moved".
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review. Alisdair will review proposed wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-29 Daniel updates wording.
+@@ -32195,7 +32281,7 @@ Move to Review. Alisdair will review proposed wording.
+
+ <p><i>[
+ 2010-02-10 Howard updates wording to reference the unordered container
+-requirements table (modified by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>) as much as possible.
++requirements table (modified by <a href="lwg-defects.html#704">704</a>) as much as possible.
+ ]</i></p>
+
+
+@@ -32240,21 +32326,21 @@ that it requires. Please put it back into Open status.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The descriptions of the semantics of the added <tt>insert</tt> functions belong
+ in the requirements table. That's where the rest of the <tt>insert</tt>
+ functions are.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move issue 676 to Ready for Pittsburgh. Nico to send Howard an issue for
+ the broader problem.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -32264,10 +32350,10 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2776.pdf">N2776</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Rationale is obsolete.
+@@ -32282,10 +32368,11 @@ Rationale is obsolete.
+ <p><b><tt>unordered_map</tt></b></p>
+
+ <p>
+-Change 23.7.1 [unord.map]:
++Change 23.5.4 [unord.map]:
+ </p>
+
+-<blockquote><pre>class unordered_map
++<blockquote><pre>
++class unordered_map
+ {
+ ...
+ unordered_map(const unordered_map&amp;);
+@@ -32312,7 +32399,7 @@ Change 23.7.1 [unord.map]:
+ </pre></blockquote>
+
+ <p>
+-Add to 23.7.1.2 [unord.map.elem]:
++Add to 23.5.4.3 [unord.map.elem]:
+ </p>
+
+ <blockquote>
+@@ -32364,7 +32451,8 @@ Add new section [unord.map.modifiers]:
+ </p>
+
+ <blockquote>
+-<pre><ins>template &lt;class P&gt;
++<pre>
++<ins>template &lt;class P&gt;
+ pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);</ins>
+ </pre>
+
+@@ -32401,7 +32489,8 @@ resolution.
+ </blockquote>
+
+
+-<pre><ins>template &lt;class P&gt;
++<pre>
++<ins>template &lt;class P&gt;
+ iterator insert(const_iterator hint, P&amp;&amp; x);</ins>
+ </pre>
+
+@@ -32441,10 +32530,11 @@ resolution.
+ <p><b><tt>unordered_multimap</tt></b></p>
+
+ <p>
+-Change 23.7.2 [unord.multimap]:
++Change 23.5.5 [unord.multimap]:
+ </p>
+
+-<blockquote><pre>class unordered_multimap
++<blockquote><pre>
++class unordered_multimap
+ {
+ ...
+ unordered_multimap(const unordered_multimap&amp;);
+@@ -32472,7 +32562,8 @@ Add new section [unord.multimap.modifiers]:
+ </p>
+
+ <blockquote>
+-<pre><ins>template &lt;class P&gt;
++<pre>
++<ins>template &lt;class P&gt;
+ iterator insert(P&amp;&amp; x);</ins>
+ </pre>
+
+@@ -32504,7 +32595,8 @@ resolution.
+
+ </blockquote>
+
+-<pre><ins>template &lt;class P&gt;
++<pre>
++<ins>template &lt;class P&gt;
+ iterator insert(const_iterator hint, P&amp;&amp; x);</ins>
+ </pre>
+
+@@ -32544,10 +32636,11 @@ resolution.
+ <p><b><tt>unordered_set</tt></b></p>
+
+ <p>
+-Change 23.7.3 [unord.set]:
++Change 23.5.6 [unord.set]:
+ </p>
+
+-<blockquote><pre>class unordered_set
++<blockquote><pre>
++class unordered_set
+ {
+ ...
+ unordered_set(const unordered_set&amp;);
+@@ -32572,10 +32665,11 @@ Change 23.7.3 [unord.set]:
+ <p><b><tt>unordered_multiset</tt></b></p>
+
+ <p>
+-Change 23.7.4 [unord.multiset]:
++Change 23.5.7 [unord.multiset]:
+ </p>
+
+-<blockquote><pre>class unordered_multiset
++<blockquote><pre>
++class unordered_multiset
+ {
+ ...
+ unordered_multiset(const unordered_multiset&amp;);
+@@ -32605,10 +32699,10 @@ Change 23.7.4 [unord.multiset]:
+
+ <hr>
+ <h3><a name="677"></a>677. Weaknesses in seed_seq::randomize [rand.util.seedseq]</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Charles Karney <b>Opened:</b> 2007-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Charles Karney <b>Opened:</b> 2007-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>seed_seq::randomize</tt> provides a mechanism for initializing random number
+@@ -32709,10 +32803,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="678"></a>678. Changes for [rand.req.eng]</h3>
+-<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Charles Karney <b>Opened:</b> 2007-05-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.1.4 [rand.req.eng] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Charles Karney <b>Opened:</b> 2007-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.req.eng">issues</a> in [rand.req.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Section 26.5.1.4 [rand.req.eng] Random number engine requirements:
+@@ -32720,7 +32814,7 @@ Section 26.5.1.4 [rand.req.eng] Random number engine requirements:
+
+ <p>
+ This change follows naturally from the proposed change to
+-<tt>seed_seq::randomize</tt> in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#677">677</a>.
++<tt>seed_seq::randomize</tt> in <a href="lwg-defects.html#677">677</a>.
+ </p>
+
+ <p>
+@@ -32764,17 +32858,18 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="679"></a>679. resize parameter by value</h3>
+-<p><b>Section:</b> 23.3 [sequences] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-06-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequences">issues</a> in [sequences].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3 [sequences] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-06-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequences">issues</a> in [sequences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The C++98 standard specifies that one member function alone of the containers
+ passes its parameter (<tt>T</tt>) by value instead of by const reference:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, T c = T());
++<blockquote><pre>
++void resize(size_type sz, T c = T());
+ </pre></blockquote>
+
+ <p>
+@@ -32787,7 +32882,8 @@ value has been:
+ <p>
+ So that self referencing statements are guaranteed to work, for example:
+ </p>
+-<blockquote><pre>v.resize(v.size() + 1, v[0]);
++<blockquote><pre>
++v.resize(v.size() + 1, v[0]);
+ </pre></blockquote>
+ </blockquote>
+
+@@ -32795,7 +32891,8 @@ So that self referencing statements are guaranteed to work, for example:
+ However this rationale is not convincing as the signature for <tt>push_back</tt> is:
+ </p>
+
+-<blockquote><pre>void push_back(const T&amp; x);
++<blockquote><pre>
++void push_back(const T&amp; x);
+ </pre></blockquote>
+
+ <p>
+@@ -32803,7 +32900,8 @@ And <tt>push_back</tt> has similar semantics to <tt>resize</tt> (append).
+ And <tt>push_back</tt> must also work in the self referencing case:
+ </p>
+
+-<blockquote><pre>v.push_back(v[0]); // must work
++<blockquote><pre>
++v.push_back(v[0]); // must work
+ </pre></blockquote>
+
+ <p>
+@@ -32817,7 +32915,8 @@ Even with move semantics available, passing this parameter by value can be expen
+ Consider for example <tt>vector&lt;vector&lt;int&gt;&gt;</tt>:
+ </p>
+
+-<blockquote><pre>std::vector&lt;int&gt; x(1000);
++<blockquote><pre>
++std::vector&lt;int&gt; x(1000);
+ std::vector&lt;std::vector&lt;int&gt;&gt; v;
+ ...
+ v.resize(v.size()+1, x);
+@@ -32847,51 +32946,57 @@ CodeWarrior library with no reports of problems which I am aware of.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 23.3.2 [deque], p2:
++Change 23.3.3 [deque], p2:
+ </p>
+
+-<blockquote><pre>class deque {
++<blockquote><pre>
++class deque {
+ ...
+ void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+ <p>
+-Change 23.3.2.2 [deque.capacity], p3:
++Change 23.3.3.3 [deque.capacity], p3:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
++<blockquote><pre>
++void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+ <p>
+-Change 23.3.4 [list], p2:
++Change 23.3.5 [list], p2:
+ </p>
+
+-<blockquote><pre>class list {
++<blockquote><pre>
++class list {
+ ...
+ void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+ <p>
+-Change 23.3.4.2 [list.capacity], p3:
++Change 23.3.5.3 [list.capacity], p3:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
++<blockquote><pre>
++void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+ <p>
+-Change 23.4.1 [vector], p2:
++Change 23.3.6 [vector], p2:
+ </p>
+
+-<blockquote><pre>class vector {
++<blockquote><pre>
++class vector {
+ ...
+ void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+ <p>
+-Change 23.4.1.2 [vector.capacity], p11:
++Change 23.3.6.3 [vector.capacity], p11:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
++<blockquote><pre>
++void resize(size_type sz, <ins>const </ins>T<ins>&amp;</ins> c);
+ </pre></blockquote>
+
+
+@@ -32901,10 +33006,10 @@ Change 23.4.1.2 [vector.capacity], p11:
+
+ <hr>
+ <h3><a name="680"></a>680. move_iterator operator-&gt; return</h3>
+-<p><b>Section:</b> 24.5.3.1 [move.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-06-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#move.iterator">issues</a> in [move.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.3.1 [move.iterator] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-06-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#move.iterator">issues</a> in [move.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>move_iterator</tt>'s <tt>operator-&gt;</tt> return type <tt>pointer</tt>
+@@ -32912,7 +33017,8 @@ does not consistently match the type which is returned in the description
+ in 24.5.3.3.5 [move.iter.op.ref].
+ </p>
+
+-<blockquote><pre>template &lt;class Iterator&gt;
++<blockquote><pre>
++template &lt;class Iterator&gt;
+ class move_iterator {
+ public:
+ ...
+@@ -32956,7 +33062,8 @@ finds a non-class type, the second solution avoids the issue of an overloaded
+ Change the synopsis in 24.5.3.1 [move.iterator]:
+ </p>
+
+-<blockquote><pre>typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
++<blockquote><pre>
++typedef <del>typename iterator_traits&lt;</del>Iterator<del>&gt;::pointer</del> pointer;
+ </pre></blockquote>
+
+
+@@ -32966,10 +33073,10 @@ Change the synopsis in 24.5.3.1 [move.iterator]:
+
+ <hr>
+ <h3><a name="681"></a>681. Operator functions impossible to compare are defined in [re.submatch.op]</h3>
+-<p><b>Section:</b> 28.9.2 [re.submatch.op] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Nozomu Katoo <b>Opened:</b> 2007-05-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.submatch.op">issues</a> in [re.submatch.op].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.9.2 [re.submatch.op] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Nozomu Katoo <b>Opened:</b> 2007-05-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.submatch.op">issues</a> in [re.submatch.op].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 28.9.2 [re.submatch.op] of N2284,
+@@ -32977,7 +33084,8 @@ operator functions numbered 31-42 seem impossible to compare. E.g.:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class BiIter&gt;
++<pre>
++template &lt;class BiIter&gt;
+ bool operator==(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+ </pre>
+@@ -33015,16 +33123,17 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="682"></a>682. basic_regex ctor takes InputIterator or ForwardIterator?</h3>
+-<p><b>Section:</b> 28.8.2 [re.regex.construct] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2007-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex.construct">issues</a> in [re.regex.construct].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 28.8.2 [re.regex.construct] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Eric Niebler <b>Opened:</b> 2007-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex.construct">issues</a> in [re.regex.construct].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Looking at N2284, 28.8 [re.regex], p3 <tt>basic_regex</tt> class template synopsis shows this
+ constructor:
+ </p>
+-<blockquote><pre>template &lt;class InputIterator&gt;
++<blockquote><pre>
++template &lt;class InputIterator&gt;
+ basic_regex(InputIterator first, InputIterator last,
+ flag_type f = regex_constants::ECMAScript);
+ </pre></blockquote>
+@@ -33033,7 +33142,8 @@ constructor:
+ In 28.8.2 [re.regex.construct], p15, the constructor appears with this signature:
+ </p>
+
+-<blockquote><pre>template &lt;class ForwardIterator&gt;
++<blockquote><pre>
++template &lt;class ForwardIterator&gt;
+ basic_regex(ForwardIterator first, ForwardIterator last,
+ flag_type f = regex_constants::ECMAScript);
+ </pre></blockquote>
+@@ -33077,14 +33187,15 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="685"></a>685. reverse_iterator/move_iterator difference has invalid signatures</h3>
+-<p><b>Section:</b> 24.5.1.3.19 [reverse.iter.opdiff], 24.5.3.3.14 [move.iter.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-06-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 24.5.1.3.19 [reverse.iter.opdiff], 24.5.3.3.14 [move.iter.nonmember] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-06-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In C++03 the difference between two <tt>reverse_iterators</tt>
+ </p>
+-<blockquote><pre>ri1 - ri2
++<blockquote><pre>
++ri1 - ri2
+ </pre></blockquote>
+ <p>
+ is possible to compute only if both iterators have the same base
+@@ -33093,7 +33204,8 @@ iterator. The result type is the <tt>difference_type</tt> of the base iterator.
+ <p>
+ In the current draft, the operator is defined as 24.5.1.3.19 [reverse.iter.opdiff]
+ </p>
+-<blockquote><pre>template&lt;class Iterator1, class Iterator2&gt;
++<blockquote><pre>
++template&lt;class Iterator1, class Iterator2&gt;
+ typename reverse_iterator&lt;Iterator&gt;::difference_type
+ operator-(const reverse_iterator&lt;Iterator1&gt;&amp; x,
+ const reverse_iterator&lt;Iterator2&gt;&amp; y);
+@@ -33119,7 +33231,8 @@ Change the synopsis in 24.5.1.1 [reverse.iterator]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Iterator1, class Iterator2&gt;
++<pre>
++template &lt;class Iterator1, class Iterator2&gt;
+ <del>typename reverse_iterator&lt;Iterator&gt;::difference_type</del> <ins>auto</ins> operator-(
+ const reverse_iterator&lt;Iterator1&gt;&amp; x,
+ const reverse_iterator&lt;Iterator2&gt;&amp; y)<ins> -&gt; decltype(y.current - x.current)</ins>;
+@@ -33131,7 +33244,8 @@ Change 24.5.1.3.19 [reverse.iter.opdiff]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Iterator1, class Iterator2&gt;
++<pre>
++template &lt;class Iterator1, class Iterator2&gt;
+ <del>typename reverse_iterator&lt;Iterator&gt;::difference_type</del> <ins>auto</ins> operator-(
+ const reverse_iterator&lt;Iterator1&gt;&amp; x,
+ const reverse_iterator&lt;Iterator2&gt;&amp; y)<ins> -&gt; decltype(y.current - x.current)</ins>;
+@@ -33149,7 +33263,8 @@ Change the synopsis in 24.5.3.1 [move.iterator]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Iterator1, class Iterator2&gt;
++<pre>
++template &lt;class Iterator1, class Iterator2&gt;
+ <del>typename move_iterator&lt;Iterator&gt;::difference_type</del> <ins>auto</ins> operator-(
+ const move_iterator&lt;Iterator1&gt;&amp; x,
+ const move_iterator&lt;Iterator2&gt;&amp; y)<ins> -&gt; decltype(x.base() - y.base())</ins>;
+@@ -33161,7 +33276,8 @@ Change 24.5.3.3.14 [move.iter.nonmember]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Iterator1, class Iterator2&gt;
++<pre>
++template &lt;class Iterator1, class Iterator2&gt;
+ <del>typename move_iterator&lt;Iterator&gt;::difference_type</del> <ins>auto</ins> operator-(
+ const move_iterator&lt;Iterator1&gt;&amp; x,
+ const move_iterator&lt;Iterator2&gt;&amp; y)<ins> -&gt; decltype(x.base() - y.base())</ins>;
+@@ -33186,10 +33302,10 @@ goes in.
+
+ <hr>
+ <h3><a name="687"></a>687. shared_ptr conversion constructor not constrained</h3>
+-<p><b>Section:</b> 20.9.10.2.1 [util.smartptr.shared.const], 20.9.10.3.1 [util.smartptr.weak.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const], 20.8.2.3.1 [util.smartptr.weak.const] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Since all conversions from <tt>shared_ptr&lt;T&gt;</tt> to <tt>shared_ptr&lt;U&gt;</tt> have the same
+@@ -33197,7 +33313,8 @@ rank regardless of the relationship between <tt>T</tt> and <tt>U</tt>, reasonabl
+ code that works with raw pointers fails with <tt>shared_ptr</tt>:
+ </p>
+
+-<blockquote><pre>void f( shared_ptr&lt;void&gt; );
++<blockquote><pre>
++void f( shared_ptr&lt;void> );
+ void f( shared_ptr&lt;int&gt; );
+
+ int main()
+@@ -33215,7 +33332,7 @@ overload resolution when the pointer types are compatible.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.9.10.2.1 [util.smartptr.shared.const], change:
++In 20.8.2.2.1 [util.smartptr.shared.const], change:
+ </p>
+
+ <blockquote><p>
+@@ -33226,11 +33343,12 @@ to <tt>T*</tt>.
+ </p></blockquote>
+
+ <p>
+-In 20.9.10.3.1 [util.smartptr.weak.const], change:
++In 20.8.2.3.1 [util.smartptr.weak.const], change:
+ </p>
+
+ <blockquote>
+-<pre><del>template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const&amp; r);</del>
++<pre>
++<del>template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const&amp; r);</del>
+ <del>weak_ptr(weak_ptr const&amp; r);</del>
+ <del>template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const&amp; r);</del>
+ <ins>weak_ptr(weak_ptr const&amp; r);</ins>
+@@ -33252,10 +33370,10 @@ overload resolution unless</ins> <tt>Y*</tt> <del>shall be</del>
+
+ <hr>
+ <h3><a name="688"></a>688. reference_wrapper, cref unsafe, allow binding to rvalues</h3>
+-<p><b>Section:</b> 20.8.4.1 [refwrap.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#refwrap.const">issues</a> in [refwrap.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.4.1 [refwrap.const] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap.const">issues</a> in [refwrap.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A <tt>reference_wrapper</tt> can be constructed from an rvalue, either by using
+@@ -33296,13 +33414,15 @@ overload.
+ Without:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; void ref(const T&amp;&amp; t) = delete;
++<blockquote><pre>
++template &lt;class T&gt; void ref(const T&amp;&amp; t) = delete;
+ </pre></blockquote>
+ <p>
+ I believe this program will compile:
+ </p>
+
+-<blockquote><pre>#include &lt;functional&gt;
++<blockquote><pre>
++#include &lt;functional&gt;
+
+ struct A {};
+
+@@ -33316,20 +33436,23 @@ int main()
+ <p>
+ I.e. in:
+ </p>
+-<blockquote><pre>template &lt;ObjectType T&gt; reference_wrapper&lt;T&gt; ref(T&amp; t);
++<blockquote><pre>
++template &lt;ObjectType T&gt; reference_wrapper&lt;T&gt; ref(T&amp; t);
+ </pre></blockquote>
+
+ <p>
+ this:
+ </p>
+
+-<blockquote><pre>ref(source())
++<blockquote><pre>
++ref(source())
+ </pre></blockquote>
+ <p>
+ deduces <tt>T</tt> as <tt>const A</tt>, and so:
+ </p>
+
+-<blockquote><pre>ref(const A&amp; t)
++<blockquote><pre>
++ref(const A&amp; t)
+ </pre></blockquote>
+
+ <p>
+@@ -33347,18 +33470,19 @@ comment and am in favor of the proposed wording as it stands. Also, CWG 606
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.8 [function.objects], add the following two signatures to the synopsis:
++In 20.9 [function.objects], add the following two signatures to the synopsis:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; void ref(const T&amp;&amp; t) = delete;
++<blockquote><pre>
++template &lt;class T&gt; void ref(const T&amp;&amp; t) = delete;
+ template &lt;class T&gt; void cref(const T&amp;&amp; t) = delete;
+ </pre></blockquote>
+
+@@ -33391,10 +33515,10 @@ the "special deduction rule" is disabled with the const T&amp;&amp; pattern.
+
+ <hr>
+ <h3><a name="689"></a>689. reference_wrapper constructor overly constrained</h3>
+-<p><b>Section:</b> 20.8.4.1 [refwrap.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#refwrap.const">issues</a> in [refwrap.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.4.1 [refwrap.const] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-05-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap.const">issues</a> in [refwrap.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The constructor of <tt>reference_wrapper</tt> is currently <tt>explicit</tt>. The primary
+@@ -33421,10 +33545,10 @@ proposed resolution of the previous issue is accepted, remove the
+
+ <hr>
+ <h3><a name="691"></a>691. const_local_iterator cbegin, cend missing from TR1</h3>
+-<p><b>Section:</b> 23.7 [unord], TR1 6.3 [tr.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Joaquín M López Muñoz <b>Opened:</b> 2007-06-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord">issues</a> in [unord].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.5 [unord], TR1 6.3 [tr.hash] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2007-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The last version of TR1 does not include the following member
+@@ -33432,7 +33556,8 @@ functions
+ for unordered containers:
+ </p>
+
+-<blockquote><pre>const_local_iterator cbegin(size_type n) const;
++<blockquote><pre>
++const_local_iterator cbegin(size_type n) const;
+ const_local_iterator cend(size_type n) const;
+ </pre></blockquote>
+
+@@ -33456,7 +33581,7 @@ requirements) in section 23.2.5 [unord.req]:
+ <blockquote>
+ <table border="1">
+ <caption>Unordered associative container requirements (in addition to container)</caption>
+-<tbody><tr>
++<tr>
+ <th>expression</th> <th>return type</th> <th>assertion/note pre/post-condition</th> <th>complexity</th>
+ </tr>
+ <tr>
+@@ -33465,38 +33590,42 @@ requirements) in section 23.2.5 [unord.req]:
+ <tr>
+ <td><ins><tt>b.cend(n)</tt></ins></td> <td><ins><tt>const_local_iterator</tt></ins></td> <td><ins><tt>n</tt> shall be in the range <tt>[0, bucket_count())</tt>.</ins></td> <td><ins>Constant</ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Add to the synopsis in 23.7.1 [unord.map]:
++Add to the synopsis in 23.5.4 [unord.map]:
+ </p>
+
+-<blockquote><pre><ins>const_local_iterator cbegin(size_type n) const;
++<blockquote><pre>
++<ins>const_local_iterator cbegin(size_type n) const;
+ const_local_iterator cend(size_type n) const;</ins>
+ </pre></blockquote>
+
+ <p>
+-Add to the synopsis in 23.7.2 [unord.multimap]:
++Add to the synopsis in 23.5.5 [unord.multimap]:
+ </p>
+
+-<blockquote><pre><ins>const_local_iterator cbegin(size_type n) const;
++<blockquote><pre>
++<ins>const_local_iterator cbegin(size_type n) const;
+ const_local_iterator cend(size_type n) const;</ins>
+ </pre></blockquote>
+
+ <p>
+-Add to the synopsis in 23.7.3 [unord.set]:
++Add to the synopsis in 23.5.6 [unord.set]:
+ </p>
+
+-<blockquote><pre><ins>const_local_iterator cbegin(size_type n) const;
++<blockquote><pre>
++<ins>const_local_iterator cbegin(size_type n) const;
+ const_local_iterator cend(size_type n) const;</ins>
+ </pre></blockquote>
+
+ <p>
+-Add to the synopsis in 23.7.4 [unord.multiset]:
++Add to the synopsis in 23.5.7 [unord.multiset]:
+ </p>
+
+-<blockquote><pre><ins>const_local_iterator cbegin(size_type n) const;
++<blockquote><pre>
++<ins>const_local_iterator cbegin(size_type n) const;
+ const_local_iterator cend(size_type n) const;</ins>
+ </pre></blockquote>
+
+@@ -33507,10 +33636,10 @@ const_local_iterator cend(size_type n) const;</ins>
+
+ <hr>
+ <h3><a name="692"></a>692. <code>get_money</code> and <code>put_money</code> should be formatted I/O functions</h3>
+-<p><b>Section:</b> 27.7.4 [ext.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 27.7.5 [ext.manip] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In a private email Bill Plauger notes:
+@@ -33532,34 +33661,35 @@ Martin's response:
+ </p>
+ <blockquote><p>
+ I agree that the manipulators should handle exceptions the same way as
+-formatted I/O functions do. The text in N2072 assumes so but the
++formatted I&#47;O functions do. The text in N2072 assumes so but the
+ <i>Returns</i> clause explicitly omits exception handling for the sake
+ of brevity. The spec should be clarified to that effect.
+ </p>
+ <p>
+ As for dealing with whitespace, I also agree it would make sense for
+ the extractors and inserters involving the new manipulators to treat
+-it the same way as formatted I/O.
++it the same way as formatted I&#47;O.
+ </p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new paragraph immediately above p4 of 27.7.4 [ext.manip] with the
++Add a new paragraph immediately above p4 of 27.7.5 [ext.manip] with the
+ following text:
+ </p>
+ <blockquote><p>
+ <i>Effects</i>: The expression <code><i>in</i> &gt;&gt; get_money(mon, intl)</code>
+ described below behaves as a formatted input function (as
+-described in 27.7.1.2.1 [istream.formatted.reqmts]).
++described in 27.7.2.2.1 [istream.formatted.reqmts]).
+ </p></blockquote>
+ <p>
+-Also change p4 of 27.7.4 [ext.manip] as follows:
++Also change p4 of 27.7.5 [ext.manip] as follows:
+ </p>
+ <blockquote><p>
+ <i>Returns</i>: An object <code>s</code> of unspecified type such that
+ if <code>in</code> is an object of type <code>basic_istream&lt;charT,
+-traits&gt;</code> then the expression <code><i>in</i> &gt;&gt; get_money(mon, intl)</code> behaves as <ins>a formatted input function
++traits&gt;</code> then the expression <code><i>in</i> &gt;&gt;
++get_money(mon, intl)</code> behaves as <ins>a formatted input function
+ that calls </ins><code>f(in, mon, intl)</code><del> were
+ called</del>. The function <code>f</code> can be defined as...
+ </p></blockquote>
+@@ -33570,23 +33700,24 @@ post Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We recommend moving immediately to Review. We've looked at the issue and
+ have a consensus that the proposed resolution is correct, but want an
+ iostream expert to sign off. Alisdair has taken the action item to putt
+ this up on the reflector for possible movement by Howard to Tenatively
+ Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+ <hr>
+ <h3><a name="693"></a>693. <code>std::bitset::all()</code> missing</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <code>bitset</code> class template provides the member function
+@@ -33608,12 +33739,13 @@ the first word with a zero bit).
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a declaration of the new member function <code>all()</code> to the
+-defintion of the <code>bitset</code> template in 20.5 [template.bitset], p1,
++Add a declaration of the new member function <code>all()</code> to the
++defintion of the <code>bitset</code> template in 20.6 [template.bitset], p1,
+ right above the declaration of <code>any()</code> as shown below:
+ </p>
+
+-<blockquote><pre>bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
++<blockquote><pre>
++bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
+ bool test(size_t pos) const;
+ <ins>bool all() const;</ins>
+ bool any() const;
+@@ -33621,14 +33753,14 @@ bool none() const;
+ </pre></blockquote>
+
+ <p>
+-Add a description of the new member function to the end of 20.5.2 [bitset.members] with the following text:
++Add a description of the new member function to the end of 20.6.2 [bitset.members] with the following text:
+ </p>
+ <blockquote><p>
+ <code>bool all() const;</code>
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Returns</i>: <code>count() == size()</code>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -33662,10 +33794,11 @@ is one</del><ins><code>count() == 0</code></ins>.
+
+ <hr>
+ <h3><a name="694"></a>694. <code>std::bitset</code> and <code>long long</code></h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Objects of the <code>bitset</code> class template specializations can
+@@ -33690,7 +33823,8 @@ template tricks to achieve the same effect provided they don't cause
+ ambiguities or changes in behavior.)
+ </p>
+ <blockquote>
+-<pre>// [bitset.cons] constructors:
++<pre>
++// [bitset.cons] constructors:
+ bitset();
+ bitset(unsigned <ins>long</ins> long val);
+ template&lt;class charT, class traits, class Allocator&gt;
+@@ -33702,13 +33836,13 @@ explicit bitset(
+ </pre>
+ </blockquote>
+ <p>
+-Make a corresponding change in 20.5.1 [bitset.cons], p2:
++Make a corresponding change in 20.6.1 [bitset.cons], p2:
+ </p>
+ <blockquote>
+ <p>
+ <code>bitset(unsigned <ins>long</ins> long val);</code>
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Effects</i>: Constructs an object of class bitset&lt;N&gt;,
+ initializing the first <code><i>M</i></code> bit positions to the
+ corresponding bit values in <code><i>val</i></code>.
+@@ -33717,7 +33851,7 @@ number of bits in the value representation (section [basic.types]) of
+ <code>unsigned <ins> long</ins> long</code>. If <code><i>M</i> &lt;
+ <i>N</i></code> <ins>is <code>true</code></ins>, the remaining bit
+ positions are initialized to zero.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -33725,10 +33859,11 @@ Additionally, introduce a new member function <code>to_ullong()</code>
+ to make it possible to convert <code>bitset</code> to values of the
+ new type. Add the following declaration to the definition of the
+ template, immediate after the declaration of <code>to_ulong()</code>
+-in 20.5 [template.bitset], p1, as shown below:
++in 20.6 [template.bitset], p1, as shown below:
+ </p>
+ <blockquote>
+-<pre>// element access:
++<pre>
++// element access:
+ bool operator[](size_t pos) const; // for b[i];
+ reference operator[](size_t pos); // for b[i];
+ unsigned long to_ulong() const;
+@@ -33738,7 +33873,7 @@ basic_string&lt;charT, traits, Allocator&gt; to_string() const;
+ </pre>
+ </blockquote>
+ <p>
+-And add a description of the new member function to 20.5.2 [bitset.members],
++And add a description of the new member function to 20.6.2 [bitset.members],
+ below the description of the existing <code>to_ulong()</code> (if
+ possible), with the following text:
+ </p>
+@@ -33746,14 +33881,14 @@ possible), with the following text:
+ <p>
+ <code>unsigned long long to_ullong() const;</code>
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Throws</i>: <code>overflow_error</code> if the integral value
+ <code><i>x</i></code> corresponding to the bits in <code>*this</code>
+ cannot be represented as type <code>unsigned long long</code>.
+-</blockquote>
+-<blockquote>
++</p></blockquote>
++<blockquote><p>
+ <i>Returns:</i> <code><i>x</i></code>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -33762,9 +33897,9 @@ cannot be represented as type <code>unsigned long long</code>.
+
+ <hr>
+ <h3><a name="695"></a>695. ctype&lt;char&gt;::classic_table() not accessible</h3>
+-<p><b>Section:</b> 22.4.1.3 [facet.ctype.special] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 22.4.1.3 [facet.ctype.special] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <code>ctype&lt;char&gt;::classic_table()</code> static member
+@@ -33804,7 +33939,8 @@ moving their declarations into the public section of the definition of
+ specialization in 22.4.1.3 [facet.ctype.special] as shown below:
+ </p>
+ <blockquote>
+-<pre> static locale::id id;
++<pre>
++ static locale::id id;
+ static const size_t table_size = IMPLEMENTATION_DEFINED;
+ <del>protected:</del>
+ const mask* table() const throw();
+@@ -33822,16 +33958,16 @@ virtual char do_toupper(char c) const;
+
+ <hr>
+ <h3><a name="696"></a>696. <code>istream::operator&gt;&gt;(int&amp;)</code> broken</h3>
+-<p><b>Section:</b> 27.7.1.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.7.2.2.2 [istream.formatted.arithmetic] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.formatted.arithmetic">issues</a> in [istream.formatted.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ From message c++std-lib-17897:
+ </p>
+ <p>
+-The code shown in 27.7.1.2.2 [istream.formatted.arithmetic] as the "as if"
++The code shown in 27.7.2.2.2 [istream.formatted.arithmetic] as the "as if"
+ implementation of the two arithmetic extractors that don't have a
+ corresponding <code>num_get</code> interface (i.e., the
+ <code>short</code> and <code>int</code> overloads) is subtly buggy in
+@@ -33912,13 +34048,14 @@ However there is a contradictory sentence in 22.4.2.1.2 [facet.num.get.virtuals]
+ </p>
+
+ <p>
+-27.7.1.2.2 [istream.formatted.arithmetic] should mimic the behavior of 22.4.2.1.2 [facet.num.get.virtuals]
++27.7.2.2.2 [istream.formatted.arithmetic] should mimic the behavior of 22.4.2.1.2 [facet.num.get.virtuals]
+ (whatever we decide that behavior is) for
+ <tt>int</tt> and <tt>short</tt>, and currently does not. I believe that the
+ correct code fragment should look like:
+ </p>
+
+-<blockquote><pre>typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
++<blockquote><pre>
++typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
+ iostate err = ios_base::goodbit;
+ long lval;
+ use_facet&lt;numget&gt;(loc).get(*this, 0, *this, err, lval);
+@@ -33943,9 +34080,9 @@ setstate(err);
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -33954,20 +34091,21 @@ Move to Ready.
+ Change 22.4.2.1.2 [facet.num.get.virtuals], p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> Reads characters from <tt>in</tt>, interpreting them
+ according to <tt>str.flags()</tt>, <tt>use_facet&lt;ctype&lt;charT&gt;
+ &gt;(loc)</tt>, and <tt>use_facet&lt; numpunct&lt;charT&gt;
+ &gt;(loc)</tt>, where <tt>loc</tt> is <tt>str.getloc()</tt>. <del>If an error
+ occurs, <tt>val</tt> is unchanged; otherwise it is set to the resulting value.</del>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 27.7.1.2.2 [istream.formatted.arithmetic], p2 and p3:
++Change 27.7.2.2.2 [istream.formatted.arithmetic], p2 and p3:
+ </p>
+
+ <blockquote>
+-<pre>operator&gt;&gt;(short&amp; val);
++<pre>
++operator>>(short&amp; val);
+ </pre>
+ <blockquote>
+ <p>
+@@ -33975,7 +34113,8 @@ Change 27.7.1.2.2 [istream.formatted.arithmetic], p2 and p3:
+ the preceding code fragment):
+ </p>
+
+-<blockquote><pre>typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
++<blockquote><pre>
++typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
+ iostate err = ios<del>tate</del><ins>_base</ins>::goodbit;
+ long lval;
+ use_facet&lt;numget&gt;(loc).get(*this, 0, *this, err, lval);
+@@ -34001,7 +34140,8 @@ setstate(err);
+
+ </blockquote>
+
+-<pre>operator&gt;&gt;(int&amp; val);
++<pre>
++operator>>(int&amp; val);
+ </pre>
+ <blockquote>
+ <p>
+@@ -34009,7 +34149,8 @@ setstate(err);
+ the preceding code fragment):
+ </p>
+
+-<blockquote><pre>typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
++<blockquote><pre>
++typedef num_get&lt;charT,istreambuf_iterator&lt;charT,traits&gt; &gt; numget;
+ iostate err = ios<del>tate</del><ins>_base</ins>::goodbit;
+ long lval;
+ use_facet&lt;numget&gt;(loc).get(*this, 0, *this, err, lval);
+@@ -34043,10 +34184,10 @@ setstate(err);
+
+ <hr>
+ <h3><a name="697"></a>697. New <tt>&lt;system_error&gt;</tt> header leads to name clashes</h3>
+-<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-06-24 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#syserr">issues</a> in [syserr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-06-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr">issues</a> in [syserr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The most recent state of
+@@ -34062,7 +34203,8 @@ the enumerators has the name <tt>invalid_argument</tt>, or fully qualified:
+ e.g. the following snippet invalid:
+ </p>
+
+-<blockquote><pre>#include &lt;system_error&gt;
++<blockquote><pre>
++#include &lt;system_error&gt;
+ #include &lt;stdexcept&gt;
+
+ void foo() { throw std::invalid_argument("Don't call us - we call you!"); }
+@@ -34105,15 +34247,15 @@ Fixed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2422.
+
+ <hr>
+ <h3><a name="698"></a>698. <tt>system_error</tt> needs <tt>const char*</tt> constructors</h3>
+-<p><b>Section:</b> 19.5.6.1 [syserr.syserr.overview] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-06-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 19.5.6.1 [syserr.syserr.overview] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-06-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 19.5.6.1 [syserr.syserr.overview] we have the class definition of
+ <tt>std::system_error</tt>. In contrast to all exception classes, which
+ are constructible with a <tt>what_arg string</tt> (see 19.2 [std.exceptions],
+-or <tt>ios_base::failure</tt> in 27.5.2.1.1 [ios::failure]), only overloads with with
++or <tt>ios_base::failure</tt> in 27.5.3.1.1 [ios::failure]), only overloads with with
+ <tt>const string&amp;</tt> are possible. For consistency with the re-designed
+ remaining exception classes this class should also provide
+ c'tors which accept a const <tt>char* what_arg</tt> string.
+@@ -34129,14 +34271,15 @@ accepting a <tt>const char*</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-This proposed wording assumes issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a> has been accepted and applied to the working paper.
++This proposed wording assumes issue <a href="lwg-closed.html#832">832</a> has been accepted and applied to the working paper.
+ </p>
+
+ <p>
+ Change 19.5.6.1 [syserr.syserr.overview] Class system_error overview, as indicated:
+ </p>
+
+-<blockquote><pre>public:
++<blockquote><pre>
++public:
+ system_error(error_code ec, const string&amp; what_arg);
+ <ins>system_error(error_code ec, const char* what_arg);</ins>
+ system_error(error_code ec);
+@@ -34152,7 +34295,8 @@ To 19.5.6.2 [syserr.syserr.members] Class system_error members add:
+ </p>
+
+ <blockquote>
+-<pre>system_error(error_code ec, const char* what_arg);
++<pre>
++system_error(error_code ec, const char* what_arg);
+ </pre>
+ <blockquote>
+ <p>
+@@ -34163,7 +34307,8 @@ To 19.5.6.2 [syserr.syserr.members] Class system_error members add:
+ </p>
+ </blockquote>
+
+-<pre>system_error(int ev, const error_category* ecat, const char* what_arg);
++<pre>
++system_error(int ev, const error_category* ecat, const char* what_arg);
+ </pre>
+
+ <blockquote>
+@@ -34183,10 +34328,10 @@ To 19.5.6.2 [syserr.syserr.members] Class system_error members add:
+
+ <hr>
+ <h3><a name="699"></a>699. N2111 changes min/max</h3>
+-<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand">issues</a> in [rand].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5 [rand] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand">issues</a> in [rand].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2111.pdf">N2111</a>
+@@ -34222,10 +34367,10 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="700"></a>700. N1856 defines struct <tt>identity</tt></h3>
+-<p><b>Section:</b> 20.3.3 [forward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-07-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward">issues</a> in [forward].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.2.4 [forward] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2007-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward">issues</a> in [forward].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1856.html">N1856</a>
+@@ -34238,18 +34383,20 @@ if we could avoid this name clash for backward compatibility.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.3.3 [forward]:
++Change 20.2.4 [forward]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class T&gt; struct identity
++<pre>
++template &lt;class T&gt; struct identity
+ {
+ typedef T type;
+ <ins>const T&amp; operator()(const T&amp; x) const;</ins>
+ };
+ </pre>
+ <blockquote>
+-<pre><ins>const T&amp; operator()(const T&amp; x) const;</ins>
++<pre>
++<ins>const T&amp; operator()(const T&amp; x) const;</ins>
+ </pre>
+ <blockquote>
+ <p>
+@@ -34267,10 +34414,10 @@ Change 20.3.3 [forward]:
+
+ <hr>
+ <h3><a name="703"></a>703. <tt>map::at()</tt> need a complexity specification</h3>
+-<p><b>Section:</b> 23.6.1.2 [map.access] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-07-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map.access">issues</a> in [map.access].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.4.4.3 [map.access] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.access">issues</a> in [map.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>map::at()</tt> need a complexity specification.
+@@ -34279,7 +34426,7 @@ Change 20.3.3 [forward]:
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following to the specification of <tt>map::at()</tt>, 23.6.1.2 [map.access]:
++Add the following to the specification of <tt>map::at()</tt>, 23.4.4.3 [map.access]:
+ </p>
+ <blockquote>
+ <p>
+@@ -34292,15 +34439,16 @@ Add the following to the specification of <tt>map::at()</tt>, 23.6.1.2 [map.acce
+
+
+ <hr>
+-<h3><a name="704"></a>704. MoveAssignable requirement for container value type overly strict</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="704"></a>704. <tt>MoveAssignable</tt> requirement for container value type overly strict</h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-05-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The move-related changes inadvertently overwrote the intent of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a>.
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#276">276</a> removed the requirement of <tt>CopyAssignable</tt> from
++The move-related changes inadvertently overwrote the intent of <a href="lwg-defects.html#276">276</a>.
++Issue <a href="lwg-defects.html#276">276</a> removed the requirement of <tt>CopyAssignable</tt> from
+ most of the member functions of node-based containers. But the move-related changes
+ unnecessarily introduced the <tt>MoveAssignable</tt> requirement for those members which used to
+ require <tt>CopyAssignable</tt>.
+@@ -34319,7 +34467,7 @@ not omitted by mistake.
+
+ <table border="1">
+ <caption>Container Requirements</caption>
+-<tbody><tr><td><tt>X u(a)</tt></td><td><tt>value_type</tt> must be <tt>CopyConstructible</tt></td></tr>
++<tr><td><tt>X u(a)</tt></td><td><tt>value_type</tt> must be <tt>CopyConstructible</tt></td></tr>
+ <tr><td><tt>X u(rv)</tt></td><td><tt>array</tt> requires <tt>value_type</tt> to be <tt>CopyConstructible</tt></td></tr>
+ <tr><td><tt>a = u</tt></td><td>Sequences require <tt>value_type</tt> to be <tt>CopyConstructible</tt> and <tt>CopyAssignable</tt>.
+ Associative containers require <tt>value_type</tt> to be <tt>CopyConstructible</tt>.</td></tr>
+@@ -34327,14 +34475,14 @@ not omitted by mistake.
+ Sequences containers with <tt>propagate_on_container_move_assignment == false</tt> allocators require <tt>value_type</tt> to be <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.
+ Associative containers with <tt>propagate_on_container_move_assignment == false</tt> allocators require <tt>value_type</tt> to be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>swap(a,u)</tt></td><td><tt>array</tt> requires <tt>value_type</tt> to be <tt>Swappable</tt>.</td></tr>
+-</tbody></table>
++</table>
+
+ <p>
+ </p>
+
+ <table border="1">
+ <caption>Sequence Requirements</caption>
+-<tbody><tr><td><tt>X(n)</tt></td><td><tt>value_type</tt> must be <tt>DefaultConstructible</tt></td></tr>
++<tr><td><tt>X(n)</tt></td><td><tt>value_type</tt> must be <tt>DefaultConstructible</tt></td></tr>
+ <tr><td><tt>X(n, t)</tt></td><td><tt>value_type</tt> must be <tt>CopyConstructible</tt></td></tr>
+ <tr><td><tt>X(i, j)</tt></td><td>Sequences require <tt>value_type</tt> to be constructible from <tt>*i</tt>. Additionally if input_iterators
+ are used, <tt>vector</tt> and <tt>deque</tt> require <tt>MoveContructible</tt> and <tt>MoveAssignable</tt>.</td></tr>
+@@ -34357,14 +34505,14 @@ not omitted by mistake.
+ <tr><td><tt>a.resize(n)</tt></td><td>The <tt>value_type</tt> must be <tt>DefaultConstructible</tt>.
+ The sequence <tt>vector</tt> also requires the <tt>value_type</tt> to be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>a.resize(n, t)</tt></td><td>The <tt>value_type</tt> must be <tt>CopyConstructible</tt>.</td></tr>
+-</tbody></table>
++</table>
+
+ <p>
+ </p>
+
+ <table border="1">
+ <caption>Optional Sequence Requirements</caption>
+-<tbody><tr><td><tt>a.front()</tt></td><td></td></tr>
++<tr><td><tt>a.front()</tt></td><td></td></tr>
+ <tr><td><tt>a.back()</tt></td><td></td></tr>
+ <tr><td><tt>a.push_front(t)</tt></td><td>The <tt>value_type</tt> must be <tt>CopyConstructible</tt>.</td></tr>
+ <tr><td><tt>a.push_front(rv)</tt></td><td>The <tt>value_type</tt> must be <tt>MoveConstructible</tt>.</td></tr>
+@@ -34374,14 +34522,14 @@ not omitted by mistake.
+ <tr><td><tt>a.pop_back()</tt></td><td></td></tr>
+ <tr><td><tt>a[n]</tt></td><td></td></tr>
+ <tr><td><tt>a.at[n]</tt></td><td></td></tr>
+-</tbody></table>
++</table>
+
+ <p>
+ </p>
+
+ <table border="1">
+ <caption>Associative Container Requirements</caption>
+-<tbody><tr><td><tt>X(i, j)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
++<tr><td><tt>X(i, j)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
+ If the iterators return an rvalue the <tt>value_type</tt> must be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>a_uniq.insert(t)</tt></td><td>The <tt>value_type</tt> must be <tt>CopyConstructible</tt>.</td></tr>
+ <tr><td><tt>a_uniq.insert(rv)</tt></td><td>The <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>.</td></tr>
+@@ -34391,14 +34539,14 @@ not omitted by mistake.
+ <tr><td><tt>a.insert(p, rv)</tt></td><td>The <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>a.insert(i, j)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
+ If the iterators return an rvalue the <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>..</td></tr>
+-</tbody></table>
++</table>
+
+ <p>
+ </p>
+
+ <table border="1">
+ <caption>Unordered Associative Container Requirements</caption>
+-<tbody><tr><td><tt>X(i, j, n, hf, eq)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
++<tr><td><tt>X(i, j, n, hf, eq)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
+ If the iterators return an rvalue the <tt>value_type</tt> must be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>a_uniq.insert(t)</tt></td><td>The <tt>value_type</tt> must be <tt>CopyConstructible</tt>.</td></tr>
+ <tr><td><tt>a_uniq.insert(rv)</tt></td><td>The <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>.</td></tr>
+@@ -34408,18 +34556,18 @@ not omitted by mistake.
+ <tr><td><tt>a.insert(p, rv)</tt></td><td>The <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>a.insert(i, j)</tt></td><td>If the iterators return an lvalue the <tt>value_type</tt> must be <tt>CopyConstructible</tt>.
+ If the iterators return an rvalue the <tt>key_type</tt> and the <tt>mapped_type</tt> (if it exists) must be <tt>MoveConstructible</tt>..</td></tr>
+-</tbody></table>
++</table>
+
+ <p>
+ </p>
+
+ <table border="1">
+ <caption>Miscellaneous Requirements</caption>
+-<tbody><tr><td><tt>map[lvalue-key]</tt></td><td>The <tt>key_type</tt> must be <tt>CopyConstructible</tt>.
++<tr><td><tt>map[lvalue-key]</tt></td><td>The <tt>key_type</tt> must be <tt>CopyConstructible</tt>.
+ The <tt>mapped_type</tt> must be <tt>DefaultConstructible</tt> and <tt>MoveConstructible</tt>.</td></tr>
+ <tr><td><tt>map[rvalue-key]</tt></td><td>The <tt>key_type</tt> must be <tt>MoveConstructible</tt>.
+ The <tt>mapped_type</tt> must be <tt>DefaultConstructible</tt> and <tt>MoveConstructible</tt>.</td></tr>
+-</tbody></table>
++</table>
+
+ <p><i>[
+ Kona (2007): Howard and Alan to update requirements table in issue with emplace signatures.
+@@ -34467,9 +34615,9 @@ MoveConstructible, etc.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave open. Howard to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-06 Howard provides wording.
+@@ -34500,29 +34648,30 @@ the argument is an rvalue. Fixed it.
+
+ <blockquote>
+ <p>
+-I took the task to see whether <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a> is covered by 704
++I took the task to see whether <a href="lwg-defects.html#868">868</a> is covered by 704
+ already.
+ However, by doing that I have the impression that
+ 704 is a big mistake.
+ </p>
+
+ <p>
+-Take e.g. the second change of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a>:
++Take e.g. the second change of <a href="lwg-defects.html#868">868</a>:
+ </p>
+
+ <blockquote>
+ <p>
+-Change 23.3.2.1 [deque.cons] para 5:
++Change 23.3.3.2 [deque.cons] para 5:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Constructs a <tt>deque</tt> with <tt>n</tt> default constructed
+ elements.
+-</blockquote>
++</p></blockquote>
+ <p>
+ where "default constructed" should be replaced by "value-initialized".
+ This is the constructor out of a number of elements:
+ </p>
+-<blockquote><pre>ContType c(num)
++<blockquote><pre>
++ContType c(num)
+ </pre></blockquote>
+
+ <p>
+@@ -34531,11 +34680,11 @@ This is the constructor out of a number of elements:
+
+ <blockquote>
+ <p>
+-Remove the entire section 23.3.2.1 [deque.cons].
++Remove the entire section 23.3.3.2 [deque.cons].
+ </p>
+-<blockquote>
++<blockquote><p>
+ [ This section is already specified by the requirements tables. ]
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -34608,10 +34757,10 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2776.pdf">N2776</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This rationale is obsolete.
+@@ -34627,27 +34776,27 @@ This rationale is obsolete.
+ Change 23.2.1 [container.requirements.general]/4:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 4 In Tables 91 and 92, <tt>X</tt> denotes a container class containing objects
+ of type <tt>T</tt>, <tt>a</tt> and <tt>b</tt> denote values of type <tt>X</tt>,
+ <tt>u</tt> denotes an identifier, <tt>r</tt> denotes <del>an lvalue or a const
+ rvalue</del> <ins>a non-const value</ins> of type <tt>X</tt>, and <tt>rv</tt>
+ denotes a non-const rvalue of type <tt>X</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change the following rows in Table 91 — Container requirements
++Change the following rows in Table 91 &mdash; Container requirements
+ 23.2.1 [container.requirements.general]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 91 — Container requirements</caption>
++<caption>Table 91 &mdash; Container requirements</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+@@ -34658,7 +34807,7 @@ Change the following rows in Table 91
+ <td>compile time</td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+@@ -34675,16 +34824,16 @@ requirements:
+
+ <ul>
+ <li>
+-..
++<p>&hellip;</p>
+ </li>
+
+-<li>
++<li><p>
+ no <tt>erase()</tt>, <ins><tt>clear()</tt>,</ins> <tt>pop_back()</tt> or
+ <tt>pop_front()</tt> function throws an exception.
+-</li>
++</p></li>
+
+ <li>
+-...
++<p>&hellip;</p>
+ </li>
+ </ul>
+
+@@ -34730,7 +34879,7 @@ The default implementation of construct will call:
+
+ <p><ins>
+ But the allocator author may override the above definition of <tt>construct</tt>
+-and do the construction of <tt>T</tt> by some other means. — <i>end
++and do the construction of <tt>T</tt> by some other means. &mdash; <i>end
+ example</i>]
+ </ins></p>
+
+@@ -34743,46 +34892,46 @@ example</i>]
+ Add to 23.2.1 [container.requirements.general]/14:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 14 In Table 93, <tt>X</tt> denotes an allocator-aware container class with a
+ <tt>value_type</tt> of <tt>T</tt> using allocator of type <tt>A</tt>, <tt>u</tt>
+ denotes a variable, <ins><tt>a</tt> and <tt>b</tt> denote non-const lvalues of
+ type <tt>X</tt>,</ins> <tt>t</tt> denotes an lvalue or a const rvalue of type
+ <tt>X</tt>, <tt>rv</tt> denotes a non-const rvalue of type <tt>X</tt>,
+ <tt>m</tt> is a value of type <tt>A</tt>, and <tt>Q</tt> is an allocator type.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change or add the following rows in Table 93 — Allocator-aware container
++Change or add the following rows in Table 93 &mdash; Allocator-aware container
+ requirements in 23.2.1 [container.requirements.general]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 93 — Allocator-aware container requirements</caption>
++<caption>Table 93 &mdash; Allocator-aware container requirements</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+ <tr>
+-<td><tt>X(t, m)<br>X u(t, m);</tt></td>
++<td><tt>X(t, m)<br/>X u(t, m);</tt></td>
+ <td></td>
+-<td><ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt>.</ins><br>
+-post: <tt>u == t</tt>,<br>
++<td><ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt>.</ins><br/>
++post: <tt>u == t</tt>,<br/>
+ <tt>get_allocator() == m</tt></td>
+ <td>linear</td>
+ </tr>
+
+ <tr>
+-<td><tt>X(rv, m)<br>X u(rv, m);</tt></td>
++<td><tt>X(rv, m)<br/>X u(rv, m);</tt></td>
+ <td></td>
+-<td><ins><i>Requires:</i> <tt>T</tt> is <tt>MoveConstructible</tt>.</ins><br>
++<td><ins><i>Requires:</i> <tt>T</tt> is <tt>MoveConstructible</tt>.</ins><br/>
+ post: <tt>u</tt> shall have the same elements, or copies of the elements, that
+-<tt>rv</tt> had before this construction,<br>
++<tt>rv</tt> had before this construction,<br/>
+ <tt>get_allocator() == m</tt></td>
+ <td>constant if <tt>m == rv.get_allocator()</tt>, otherwise linear</td>
+ </tr>
+@@ -34791,7 +34940,7 @@ post: <tt>u</tt> shall have the same elements, or copies of the elements, that
+ <td><ins><tt>a = t</tt></ins></td>
+ <td><ins><tt>X&amp;</tt></ins></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt> and
+-<tt>CopyAssignable</tt><br>
++<tt>CopyAssignable</tt><br/>
+ post: <tt>a == t</tt>.</ins></td>
+ <td><ins>linear</ins></td>
+ </tr>
+@@ -34801,9 +34950,9 @@ post: <tt>a == t</tt>.</ins></td>
+ <td><ins><tt>X&amp;</tt></ins></td>
+ <td><ins><i>Requires:</i> If <tt>allocator_traits&lt; allocator_type &gt;
+ ::propagate_on_container_move_assignment ::value</tt> is <tt>false</tt>,
+-<tt>T</tt> is <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.<br>
++<tt>T</tt> is <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.<br/>
+ All existing elements of <tt>a</tt> are either move assigned
+-<ins>to</ins> or destroyed.<br>
++<ins>to</ins> or destroyed.<br/>
+ <tt>a</tt> shall be equal to the value that <tt>rv</tt> had before this
+ assignment</ins></td>
+ <td><ins>linear</ins></td>
+@@ -34816,37 +34965,37 @@ assignment</ins></td>
+ <td><ins>constant</ins></td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+ <p>
+-Change the following rows in Table 94 — Sequence container requirements
++Change the following rows in Table 94 &mdash; Sequence container requirements
+ (in addition to container) in 23.2.3 [sequence.reqmts]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 94 — Sequence container requirements (in addition to
++<caption>Table 94 &mdash; Sequence container requirements (in addition to
+ container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j)<br>X a(i, j)</tt></td>
++<td><tt>X(i, j)<br/>X a(i, j)</tt></td>
+ <td></td>
+ <td><i>Requires:</i> <del>If the iterator's dereference operation returns an
+ lvalue or a const rvalue, <tt>T</tt> shall be <tt>CopyConstructible</tt>.</del>
+-<ins><tt>T</tt> shall be constructible from <tt>*i</tt>.</ins><br>
++<ins><tt>T</tt> shall be constructible from <tt>*i</tt>.</ins><br/>
+ <ins>If the iterator does not meet the forward iterator requirements (24.2.5 [forward.iterators]), then <tt>vector</tt> also requires <tt>T</tt> to
+-be <tt>MoveConstructible</tt>.</ins><br>
++be <tt>MoveConstructible</tt>.</ins><br/>
+ Each iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly
+-once.<br>
+-post: <tt>size() ==</tt> distance between <tt>i</tt> and <tt>j</tt><br>
++once.<br/>
++post: <tt>size() ==</tt> distance between <tt>i</tt> and <tt>j</tt><br/>
+ Constructs a sequence container equal to the range <tt>[i, j)</tt></td>
+ </tr>
+
+@@ -34854,10 +35003,10 @@ Constructs a sequence container equal to the range <tt>[i, j)</tt></td>
+ <td><tt>a = il;</tt></td>
+ <td><tt>X&amp;</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt> and
+-<tt>CopyAssignable</tt>.</ins><br>
+-<del><tt>a = X(il);</tt></del><br>
++<tt>CopyAssignable</tt>.</ins><br/>
++<del><tt>a = X(il);</tt></del><br/>
+ <ins>Assigns the range <tt>[il.begin(), il.end())</tt> into <tt>a</tt>. All
+-existing elements of <tt>a</tt> are either assigned or destroyed.</ins><br>
++existing elements of <tt>a</tt> are either assigned or destroyed.</ins><br/>
+ <del>r</del><ins>R</ins>eturn<ins>s</ins> <tt>*this;</tt></td>
+ </tr>
+
+@@ -34897,11 +35046,11 @@ Inserts a copy <tt>rv</tt> before <tt>p</tt>.</td>
+ <td><tt>iterator</tt></td>
+ <td><i>Requires:</i> <del>If the iterator's dereference operation returns an
+ lvalue or a const rvalue, <tt>T</tt> shall be <tt>CopyConstructible</tt>.</del>
+-<ins><tt>T</tt> shall be constructible from <tt>*i</tt>.</ins><br> <ins>If the
++<ins><tt>T</tt> shall be constructible from <tt>*i</tt>.</ins><br/> <ins>If the
+ iterator does not meet the forward iterator requirements (24.2.5 [forward.iterators]), then <tt>vector</tt> also requires <tt>T</tt> to
+-be <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.</ins><br> Each
+-iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly once.<br>
+-pre: <tt>i</tt> and <tt>j</tt> are not iterators into <tt>a</tt>.<br> Inserts
++be <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.</ins><br/> Each
++iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly once.<br/>
++pre: <tt>i</tt> and <tt>j</tt> are not iterators into <tt>a</tt>.<br/> Inserts
+ copies of elements in <tt>[i, j)</tt> before <tt>p</tt></td>
+ </tr>
+
+@@ -34926,10 +35075,10 @@ copies of elements in <tt>[i, j)</tt> before <tt>p</tt></td>
+ <tr>
+ <td><tt>a.clear();</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>erase(begin(), end())</tt></del><br>
++<td><del><tt>erase(begin(), end())</tt></del><br/>
+ <ins>Destroys all elements in <tt>a</tt>. <ins>Invalidates all references,
+ pointers, and iterators referring to the elements of <tt>a</tt> and may
+-invalidate the past-the-end iterator.</ins><br></ins>
++invalidate the past-the-end iterator.</ins><br/></ins>
+ post: <tt><del>size() == 0</del> <ins>a.empty() == true</ins></tt></td>
+ </tr>
+
+@@ -34941,27 +35090,27 @@ lvalue or a const rvalue, <tt>T</tt> shall be <tt>CopyConstructible</tt> and
+ <tt>CopyAssignable</tt>.</del>
+ <ins><tt>T</tt> shall be constructible and assignable from <tt>*i</tt>. If the
+ iterator does not meet the forward iterator requirements (24.2.5 [forward.iterators]), then <tt>vector</tt> also requires <tt>T</tt> to
+-be <tt>MoveConstructible</tt>.</ins><br>
++be <tt>MoveConstructible</tt>.</ins><br/>
+ Each iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly
+-once.<br>
+-pre: <tt>i</tt>, <tt>j</tt> are not iterators into <tt>a</tt>.<br>
++once.<br/>
++pre: <tt>i</tt>, <tt>j</tt> are not iterators into <tt>a</tt>.<br/>
+ Replaces elements in <tt>a</tt> with a copy of <tt>[i, j)</tt>.</td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+ <p>
+-Change the following rows in Table 95 — Optional sequence container operations
++Change the following rows in Table 95 &mdash; Optional sequence container operations
+ in 23.2.3 [sequence.reqmts]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 95 — Optional sequence container operations</caption>
++<caption>Table 95 &mdash; Optional sequence container operations</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+@@ -34971,9 +35120,9 @@ in 23.2.3 [sequence.reqmts]:
+ <tr>
+ <td><tt>a.emplace_front(args)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.emplace(a.begin(), std::forward&lt;Args&gt;(args)...)</tt></del><br>
++<td><del><tt>a.emplace(a.begin(), std::forward&lt;Args&gt;(args)...)</tt></del><br/>
+ <ins>Prepends an object of type <tt>T</tt> constructed with
+-<tt>std::forward&lt;Args&gt;(args)...</tt>.</ins><br>
++<tt>std::forward&lt;Args&gt;(args)...</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, Args&gt;</tt></del>
+ <ins><tt>T</tt> shall be constructible from <tt>args</tt>.</ins></td>
+ <td><tt>list</tt>, <tt>deque</tt>, <tt>forward_list</tt></td>
+@@ -34982,9 +35131,9 @@ in 23.2.3 [sequence.reqmts]:
+ <tr>
+ <td><tt>a.emplace_back(args)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.emplace(a.end(), std::forward&lt;Args&gt;(args)...)</tt></del><br>
++<td><del><tt>a.emplace(a.end(), std::forward&lt;Args&gt;(args)...)</tt></del><br/>
+ <ins>Appends an object of type <tt>T</tt> constructed with
+-<tt>std::forward&lt;Args&gt;(args)...</tt>.</ins><br>
++<tt>std::forward&lt;Args&gt;(args)...</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, Args&gt;</tt></del>
+ <ins><tt>T</tt> shall be constructible from <tt>args</tt>. <tt>vector</tt> also
+ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+@@ -34994,8 +35143,8 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.push_front(t)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.insert(a.begin(), t)</tt></del><br>
+-<ins>Prepends a copy of <tt>t</tt>.</ins><br>
++<td><del><tt>a.insert(a.begin(), t)</tt></del><br/>
++<ins>Prepends a copy of <tt>t</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, T&gt;</tt> and
+ <tt>T</tt> shall be <tt>CopyAssignable</tt>.</del>
+ <ins><tt>T</tt> shall be <tt>CopyConstructible</tt>.</ins></td>
+@@ -35005,8 +35154,8 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.push_front(rv)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.insert(a.begin(), t)</tt></del><br>
+-<ins>Prepends a copy of <tt>rv</tt>.</ins><br>
++<td><del><tt>a.insert(a.begin(), t)</tt></del><br/>
++<ins>Prepends a copy of <tt>rv</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, T&amp;&amp;&gt;</tt> and
+ <tt>T</tt> shall be <tt>MoveAssignable</tt>.</del>
+ <ins><tt>T</tt> shall be <tt>MoveConstructible</tt>.</ins></td>
+@@ -35016,8 +35165,8 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.push_back(t)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.insert(a.end(), t)</tt></del><br>
+-<ins>Appends a copy of <tt>t</tt>.</ins><br>
++<td><del><tt>a.insert(a.end(), t)</tt></del><br/>
++<ins>Appends a copy of <tt>t</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, T&gt;</tt> and
+ <tt>T</tt> shall be <tt>CopyAssignable</tt>.</del>
+ <ins><tt>T</tt> shall be <tt>CopyConstructible</tt>.</ins></td>
+@@ -35027,8 +35176,8 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.push_back(rv)</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.insert(a.end(), t)</tt></del><br>
+-<ins>Appends a copy of <tt>rv</tt>.</ins><br>
++<td><del><tt>a.insert(a.end(), t)</tt></del><br/>
++<ins>Appends a copy of <tt>rv</tt>.</ins><br/>
+ <i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, T, T&amp;&amp;&gt;</tt> and
+ <tt>T</tt> shall be <tt>MoveAssignable</tt>.</del>
+ <ins><tt>T</tt> shall be <tt>MoveConstructible</tt>.</ins></td>
+@@ -35038,8 +35187,8 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.pop_front()</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>a.erase(a.begin())</tt></del><br>
+-<ins>Destroys the first element.</ins><br>
++<td><del><tt>a.erase(a.begin())</tt></del><br/>
++<ins>Destroys the first element.</ins><br/>
+ <ins><i>Requires:</i> <tt>a.empty()</tt> shall be <tt>false</tt>.</ins></td>
+ <td><tt>list</tt>, <tt>deque</tt>, <tt>forward_list</tt></td>
+ </tr>
+@@ -35047,13 +35196,13 @@ requires <tt>T</tt> to be <tt>MoveConstructible</tt>.</ins></td>
+ <tr>
+ <td><tt>a.pop_back()</tt></td>
+ <td><tt>void</tt></td>
+-<td><del><tt>{ iterator tmp = a.end();<br>--tmp;<br>a.erase(tmp); }</tt></del><br>
+-<ins>Destroys the last element.</ins><br>
++<td><del><tt>{ iterator tmp = a.end();<br/>--tmp;<br/>a.erase(tmp); }</tt></del><br/>
++<ins>Destroys the last element.</ins><br/>
+ <ins><i>Requires:</i> <tt>a.empty()</tt> shall be <tt>false</tt>.</ins></td>
+ <td><tt>vector</tt>, <tt>list</tt>, <tt>deque</tt>, <tt>basic_string</tt></td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+@@ -35071,7 +35220,7 @@ containers <tt>map</tt> and <tt>multimap</tt>, the requirements placed on
+ <tt>mapped_type</tt>. [<i>Note:</i> For example <tt>key_type</tt> and
+ <tt>mapped_type</tt> are sometimes required to be <tt>CopyAssignable</tt> even
+ though the <tt>value_type</tt> (<tt>pair&lt;const key_type,
+-mapped_type&gt;</tt>) is not <tt>CopyAssignable</tt>. — <i>end note</i>]
++mapped_type&gt;</tt>) is not <tt>CopyAssignable</tt>. &mdash; <i>end note</i>]
+ </ins></p>
+
+ <p>
+@@ -35095,19 +35244,19 @@ an allocator of a type convertible to <tt>A</tt>. </p>
+ </blockquote>
+
+ <p>
+-Change or add the following rows in Table 96 — Associative container
++Change or add the following rows in Table 96 &mdash; Associative container
+ requirements (in addition to container) in 23.2.4 [associative.reqmts]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 96 — Associative container requirements (in addition to
++<caption>Table 96 &mdash; Associative container requirements (in addition to
+ container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+@@ -35127,34 +35276,34 @@ container)</caption>
+ </tr>
+
+ <tr>
+-<td><tt>X(c)<br>X a(c);</tt></td>
++<td><tt>X(c)<br/>X a(c);</tt></td>
+ <td></td>
+ <td><i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, key_compare,
+-key_compare&gt;</tt></del>.<br>
+-<ins><tt>key_compare</tt> is <tt>CopyConstructible</tt>.</ins><br>
+-Constructs an empty container.<br>
++key_compare&gt;</tt></del>.<br/>
++<ins><tt>key_compare</tt> is <tt>CopyConstructible</tt>.</ins><br/>
++Constructs an empty container.<br/>
+ Uses a copy of <tt>c</tt> as a comparison object.</td>
+ <td>constant</td>
+ </tr>
+
+ <tr>
+-<td><tt>X()<br>X a;</tt></td>
++<td><tt>X()<br/>X a;</tt></td>
+ <td></td>
+ <td><i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, key_compare,
+-key_compare&gt;</tt></del>.<br>
+-<ins><tt>key_compare</tt> is <tt>DefaultConstructible</tt>.</ins><br>
+-Constructs an empty container.<br>
++key_compare&gt;</tt></del>.<br/>
++<ins><tt>key_compare</tt> is <tt>DefaultConstructible</tt>.</ins><br/>
++Constructs an empty container.<br/>
+ Uses <tt>Compare()</tt> as a comparison object.</td>
+ <td>constant</td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j, c)<br>X a(i, j, c);</tt></td>
++<td><tt>X(i, j, c)<br/>X a(i, j, c);</tt></td>
+ <td></td>
+ <td><i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, key_compare,
+-key_compare&gt;</tt></del>.<br>
++key_compare&gt;</tt></del>.<br/>
+ <ins><tt>key_compare</tt> is <tt>CopyConstructible</tt>. <tt>value_type</tt>
+-shall be constructible from <tt>*i</tt>.</ins><br>
++shall be constructible from <tt>*i</tt>.</ins><br/>
+ Constructs an empty container ans inserts elements from the range <tt>[i,
+ j)</tt> into it; uses <tt>c</tt> as a comparison object.</td>
+ <td><tt>N</tt> log <tt>N</tt> in general (<tt>N</tt> is the distance from
+@@ -35163,12 +35312,12 @@ j)</tt> into it; uses <tt>c</tt> as a comparison object.</td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j)<br>X a(i, j);</tt></td>
++<td><tt>X(i, j)<br/>X a(i, j);</tt></td>
+ <td></td>
+ <td><i>Requires:</i> <del><tt>ConstructibleAsElement&lt;A, key_compare,
+-key_compare&gt;</tt></del>.<br> <ins><tt>value_type</tt> shall be constructible
++key_compare&gt;</tt></del>.<br/> <ins><tt>value_type</tt> shall be constructible
+ from <tt>*i</tt>. <tt>key_compare</tt> is
+-<tt>DefaultConstructible</tt>.</ins><br> Same as above, but uses
++<tt>DefaultConstructible</tt>.</ins><br/> Same as above, but uses
+ <tt>Compare()</tt> as a comparison object.</td>
+ <td>same as above</td>
+ </tr>
+@@ -35176,10 +35325,10 @@ from <tt>*i</tt>. <tt>key_compare</tt> is
+ <tr>
+ <td><tt>a = il</tt></td>
+ <td><tt>X&amp;</tt></td>
+-<td><del><tt>a = X(il);<br>
+-return *this;</tt></del><br>
++<td><del><tt>a = X(il);<br/>
++return *this;</tt></del><br/>
+ <ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt> and
+-<tt>CopyAssignable</tt>.</ins><br>
++<tt>CopyAssignable</tt>.</ins><br/>
+ <ins>Assigns the range <tt>[il.begin(), il.end())</tt> into <tt>a</tt>. All
+ existing elements of <tt>a</tt> are either assigned or destroyed.</ins></td>
+ <td><del>Same as <tt><tt>a = X(il)</tt></tt>.</del>
+@@ -35192,7 +35341,7 @@ existing elements of <tt>a</tt> are either assigned or destroyed.</ins></td>
+ <td><tt>a_uniq.emplace(args)</tt></td>
+ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be constructible from
+-<tt>args</tt></ins><br>
++<tt>args</tt></ins><br/>
+ inserts a <tt>T</tt> object <tt>t</tt> constructed with
+ <tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element in
+ the container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt>
+@@ -35206,7 +35355,7 @@ to the key of <tt>t</tt>.</td>
+ <td><tt>a_eq.emplace(args)</tt></td>
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be constructible from
+-<tt>args</tt></ins><br>
++<tt>args</tt></ins><br/>
+ inserts a <tt>T</tt> object <tt>t</tt> constructed with
+ <tt>std::forward&lt;Args&gt;(args)...</tt> and returns the iterator pointing to
+ the newly inserted element.</td>
+@@ -35218,7 +35367,7 @@ the newly inserted element.</td>
+ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ inserts <tt>t</tt> if and only if there is no element in the container with key
+ equivalent to the key of <tt>t</tt>. The <tt>bool</tt> component of the returned
+ pair is true if and only if the insertion takes place, and the iterator
+@@ -35232,7 +35381,7 @@ component of the pair points to the element with key equivalent to the key of
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ inserts <tt>t</tt> and returns the iterator pointing to the newly inserted
+ element. If a range containing elements equivalent to <tt>t</tt> exists in
+ <tt>a_eq</tt>, <tt>t</tt> is inserted at the end of that range.</td>
+@@ -35244,7 +35393,7 @@ element. If a range containing elements equivalent to <tt>t</tt> exists in
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ inserts <tt>t</tt> if and only if there is no element with key equivalent to the
+ key of <tt>t</tt> in containers with unique keys; always inserts <tt>t</tt> in
+ containers with equivalent keys; always returns the iterator pointing to the
+@@ -35258,7 +35407,7 @@ right before <tt>p</tt>.</td>
+ <td><tt>a.insert(i, j)</tt></td>
+ <td><tt>void</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be
+-constructible from <tt>*i</tt>.</ins><br>
++constructible from <tt>*i</tt>.</ins><br/>
+ pre: <tt>i</tt>, <tt>j</tt> are not iterators into <tt>a</tt>. inserts each
+ element from the range <tt>[i,j)</tt> if and only if there is no element with
+ key equivalent to the key of that element in containers with unique keys; always
+@@ -35266,7 +35415,7 @@ inserts that element in containers with equivalent keys.</td>
+ <td>N log(size() + N ) (N is the distance from i to j)</td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+@@ -35283,7 +35432,7 @@ the requirements placed on <tt>value_type</tt> in Table 93 apply instead
+ directly to <tt>key_type</tt> and <tt>mapped_type</tt>. [<i>Note:</i> For
+ example <tt>key_type</tt> and <tt>mapped_type</tt> are sometimes required to be
+ <tt>CopyAssignable</tt> even though the <tt>value_type</tt> (<tt>pair&lt;const
+-key_type, mapped_type&gt;</tt>) is not <tt>CopyAssignable</tt>. — <i>end
++key_type, mapped_type&gt;</tt>) is not <tt>CopyAssignable</tt>. &mdash; <i>end
+ note</i>]
+ </ins></p>
+
+@@ -35293,19 +35442,19 @@ note</i>]
+ </blockquote>
+
+ <p>
+-Change or add the following rows in Table 98 — Unordered associative
++Change or add the following rows in Table 98 &mdash; Unordered associative
+ container requirements (in addition to container) in 23.2.5 [unord.req]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 98 — Unordered associative
++<caption>Table 98 &mdash; Unordered associative
+ container requirements (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+@@ -35326,7 +35475,7 @@ container requirements (in addition to container)</caption>
+ </tr>
+
+ <tr>
+-<td><tt>X(n, hf, eq)<br>X a(n, hf, eq)</tt></td>
++<td><tt>X(n, hf, eq)<br/>X a(n, hf, eq)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>hasher</tt> and <tt>key_equal</tt> are
+ <tt>CopyConstructible</tt>.</ins> Constructs an empty container with at least
+@@ -35336,7 +35485,7 @@ the key equality predicate. </td>
+ </tr>
+
+ <tr>
+-<td><tt>X(n, hf)<br>X a(n, hf)</tt></td>
++<td><tt>X(n, hf)<br/>X a(n, hf)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>hasher</tt> is <tt>CopyConstructible</tt> and
+ <tt>key_equal</tt> is <tt>DefaultConstructible</tt>.</ins> Constructs an empty
+@@ -35346,7 +35495,7 @@ function and <tt>key_equal()</tt> as the key equality predicate.</td>
+ </tr>
+
+ <tr>
+-<td><tt>X(n)<br>X a(n)</tt></td>
++<td><tt>X(n)<br/>X a(n)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>hasher</tt> and <tt>key_equal</tt> are
+ <tt>DefaultConstructible</tt>.</ins> Constructs an empty container with at least
+@@ -35356,7 +35505,7 @@ the key equality predicate. </td>
+ </tr>
+
+ <tr>
+-<td><tt>X()<br>X a</tt></td>
++<td><tt>X()<br/>X a</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>hasher</tt> and <tt>key_equal</tt> are
+ <tt>DefaultConstructible</tt>.</ins> Constructs an empty container an unspecified number of buckets,
+@@ -35366,11 +35515,11 @@ the key equality predicate. </td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j, n, hf, eq)<br>X a(i, j, n, hf, eq)</tt></td>
++<td><tt>X(i, j, n, hf, eq)<br/>X a(i, j, n, hf, eq)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>value_type</tt> is constructible from
+ <tt>*i</tt>. <tt>hasher</tt> and <tt>key_equal</tt> are
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ Constructs an empty container with at least <tt>n</tt> buckets, using
+ <tt>hf</tt> as the hash function and <tt>eq</tt> as the key equality predicate,
+ and inserts elements from <tt>[i, j)</tt> into it.</td>
+@@ -35379,11 +35528,11 @@ case <tt>O(N<sup>2</sup>)</tt></td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j, n, hf)<br>X a(i, j, n, hf)</tt></td>
++<td><tt>X(i, j, n, hf)<br/>X a(i, j, n, hf)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>value_type</tt> is constructible from <tt>*i</tt>.
+ <tt>hasher</tt> is <tt>CopyConstructible</tt> and <tt>key_equal</tt> is
+-<tt>DefaultConstructible</tt>.</ins><br> Constructs an empty container with at
++<tt>DefaultConstructible</tt>.</ins><br/> Constructs an empty container with at
+ least <tt>n</tt> buckets, using <tt>hf</tt> as the hash function and
+ <tt>key_equal()</tt> as the key equality predicate, and inserts elements from
+ <tt>[i, j)</tt> into it.</td>
+@@ -35392,11 +35541,11 @@ case <tt>O(N<sup>2</sup>)</tt></td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j, n)<br>X a(i, j, n)</tt></td>
++<td><tt>X(i, j, n)<br/>X a(i, j, n)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>value_type</tt> is constructible from <tt>*i</tt>.
+ <tt>hasher</tt> and <tt>key_equal</tt> are
+-<tt>DefaultConstructible</tt>.</ins><br> Constructs an empty container with at
++<tt>DefaultConstructible</tt>.</ins><br/> Constructs an empty container with at
+ least <tt>n</tt> buckets, using <tt>hasher()</tt> as the hash function and
+ <tt>key_equal()</tt> as the key equality predicate, and inserts elements from
+ <tt>[i, j)</tt> into it.</td>
+@@ -35405,11 +35554,11 @@ case <tt>O(N<sup>2</sup>)</tt></td>
+ </tr>
+
+ <tr>
+-<td><tt>X(i, j)<br>X a(i, j)</tt></td>
++<td><tt>X(i, j)<br/>X a(i, j)</tt></td>
+ <td><tt>X</tt></td>
+ <td><ins><i>Requires:</i> <tt>value_type</tt> is constructible from <tt>*i</tt>.
+ <tt>hasher</tt> and <tt>key_equal</tt> are
+-<tt>DefaultConstructible</tt>.</ins><br> Constructs an empty container with an
++<tt>DefaultConstructible</tt>.</ins><br/> Constructs an empty container with an
+ unspecified number of buckets, using <tt>hasher()</tt> as the hash function and
+ <tt>key_equal()</tt> as the key equality predicate, and inserts elements from
+ <tt>[i, j)</tt> into it.</td>
+@@ -35418,7 +35567,7 @@ case <tt>O(N<sup>2</sup>)</tt></td>
+ </tr>
+
+ <tr>
+-<td><tt>X(b)<br>X a(b)</tt></td>
++<td><tt>X(b)<br/>X a(b)</tt></td>
+ <td><tt>X</tt></td>
+ <td>Copy constructor. In addition to the <del>contained elements</del>
+ <ins>requirements of Table 93 (23.2.1 [container.requirements.general])</ins>, copies the hash function,
+@@ -35438,9 +35587,9 @@ predicate, and maximum load factor.</td>
+ <tr>
+ <td><tt>a = il</tt></td>
+ <td><tt>X&amp;</tt></td>
+-<td><del><tt>a = X(il); return *this;</tt></del><br>
++<td><del><tt>a = X(il); return *this;</tt></del><br/>
+ <ins><i>Requires:</i> <tt>T</tt> is <tt>CopyConstructible</tt> and
+-<tt>CopyAssignable</tt>.</ins><br>
++<tt>CopyAssignable</tt>.</ins><br/>
+ <ins>Assigns the range <tt>[il.begin(), il.end())</tt> into <tt>a</tt>. All
+ existing elements of <tt>a</tt> are either assigned or destroyed.</ins></td>
+ <td>Average case linear in <tt>il.size()</tt>, worst case quadratic.</td>
+@@ -35450,7 +35599,7 @@ existing elements of <tt>a</tt> are either assigned or destroyed.</ins></td>
+ <td><tt>a_uniq.emplace(args)</tt></td>
+ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be constructible from
+-<tt>args</tt></ins><br>
++<tt>args</tt></ins><br/>
+ inserts a <tt>T</tt> object <tt>t</tt> constructed with
+ <tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element in
+ the container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt>
+@@ -35464,7 +35613,7 @@ to the key of <tt>t</tt>.</td>
+ <td><tt>a_eq.emplace(args)</tt></td>
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be constructible from
+-<tt>args</tt></ins><br>
++<tt>args</tt></ins><br/>
+ inserts a <tt>T</tt> object <tt>t</tt> constructed with
+ <tt>std::forward&lt;Args&gt;(args)...</tt> and returns the iterator pointing to
+ the newly inserted element.</td>
+@@ -35475,7 +35624,7 @@ the newly inserted element.</td>
+ <td><tt>a.emplace_hint(p, args)</tt></td>
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be constructible from
+-<tt>args</tt></ins><br>
++<tt>args</tt></ins><br/>
+ equivalent to <tt>a.emplace( std::forward&lt;Args&gt;(args)...)</tt>. Return
+ value is an iterator pointing to the element with the key equivalent to the
+ newly inserted element. The <tt>const_iterator p</tt> is a hint pointing to
+@@ -35489,7 +35638,7 @@ hint.</td>
+ <td><tt>pair&lt;iterator, bool&gt;</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ Inserts <tt>t</tt> if and only if there is no element in the container with key
+ equivalent to the key of <tt>t</tt>. The <tt>bool</tt> component of the returned
+ pair indicates whether the insertion takes place, and the iterator component
+@@ -35502,7 +35651,7 @@ points to the element with key equivalent to the key of <tt>t</tt>.</td>
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ Inserts <tt>t</tt>, and returns an iterator pointing to the newly inserted
+ element.</td>
+ <td>Average case O(1), worst case O(<tt>a_uniq.size()</tt>).</td>
+@@ -35513,7 +35662,7 @@ element.</td>
+ <td><tt>iterator</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt> if
+ <tt>t</tt> is a non-const rvalue expression, else <tt>T</tt> shall be
+-<tt>CopyConstructible</tt>.</ins><br>
++<tt>CopyConstructible</tt>.</ins><br/>
+ Equivalent to <tt>a.insert(t)</tt>. Return value is an iterator pointing to the
+ element with the key equivalent to that of <tt>t</tt>. The iterator <tt>q</tt>
+ is a hint pointing to where the search should start. Implementations are
+@@ -35525,22 +35674,22 @@ permitted to ignore the hint.</td>
+ <td><tt>a.insert(i, j)</tt></td>
+ <td><tt>void</tt></td>
+ <td><ins><i>Requires:</i> <tt>T</tt> shall be
+-constructible from <tt>*i</tt>.</ins><br>
++constructible from <tt>*i</tt>.</ins><br/>
+ Pre: <tt>i</tt> and <tt>j</tt> are not iterators in <tt>a</tt>. Equivalent to
+ <tt>a.insert(t)</tt> for each element in <tt>[i,j)</tt>.</td>
+ <td>Average case O(<tt>N</tt>), where <tt>N</tt> is <tt>distance(i, j)</tt>.
+ Worst case O(<tt>N * a.size()</tt>).</td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+ <p>
+-Change 23.3.3 [forwardlist]/2:
++Change 23.3.4 [forwardlist]/2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 A <tt>forward_list</tt> satisfies all of the requirements of a container
+ (table 91), except that the <tt>size()</tt> member function is not provided.
+ <ins>A <tt>forward_list</tt> also satisfies all of the requirements of an
+@@ -35551,13 +35700,14 @@ requirements, and several of the optional sequence container requirements (Table
+ Descriptions are provided here only for operations on <tt>forward_list</tt> that
+ are not described in that table or for operations where there is additional
+ semantic information.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Add a new paragraph after 23.3.3.4 [forwardlist.modifiers]/23:
++Add a new paragraph after 23.3.4.5 [forwardlist.modifiers]/23:
+ </p>
+
+-<blockquote><pre>void clear();
++<blockquote><pre>
++void clear();
+ </pre>
+
+ <blockquote>
+@@ -35571,20 +35721,21 @@ Add a new paragraph after 23.3.3.4 [forwardlist.modifiers]/23:
+ </blockquote>
+
+ <p>
+-Change 23.4.1.2 [vector.capacity]/13:
++Change 23.3.6.3 [vector.capacity]/13:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, const T&amp; c);
++<blockquote><pre>
++void resize(size_type sz, const T&amp; c);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 13 <i>Requires:</i> <ins><tt>T</tt> shall be <tt>CopyConstructible</tt>.</ins>
+ If <tt>value_type</tt> has a move constructor, that constructor shall not throw
+ any exceptions.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-In 23.7.3 [unord.set] and 23.7.4 [unord.multiset] substitute
++In 23.5.6 [unord.set] and 23.5.7 [unord.multiset] substitute
+ "<tt>Key</tt>" for "<tt>Value</tt>".
+ </p>
+
+@@ -35602,13 +35753,14 @@ The above substitution is normative as it ties into the requirements table.
+
+ <hr>
+ <h3><a name="705"></a>705. type-trait <tt>decay</tt> incompletely specified</h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2007-07-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2007-07-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The current working draft has a type-trait <tt>decay</tt> in 20.7.7.6 [meta.trans.other].
++The current working draft has a type-trait <tt>decay</tt> in 20.10.7.6 [meta.trans.other].
+ </p>
+
+ <p>
+@@ -35622,7 +35774,7 @@ cv-qualification, as pass-by-value does.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.7.7.6 [meta.trans.other] change the last sentence:
++In 20.10.7.6 [meta.trans.other] change the last sentence:
+ </p>
+
+ <blockquote><p>
+@@ -35653,13 +35805,13 @@ is <tt>X&amp;</tt> if <tt>Ui</tt> equals
+
+ <hr>
+ <h3><a name="706"></a>706. <tt>make_pair()</tt> should behave as <tt>make_tuple()</tt> wrt. <tt>reference_wrapper()</tt></h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2007-07-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2007-07-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The current draft has <tt>make_pair()</tt> in 20.3.5 [pairs]/16
++The current draft has <tt>make_pair()</tt> in 20.3 [pairs]/16
+ and <tt>make_tuple()</tt> in 20.4.2.4 [tuple.creation].
+ <tt>make_tuple()</tt> detects the presence of
+ <tt>reference_wrapper&lt;X&gt;</tt> arguments and "unwraps" the reference in
+@@ -35672,16 +35824,17 @@ confusion.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.3 [utility] change the synopsis for make_pair() to read
++In 20.2 [utility] change the synopsis for make_pair() to read
+ </p>
+
+-<blockquote><pre>template &lt;class T1, class T2&gt;
++<blockquote><pre>
++template &lt;class T1, class T2&gt;
+ pair&lt;<del>typename decay&lt;T1&gt;::type</del> <ins>V1</ins>, <del>typename decay&lt;T2&gt;::type</del> <ins>V2</ins>&gt; make_pair(T1&amp;&amp;, T2&amp;&amp;);
+ </pre></blockquote>
+
+ <p>
+-In 20.3.5 [pairs]/16 change the declaration to match the above synopsis.
+-Then change the 20.3.5 [pairs]/17 to:
++In 20.3 [pairs]/16 change the declaration to match the above synopsis.
++Then change the 20.3 [pairs]/17 to:
+ </p>
+
+ <blockquote>
+@@ -35702,10 +35855,10 @@ Then change the 20.3.5 [pairs]/17 to:
+
+ <hr>
+ <h3><a name="709"></a>709. <tt>char_traits::not_eof</tt> has wrong signature</h3>
+-<p><b>Section:</b> 21.2.3 [char.traits.specializations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#char.traits.specializations">issues</a> in [char.traits.specializations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.2.3 [char.traits.specializations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2007-08-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#char.traits.specializations">issues</a> in [char.traits.specializations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The changes made for <tt>constexpr</tt> in 21.2.3 [char.traits.specializations] have
+@@ -35740,7 +35893,8 @@ Change the signature in 21.2.3.1 [char.traits.specializations.char],
+ and 21.2.3.4 [char.traits.specializations.wchar.t] to
+ </p>
+
+-<blockquote><pre>static constexpr int_type not_eof(<del>char_type</del> <ins>int_type</ins> c);
++<blockquote><pre>
++static constexpr int_type not_eof(<del>char_type</del> <ins>int_type</ins> c);
+ </pre></blockquote>
+
+
+@@ -35750,28 +35904,29 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Resolution: NAD editorial - up to Pete's judgment
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Sophia Antipolis
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Pending NAD Editorial to Review. The proposed wording appears to be correct but non-editorial.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+ <hr>
+ <h3><a name="710"></a>710. Missing postconditions</h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-08-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A discussion on
+@@ -35801,11 +35956,12 @@ editor should consider rewording "If w is the return value...", e. g. as
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 20.9.10.2.1 [util.smartptr.shared.const]:
++Add to 20.8.2.2.1 [util.smartptr.shared.const]:
+ </p>
+
+ <blockquote>
+-<pre>shared_ptr(shared_ptr&amp;&amp; r);
++<pre>
++shared_ptr(shared_ptr&amp;&amp; r);
+ template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt;&amp;&amp; r);
+ </pre>
+ <blockquote>
+@@ -35817,11 +35973,12 @@ shall be empty. <ins><tt>r.get() == 0</tt>.</ins>
+ </blockquote>
+
+ <p>
+-Add to 20.9.10.2.10 [util.smartptr.shared.cast]:
++Add to 20.8.2.2.9 [util.smartptr.shared.cast]:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
++<pre>
++template&lt;class T, class U&gt; shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
+ </pre>
+ <blockquote>
+ <p>
+@@ -35832,7 +35989,8 @@ Add to 20.9.10.2.10 [util.smartptr.shared.cast]:
+ </blockquote>
+
+ <blockquote>
+-<pre>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
++<pre>
++template&lt;class T, class U&gt; shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
+ </pre>
+ <blockquote>
+ <p>
+@@ -35842,7 +36000,8 @@ Add to 20.9.10.2.10 [util.smartptr.shared.cast]:
+ </blockquote>
+
+ <blockquote>
+-<pre>template&lt;class T, class U&gt; shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
++<pre>
++template&lt;class T, class U&gt; shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const&amp; r);
+ </pre>
+ <blockquote>
+ <p>
+@@ -35860,7 +36019,7 @@ the aliasing constructor as follows:
+ </p>
+
+ <p>
+-Change 20.9.10.2.10 [util.smartptr.shared.cast]:
++Change 20.8.2.2.9 [util.smartptr.shared.cast]:
+ </p>
+
+ <blockquote>
+@@ -35907,10 +36066,10 @@ in the aliasing constructor postcondition "by reference".
+
+ <hr>
+ <h3><a name="711"></a>711. Contradiction in empty <tt>shared_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-08-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2007-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A discussion on
+@@ -35928,7 +36087,8 @@ The note:
+ after the aliasing constructor
+ </p>
+
+-<blockquote><pre>template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const&amp; r, T *p);
++<blockquote><pre>
++template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt; const&amp; r, T *p);
+ </pre></blockquote>
+
+ <p>
+@@ -35939,11 +36099,12 @@ with a non-NULL stored pointer.
+ </p>
+
+ <p>
+-This is contradicted by the second sentence in the Returns clause of 20.9.10.2.5 [util.smartptr.shared.obs]:
++This is contradicted by the second sentence in the Returns clause of 20.8.2.2.5 [util.smartptr.shared.obs]:
+ </p>
+
+ <blockquote>
+-<pre>T* get() const;
++<pre>
++T* get() const;
+ </pre>
+ <blockquote><p>
+ <i>Returns:</i> the stored pointer. Returns a null pointer if <tt>*this</tt> is empty.
+@@ -35965,7 +36126,7 @@ isn't defined anywhere), and whether we have a good mental model for how
+ one behaves. We think it might be possible to deduce what the definition
+ should be, but the words just aren't there. We need to open an issue on
+ the use of this undefined term. (The resolution of that issue might
+-affect the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>.)
++affect the resolution of issue <a href="lwg-defects.html#711">711</a>.)
+ </p>
+ <p>
+ The LWG is getting more uncomfortable with the aliasing proposal (N2351)
+@@ -35995,7 +36156,7 @@ The aliasing constructor is sharp enough as it is, so "protecting" users
+ doesn't make much sense in this particular case.
+ </p>
+ <p>
+-&gt; Do you have a use case for r being empty and r being non-null?
++> Do you have a use case for r being empty and r being non-null?
+ </p>
+ <p>
+ I have received a few requests for it from "performance-conscious"
+@@ -36030,11 +36191,12 @@ Howard: Option 2 commented out for clarity, and can be brought back.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In keeping the N2351 spirit and obviously my preference, change 20.9.10.2.5 [util.smartptr.shared.obs]:
++In keeping the N2351 spirit and obviously my preference, change 20.8.2.2.5 [util.smartptr.shared.obs]:
+ </p>
+
+ <blockquote>
+-<pre>T* get() const;
++<pre>
++T* get() const;
+ </pre>
+ <blockquote><p>
+ <i>Returns:</i> the stored pointer. <del>Returns a null pointer if <tt>*this</tt> is empty.</del>
+@@ -36050,10 +36212,10 @@ In keeping the N2351 spirit and obviously my preference, change 20.9.10.2.5 [uti
+
+ <hr>
+ <h3><a name="712"></a>712. <tt>seed_seq::size</tt> no longer useful</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Marc Paterno <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Marc Paterno <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ One of the motivations for incorporating <tt>seed_seq::size()</tt>
+@@ -36093,9 +36255,9 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
+
+ <hr>
+ <h3><a name="713"></a>713. <tt>sort()</tt> complexity is too lax</h3>
+-<p><b>Section:</b> 25.4.1.1 [sort] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.1.1 [sort] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The complexity of <tt>sort()</tt> is specified as "Approximately <tt>N
+@@ -36137,10 +36299,10 @@ If the worst case behavior is important <tt>stable_sort()</tt> (25.3.1.2) or <tt
+
+ <hr>
+ <h3><a name="714"></a>714. <tt>search_n</tt> complexity is too lax</h3>
+-<p><b>Section:</b> 25.2.13 [alg.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.search">issues</a> in [alg.search].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.2.13 [alg.search] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.search">issues</a> in [alg.search].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The complexity for <tt>search_n</tt> (25.2.13 [alg.search] par 7) is specified as "At most
+@@ -36157,7 +36319,8 @@ Change the complexity to "At most (last - first) applications of the correspondi
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class ForwardIterator, class Size, class T&gt;
++<pre>
++template&lt;class ForwardIterator, class Size, class T&gt;
+ ForwardIterator
+ search_n(ForwardIterator first , ForwardIterator last , Size count ,
+ const T&amp; value );
+@@ -36183,10 +36346,10 @@ template&lt;class ForwardIterator, class Size, class T,
+
+ <hr>
+ <h3><a name="715"></a>715. <tt>minmax_element</tt> complexity is too lax</h3>
+-<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2007-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The complexity for <tt>minmax_element</tt> (25.4.7 [alg.min.max] par 16) says "At most <tt>max(2 *
+@@ -36204,7 +36367,8 @@ Change 25.4.7 [alg.min.max] to:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class ForwardIterator&gt;
++<pre>
++template&lt;class ForwardIterator&gt;
+ pair&lt;ForwardIterator, ForwardIterator&gt;
+ minmax_element(ForwardIterator first , ForwardIterator last);
+ template&lt;class ForwardIterator, class Compare&gt;
+@@ -36223,7 +36387,7 @@ in <tt>[first, last)</tt> such that no iterator in the range refers to a larger
+ </p>
+ <p>
+ <i>Complexity:</i> At most <del><tt>max(2 * (last - first ) - 2, 0)</tt></del>
+-<ins><tt>max(&#8970;(3/2) (N-1)&#8971;, 0)</tt></ins> applications of the
++<ins><tt>max(&lfloor;(3/2) (N-1)&rfloor;, 0)</tt></ins> applications of the
+ corresponding <del>comparisons</del> <ins>predicate, where <tt>N</tt> is <tt>distance(first, last)</tt></ins>.
+ </p>
+ </blockquote>
+@@ -36236,9 +36400,10 @@ corresponding <del>comparisons</del> <ins>predicate, where <tt>N</tt> is <tt>dis
+
+ <hr>
+ <h3><a name="716"></a>716. Production in [re.grammar] not actually modified</h3>
+-<p><b>Section:</b> 28.13 [re.grammar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-08-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.13 [re.grammar] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-08-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.grammar">issues</a> in [re.grammar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.13 [re.grammar]/3 say:
+@@ -36249,8 +36414,9 @@ TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.13 [re.grammar]/3 say:
+ The following productions within the ECMAScript grammar are modified as follows:
+ </p>
+
+-<blockquote><pre>CharacterClass ::
+-[ [lookahead &#8713; {^}] ClassRanges ]
++<blockquote><pre>
++CharacterClass ::
++[ [lookahead &notin; {^}] ClassRanges ]
+ [ ^ ClassRanges ]
+ </pre></blockquote>
+
+@@ -36285,9 +36451,9 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -36296,8 +36462,9 @@ Move to Ready.
+ Remove this mention of the CharacterClass production.
+ </p>
+
+-<blockquote><pre><del>CharacterClass ::
+-[ [lookahead &#8713; {^}] ClassRanges ]
++<blockquote><pre>
++<del>CharacterClass ::
++[ [lookahead &notin; {^}] ClassRanges ]
+ [ ^ ClassRanges ]</del>
+ </pre></blockquote>
+
+@@ -36308,11 +36475,12 @@ Remove this mention of the CharacterClass production.
+
+ <hr>
+ <h3><a name="719"></a>719. <tt>std::is_literal</tt> type traits should be provided</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#750">750</a></p>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#750">750</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Since the inclusion of <tt>constexpr</tt> in the standard draft N2369 we have
+@@ -36340,10 +36508,10 @@ a new type category "literal", which is defined in 3.9 [basic.types]/p.11:
+
+ <p>
+ I strongly suggest that the standard provides a type traits for
+-literal types in 20.7.4.3 [meta.unary.prop] for several reasons:
++literal types in 20.10.4.3 [meta.unary.prop] for several reasons:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>To keep the traits in sync with existing types.</li>
+ <li>I see many reasons for programmers to use this trait in template
+ code to provide optimized template definitions for these types,
+@@ -36376,9 +36544,9 @@ These two issues should move to OPEN pending AM paper on type traits.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Beman, Daniel, and Alisdair will work on a paper proposing new type traits.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2947.html">N2947</a>.
+@@ -36390,36 +36558,38 @@ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.htm">N2984</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.7.2 [meta.type.synop] in the group "type properties",
++In 20.10.2 [meta.type.synop] in the group "type properties",
+ just below the line
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct is_pod;
++<blockquote><pre>
++template &lt;class T&gt; struct is_pod;
+ </pre></blockquote>
+
+ <p>
+ add a new one:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct is_literal;
++<blockquote><pre>
++template &lt;class T&gt; struct is_literal;
+ </pre></blockquote>
+
+ <p>
+-In 20.7.4.3 [meta.unary.prop], table Type Property Predicates, just
++In 20.10.4.3 [meta.unary.prop], table Type Property Predicates, just
+ below the line for the <tt>is_pod</tt> property add a new line:
+ </p>
+
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Template</th><th>Condition</th><th>Preconditions</th>
+ </tr>
+ <tr>
+@@ -36429,7 +36599,7 @@ below the line for the <tt>is_pod</tt> property add a new line:
+ array of unknown bound, or
+ (possibly cv-qualified) <tt>void</tt>.</td>
+ </tr>
+-</tbody></table>
++</table>
+
+
+
+@@ -36438,10 +36608,11 @@ array of unknown bound, or
+
+ <hr>
+ <h3><a name="720"></a>720. Omissions in constexpr usages</h3>
+-<p><b>Section:</b> 23.3.1 [array], 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.2 [array], 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <ol>
+ <li>
+@@ -36494,21 +36665,24 @@ In order to have a consistent working paper, Alisdair and Daniel produced a new
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+ <li>
+-<p>In the class template definition of 23.3.1 [array]/p. 3 change</p>
+-<blockquote><pre><ins>constexpr</ins> bool empty() const;
++<p>In the class template definition of 23.3.2 [array]/p. 3 change</p>
++<blockquote><pre>
++<ins>constexpr</ins> bool empty() const;
+ </pre></blockquote>
+ </li>
+
+ <li>
+-<p>In the class template definition of 20.5 [template.bitset]/p. 1 change</p>
+-<blockquote><pre><ins>constexpr</ins> bool test(size_t pos ) const;
++<p>In the class template definition of 20.6 [template.bitset]/p. 1 change</p>
++<blockquote><pre>
++<ins>constexpr</ins> bool test(size_t pos ) const;
+ </pre></blockquote>
+
+ <p>
+-and in 20.5.2 [bitset.members] change
++and in 20.6.2 [bitset.members] change
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> bool test(size_t pos ) const;
++<blockquote><pre>
++<ins>constexpr</ins> bool test(size_t pos ) const;
+ </pre></blockquote>
+
+ </li>
+@@ -36520,17 +36694,19 @@ and in 20.5.2 [bitset.members] change
+
+ <hr>
+ <h3><a name="722"></a>722. Missing [c.math] functions <tt>nanf</tt> and <tt>nanl</tt></h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the listing of 26.8 [c.math], table 108: Header <tt>&lt;cmath&gt;</tt> synopsis I miss
+ the following C99 functions (from 7.12.11.2):
+ </p>
+
+-<blockquote><pre>float nanf(const char *tagp);
++<blockquote><pre>
++float nanf(const char *tagp);
+ long double nanl(const char *tagp);
+ </pre></blockquote>
+
+@@ -36552,10 +36728,10 @@ just after the existing entry <tt>nan</tt>.
+
+ <hr>
+ <h3><a name="723"></a>723. <tt>basic_regex</tt> should be moveable</h3>
+-<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-08-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex">issues</a> in [re.regex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex">issues</a> in [re.regex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 316</b></p>
+@@ -36575,9 +36751,9 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Needs wording for the semantics, the idea is agreed upon.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Daniel updated wording to reflect new "swap rules".
+@@ -36589,9 +36765,9 @@ Post Summit Daniel updated wording to reflect new "swap rules".
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -36601,27 +36777,30 @@ In the class definition of <tt>basic_regex</tt>, just below 28.8 [re.regex]/3,
+ perform the following changes:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ Just after <tt>basic_regex(const basic_regex&amp;);</tt> insert:
+ </p>
+
+-<blockquote><pre>basic_regex(basic_regex&amp;&amp;);
++<blockquote><pre>
++basic_regex(basic_regex&amp;&amp;);
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+ Just after <tt>basic_regex&amp; operator=(const basic_regex&amp;);</tt> insert:
+ </p>
+-<blockquote><pre>basic_regex&amp; operator=(basic_regex&amp;&amp;);
++<blockquote><pre>
++basic_regex&amp; operator=(basic_regex&amp;&amp;);
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+ Just after <tt>basic_regex&amp; assign(const basic_regex&amp; that);</tt> insert:
+ </p>
+-<blockquote><pre>basic_regex&amp; assign(basic_regex&amp;&amp; that);
++<blockquote><pre>
++basic_regex&amp; assign(basic_regex&amp;&amp; that);
+ </pre></blockquote>
+ </li>
+ <li>
+@@ -36629,7 +36808,8 @@ Just after <tt>basic_regex&amp; assign(const basic_regex&amp; that);</tt> insert
+ In 28.8.2 [re.regex.construct], just after p.11 add the following
+ new member definition:
+ </p>
+-<blockquote><pre>basic_regex(basic_regex&amp;&amp; e);
++<blockquote><pre>
++basic_regex(basic_regex&amp;&amp; e);
+ </pre>
+ <blockquote>
+ <p>
+@@ -36653,11 +36833,12 @@ Also in 28.8.2 [re.regex.construct], just after p.18 add the
+ following new member definition:
+ </p>
+
+-<blockquote><pre>basic_regex&amp; operator=(basic_regex&amp;&amp; e);
++<blockquote><pre>
++basic_regex&amp; operator=(basic_regex&amp;&amp; e);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Returns the result of <tt>assign(std::move(e))</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ <li>
+@@ -36665,7 +36846,8 @@ following new member definition:
+ In 28.8.3 [re.regex.assign], just after p. 2 add the following new
+ member definition:
+ </p>
+-<blockquote><pre>basic_regex&amp; assign(basic_regex&amp;&amp; rhs);
++<blockquote><pre>
++basic_regex&amp; assign(basic_regex&amp;&amp; rhs);
+ </pre>
+ <blockquote>
+ <p>
+@@ -36691,10 +36873,10 @@ in a valid state with an unspecified value.
+
+ <hr>
+ <h3><a name="724"></a>724. <tt>DefaultConstructible</tt> is not defined</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2007-09-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2007-09-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>DefaultConstructible</tt> requirement is referenced in
+@@ -36710,7 +36892,7 @@ Bellevue:
+
+ <blockquote>
+ <p>
+-Walking into the default/value-initialization mess...
++Walking into the default&#47;value-initialization mess...
+ </p>
+ <p>
+ Why two lines? Because we need both expressions to be valid.
+@@ -36720,7 +36902,7 @@ AJM not sure what the phrase "default constructed" means. This is
+ unfortunate, as the phrase is already used 24 times in the library!
+ </p>
+ <p>
+-Example: const int would not accept first line, but will accept the second.
++Example: <tt>const int</tt> would not accept first line, but will accept the second.
+ </p>
+ <p>
+ This is an issue that must be solved by concepts, but we might need to solve it independantly first.
+@@ -36733,7 +36915,7 @@ column is valid, but not clear what semantics we need.
+ A table where there is no post-condition seems odd, but appears to sum up our position best.
+ </p>
+ <p>
+-At a minimum an object is declared and is destuctible.
++At a minimum an object is declared and is destructible.
+ </p>
+ <p>
+ Move to open, as no-one happy to produce wording on the fly.
+@@ -36746,7 +36928,7 @@ Move to open, as no-one happy to produce wording on the fly.
+
+
+ <p><i>[
+-2009-08-17 Daniel adds "[defaultconstructible]" to table title. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>
++2009-08-17 Daniel adds "[defaultconstructible]" to table title. <a href="lwg-closed.html#408">408</a>
+ depends upon this issue.
+ ]</i></p>
+
+@@ -36764,7 +36946,7 @@ Looking at the proposed table in this issue, it really needs two rows:
+ <blockquote>
+ <table border="1">
+ <caption>Table 33: <tt>DefaultConstructible</tt> requirements [defaultconstructible]</caption>
+-<tbody><tr>
++<tr>
+ <th>expression</th><th>post-condition</th>
+ </tr>
+
+@@ -36775,7 +36957,7 @@ Looking at the proposed table in this issue, it really needs two rows:
+ <tr>
+ <td><tt>T{}</tt></td><td>Object of type <tt>T</tt> is value-initialized.</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -36807,7 +36989,8 @@ would fall back to suggest to use the expression <tt>T()</tt> instead of
+ expression
+ </p>
+
+-<blockquote><pre>T t();
++<blockquote><pre>
++T t();
+ </pre></blockquote>
+ </blockquote>
+
+@@ -36816,58 +36999,46 @@ expression
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open. Core is looking to make Alisdair's proposed
+ resolution correct.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-2010-01-24 At Alisdiar's request, moved his proposal into the proposed wording
+-seciton. The old wording is preserved here:
++2010-01-24 At Alisdair's request, moved his proposal into the proposed wording
++section. The old wording is preserved here:
+ ]</i></p>
+
+
+ <blockquote>
+ <p>
+-In section 20.2.1 [utility.arg.requirements], before table 33, add the
++In section 17.6.3.1 [utility.arg.requirements], before table 33, add the
+ following table:
+ </p>
+
+-<p align="center" style="text-align:center">Table 33: <tt>DefaultConstructible</tt> requirements [defaultconstructible]</p>
++<p style='text-align:center'>Table 33: <tt>DefaultConstructible</tt>
++requirements [defaultconstructible]</p>
+
+-<div align="center">
+-
+-<table border="0" cellspacing="0" cellpadding="0" style="border-collapse:collapse">
+- <tbody><tr>
+- <td width="114" valign="top" style="width:85.5pt;border-top:solid navy 1.0pt;
+- border-left:solid navy 1.0pt;border-bottom:double navy 1.5pt;border-right:
+- none;padding:0in 5.4pt 0in 5.4pt">
+- <p align="center" style="margin:0in;margin-bottom:.0001pt;text-align:center">expression</p>
++<table border='0' cellspacing='0' cellpadding='0'
++ style='border-collapse:collapse'>
++ <tr>
++ <td>
++ <p style='text-align:center'>expression</p>
+ </td>
+- <td width="324" valign="top" style="width:243.0pt;border-top:solid navy 1.0pt;
+- border-left:none;border-bottom:double navy 1.5pt;border-right:solid navy 1.0pt;
+- padding:0in 5.4pt 0in 5.4pt">
+- <p align="center" style="margin:0in;margin-bottom:.0001pt;text-align:center">post-condition</p>
++ <td>
++ <p style='text-align:center'>post-condition</p>
+ </td>
+ </tr>
+ <tr>
+- <td width="114" valign="top" style="width:85.5pt;border-top:none;border-left:
+- solid navy 1.0pt;border-bottom:solid navy 1.0pt;border-right:none;padding:
+- 0in 5.4pt 0in 5.4pt">
+- <p style="margin:0in;margin-bottom:.0001pt"><tt>T
+- t;</tt><br>
++ <td>
++ <p><tt>T t;</tt><br/>
+ <tt>T()</tt></p>
+ </td>
+- <td width="324" valign="top" style="width:243.0pt;border-top:none;border-left:
+- none;border-bottom:solid navy 1.0pt;border-right:solid navy 1.0pt;padding:
+- 0in 5.4pt 0in 5.4pt">
+- <p style="margin:0in;margin-bottom:.0001pt"><tt>T</tt>
+- is <i>default constructed.</i></p>
++ <td>
++ <p><tt>T</tt> is <i>default constructed.</i></p>
+ </td>
+ </tr>
+-</tbody></table>
+-
+-</div>
++</table>
+
+ </blockquote>
+
+@@ -36883,10 +37054,10 @@ following table:
+ San Francisco:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We believe concepts will solve this problem
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2774.pdf">N2774</a>).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Rationale is obsolete.
+@@ -36896,14 +37067,14 @@ Rationale is obsolete.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In section 20.2.1 [utility.arg.requirements], before table 33, add the
++In section 17.6.3.1 [utility.arg.requirements], before table 33, add the
+ following table:
+ </p>
+
+ <blockquote>
+ <table border="1">
+ <caption>Table 33: <tt>DefaultConstructible</tt> requirements [defaultconstructible]</caption>
+-<tbody><tr>
++<tr>
+ <th>expression</th><th>post-condition</th>
+ </tr>
+
+@@ -36916,10 +37087,10 @@ following table:
+ </tr>
+
+ <tr>
+-<td><tt>T()<br>T{}</tt></td><td>A temporary object of type <tt>T</tt> is value-initialized.</td>
++<td><tt>T()<br/>T{}</tt></td><td>A temporary object of type <tt>T</tt> is value-initialized.</td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -36929,10 +37100,10 @@ following table:
+
+ <hr>
+ <h3><a name="727"></a>727. <tt>regex_replace()</tt> doesn't accept <tt>basic_string</tt>s with custom traits and allocators</h3>
+-<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-09-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2007-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>regex_match()</tt> and <tt>regex_search()</tt> take <tt>const basic_string&lt;charT, ST,
+@@ -36973,9 +37144,9 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Howard to ask Stephan Lavavej to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-17 Stephan provided wording.
+@@ -36983,7 +37154,7 @@ Howard to ask Stephan Lavavej to provide wording.
+
+
+ <p><i>[
+-2009-07-25 Daniel tweaks both this issue and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#726">726</a>.
++2009-07-25 Daniel tweaks both this issue and <a href="lwg-closed.html#726">726</a>.
+ ]</i></p>
+
+
+@@ -37021,9 +37192,9 @@ in the Proposed Resolution.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review. Chair is anxious to move this to Ready in Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-01-27 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+@@ -37040,7 +37211,8 @@ Move to Review. Chair is anxious to move this to Ready in Pittsburgh.
+ Change 28.4 [re.syn] as indicated:
+ </p>
+
+-<blockquote><pre>// 28.11.4, function template regex_replace:
++<blockquote><pre>
++// 28.11.4, function template regex_replace:
+ template &lt;class OutputIterator, class BidirectionalIterator,
+ class traits, class charT<ins>, class ST, class SA</ins>&gt;
+ OutputIterator
+@@ -37106,11 +37278,12 @@ template &lt;class traits, class charT&gt;
+
+ <li>
+ <p>
+-Change 28.10 [re.results]/3, class template <tt>match_results</tt> as
++Change 28.10 [re.results]&#47;3, class template <tt>match_results</tt> as
+ indicated:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ template &lt;class OutputIter&gt;
+ OutputIter
+ format(OutputIter out,
+@@ -37146,7 +37319,8 @@ format(const char_type* fmt,
+ Insert at the very beginning of 28.10.5 [re.results.form] the following:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ template &lt;class OutputIter&gt;
+ OutputIter
+ format(OutputIter out,
+@@ -37183,7 +37357,8 @@ recognized.
+ Change 28.10.5 [re.results.form], before p. 1 until p. 3 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class OutputIter<ins>, class ST, class SA</ins>&gt;
++<blockquote><pre>
++template &lt;class OutputIter<ins>, class ST, class SA</ins>&gt;
+ OutputIter
+ format(OutputIter out,
+ const <del>string_type</del><ins>basic_string&lt;char_type, ST, SA&gt;</ins>&amp; fmt,
+@@ -37219,7 +37394,8 @@ specifiers and escape sequences are recognized</del> <ins>Equivalent to
+ Change 28.10.5 [re.results.form], before p. 4 until p. 4 as indicated:
+ </p>
+
+-<blockquote><pre><ins>template &lt;class ST, class SA&gt;</ins>
++<blockquote><pre>
++<ins>template &lt;class ST, class SA&gt;</ins>
+ <del>string_type</del><ins>basic_string&lt;char_type, ST, SA&gt;</ins>
+ format(const <del>string_type</del><ins>basic_string&lt;char_type, ST, SA&gt;</ins>&amp; fmt,
+ regex_constants::match_flag_type flags =
+@@ -37251,7 +37427,8 @@ and calls <tt>format(back_inserter(result), fmt, flags)</tt>.</ins>
+ At the end of 28.10.5 [re.results.form] insert as indicated:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ string_type
+ format(const char_type* fmt,
+ regex_constants::match_flag_type flags =
+@@ -37277,7 +37454,8 @@ char_traits&lt;char_type&gt;::length(fmt), flags)</tt>.</ins>
+ Change 28.11.4 [re.alg.replace] before p. 1 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class OutputIterator, class BidirectionalIterator,
++<blockquote><pre>
++template &lt;class OutputIterator, class BidirectionalIterator,
+ class traits, class charT<ins>, class ST, class SA</ins>&gt;
+ OutputIterator
+ regex_replace(OutputIterator out,
+@@ -37299,7 +37477,7 @@ template &lt;class OutputIterator, class BidirectionalIterator,
+ regex_constants::match_default);
+ </ins></pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> [..]. If any matches are found then, for each such match, if <tt>!(flags &amp;
+ regex_constants::format_no_copy)</tt> calls <tt>std::copy(m.prefix().first,
+ m.prefix().second,
+@@ -37308,7 +37486,7 @@ form of the function
+ and <tt>m.format(out, fmt, fmt + char_traits&lt;charT&gt;::length(fmt), flags)</tt>
+ for the second
+ form</ins>. [..].
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -37317,7 +37495,8 @@ for the second
+ Change 28.11.4 [re.alg.replace] before p. 3 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class traits, class charT<ins>, class ST, class SA,
++<blockquote><pre>
++template &lt;class traits, class charT<ins>, class ST, class SA,
+ class FST, class FSA</ins>&gt;
+ basic_string&lt;charT<ins>, ST, SA</ins>&gt;
+ regex_replace(const basic_string&lt;charT<ins>, ST, SA</ins>&gt;&amp; s,
+@@ -37336,11 +37515,11 @@ template &lt;class traits, class charT, class ST, class SA&gt;
+ regex_constants::match_default);
+ </ins></pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Constructs an empty string <tt>result</tt> of type <tt>basic_string&lt;charT<ins>,
+ ST, SA</ins>&gt;</tt>, calls <tt>regex_replace(back_inserter(result), s.begin(), s.end(),
+ e, fmt, flags)</tt>, and then returns <tt>result</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -37349,7 +37528,8 @@ e, fmt, flags)</tt>, and then returns <tt>result</tt>.
+ At the end of 28.11.4 [re.alg.replace] add the following new prototype description:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ template &lt;class traits, class charT, class ST, class SA&gt;
+ basic_string&lt;charT&gt;
+ regex_replace(const charT* s,
+@@ -37369,14 +37549,14 @@ template &lt;class traits, class charT&gt;
+ regex_constants::match_default);
+ </ins></pre>
+
+-<blockquote>
++<blockquote><p>
+ <ins>
+ <i>Effects:</i> Constructs an empty string <tt>result</tt> of type <tt>basic_string&lt;charT&gt;</tt>,
+ calls <tt>regex_replace(back_inserter(result), s, s +
+ char_traits&lt;charT&gt;::length(s),
+ e, fmt, flags)</tt>, and then returns <tt>result</tt>.
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -37389,11 +37569,11 @@ e, fmt, flags)</tt>, and then returns <tt>result</tt>.
+
+
+ <hr>
+-<h3><a name="728"></a>728. Problem in [rand.eng.mers]/6</h3>
+-<p><b>Section:</b> 26.5.3.2 [rand.eng.mers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="728"></a>728. Problem in [rand.eng.mers]&#47;6</h3>
++<p><b>Section:</b> 26.5.3.2 [rand.eng.mers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>mersenne_twister_engine</tt> is required to use a seeding method that is given
+@@ -37409,7 +37589,7 @@ Matsumoto have chosen a dif ferent multiplier for their 64 bit Mersenne Twister
+ I see two possible resolutions:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>Restrict the parameter <tt>W</tt> of the <tt>mersenne_twister_template</tt> to values of 32 or 64 and use the
+ multiplier from [the above reference] for the 64-bit case (my preference)</li>
+ <li>Interpret the state array for any <tt>W</tt> as a 32-bit array of appropriate length (and a specified byte
+@@ -37455,7 +37635,7 @@ Stephan Tolksdorf adds pre-Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I support the proposed resolution in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2424.pdf">N2424</a>,
+ but there is a typo in the
+@@ -37464,28 +37644,105 @@ required behaviour for <tt>mt19937_64</tt>: It should be the 10000<sup>th</sup>
+ 9981545732273789042 (not 14002232017267485025). The change to para. 8
+ proposed by Charles Karney should also be included in the proposed
+ wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Note the main part of the issue is resolved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2424.pdf">N2424</a>.
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="732"></a>732. Defect in [rand.dist.samp.genpdf]</h3>
++<p><b>Section:</b> X [rand.dist.samp.genpdf] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.genpdf">issues</a> in [rand.dist.samp.genpdf].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#795">795</a></p>
++<p><b>Discussion:</b></p>
++<p>
++X [rand.dist.samp.genpdf] describes the interface for a distribution template that is
++meant to simulate random numbers from any general distribution given only the density and the
++support of the distribution. I'm not aware of any general purpose algorithm that would be capable
++of correctly and efficiently implementing the described functionality. From what I know, this is
++essentially an unsolved research problem. Existing algorithms either require more knowledge
++about the distribution and the problem domain or work only under very limited circumstances.
++Even the state of the art special purpose library UNU.RAN does not solve the problem in full
++generality, and in any case, testing and customer support for such a library feature would be a
++nightmare.
++</p>
++
++<p>
++<b>Possible resolution:</b> For these reasons, I propose to delete section X [rand.dist.samp.genpdf].
++</p>
++
++<p><i>[
++Bellevue:
++]</i></p>
++
++
++<blockquote>
++<p>
++Disagreement persists.
++</p>
++<p>
++Objection to this issue is that this function takes a general functor.
++The general approach would be to normalize this function, integrate it,
++and take the inverse of the integral, which is not possible in general.
++An example function is sin(1+n*x) &mdash; for any spatial frequency that the
++implementor chooses, there is a value of n that renders that choice
++arbitrarily erroneous.
++</p>
++<p>
++Correction: The formula above should instead read 1+sin(n*x).
++</p>
++<p>
++Objector proposes the following possible compromise positions:
++</p>
++<ul>
++<li>
++rand.dist.samp.genpdf takes an number of points so that implementor need not guess.
++</li>
++<li>
++replace rand.disk.samp.genpdf with an extension to either or both of the discrete
++functions to take arguments that take a functor and number of points in place of
++the list of probabilities. Reference issues 793 and 794.
++</li>
++</ul>
+ </blockquote>
+
+
+
++<p><b>Proposed resolution:</b></p>
++<p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2813.pdf">N2813</a>
++for the proposed resolution.
++</p>
++
++
++<p><b>Rationale:</b></p><p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>
++"Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
++
+
+
+
+ <hr>
+ <h3><a name="734"></a>734. Unnecessary restriction in [rand.dist.norm.chisq]</h3>
+-<p><b>Section:</b> 26.5.8.4.3 [rand.dist.norm.chisq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.8.5.3 [rand.dist.norm.chisq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2007-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>chi_squared_distribution</tt>, <tt>fisher_f_distribution</tt> and <tt>student_t_distribution</tt>
+@@ -37493,9 +37750,8 @@ have parameters for the "degrees of freedom" <tt>n</tt> and <tt>m</tt> that are
+ following two reasons this is an unnecessary restriction: First, in many applications such as
+ Bayesian inference or Monte Carlo simulations it is more convenient to treat the respective param-
+ eters as continuous variables. Second, the standard non-naive algorithms (i.e.
+-O(1) algorithms)
+-for simulating from these distributions work with floating-point parameters anyway (all three
+-distributions could be easily implemented using the Gamma distribution, for instance).
++O(1) algorithms) for simulating from these distributions work with floating-point parameters anyway (all
++three distributions could be easily implemented using the Gamma distribution, for instance).
+ </p>
+
+ <p>
+@@ -37517,10 +37773,10 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ In N2424. Not wildly enthusiastic, not really felt necessary. Less
+ frequently used in practice. Not terribly bad either. Move to OPEN.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+@@ -37557,7 +37813,7 @@ Stephan Tolksdorf adds pre-Bellevue:
+
+ <blockquote>
+ <p>
+-In 26.5.8.4.3 [rand.dist.norm.chisq]:
++In 26.5.8.5.3 [rand.dist.norm.chisq]:
+ </p>
+
+ <blockquote>
+@@ -37577,7 +37833,7 @@ Replace both occurrences of "<tt>int n() const;</tt>" with "<tt>RealType n() con
+ </blockquote>
+
+ <p>
+-In 26.5.8.4.5 [rand.dist.norm.f]:
++In 26.5.8.5.5 [rand.dist.norm.f]:
+ </p>
+ <blockquote>
+ <p>
+@@ -37587,12 +37843,14 @@ Delete ", where <tt>m</tt> and <tt>n</tt> are positive integers" in the first pa
+ <p>
+ Replace both occurrences of
+ </p>
+-<blockquote><pre>explicit fisher_f_distribution(int m = 1, int n = 1);
++<blockquote><pre>
++explicit fisher_f_distribution(int m = 1, int n = 1);
+ </pre></blockquote>
+ <p>
+ with
+ </p>
+-<blockquote><pre>explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
++<blockquote><pre>
++explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
+ </pre></blockquote>
+
+ <p>
+@@ -37605,7 +37863,7 @@ Replace both occurrences of "<tt>int n() const;" with "RealType n() const;</tt>"
+ </blockquote>
+
+ <p>
+-In 26.5.8.4.6 [rand.dist.norm.t]:
++In 26.5.8.5.6 [rand.dist.norm.t]:
+ </p>
+
+ <blockquote>
+@@ -37631,9 +37889,10 @@ Replace both occurrences of "<tt>int n() const;</tt>" with "<tt>RealType n() con
+
+ <hr>
+ <h3><a name="740"></a>740. Please remove <tt>*_ptr&lt;T[N]&gt;</tt></h3>
+-<p><b>Section:</b> X [unique.ptr.compiletime] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2007-10-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.1 [unique.ptr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2007-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr">issues</a> in [unique.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Please don't provide <tt>*_ptr&lt;T[N]&gt;</tt>. It doesn't enable any useful
+@@ -37694,10 +37953,11 @@ straw poll unanimous move to Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis under 20.9.9 [unique.ptr] p2:
++Change the synopsis under 20.8.1 [unique.ptr] p2:
+ </p>
+
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ template&lt;class T&gt; struct default_delete;
+ template&lt;class T&gt; struct default_delete&lt;T[]&gt;;
+ <del>template&lt;class T, size_t N&gt; struct default_delete&lt;T[N]&gt;;</del>
+@@ -37713,7 +37973,7 @@ Remove the entire section [unique.ptr.dltr.dflt2] <b><tt>default_delete&lt;T[N]
+ </p>
+
+ <p>
+-Remove the entire section X [unique.ptr.compiletime] <b><tt>unique_ptr</tt> for array objects with a compile time length</b>
++Remove the entire section [unique.ptr.compiletime] <b><tt>unique_ptr</tt> for array objects with a compile time length</b>
+ and its subsections: [unique.ptr.compiletime.dtor], [unique.ptr.compiletime.observers],
+ [unique.ptr.compiletime.modifiers].
+ </p>
+@@ -37725,13 +37985,13 @@ and its subsections: [unique.ptr.compiletime.dtor], [unique.ptr.compiletime.ob
+
+ <hr>
+ <h3><a name="742"></a>742. Enabling <tt>swap</tt> for proxy iterators</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-This issue was split from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a>. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#672">672</a> now just
++This issue was split from <a href="lwg-defects.html#672">672</a>. <a href="lwg-defects.html#672">672</a> now just
+ deals with changing the requirements of <tt>T</tt> in the <tt>Swappable</tt>
+ requirement from <tt>CopyConstructible</tt> and <tt>CopyAssignable</tt> to
+ <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt>.
+@@ -37742,7 +38002,8 @@ This issue seeks to widen the <tt>Swappable</tt> requirement to support proxy it
+ is example code:
+ </p>
+
+-<blockquote><pre>namespace Mine {
++<blockquote><pre>
++namespace Mine {
+
+ template &lt;class T&gt;
+ struct proxy {...};
+@@ -37832,29 +38093,29 @@ satisfies the semantics of swapping?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as Open. Dave to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-08 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Updated wording to sync with
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>.
+-Also this issue is very closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>.
+-</blockquote>
++Also this issue is very closely related to <a href="lwg-defects.html#594">594</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -37866,7 +38127,7 @@ Solved by N3048.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.2.1 [utility.arg.requirements]:
++Change 17.6.3.1 [utility.arg.requirements]:
+ </p>
+
+ <blockquote>
+@@ -37884,7 +38145,7 @@ rvalue of type <tt>T</tt><ins>; <tt>w</tt> is a value of type <tt>T</tt>; and <t
+
+ <table border="1">
+ <caption>Table 37: <tt>Swappable</tt> requirements <b>[swappable]</b></caption>
+-<tbody><tr><th>expression</th><th>Return type</th><th>Post-condition</th></tr>
++<tr><th>expression</th><th>Return type</th><th>Post-condition</th></tr>
+ <tr><td><tt>swap(<del>s</del><ins>w</ins>,<del>t</del><ins>v</ins>)</tt></td><td><tt>void</tt></td>
+ <td><del><tt>t</tt></del><ins><tt>w</tt></ins> has the value originally
+ held by <del><tt>u</tt></del><ins><tt>v</tt></ins>, and
+@@ -37916,7 +38177,7 @@ element type is <tt>Swappable</tt>.
+ </li>
+ </ul>
+ </td></tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -37927,10 +38188,10 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2758.pdf">N2758</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -37939,12 +38200,12 @@ Solved by
+
+ <hr>
+ <h3><a name="743"></a>743. rvalue <tt>swap</tt> for <tt>shared_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.9 [util.smartptr.shared.spec] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.8 [util.smartptr.shared.spec] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-When the LWG looked at <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#674">674</a> in Kona the following note was made:
++When the LWG looked at <a href="lwg-defects.html#674">674</a> in Kona the following note was made:
+ </p>
+
+ <blockquote><p>
+@@ -37981,10 +38242,11 @@ Adopt issue as written.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in 20.9.10.2 [util.smartptr.shared]:
++Change the synopsis in 20.8.2.2 [util.smartptr.shared]:
+ </p>
+
+-<blockquote><pre>void swap(shared_ptr&amp;<ins>&amp;</ins> r);
++<blockquote><pre>
++void swap(shared_ptr&amp;<ins>&amp;</ins> r);
+ ...
+ template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+ <ins>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+@@ -37992,17 +38254,19 @@ template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.10.2.4 [util.smartptr.shared.mod]:
++Change 20.8.2.2.4 [util.smartptr.shared.mod]:
+ </p>
+
+-<blockquote><pre>void swap(shared_ptr&amp;<ins>&amp;</ins> r);
++<blockquote><pre>
++void swap(shared_ptr&amp;<ins>&amp;</ins> r);
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.10.2.9 [util.smartptr.shared.spec]:
++Change 20.8.2.2.8 [util.smartptr.shared.spec]:
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b);
++<blockquote><pre>
++template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+ <ins>template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp;&amp; a, shared_ptr&lt;T&gt;&amp; b);
+ template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp;&amp; b);</ins>
+ </pre></blockquote>
+@@ -38012,17 +38276,16 @@ template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt
+
+
+ <hr>
+-<h3><a name="744"></a>744. What is the lifetime of an exception pointed to by an exception_ptr?</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="744"></a>744. What is the lifetime of an exception pointed to by an <tt>exception_ptr</tt>?</h3>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Without some lifetime guarantee, it is hard to know how this type can be
+ used. Very specifically, I don't see how the current wording would
+-guarantee and exception_ptr caught at the end of one thread could be safely
++guarantee and <tt>exception_ptr</tt> caught at the end of one thread could be safely
+ stored and rethrown in another thread - the original motivation for this
+ API.
+ </p>
+@@ -38062,7 +38325,7 @@ Move to Open.
+ Change 18.8.5 [propagation]/7:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -7- Returns: An <tt>exception_ptr</tt> object that refers to the currently
+ handled exception or a copy of the currently handled exception, or a
+ null <tt>exception_ptr</tt> object if no exception is being handled.
+@@ -38074,19 +38337,18 @@ fails, it returns an <tt>exception_ptr</tt> object that refers to an instance of
+ calls to <tt>current_exception</tt> refer to the same exception object. [<i>Note:</i>
+ that is, it is unspecified whether <tt>current_exception</tt> creates a new copy
+ each time it is called. <i>--end note</i>]
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="746"></a>746. current_exception may fail with bad_alloc</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="746"></a>746. <tt>current_exception</tt> may fail with <tt>bad_alloc</tt></h3>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I understand that the attempt to copy an exception may run out of memory,
+@@ -38138,25 +38400,26 @@ Accept the broad view and move to ready
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following exemption clause to 17.6.4.12 [res.on.exception.handling]:
++Add the following exemption clause to 17.6.5.12 [res.on.exception.handling]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A function may throw a type not listed in its <i>Throws</i> clause so long as it is
+ derived from a class named in the <i>Throws</i> clause, and would be caught by an
+ exception handler for the base type.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="749"></a>749. Currently <tt>has_nothrow_copy_constructor&lt;T&gt;::value</tt> is true if T has 'a' nothrow copy constructor.</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="749"></a>749. Currently <tt>has_nothrow_copy_constructor&lt;T&gt;::value</tt> is true if <tt>T</tt> has 'a' nothrow copy constructor.</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2007-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Unfortunately a class can have multiple copy constructors, and I believe to
+@@ -38167,7 +38430,8 @@ no-throw.
+ For instance:
+ </p>
+ <blockquote>
+-<pre>struct awkward {
++<pre>
++struct awkward {
+ awkward( const awkward &amp; ) throw() {}
+ awkward( awkward &amp; ) { throw "oops"; } };
+ </pre>
+@@ -38176,44 +38440,44 @@ For instance:
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.7.4.3 [meta.unary.prop]:
++Change 20.10.4.3 [meta.unary.prop]:
+ </p>
+
+ <blockquote>
+ <pre>has_trivial_copy_constructor</pre>
+-<blockquote>
++<blockquote><p>
+ <tt>T</tt> is a trivial type (3.9) or a reference type or a class type <del>with a trivial copy constructor</del>
+ <ins>where all copy constructors are trivial</ins> (12.8).
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <blockquote>
+ <pre>has_trivial_assign</pre>
+-<blockquote>
++<blockquote><p>
+ <tt>T</tt> is neither <tt>const</tt> nor a reference type, and <tt>T</tt> is a trivial type (3.9)
+ or a class type <del>with a trivial copy assignment operator</del> <ins>where all copy assignment operators are trivial</ins> (12.8).
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <blockquote>
+ <pre>has_nothrow_copy_constructor</pre>
+-<blockquote>
++<blockquote><p>
+ <tt>has_trivial_copy_constructor&lt;T&gt;::value</tt> is <tt>true</tt> or <tt>T</tt> is a class type <del>with
+ a</del> <ins>where all</ins> copy constructor<ins>s</ins> <del>that is</del> <ins>are</ins>
+ known not to throw any exceptions or <tt>T</tt> is an
+ array of such a class type
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <blockquote>
+ <pre>has_nothrow_assign</pre>
+-<blockquote>
++<blockquote><p>
+ <tt>T</tt> is neither <tt>const</tt> nor a reference type, and
+ <tt>has_trivial_assign&lt;T&gt;::value</tt> is <tt>true</tt> or <tt>T</tt> is a class type <del>with a</del>
+ <ins>where all</ins> copy
+ assignment operator<ins>s</ins> tak<ins>e</ins><del>ing</del> an lvalue of type <tt>T</tt> that is known not to
+ throw any exceptions or <tt>T</tt> is an array of such a class type.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -38223,13 +38487,14 @@ throw any exceptions or <tt>T</tt> is an array of such a class type.
+
+ <hr>
+ <h3><a name="752"></a>752. Allocator complexity requirement</h3>
+-<p><b>Section:</b> 20.2.5 [allocator.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2007-10-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2007-10-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Did LWG recently discuss 20.2.5 [allocator.requirements]-2, which states that "All the operations
++Did LWG recently discuss 17.6.3.5 [allocator.requirements]-2, which states that "All the operations
+ on the allocators are expected to be amortized constant time."?
+ </p>
+ <p>
+@@ -38252,7 +38517,7 @@ the constants, not the asymptotic complexity.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.2.5 [allocator.requirements]/2:
++Change 17.6.3.5 [allocator.requirements]/2:
+ </p>
+
+ <blockquote>
+@@ -38270,10 +38535,10 @@ requirements on allocator types.
+
+ <hr>
+ <h3><a name="753"></a>753. Move constructor in draft</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Yechezkel Mett <b>Opened:</b> 2007-10-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Yechezkel Mett <b>Opened:</b> 2007-10-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The draft standard n2369 uses the term <i>move constructor</i> in a few
+@@ -38281,24 +38546,24 @@ places, but doesn't seem to define it.
+ </p>
+
+ <p>
+-<tt>MoveConstructible</tt> requirements are defined in Table 33 in 20.2.1 [utility.arg.requirements] as
++<tt>MoveConstructible</tt> requirements are defined in Table 33 in 17.6.3.1 [utility.arg.requirements] as
+ follows:
+ </p>
+
+ <blockquote>
+ <table border="1">
+ <caption><tt>MoveConstructible</tt> requirements</caption>
+-<tbody><tr>
++<tr>
+ <th>expression</th> <th>post-condition</th>
+ </tr>
+ <tr>
+ <td><tt>T t = rv</tt></td> <td><tt>t</tt> is equivalent to the value of <tt>rv</tt> before the construction</td>
+ </tr>
+ <tr>
+-<td colspan="2">[<i>Note:</i> There is no requirement on the value of <tt>rv</tt> after the
++<td colspan="2">[<i>Note:</i> There is no requirement on the value of <tt>rv</tt> after the
+ construction. <i>-- end note</i>]</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -38312,13 +38577,13 @@ in filling the above requirement.
+
+ <p>
+ For <tt>vector::reserve</tt>, <tt>vector::resize</tt> and the <tt>vector</tt> modifiers given in
+-23.4.1.4 [vector.modifiers] we have
++23.3.6.5 [vector.modifiers] we have
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> If <tt>value_type</tt> has a move constructor, that constructor shall
+ not throw any exceptions.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Firstly "If <tt>value_type</tt> has a move constructor" is superfluous; every
+@@ -38384,11 +38649,12 @@ Howard adds post-Bellevue:
+
+ <blockquote>
+ <p>
+-Unfortunately I believe the wording recommended by the LWG in Bellevue is incorrect. <tt>reserve</tt> et. al. will use a move constructor
+-if one is available, else it will use a copy constructor. A type may have both. If the move constructor is
+-used, it must not throw. If the copy constructor is used, it can throw. The sentence in the proposed wording
+-is correct without the recommended insertion. The Bellevue LWG recommended moving this issue to Ready. I am
+-unfortunately pulling it back to Open. But I'm drafting wording to atone for this egregious action. :-)
++Unfortunately I believe the wording recommended by the LWG in Bellevue is incorrect. <tt>reserve</tt> et. al.
++will use a move constructor if one is available, else it will use a copy constructor. A type may have both.
++If the move constructor is used, it must not throw. If the copy constructor is used, it can throw. The
++sentence in the proposed wording is correct without the recommended insertion. The Bellevue LWG recommended
++moving this issue to Ready. I am unfortunately pulling it back to Open. But I'm drafting wording to atone
++for this egregious action. :-)
+ </p>
+ </blockquote>
+
+@@ -38399,28 +38665,32 @@ unfortunately pulling it back to Open. But I'm drafting wording to atone for th
+
+ <hr>
+ <h3><a name="755"></a>755. <tt>std::vector</tt> and <tt>std:string</tt> lack explicit shrink-to-fit operations</h3>
+-<p><b>Section:</b> 23.4.1.2 [vector.capacity], 21.4.4 [string.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity], 21.4.4 [string.capacity] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A <tt>std::vector</tt> can be shrunk-to-fit via the swap idiom:
+ </p>
+
+-<blockquote><pre>vector&lt;int&gt; v;
++<blockquote><pre>
++vector&lt;int&gt; v;
+ ...
+ v.swap(vector&lt;int&gt;(v)); // shrink to fit
+ </pre>
+ <blockquote><p>
+ or:
+ </p></blockquote>
+-<pre>vector&lt;int&gt;(v).swap(v); // shrink to fit
++<pre>
++vector&lt;int&gt;(v).swap(v); // shrink to fit
+ </pre>
+ <blockquote><p>
+ or:
+ </p></blockquote>
+-<pre>swap(v, vector&lt;int&gt;(v)); // shrink to fit
++<pre>
++swap(v, vector&lt;int&gt;(v)); // shrink to fit
+ </pre>
+ </blockquote>
+
+@@ -38428,7 +38698,8 @@ or:
+ A non-binding request for shrink-to-fit can be made to a <tt>std::string</tt> via:
+ </p>
+
+-<blockquote><pre>string s;
++<blockquote><pre>
++string s;
+ ...
+ s.reserve(0);
+ </pre></blockquote>
+@@ -38454,8 +38725,8 @@ takes no arguments to keep the solution simple and focused.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ To Class template basic_string 21.4 [basic.string] synopsis,
+-Class template vector 23.4.1 [vector] synopsis, and Class
+-vector&lt;bool&gt; 23.4.2 [vector.bool] synopsis, add:
++Class template vector 23.3.6 [vector] synopsis, and Class
++vector&lt;bool&gt; 23.3.7 [vector.bool] synopsis, add:
+ </p>
+
+ <blockquote><pre>
+@@ -38464,22 +38735,23 @@ void shrink_to_fit();
+
+ <p>
+ To basic_string capacity 21.4.4 [string.capacity] and vector
+-capacity 23.4.1.2 [vector.capacity], add:
++capacity 23.3.6.3 [vector.capacity], add:
+ </p>
+
+ <blockquote>
+-<pre>void shrink_to_fit();
++<pre>
++void shrink_to_fit();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Remarks:</i> <tt>shrink_to_fit</tt> is a non-binding request to reduce
+ <tt>capacity()</tt> to <tt>size()</tt>. [<i>Note:</i> The request is non-binding to
+ allow latitude for implementation-specific optimizations.
+-<i>-- end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#850">850</a> has been added to deal with this issue with respect to <tt>deque</tt>.
++<a href="lwg-defects.html#850">850</a> has been added to deal with this issue with respect to <tt>deque</tt>.
+ ]</i></p>
+
+
+@@ -38488,17 +38760,124 @@ allow latitude for implementation-specific optimizations.
+
+
+ <hr>
++<h3><a name="756"></a>756. Container adaptors push</h3>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++After n2369 we have a single <tt>push_back</tt> overload in the sequence containers,
++of the "emplace" type. At variance with that, still in n2461, we have
++two separate overloads, the C++03 one + one taking an rvalue reference
++in the container adaptors. Therefore, simply from a consistency point of
++view, I was wondering whether the container adaptors should be aligned
++with the specifications of the sequence container themselves: thus have
++a single <tt>push</tt> along the lines:
++</p>
++
++<blockquote><pre>
++template&lt;typename... _Args&gt;
++void
++push(_Args&amp;&amp;... __args)
++ { c.push_back(std::forward&lt;_Args&gt;(__args)...); }
++</pre></blockquote>
++
++<p><i>[
++Related to <a href="lwg-defects.html#767">767</a>
++]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 23.6.3.1 [queue.defn]:
++</p>
++
++<blockquote><pre>
++<del>void push(const value_type&amp; x) { c.push_back(x); }</del>
++<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
++<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
++</pre></blockquote>
++
++<p>
++Change 23.6.4 [priority.queue]:
++</p>
++
++<blockquote><pre>
++<del>void push(const value_type&amp; x) { c.push_back(x); }</del>
++<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
++<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
++</pre></blockquote>
++
++<p>
++Change 23.6.4.3 [priqueue.members]:
++</p>
++
++<blockquote>
++<pre>
++<del>void push(const value_type&amp; x);</del>
++</pre>
++<blockquote>
++<p>
++<del><i>Effects:</i></del>
++</p>
++<blockquote><pre>
++<del>c.push_back(x);</del>
++<del>push_heap(c.begin(), c.end(), comp);</del>
++</pre></blockquote>
++</blockquote>
++
++<pre>
++<ins>template&lt;class... Args&gt;</ins> void push(<del>value_type</del> <ins>Args</ins>&amp;&amp;<ins>...</ins> <del>x</del> <ins>args</ins>);
++</pre>
++<blockquote>
++<p>
++<i>Effects:</i>
++</p>
++<blockquote><pre>
++c.push_back(std::<del>move</del><ins>forward&lt;Args&gt;</ins>(<del>x</del> <ins>args</ins>)<ins>...</ins>);
++push_heap(c.begin(), c.end(), comp);
++</pre></blockquote>
++</blockquote>
++</blockquote>
++
++<p>
++Change 23.6.5.2 [stack.defn]:
++</p>
++
++<blockquote><pre>
++<del>void push(const value_type&amp; x) { c.push_back(x); }</del>
++<del>void push(value_type&amp;&amp; x) { c.push_back(std::move(x)); }</del>
++<ins>template&lt;class... Args&gt; void push(Args&amp;&amp;... args) { c.push_back(std::forward&lt;Args&gt;(args)...); }</ins>
++</pre></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680 Proposed Wording for Placement Insert (Revision 1)</a>.
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="758"></a>758. <tt>shared_ptr</tt> and <tt>nullptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Consider the following program:
+ </p>
+
+-<blockquote><pre>int main() {
++<blockquote><pre>
++int main() {
+ shared_ptr&lt;int&gt; p(nullptr);
+ return 0;
+ }
+@@ -38509,7 +38888,8 @@ This program will fail to compile because <tt>shared_ptr</tt> uses the following
+ template constructor to construct itself from pointers:
+ </p>
+
+-<blockquote><pre>template &lt;class Y&gt; shared_ptr(Y *);
++<blockquote><pre>
++template &lt;class Y&gt; shared_ptr(Y *);
+ </pre></blockquote>
+
+ <p>
+@@ -38519,7 +38899,8 @@ the conversion from <tt>nullptr_t</tt> to <tt>Y *</tt> is not
+ deducible, so the above constructor will not be found. There are similar problems with the
+ constructors that take a pointer and a <tt>deleter</tt> or a
+ pointer, a <tt>deleter</tt> and an allocator, as well as the
+-corresponding forms of <tt>reset()</tt>. Note that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2435.htm">N2435</a>
++corresponding forms of <tt>reset()</tt>. Note that <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2435.htm">N2435</a>
+ will solve this problem for constructing from just <tt>nullptr</tt>, but not for constructors that use
+ <tt>deleters</tt> or allocators or for <tt>reset()</tt>.
+ </p>
+@@ -38587,17 +38968,19 @@ The following wording changes are less intrusive:
+ </p>
+
+ <p>
+-In 20.9.10.2.1 [util.smartptr.shared.const], add:
++In 20.8.2.2.1 [util.smartptr.shared.const], add:
+ </p>
+
+-<blockquote><pre>shared_ptr(nullptr_t);
++<blockquote><pre>
++shared_ptr(nullptr_t);
+ </pre></blockquote>
+
+ <p>
+ after:
+ </p>
+
+-<blockquote><pre>shared_ptr();
++<blockquote><pre>
++shared_ptr();
+ </pre></blockquote>
+
+ <p>
+@@ -38616,7 +38999,8 @@ extended to take <tt>nullptr</tt>, but if they need to:
+ Add
+ </p>
+
+-<blockquote><pre>template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
++<blockquote><pre>
++template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
+ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ </pre></blockquote>
+
+@@ -38624,7 +39008,8 @@ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ after
+ </p>
+
+-<blockquote><pre>template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
++<blockquote><pre>
++template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
+ template&lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);
+ </pre></blockquote>
+
+@@ -38666,11 +39051,12 @@ Disposition: move to review. The review should check the wording in the then-cur
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.9.10.2 [util.smartptr.shared] p4, add to the definition/synopsis
++In 20.8.2.2 [util.smartptr.shared] p4, add to the definition/synopsis
+ of <tt>shared_ptr</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
++<blockquote><pre>
++template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
+ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ </pre></blockquote>
+
+@@ -38678,15 +39064,17 @@ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ after
+ </p>
+
+-<blockquote><pre>template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
++<blockquote><pre>
++template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
+ template&lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);
+ </pre></blockquote>
+
+ <p>
+-In 20.9.10.2.1 [util.smartptr.shared.const] add:
++In 20.8.2.2.1 [util.smartptr.shared.const] add:
+ </p>
+
+-<blockquote><pre>template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
++<blockquote><pre>
++template&lt;class D&gt; shared_ptr(nullptr_t p, D d);
+ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ </pre></blockquote>
+
+@@ -38694,23 +39082,24 @@ template&lt;class D, class A&gt; shared_ptr(nullptr_t p, D d, A a);
+ after
+ </p>
+
+-<blockquote><pre>template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
++<blockquote><pre>
++template&lt;class Y, class D&gt; shared_ptr(Y* p, D d);
+ template&lt;class Y, class D, class A&gt; shared_ptr(Y* p, D d, A a);
+ </pre></blockquote>
+
+ <p>
+-(reusing the following paragraphs 20.9.10.2.1 [util.smartptr.shared.const]/9-13 that speak of p.)
++(reusing the following paragraphs 20.8.2.2.1 [util.smartptr.shared.const]/9-13 that speak of p.)
+ </p>
+
+ <p>
+-In 20.9.10.2.1 [util.smartptr.shared.const]/10, change
++In 20.8.2.2.1 [util.smartptr.shared.const]/10, change
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Constructs a <tt>shared_ptr</tt> object that <i>owns</i> the
+ <del>pointer</del> <ins>object</ins> <tt>p</tt> and the deleter <tt>d</tt>. The second
+ constructor shall use a copy of <tt>a</tt> to allocate memory for internal use.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Rationale:</b></p>
+@@ -38719,9 +39108,9 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
+-"pointer" is changed to "object" to handle the fact that nullptr_t isn't a pointer.
+-</blockquote>
++<blockquote><p>
++"pointer" is changed to "object" to handle the fact that <tt>nullptr_t</tt> isn't a pointer.
++</p></blockquote>
+
+
+
+@@ -38730,19 +39119,20 @@ San Francisco:
+
+ <hr>
+ <h3><a name="759"></a>759. A reference is not an object</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2007-11-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2007-11-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 23.2 [container.requirements] says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -12- Objects passed to member functions of a container as rvalue references shall not be elements of that container. No
+ diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ A reference is not an object, but this sentence appears to claim so.
+@@ -38751,11 +39141,11 @@ A reference is not an object, but this sentence appears to claim so.
+ <p>
+ What is probably meant here:
+ </p>
+-<blockquote>
++<blockquote><p>
+ An object bound to an rvalue
+ reference parameter of a member function of a container shall not be
+ an element of that container; no diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -38764,14 +39154,14 @@ an element of that container; no diagnostic required.
+ Change 23.2 [container.requirements]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -12- <del>Objects passed to member functions of a container as rvalue references shall not be elements</del>
+ <ins>An object bound to an rvalue
+ reference parameter of a member function of a container shall not be
+ an element</ins>
+ of that container<del>.</del><ins>;</ins> <del>N</del><ins>n</ins>o
+ diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -38780,9 +39170,9 @@ diagnostic required.
+
+ <hr>
+ <h3><a name="761"></a>761. <tt>unordered_map</tt> needs an <tt>at()</tt> member function</h3>
+-<p><b>Section:</b> 23.7.1.2 [unord.map.elem] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-11-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.5.4.3 [unord.map.elem] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2007-11-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The new member function <tt>at()</tt> was recently added to <tt>std::map()</tt>. It acts
+@@ -38797,19 +39187,21 @@ in <tt>std::unordered_map</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following functions to the definition of <tt>unordered_map</tt> under "lookup" (23.7.1 [unord.map]):
++Add the following functions to the definition of <tt>unordered_map</tt> under "lookup" (23.5.4 [unord.map]):
+ </p>
+
+-<blockquote><pre>mapped_type&amp; at(const key_type&amp; k);
++<blockquote><pre>
++mapped_type&amp; at(const key_type&amp; k);
+ const mapped_type &amp;at(const key_type &amp;k) const;
+ </pre></blockquote>
+
+ <p>
+-Add the following definitions to 23.7.1.2 [unord.map.elem]:
++Add the following definitions to 23.5.4.3 [unord.map.elem]:
+ </p>
+
+ <blockquote>
+-<pre>mapped_type&amp; at(const key_type&amp; k);
++<pre>
++mapped_type&amp; at(const key_type&amp; k);
+ const mapped_type &amp;at(const key_type &amp;k) const;
+ </pre>
+ <blockquote>
+@@ -38836,20 +39228,19 @@ Bellevue: Editorial note: the "(unique)" differs from map.
+
+ <hr>
+ <h3><a name="762"></a>762. <tt>std::unique_ptr</tt> requires complete type?</h3>
+-<p><b>Section:</b> 20.9.9 [unique.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-11-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr">issues</a> in [unique.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.1 [unique.ptr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr">issues</a> in [unique.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In contrast to the proposed <tt>std::shared_ptr</tt>, <tt>std::unique_ptr</tt>
+ does currently not support incomplete types, because it
+ gives no explicit grant - thus instantiating <tt>unique_ptr</tt> with
+ an incomplete pointee type <tt>T</tt> automatically belongs to
+-undefined behaviour according to 17.6.3.8 [res.on.functions]/2, last
++undefined behaviour according to 17.6.4.8 [res.on.functions]&#47;2, last
+ bullet. This is an unnecessary restriction and prevents
+-many well-established patterns - like the bridge pattern -
+-for <tt>std::unique_ptr</tt>.
++many well-established patterns - like the bridge pattern - for <tt>std::unique_ptr</tt>.
+ </p>
+
+ <p><i>[
+@@ -38857,7 +39248,7 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to open. The LWG is comfortable with the intent of allowing
+ incomplete types and making <tt>unique_ptr</tt> more like <tt>shared_ptr</tt>, but we are
+ not comfortable with the wording. The specification for <tt>unique_ptr</tt>
+@@ -38868,28 +39259,28 @@ we need the same level of care here. We also aren't comfortable with the
+ "part of the operational semantic" language; it's not used elsewhere in
+ the standard, and it's not clear what it means. We need a volunteer to
+ produce new wording.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ The proposed changes in the following revision refers to the current state of
+-N2521 including the assumption that X [unique.ptr.compiletime] will be removed
+-according to the current state of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#740">740</a>.
++N2521 including the assumption that [unique.ptr.compiletime] will be removed
++according to the current state of <a href="lwg-defects.html#740">740</a>.
+ </p>
+ <p>
+ The specialization <tt>unique_ptr&lt;T[]&gt;</tt> has some more restrictive constraints on
+ type-completeness on <tt>T</tt> than <tt>unique_ptr&lt;T&gt;</tt>. The following proposed wordings
+ try to cope with that. If the committee sees less usefulness on relaxed
+ constraints on <tt>unique_ptr&lt;T[]&gt;</tt>, the alternative would be to stop this relaxation
+-e.g. by adding one further bullet to 20.9.9.3 [unique.ptr.runtime]/1:
++e.g. by adding one further bullet to 20.8.1.3 [unique.ptr.runtime]&#47;1:
+ "<tt>T</tt> shall be a complete type, if used as template argument of
+ <tt>unique_ptr&lt;T[], D&gt;</tt>
+ </p>
+ <p>
+-This issue has some overlap with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a>, but it seems not to cause any
++This issue has some overlap with <a href="lwg-defects.html#673">673</a>, but it seems not to cause any
+ problems with this one,
+-because <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a> adds only optional requirements on <tt>D</tt> that do not conflict
++because <a href="lwg-defects.html#673">673</a> adds only optional requirements on <tt>D</tt> that do not conflict
+ with the here discussed
+ ones, provided that <tt>D::pointer</tt>'s operations (including default
+ construction, copy construction/assignment,
+@@ -38901,10 +39292,10 @@ current specification of <tt>unique_ptr</tt>.
+ <ol>
+ <li>
+ <p>
+-In 20.9.9 [unique.ptr]/2 add as the last sentence to the existing para:
++In 20.8.1 [unique.ptr]&#47;2 add as the last sentence to the existing para:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>unique_ptr</tt> provides a semantics of strict ownership. A
+ <tt>unique_ptr</tt> owns the object it holds a pointer to. A
+ <tt>unique_ptr</tt> is not <tt>CopyConstructible</tt>, nor
+@@ -38915,12 +39306,12 @@ uses of <tt>unique_ptr</tt> include providing exception safety for
+ dynamically allcoated memory, passing ownership of dynamically allocated
+ memory to a function, and returning dynamically allocated memory from a
+ function. -- <i>end note</i> ]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-20.9.9.2.1 [unique.ptr.single.ctor]/1: No changes necessary.
++20.8.1.2.1 [unique.ptr.single.ctor]&#47;1: No changes necessary.
+ </p>
+
+ <blockquote>
+@@ -38934,7 +39325,7 @@ The current wording says just this.
+
+ <li>
+ <p>
+-In 20.9.9.2.1 [unique.ptr.single.ctor]/5 change the requires clause to say:
++In 20.8.1.2.1 [unique.ptr.single.ctor]&#47;5 change the requires clause to say:
+ </p>
+
+ <blockquote>
+@@ -38971,7 +39362,7 @@ again requires Completeness of <tt>Y</tt>, if <tt>!SameType&lt;X, Y&gt;</tt>
+
+ <li>
+ <p>
+-Merge 20.9.9.2.1 [unique.ptr.single.ctor]/12+13 thereby removing the sentence
++Merge 20.8.1.2.1 [unique.ptr.single.ctor]&#47;12+13 thereby removing the sentence
+ of 12, but transferring the "requires" to 13:
+ </p>
+
+@@ -38990,12 +39381,12 @@ pointer and the <tt>D</tt> deleter are well-formed and well-defined.
+ </li>
+
+ <li>
+-20.9.9.2.1 [unique.ptr.single.ctor]/17: No changes necessary.
++20.8.1.2.1 [unique.ptr.single.ctor]&#47;17: No changes necessary.
+ </li>
+ <li>
+-<p>20.9.9.2.1 [unique.ptr.single.ctor]/21:</p>
++<p>20.8.1.2.1 [unique.ptr.single.ctor]&#47;21:</p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> If <tt>D</tt> is not a reference type, construction of
+ the deleter <tt>D</tt> from an rvalue of type <tt>E</tt> shall be well
+ formed and shall not throw an exception. If <tt>D</tt> is a reference
+@@ -39003,7 +39394,7 @@ type, then <tt>E</tt> shall be the same type as <tt>D</tt> (diagnostic
+ required). <tt>U*</tt> shall be implicitly convertible to <tt>T*</tt>.
+ <ins>[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt>
+ be complete types. <i>-- end note</i>]</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ N.B.: The current wording of 21 already implicitly guarantees that <tt>U</tt>
+@@ -39016,7 +39407,7 @@ e.g. "<tt>U</tt> shall be a complete type."
+
+ <li>
+ <p>
+-20.9.9.2.2 [unique.ptr.single.dtor]: Just before p1 add a new paragraph:
++20.8.1.2.2 [unique.ptr.single.dtor]: Just before p1 add a new paragraph:
+ </p>
+ <blockquote>
+ <p>
+@@ -39035,7 +39426,7 @@ type-completeness of <tt>T</tt> is delegated to this expression.
+
+ <li>
+ <p>
+-20.9.9.2.3 [unique.ptr.single.asgn]/1: No changes necessary, except the
++20.8.1.2.3 [unique.ptr.single.asgn]&#47;1: No changes necessary, except the
+ current editorial issue, that "must shall" has to be changed to
+ "shall", but this change is not a special part of this resolution.
+ </p>
+@@ -39049,16 +39440,16 @@ further requirements on the requirements of the effects clause
+
+ <li>
+ <p>
+-20.9.9.2.3 [unique.ptr.single.asgn]/6:
++20.8.1.2.3 [unique.ptr.single.asgn]&#47;6:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> Assignment of the deleter <tt>D</tt> from an rvalue
+ <tt>D</tt> shall not throw an exception. <tt>U*</tt> shall be implicitly
+ convertible to <tt>T*</tt>.
+ <ins>[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt>
+ be complete types. <i>-- end note</i>]</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ N.B.: The current wording of p. 6 already implicitly guarantees that
+@@ -39070,7 +39461,7 @@ is true, see (6)+(8).
+
+ <li>
+ <p>
+-20.9.9.2.3 [unique.ptr.single.asgn]/11: No changes necessary.
++20.8.1.2.3 [unique.ptr.single.asgn]&#47;11: No changes necessary.
+ </p>
+ <p><i>[
+ N.B.: Delegation to requirements of effects clause is sufficient.
+@@ -39079,37 +39470,39 @@ N.B.: Delegation to requirements of effects clause is sufficient.
+ </li>
+
+ <li>
+-20.9.9.2.4 [unique.ptr.single.observers]/1+4+7+9+11:
+-</li>
++<p>
++20.8.1.2.4 [unique.ptr.single.observers]&#47;1+4+7+9+11:
++</p>
+
+ <blockquote>
+ <pre>T* operator-&gt;() const;</pre>
+-<blockquote>
+-<ins><i>Note:</i> Use typically requires <tt>T</tt> shall be complete. <i>-- end note</i>]</ins>
+-</blockquote>
++<blockquote><p>
++<ins><i>Note:</i> Use typically requires <tt>T</tt> shall be complete. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
+ </blockquote>
++</li>
+
+ <li>
+-20.9.9.2.5 [unique.ptr.single.modifiers]/1: No changes necessary.
++20.8.1.2.5 [unique.ptr.single.modifiers]&#47;1: No changes necessary.
+ </li>
+
+ <li>
+ <p>
+-20.9.9.2.5 [unique.ptr.single.modifiers]/4: Just before p. 4 add a new paragraph:
++20.8.1.2.5 [unique.ptr.single.modifiers]&#47;4: Just before p. 4 add a new paragraph:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The expression <tt>get_deleter()(get())</tt> shall be well-formed,
+ shall have well-defined behavior, and shall not throw exceptions.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+-20.9.9.2.5 [unique.ptr.single.modifiers]/7: No changes necessary.
++20.8.1.2.5 [unique.ptr.single.modifiers]&#47;7: No changes necessary.
+ </li>
+
+ <li>
+ <p>
+-20.9.9.3 [unique.ptr.runtime]: Add one additional bullet on paragraph 1:
++20.8.1.3 [unique.ptr.runtime]: Add one additional bullet on paragraph 1:
+ </p>
+
+ <blockquote>
+@@ -39140,15 +39533,15 @@ post Bellevue: Daniel provided revised wording.
+
+
+ <hr>
+-<h3><a name="765"></a>765. more on iterator validity</h3>
+-<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-12-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="765"></a>765. More on iterator validity</h3>
++<p><b>Section:</b> X [iterator.concepts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2007-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.concepts">issues</a> in [iterator.concepts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a>
++Issue <a href="lwg-defects.html#278">278</a>
+ defines the meaning of the term "invalid iterator" as one that may be
+ singular.
+
+@@ -39158,7 +39551,8 @@ singular.
+ Consider the following code:
+
+ </p>
+- <pre> std::deque&lt;int&gt; x, y;
++ <pre>
++ std::deque&lt;int&gt; x, y;
+ std::deque&lt;int&gt;::iterator i = x.end(), j = y.end();
+ x.swap(y);
+ </pre>
+@@ -39176,7 +39570,8 @@ I.e., is the expression below required to evaluate
+ to <code>true</code>?
+
+ </p>
+- <pre> i == y.end() &amp;&amp; j == x.end()
++ <pre>
++ i == y.end() &amp;&amp; j == x.end()
+ </pre>
+ <p>
+
+@@ -39186,7 +39581,7 @@ returns <code>false</code>.)
+ </p>
+ <p>
+
+-More generally, is the definition introduced in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#278">278</a> meant to
++More generally, is the definition introduced in issue <a href="lwg-defects.html#278">278</a> meant to
+ make any guarantees about whether iterators actually point to the same
+ elements or be associated with the same containers after a
+ non-invalidating operation as they did before?
+@@ -39198,7 +39593,8 @@ Here's a motivating example intended to demonstrate the importance of
+ the question:
+
+ </p>
+- <pre> Container x, y ({ 1, 2}); // pseudocode to initialize y with { 1, 2 }
++ <pre>
++ Container x, y ({ 1, 2}); // pseudocode to initialize y with { 1, 2 }
+ Container::iterator i = y.begin() + 1;
+ Container::iterator j = y.end();
+ std::swap(x, y);
+@@ -39220,15 +39616,16 @@ San Francisco:
+
+ <blockquote>
+ <p>
+-Pablo: add a note to the last bullet of paragraph 11 of 23.1.1 clarifying that the end() iterator doesn't refer to an element and that it can therefore be invalidated.
++Pablo: add a note to the last bullet of paragraph 11 of 23.1.1 clarifying that
++the <tt>end()</tt> iterator doesn't refer to an element and that it can therefore be invalidated.
+ </p>
+ <p>
+ Proposed wording:
+ </p>
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> The <tt>end()</tt> iterator does not refer to any element and can
+ therefore be invalidated. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+ <p>
+ Howard will add this proposed wording to the issue and then move it to Review.
+ </p>
+@@ -39277,8 +39674,8 @@ additional requirements:
+ <li>
+ no <tt>swap()</tt> function invalidates any references, pointers, or
+ iterators referring to the elements of the containers being swapped.
+-<ins>[<i>Note:</i> The <tt>end()</tt> iterator does not refer to any element. It is therefore
+-subject to being invalidated. <i>-- end note</i>]</ins>
++<ins>[<i>Note:</i> The <tt>end()</tt> iterator does not refer to any element.
++It is therefore subject to being invalidated. &mdash; <i>end note</i>]</ins>
+ </li>
+ </ul>
+ </blockquote>
+@@ -39289,10 +39686,11 @@ subject to being invalidated. <i>-- end note</i>]</ins>
+
+ <hr>
+ <h3><a name="766"></a>766. Inconsistent exception guarantees between ordered and unordered associative containers</h3>
+-<p><b>Section:</b> 23.2 [container.requirements], 23.2.5.1 [unord.req.except] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Ion Gaztañaga <b>Opened:</b> 2007-12-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.2 [container.requirements], 23.2.5.1 [unord.req.except] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Ion Gazta&ntilde;aga <b>Opened:</b> 2007-12-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 23.2 [container.requirements]p10 states:
+@@ -39313,24 +39711,26 @@ additional requirements:
+ </blockquote>
+
+ <p>
+-23.3.2.3 [deque.modifiers] and 23.4.1.4 [vector.modifiers] offer
++23.3.3.4 [deque.modifiers] and 23.3.6.5 [vector.modifiers] offer
+ additional guarantees for <tt>deque</tt>/<tt>vector insert()</tt> and
+-<tt>erase()</tt> members. However, 23.2 [container.requirements]p10 does not mention 23.2.5.1 [unord.req.except] that specifies exception safety guarantees
+-for unordered containers. In addition, 23.2.5.1 [unord.req.except]p1 offers the following guaratee for
++<tt>erase()</tt> members. However, 23.2 [container.requirements] p10
++does not mention 23.2.5.1 [unord.req.except] that specifies exception
++safety guarantees for unordered containers. In addition,
++23.2.5.1 [unord.req.except] p1 offers the following guaratee for
+ <tt>erase()</tt>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ No <tt>erase()</tt> function throws an exception unless that exception
+ is thrown by the container's Hash or Pred object (if any).
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Summary:
+ </p>
+
+ <p>
+-According to 23.2 [container.requirements]p10 no
++According to 23.2 [container.requirements] p10 no
+ <tt>erase()</tt> function should throw an exception unless otherwise
+ specified. Although does not explicitly mention 23.2.5.1 [unord.req.except], this section offers additional guarantees
+ for unordered containers, allowing <tt>erase()</tt> to throw if
+@@ -39376,8 +39776,8 @@ exception or swallow it, leaving the object registered.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Create a new sub-section of 23.2.4 [associative.reqmts] (perhaps [associative.req.except]) titled "Exception
+-safety guarantees".
++Create a new sub-section of 23.2.4 [associative.reqmts] (perhaps
++[associative.req.except]) titled "Exception safety guarantees".
+ </p>
+
+ <blockquote>
+@@ -39404,27 +39804,27 @@ assignment operator of the container's Pred object (if any).
+ Change 23.2.5.1 [unord.req.except]p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For unordered associative containers, no <tt>clear()</tt> function
+ throws an exception. <del>No</del> <tt>erase(<ins>k</ins>)</tt>
+ <del>function</del> <ins>does not</ins> throw<del>s</del> an exception
+ unless that exception is thrown by the container's Hash or Pred object
+ (if any).
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.2 [container.requirements]p10 to add references to new sections:
++Change 23.2 [container.requirements] p10 to add references to new sections:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Unless otherwise specified (see [deque.modifiers]<ins>,</ins>
+ <del>and</del> [vector.modifiers]<ins>, [associative.req.except],
+ [unord.req.except]</ins>) all container types defined in this clause meet
+ the following additional requirements:
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.2 [container.requirements]p10 referring to <tt>swap</tt>:
++Change 23.2 [container.requirements] p10 referring to <tt>swap</tt>:
+ </p>
+
+ <blockquote>
+@@ -39443,11 +39843,282 @@ Compare object (if any; see [associative.reqmts])</del>.
+
+
+ <hr>
++<h3><a name="767"></a>767. Forwarding and backward compatibility</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Sylvain Pion <b>Opened:</b> 2007-12-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Playing with g++'s C++0X mode, I noticed that the following code, which used to compile:
++</p>
++
++<blockquote><pre>
++#include &lt;vector&gt;
++
++int main()
++{
++ std::vector&lt;char *&gt; v;
++ v.push_back(0);
++}
++</pre></blockquote>
++
++<p>
++now fails with the following error message:
++</p>
++
++<blockquote><p>
++.../include/c++/4.3.0/ext/new_allocator.h: In member function 'void __gnu_cxx::new_allocator&lt;_Tp&gt;::construct(_Tp*, _Args&amp;&amp; ...) [with _Args = int, _Tp = char*]':
++.../include/c++/4.3.0/bits/stl_vector.h:707: instantiated from 'void std::vector&lt;_Tp, _Alloc&gt;::push_back(_Args&amp;&amp; ...) [with _Args = int, _Tp = char*, _Alloc = std::allocator&lt;char*&gt;]'
++test.cpp:6: instantiated from here
++.../include/c++/4.3.0/ext/new_allocator.h:114: error: invalid conversion from 'int' to 'char*'
++</p></blockquote>
++
++<p>
++As far as I know, g++ follows the current draft here.
++</p>
++<p>
++Does the committee really intend to break compatibility for such cases?
++</p>
++
++<p><i>[
++Sylvain adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++I just noticed that <tt>std::pair</tt> has the same issue.
++The following now fails with GCC's -std=c++0x mode:
++</p>
++
++<blockquote><pre>
++#include &lt;utility&gt;
++
++int main()
++{
++ std::pair&lt;char *, char *&gt; p (0,0);
++}
++</pre></blockquote>
++
++<p>
++I have not made any general audit for such problems elsewhere.
++</p>
++</blockquote>
++
++<p><i>[
++Related to <a href="lwg-defects.html#756">756</a>
++]</i></p>
++
++
++<p><i>[
++Bellevue:
++]</i></p>
++
++
++<blockquote>
++<p>
++Motivation is to handle the old-style int-zero-valued <tt>NULL</tt> pointers.
++Problem: this solution requires concepts in some cases, which some users
++will be slow to adopt. Some discussion of alternatives involving
++prohibiting variadic forms and additional library-implementation
++complexity.
++</p>
++<p>
++Discussion of "perfect world" solutions, the only such solution put
++forward being to retroactively prohibit use of the integer zero for a
++<tt>NULL</tt> pointer. This approach was deemed unacceptable given the large
++bodies of pre-existing code that do use integer zero for a <tt>NULL</tt> pointer.
++</p>
++<p>
++Another approach is to change the member names. Yet another approach is
++to forbid the extension in absence of concepts.
++</p>
++<p>
++Resolution: These issues (<a href="lwg-defects.html#756">756</a>, <a href="lwg-defects.html#767">767</a>, <a href="lwg-active.html#760">760</a>,
++<a href="lwg-closed.html#763">763</a>) will be subsumed into a paper to be produced by Alan Talbot
++in time for review at the 2008 meeting in France. Once this paper is produced,
++these issues will be moved to <del>NAD</del><ins>Resolved</ins>.
++</p>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add the following rows to Table 90 "Optional sequence container operations", 23.2.3 [sequence.reqmts]:
++</p>
++
++<blockquote>
++<table border="1">
++<tr>
++<th>expression</th> <th>return type</th> <th>assertion/note<br/>pre-/post-condition</th> <th>container</th>
++</tr>
++
++<tr>
++<td>
++<tt>a.push_front(t)</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++<tt>a.insert(a.begin(), t)</tt><br/>
++<i>Requires:</i> <tt>T</tt> shall be <tt>CopyConstructible</tt>.
++</td>
++<td>
++<tt>list, deque</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.push_front(rv)</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++<tt>a.insert(a.begin(), rv)</tt><br/>
++<i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt>.
++</td>
++<td>
++<tt>list, deque</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.push_back(t)</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++<tt>a.insert(a.end(), t)</tt><br/>
++<i>Requires:</i> <tt>T</tt> shall be <tt>CopyConstructible</tt>.
++</td>
++<td>
++<tt>list, deque, vector, basic_string</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.push_back(rv)</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++<tt>a.insert(a.end(), rv)</tt><br/>
++<i>Requires:</i> <tt>T</tt> shall be <tt>MoveConstructible</tt>.
++</td>
++<td>
++<tt>list, deque, vector, basic_string</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++<p>
++Change the synopsis in 23.3.3 [deque]:
++</p>
++
++<blockquote><pre>
++<ins>void push_front(const T&amp; x);</ins>
++<ins>void push_front(T&amp;&amp; x);</ins>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++<p>
++Change 23.3.3.4 [deque.modifiers]:
++</p>
++
++<blockquote><pre>
++<ins>void push_front(const T&amp; x);</ins>
++<ins>void push_front(T&amp;&amp; x);</ins>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++<p>
++Change the synopsis in 23.3.5 [list]:
++</p>
++
++<blockquote><pre>
++<ins>void push_front(const T&amp; x);</ins>
++<ins>void push_front(T&amp;&amp; x);</ins>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++<p>
++Change 23.3.5.4 [list.modifiers]:
++</p>
++
++<blockquote><pre>
++<ins>void push_front(const T&amp; x);</ins>
++<ins>void push_front(T&amp;&amp; x);</ins>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_front(Args&amp;&amp;... args);
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++<p>
++Change the synopsis in 23.3.6 [vector]:
++</p>
++
++<blockquote><pre>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++<p>
++Change 23.3.6.5 [vector.modifiers]:
++</p>
++
++<blockquote><pre>
++<ins>void push_back(const T&amp; x);</ins>
++<ins>void push_back(T&amp;&amp; x);</ins>
++template &lt;class... Args&gt; <ins>requires Constructible&lt;T, Args&amp;&amp;...&gt;</ins> void push_back(Args&amp;&amp;... args);
++</pre></blockquote>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2680.pdf">N2680 Proposed Wording for Placement Insert (Revision 1)</a>.
++</p>
++
++<p>
++If there is still an issue with pair, Howard should submit another issue.
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="768"></a>768. Typos in [atomics]?</h3>
+-<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2007-12-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2007-12-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ in the latest publicly available draft, paper
+@@ -39456,7 +40127,8 @@ in section 29.5 [atomics.types.generic], the following specialization of the tem
+ <tt>atomic&lt;&gt;</tt> is provided for pointers:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct atomic&lt;T*&gt; : atomic_address {
++<blockquote><pre>
++template &lt;class T&gt; struct atomic&lt;T*&gt; : atomic_address {
+ T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
+ T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
+
+@@ -39487,7 +40159,8 @@ methods from the base class <tt>atomic_address</tt>, namely <tt>fetch_add</tt>,
+ to the other methods, in particular these ones:
+ </p>
+
+-<blockquote><pre>void store(T*, memory_order = memory_order_seq_cst) volatile;
++<blockquote><pre>
++void store(T*, memory_order = memory_order_seq_cst) volatile;
+ T* load( memory_order = memory_order_seq_cst ) volatile;
+ T* swap( T*, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_swap( T*&amp;, T*, memory_order, memory_order ) volatile;
+@@ -39539,7 +40212,8 @@ initialization.
+ Change the synopsis in 29.5 [atomics.types.generic]:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct atomic&lt;T*&gt; : atomic_address {
++<blockquote><pre>
++template &lt;class T&gt; struct atomic&lt;T*&gt; : atomic_address {
+ <ins>void store(T*, memory_order = memory_order_seq_cst) volatile;</ins>
+ <ins>T* load( memory_order = memory_order_seq_cst ) volatile;</ins>
+ <ins>T* swap( T*, memory_order = memory_order_seq_cst ) volatile;</ins>
+@@ -39571,13 +40245,14 @@ Change the synopsis in 29.5 [atomics.types.generic]:
+
+ <hr>
+ <h3><a name="769"></a>769. std::function should use nullptr_t instead of "unspecified-null-pointer-type"</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-N2461 already replaced in 20.8.14.2 [func.wrap.func] it's originally proposed
++N2461 already replaced in 20.9.12.2 [func.wrap.func] it's originally proposed
+ (implicit) conversion operator to "unspecified-bool-type" by the new
+ explicit bool conversion, but the inverse conversion should also
+ use the new <tt>std::nullptr_t</tt> type instead of "unspecified-null-pointer-
+@@ -39588,10 +40263,11 @@ type".
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-In 20.8 [function.objects], header <tt>&lt;functional&gt;</tt> synopsis replace:
++In 20.9 [function.objects], header <tt>&lt;functional&gt;</tt> synopsis replace:
+ </p>
+
+-<blockquote><pre>template&lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
+ bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, <del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ template&lt;class R, class... ArgTypes&gt;
+ bool operator==(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins> , const function&lt;R(ArgTypes...)&gt;&amp;);
+@@ -39602,19 +40278,21 @@ template&lt;class R, class... ArgTypes&gt;
+ </pre></blockquote>
+
+ <p>
+-In the class function synopsis of 20.8.14.2 [func.wrap.func] replace
++In the class function synopsis of 20.9.12.2 [func.wrap.func] replace
+ </p>
+
+-<blockquote><pre>function(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
++<blockquote><pre>
++function(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ ...
+ function&amp; operator=(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2 [func.wrap.func], "Null pointer comparisons" replace:
++In 20.9.12.2 [func.wrap.func], "Null pointer comparisons" replace:
+ </p>
+
+-<blockquote><pre>template &lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template &lt;class R, class... ArgTypes&gt;
+ bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, <del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ template &lt;class R, class... ArgTypes&gt;
+ bool operator==(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins> , const function&lt;R(ArgTypes...)&gt;&amp;);
+@@ -39625,19 +40303,21 @@ template &lt;class R, class... ArgTypes&gt;
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2.1 [func.wrap.func.con], replace
++In 20.9.12.2.1 [func.wrap.func.con], replace
+ </p>
+
+-<blockquote><pre>function(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
++<blockquote><pre>
++function(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ ...
+ function&amp; operator=(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2.6 [func.wrap.func.nullptr], replace
++In 20.9.12.2.6 [func.wrap.func.nullptr], replace
+ </p>
+
+-<blockquote><pre>template &lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template &lt;class R, class... ArgTypes&gt;
+ bool operator==(const function&lt;R(ArgTypes...)&gt;&amp; f, <del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ template &lt;class R, class... ArgTypes&gt;
+ bool operator==(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins> , const function&lt;R(ArgTypes...)&gt;&amp; f);
+@@ -39647,7 +40327,8 @@ template &lt;class R, class... ArgTypes&gt;
+ and replace
+ </p>
+
+-<blockquote><pre>template &lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template &lt;class R, class... ArgTypes&gt;
+ bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp; f, <del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins>);
+ template &lt;class R, class... ArgTypes&gt;
+ bool operator!=(<del>unspecified-null-pointer-type</del> <ins>nullptr_t</ins> , const function&lt;R(ArgTypes...)&gt;&amp; f);
+@@ -39660,9 +40341,9 @@ template &lt;class R, class... ArgTypes&gt;
+
+ <hr>
+ <h3><a name="770"></a>770. std::function should use rvalue swap</h3>
+-<p><b>Section:</b> 20.8.14 [func.wrap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.9.12 [func.wrap] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It is expected that typical implementations of <tt>std::function</tt> will
+@@ -39674,10 +40355,11 @@ this class to rvalue swappability.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.8 [function.objects], header <tt>&lt;functional&gt;</tt> synopsis, just below of
++In 20.9 [function.objects], header <tt>&lt;functional&gt;</tt> synopsis, just below of
+ </p>
+
+-<blockquote><pre>template&lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+ <ins>template&lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+@@ -39686,17 +40368,19 @@ template&lt;class R, class... ArgTypes&gt;
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2 [func.wrap.func] class <tt>function</tt> definition, change
++In 20.9.12.2 [func.wrap.func] class <tt>function</tt> definition, change
+ </p>
+
+-<blockquote><pre>void swap(function&amp;<ins>&amp;</ins>);
++<blockquote><pre>
++void swap(function&amp;<ins>&amp;</ins>);
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2 [func.wrap.func], just below of
++In 20.9.12.2 [func.wrap.func], just below of
+ </p>
+
+-<blockquote><pre>template &lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++template &lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+ <ins>template &lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
+@@ -39705,17 +40389,19 @@ template &lt;class R, class... ArgTypes&gt;
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2.2 [func.wrap.func.mod] change
++In 20.9.12.2.2 [func.wrap.func.mod] change
+ </p>
+
+-<blockquote><pre>void swap(function&amp;<ins>&amp;</ins> other);
++<blockquote><pre>
++void swap(function&amp;<ins>&amp;</ins> other);
+ </pre></blockquote>
+
+ <p>
+-In 20.8.14.2.7 [func.wrap.func.alg] add the two overloads
++In 20.9.12.2.7 [func.wrap.func.alg] add the two overloads
+ </p>
+
+-<blockquote><pre><ins>template&lt;class R, class... ArgTypes&gt;
++<blockquote><pre>
++<ins>template&lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp; f2);
+ template&lt;class R, class... ArgTypes&gt;
+ void swap(function&lt;R(ArgTypes...)&gt;&amp; f1, function&lt;R(ArgTypes...)&gt;&amp;&amp; f2);</ins>
+@@ -39728,19 +40414,19 @@ template&lt;class R, class... ArgTypes&gt;
+
+ <hr>
+ <h3><a name="771"></a>771. Impossible throws clause in [string.conversions]</h3>
+-<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The new <tt>to_string</tt> and <tt>to_wstring</tt> functions described in 21.5 [string.conversions]
+ have throws clauses (paragraphs 8 and 16) which say:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> nothing
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Since all overloads return either a <tt>std::string</tt> or a <tt>std::wstring</tt> by value
+@@ -39749,9 +40435,9 @@ constructors can fail due to out-of-memory conditions. Either these throws
+ clauses should be removed or should be more detailled like:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> Nothing if the string construction throws nothing
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Further there is an editorial issue in p. 14: All three <tt>to_wstring</tt>
+@@ -39768,23 +40454,25 @@ In 21.5 [string.conversions], remove the paragraphs 8 and 16.
+ </p>
+
+ <blockquote>
+-<pre>string to_string(long long val);
++<pre>
++string to_string(long long val);
+ string to_string(unsigned long long val);
+ string to_string(long double val);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Throws:</i> nothing</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <blockquote>
+-<pre><ins>w</ins>string to_wstring(long long val);
++<pre>
++<ins>w</ins>string to_wstring(long long val);
+ <ins>w</ins>string to_wstring(unsigned long long val);
+ <ins>w</ins>string to_wstring(long double val);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Throws:</i> nothing</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -39793,33 +40481,34 @@ string to_string(long double val);
+
+
+ <hr>
+-<h3><a name="772"></a>772. Impossible return clause in [string.conversions]</h3>
+-<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="772"></a>772. Impossible return clause in [string.conversions]</h3>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The return clause 21.5 [string.conversions]/paragraph 15 of the new <tt>to_wstring</tt>
++The return clause 21.5 [string.conversions] paragraph 15 of the new <tt>to_wstring</tt>
+ overloads says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> each function returns a <tt>wstring</tt> object holding the character
+ representation of the value of its argument that would be generated by
+ calling <tt>wsprintf(buf, fmt, val)</tt> with a format specifier of <tt>L"%lld"</tt>, <tt>L"%ulld"</tt>,
+ or <tt>L"%f"</tt>, respectively.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Problem is: There does not exist any <tt>wsprintf</tt> function in C99 (I checked
+ the 2nd edition of ISO 9899, and the first and the second corrigenda from
+ 2001-09-01 and 2004-11-15). What probably meant here is the function
+-<tt>swprintf</tt> from <tt>&lt;wchar.h&gt;/&lt;cwchar&gt;</tt>, but this has the non-equivalent
++<tt>swprintf</tt> from <tt>&lt;wchar.h&gt;&#47;&lt;cwchar&gt;</tt>, but this has the non-equivalent
+ declaration:
+ </p>
+
+-<blockquote><pre>int swprintf(wchar_t * restrict s, size_t n,
++<blockquote><pre>
++int swprintf(wchar_t * restrict s, size_t n,
+ const wchar_t * restrict format, ...);
+ </pre></blockquote>
+
+@@ -39831,10 +40520,10 @@ therefore the paragraph needs to mention the <tt>size_t</tt> parameter <tt>n</tt
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the current wording of 21.5 [string.conversions]/p. 15 to:
++Change the current wording of 21.5 [string.conversions] p. 15 to:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <del>e</del><ins>E</ins>ach function returns a
+ <tt>wstring</tt> object holding the character representation of the
+ value of its argument that would be generated by calling
+@@ -39842,7 +40531,7 @@ value of its argument that would be generated by calling
+ val)</tt> with a format specifier <ins><tt>fmt</tt></ins> of <tt>L"%lld"</tt>,
+ <tt>L"%ulld"</tt>, or <tt>L"%f"</tt>, respectively<ins>, where <tt>buf</tt>
+ designates an internal character buffer of sufficient size <tt>bufsz</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ [Hint to the editor: The resolution also adds to mention the name of
+@@ -39855,16 +40544,16 @@ paragraph 7 should also mention the meaning of <tt>buf</tt> and <tt>fmt</tt>.
+ </p>
+
+ <p>
+-Change the current wording of 21.5 [string.conversions]/p. 7 to:
++Change the current wording of 21.5 [string.conversions] p. 7 to:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <del>e</del><ins>E</ins>ach function returns a string object holding the
+ character representation of the value of its argument that would be
+ generated by calling <tt>sprintf(buf, fmt, val)</tt> with a format specifier <ins><tt>fmt</tt></ins> of
+ <tt>"%lld"</tt>, <tt>"%ulld"</tt>, or <tt>"%f"</tt>, respectively<ins>, where <tt>buf</tt> designates an internal
+ character buffer of sufficient size</ins>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -39872,11 +40561,12 @@ character buffer of sufficient size</ins>.
+
+
+ <hr>
+-<h3><a name="774"></a>774. Member swap undefined for most containers</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-01-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="774"></a>774. Member <tt>swap</tt> undefined for most containers</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-01-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It appears most containers declare but do not define a member-swap
+@@ -39901,7 +40591,8 @@ A quick survey of clause 23 shows that the following containers provide a
+ definition for member-swap:
+ </p>
+
+-<blockquote><pre>array
++<blockquote><pre>
++array
+ queue
+ stack
+ vector
+@@ -39911,7 +40602,8 @@ vector
+ Whereas the following declare it, but do not define the semantics:
+ </p>
+
+-<blockquote><pre>deque
++<blockquote><pre>
++deque
+ list
+ map
+ multimap
+@@ -39927,29 +40619,29 @@ unordered_set
+ <p>
+ Suggested resolution:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Provide a definition for each of the affected containers...
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open and ask Alisdair to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Daniel to provide wording.
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2590.pdf">N2590</a>
+ is no longer applicable.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-28 Daniel provided wording.
+@@ -39959,7 +40651,7 @@ is no longer applicable.
+ <blockquote>
+ <ol>
+ <li>
+-It assumes that the proposed resolution for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a> is applied,
++It assumes that the proposed resolution for <a href="lwg-defects.html#883">883</a> is applied,
+ which breaks the circularity of definition between member
+ <tt>swap</tt> and free <tt>swap</tt>.
+ </li>
+@@ -39973,7 +40665,7 @@ next refactoring phase of generalized allocators.
+ <li>
+ It requires that compare objects, key equal functions and
+ hash functions in containers are swapped via unqualified free
+-<tt>swap</tt> according to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#594">594</a>.
++<tt>swap</tt> according to <a href="lwg-defects.html#594">594</a>.
+ </li>
+ </ol>
+ </blockquote>
+@@ -39983,32 +40675,32 @@ hash functions in containers are swapped via unqualified free
+ ]</i></p>
+
+
+-<blockquote>
+-The outcome of this issue should be considered with the outcome of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1198">1198</a> both in style and in content (e.g. bullet 9 suggests to
+-define the semantic of <tt>void
+-priority_queue::swap(priority_queue&amp;)</tt> in terms of the member
+-<tt>swap</tt> of the container).
+-</blockquote>
++<blockquote><p>
++The outcome of this issue should be considered with the outcome of
++<a href="lwg-defects.html#1198">1198</a> both in style and in content (e.g. bullet 9 suggests to
++define the semantic of <tt>void priority_queue::swap(priority_queue&amp;)</tt>
++in terms of the member <tt>swap</tt> of the container).
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Looked at, but took no action on as it overlaps too much with
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+ Waiting for a new draft WP.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as open. Pablo to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-26 Pablo updated wording. Here is the wording he replaced:
+@@ -40022,7 +40714,8 @@ Leave as open. Pablo to provide wording.
+ Add a new Throws clause just after X [allocator.propagation.map]/5:
+ </p>
+
+-<blockquote><pre>static void swap(Alloc&amp; a, Alloc&amp; b);
++<blockquote><pre>
++static void swap(Alloc&amp; a, Alloc&amp; b);
+ </pre>
+ <blockquote>
+ <p>
+@@ -40052,12 +40745,12 @@ swap does never propagate an exception
+ Change 23.2.4.1 [associative.reqmts.except]/3 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For associative containers, no <tt>swap</tt> function throws an exception unless that
+ exception is thrown by the <del>copy constructor or copy assignment
+ operator</del>
+ <ins><tt>swap</tt></ins> of the container's <tt>Pred</tt> object<ins>s</ins><del> (if any)</del>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -40065,14 +40758,14 @@ operator</del>
+ Change 23.2.5.1 [unord.req.except]/3 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For unordered associative containers, no <tt>swap</tt> function throws an
+ exception unless
+ that exception is thrown by the <del>copy constructor or copy
+ assignment operator</del>
+ <ins><tt>swap</tt></ins> of the container's <tt>Hash</tt> or <tt>Pred</tt> object<ins>s,
+ respectively</ins><del> (if any)</del>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -40080,11 +40773,11 @@ respectively</ins><del> (if any)</del>.
+ Insert a new paragraph just after 23.3 [sequences]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>In addition to being available via inclusion of the <tt>&lt;algorithm&gt;</tt> header,
+ the <tt>swap</tt> function templates in 25.3.3 [alg.swap] are also available when the
+ header <tt>&lt;queue&gt;</tt> is included.</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ There is a new issue in process that will suggest a minimum header for <tt>swap</tt>
+@@ -40097,35 +40790,37 @@ dependency should be added to <tt>&lt;queue&gt;</tt>
+
+ <li>
+ <p>
+-Add one further clause at the end of 23.3.1.2 [array.special]:
++Add one further clause at the end of 23.3.2.3 [array.special]:
+ </p>
+ <p><i>[This part is added, because otherwise <tt>array::swap</tt> would otherwise
+ contradict the
+ general contract of 23.2.1 [container.requirements.general] p. 10 b. 5]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <ins><i>Throws:</i> Nothing, unless one of the element-wise <tt>swap</tt> calls throws
+ an exception.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.3.2 [deque], class template deque synopsis change as indicated:
++In 23.3.3 [deque], class template <tt>deque</tt> synopsis change as indicated:
+ </p>
+-<blockquote><pre>void swap(deque<del>&lt;T,Alloc&gt;</del>&amp;);
++<blockquote><pre>
++void swap(deque<del>&lt;T,Alloc&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-At the end of 23.3.2.3 [deque.modifiers] add as indicated:
++At the end of 23.3.3.4 [deque.modifiers] add as indicated:
+ </p>
+
+-<blockquote><pre><ins>void swap(deque&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(deque&amp; x);</ins>
+ </pre>
+ <blockquote>
+ <p>
+@@ -40142,22 +40837,24 @@ with that of <tt>x</tt>.</ins>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.3.3 [forwardlist], class template <tt>forward_list</tt> synposis change as indicated:
++In 23.3.4 [forwardlist], class template <tt>forward_list</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(forward_list<del>&lt;T,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(forward_list<del>&lt;T,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-At the end of 23.3.3.4 [forwardlist.modifiers] add as indicated:
++At the end of 23.3.4.5 [forwardlist.modifiers] add as indicated:
+ </p>
+
+-<blockquote><pre><ins>void swap(forward_list&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(forward_list&amp; x);</ins>
+ </pre>
+ <blockquote>
+ <p>
+@@ -40174,22 +40871,24 @@ with that of <tt>x</tt>.</ins>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.3.4 [list], class template <tt>list</tt> synopsis change as indicated:
++In 23.3.5 [list], class template <tt>list</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(list<del>&lt;T,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(list<del>&lt;T,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-At the end of 23.3.4.3 [list.modifiers] add as indicated:
++At the end of 23.3.5.4 [list.modifiers] add as indicated:
+ </p>
+
+-<blockquote><pre><ins>void swap(list&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(list&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40209,10 +40908,11 @@ with that of <tt>x</tt>.</ins>
+
+ <li>
+ <p>
+-At the end of 23.5.2.3 [priqueue.members] add a new prototype description:
++At the end of 23.6.4.3 [priqueue.members] add a new prototype description:
+ </p>
+
+-<blockquote><pre><ins>void swap(priority_queue&amp; q);</ins>
++<blockquote><pre>
++<ins>void swap(priority_queue&amp; q);</ins>
+ </pre>
+ <blockquote>
+ <p>
+@@ -40222,8 +40922,7 @@ At the end of 23.5.2.3 [priqueue.members] add a new prototype description:
+
+ <p><i>[
+ This requirement is added to ensure that even a user defined <tt>swap</tt>
+-which is found by
+-ADL for <tt>Compare</tt> satisfies the <tt>Swappable</tt> requirements
++which is found by ADL for <tt>Compare</tt> satisfies the <tt>Swappable</tt> requirements
+ ]</i></p>
+
+
+@@ -40243,29 +40942,30 @@ contradict the general contract of 23.2.1 [container.requirements.general] p. 10
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.4.1 [vector], class template <tt>vector</tt> synopsis change as indicated:
++In 23.3.6 [vector], class template <tt>vector</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(vector<del>&lt;T,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(vector<del>&lt;T,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.4.1.2 [vector.capacity]/8 as indicated:
++Change 23.3.6.3 [vector.capacity] p. 8 as indicated:
+ </p>
+
+-<blockquote><pre>void swap(vector<del>&lt;T,Allocator&gt;</del>&amp; x);
++<blockquote><pre>
++void swap(vector<del>&lt;T,Allocator&gt;</del>&amp; x);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Exchanges the contents and <tt>capacity()</tt> <ins>and swaps the
+-allocators</ins>
+-of <tt>*this</tt> with that of <tt>x</tt>.
+-</blockquote>
++allocators</ins> of <tt>*this</tt> with that of <tt>x</tt>.
++</p></blockquote>
+ </blockquote>
+ </li>
+ </ol>
+@@ -40273,33 +40973,35 @@ of <tt>*this</tt> with that of <tt>x</tt>.
+
+ <li>
+ <p>
+-Insert a new paragraph just before 23.6 [associative]/1:
++Insert a new paragraph just before 23.4 [associative]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>In addition to being available via inclusion of the <tt>&lt;algorithm&gt;</tt> header,
+ the <tt>swap</tt> function templates in 25.3.3 [alg.swap] are also available when any of the
+ headers <tt>&lt;map&gt;</tt> or <tt>&lt;set&gt;</tt> are included.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.6.1 [map], class template <tt>map</tt> synopsis change as indicated:
++In 23.4.4 [map], class template <tt>map</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(map<del>&lt;Key,T,Compare,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(map<del>&lt;Key,T,Compare,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-At the end of 23.6.1.3 [map.modifiers] add as indicated:
++At the end of 23.4.4.4 [map.modifiers] add as indicated:
+ </p>
+
+-<blockquote><pre><ins>void swap(map&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(map&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40331,22 +41033,24 @@ of <tt>*this</tt> and <tt>x</tt>.</ins>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.6.2 [multimap], class template <tt>multimap</tt> synopsis change as indicated:
++In 23.4.5 [multimap], class template <tt>multimap</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(multimap<del>&lt;Key,T,Compare,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(multimap<del>&lt;Key,T,Compare,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-At the end of 23.6.2.2 [multimap.modifiers] add as indicated:
++At the end of 23.4.5.3 [multimap.modifiers] add as indicated:
+ </p>
+
+-<blockquote><pre><ins>void swap(multimap&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(multimap&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40369,24 +41073,26 @@ of <tt>*this</tt> and <tt>x</tt>.</ins>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.6.3 [set], class template <tt>set</tt> synopsis change as indicated:
++In 23.4.6 [set], class template <tt>set</tt> synopsis change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(set<del>&lt;Key,Compare,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(set<del>&lt;Key,Compare,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-After section 23.6.3.1 [set.cons] add a new section <ins><tt>set</tt> modifiers
++After section 23.4.6.2 [set.cons] add a new section <ins><tt>set</tt> modifiers
+ [set.modifiers]</ins>
+ and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(set&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(set&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40411,23 +41117,25 @@ of <tt>*this</tt> and <tt>x</tt>.</ins>
+ </li>
+
+ <li>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-In 23.6.4 [multiset], class template <tt>multiset</tt> synosis, change as indicated:
++In 23.4.7 [multiset], class template <tt>multiset</tt> synosis, change as indicated:
+ </p>
+
+-<blockquote><pre>void swap(multiset<del>&lt;Key,Compare,Allocator&gt;</del>&amp;);
++<blockquote><pre>
++void swap(multiset<del>&lt;Key,Compare,Allocator&gt;</del>&amp;);
+ </pre></blockquote>
+ </li>
+
+ <li>
+ <p>
+-After section 23.6.4.1 [multiset.cons] add a new section <ins><tt>multiset</tt> modifiers
++After section 23.4.7.2 [multiset.cons] add a new section <ins><tt>multiset</tt> modifiers
+ [multiset.modifiers]</ins> and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(multiset&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(multiset&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40453,24 +41161,25 @@ of <tt>*this</tt> and <tt>x</tt>.</ins>
+
+ <li>
+ <p>
+-Insert a new paragraph just before 23.7 [unord]/1:
++Insert a new paragraph just before 23.5 [unord] p. 1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>In addition to being available via inclusion of the <tt>&lt;algorithm&gt;</tt> header,
+ the <tt>swap</tt> function templates in 25.3.3 [alg.swap] are also available when any of the
+ headers <tt>&lt;unordered_map&gt;</tt> or <tt>&lt;unordered_set&gt;</tt> are included.</ins>
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-After section 23.7.1.2 [unord.map.elem] add a new section <ins>unordered_map
+-modifiers [unord.map.modifiers]</ins> and add the following paragraphs:
++After section 23.5.4.3 [unord.map.elem] add a new section <ins>unordered_map
++modifiers 23.5.4.4 [unord.map.modifiers]</ins> and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(unordered_map&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(unordered_map&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40487,8 +41196,7 @@ requirements
+
+
+ <p>
+-<ins><i>Effects:</i> Exchanges the contents and hash policy and swaps the
+-allocators of <tt>*this</tt>
++<ins><i>Effects:</i> Exchanges the contents and hash policy and swaps the allocators of <tt>*this</tt>
+ with that of <tt>x</tt>, followed by an unqualified <tt>swap</tt> of the <tt>Pred</tt> objects
+ and an unqualified <tt>swap</tt> of the <tt>Hash</tt> objects of <tt>*this</tt> and <tt>x</tt>.</ins>
+ </p>
+@@ -40502,12 +41210,13 @@ and an unqualified <tt>swap</tt> of the <tt>Hash</tt> objects of <tt>*this</tt>
+
+ <li>
+ <p>
+-After section 23.7.2.1 [unord.multimap.cnstr] add a new section
++After section 23.5.5.2 [unord.multimap.cnstr] add a new section
+ <ins>unordered_multimap
+-modifiers [unord.multimap.modifiers]</ins> and add the following paragraphs:
++modifiers 23.5.5.3 [unord.multimap.modifiers]</ins> and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(unordered_multimap&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(unordered_multimap&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40531,12 +41240,13 @@ and an unqualified <tt>swap</tt> of the <tt>Hash</tt> objects of <tt>*this</tt>
+
+ <li>
+ <p>
+-After section 23.7.3.1 [unord.set.cnstr] add a new section
++After section 23.5.6.2 [unord.set.cnstr] add a new section
+ <ins>unordered_set modifiers
+ [unord.set.modifiers]</ins> and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(unordered_set&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(unordered_set&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40561,12 +41271,13 @@ and an unqualified <tt>swap</tt> of the <tt>Hash</tt> objects of <tt>*this</tt>
+
+ <li>
+ <p>
+-After section 23.7.4.1 [unord.multiset.cnstr] add a new section
++After section 23.5.7.2 [unord.multiset.cnstr] add a new section
+ <ins>unordered_multiset
+ modifiers [unord.multiset.modifiers]</ins> and add the following paragraphs:
+ </p>
+
+-<blockquote><pre><ins>void swap(unordered_multiset&amp; x);</ins>
++<blockquote><pre>
++<ins>void swap(unordered_multiset&amp; x);</ins>
+ </pre>
+
+ <blockquote>
+@@ -40609,25 +41320,25 @@ and an unqualified <tt>swap</tt> of the <tt>Hash</tt> objects of <tt>*this</tt>
+ <p><i>[
+ This resolution is based on the September 2009 WP,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>,
+-except that it
+-assumes that
++except that it assumes that
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
+-and issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#883">883</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1232">1232</a> have already been applied. Note in
++and issues <a href="lwg-defects.html#883">883</a> and <a href="lwg-closed.html#1232">1232</a> have already been applied. Note in
+ particular that Table 91 in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
+ is refered to as Table 90 because
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
+-removed the old Table 90. This resolution also addresses issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#431">431</a>.
++removed the old Table 90. This resolution also addresses issue <a href="lwg-defects.html#431">431</a>.
+ ]</i></p>
+
+ <p>
+ In 23.2.1 [container.requirements.general], replace the a.swap(b) row in table 90,
+-"container requirements" (was table 91 before the application of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a> to the
+-WP):
++"container requirements" (was table 91 before the application of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
++to the WP):
+ </p>
+ <blockquote>
+ <table border="1">
+- <tbody><tr>
++ <tr>
+ <td><code>a.swap(b)</code></td>
+ <td><code>void</code></td>
+ <td>&nbsp;&nbsp;&nbsp;</td>
+@@ -40641,13 +41352,14 @@ WP):
+ <td><ins><code>a.swap(b)</code></ins></td>
+ <td><ins>(Note A)</ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+ <p>
+ Modify the notes immediately following Table 90 in
+ 23.2.1 [container.requirements.general] as follows (The wording below is after the
+-application of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a> to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>. The editor might also want to combine Notes
+-A and B into one.):
++application of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>
++to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>. The
++editor might also want to combine Notes A and B into one.):
+ </p>
+ <blockquote><p>
+ Notes: the algorithms<del> swap(),</del> equal() and lexicographical_compare()
+@@ -40719,11 +41431,11 @@ assignment operator</del><ins>swap</ins> of the container's <code>Hash</code>
+ or <code>Pred</code> object (if any).
+ </p></blockquote>
+ <p>
+-Modify section 23.3.1.2 [array.special]:
++Modify section 23.3.2.3 [array.special]:
+ </p>
+ <blockquote>
+ <p>
+-<b>array specialized algorithms 23.3.1.2 [array.special]</b>
++<b>array specialized algorithms 23.3.2.3 [array.special]</b>
+ </p>
+ <p>
+ <code>template &lt;class T, size_t N&gt; void swap(array&lt;T,N&gt;&amp; x,array&lt;T,N&gt;&amp; y);</code>
+@@ -40735,7 +41447,7 @@ Modify section 23.3.1.2 [array.special]:
+ </blockquote>
+ </blockquote>
+ <p>
+-Add a new section after 23.3.1.5 [array.fill] (Note to the editor: array::fill make use
++Add a new section after 23.3.2.6 [array.fill] (Note to the editor: array::fill make use
+ of a concept requirement that must be removed or changed to text.):
+ </p>
+ <blockquote>
+@@ -40757,13 +41469,13 @@ exception.
+ [<i>Note</i>: Unlike other containers' <code>swap</code> functions,
+ <code>array::swap</code> takes linear, not constant, time, may exit via an
+ exception, and does not cause iterators to become associated with the other
+-container. — <i>end note</i>]
++container. &mdash; <i>end note</i>]
+ </ins></p>
+ </blockquote>
+ </blockquote>
+
+ <p>
+-Insert a new paragraph just after 23.5 [container.adaptors]/1:
++Insert a new paragraph just after 23.6 [container.adaptors]/1:
+ </p>
+ <blockquote><p><ins>
+ For container adaptors, no <code>swap</code> function throws an exception
+@@ -40784,10 +41496,10 @@ adaptor's <code>Container</code> or <code>Compare</code> object (if any).
+
+ <hr>
+ <h3><a name="775"></a>775. Tuple indexing should be unsigned?</h3>
+-<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-01-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-01-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The tuple element access API identifies the element in the sequence
+@@ -40796,7 +41508,8 @@ I be &gt;= 0. There is a much easier way to do this - declare I as
+ <tt>unsigned</tt>.
+ </p>
+ <p>
+-In fact the proposal is to use <code>std::size_t</code>, matching the type used in the <tt>tuple_size</tt> API.
++In fact the proposal is to use <code>std::size_t</code>, matching the
++type used in the <tt>tuple_size</tt> API.
+ </p>
+ <p>
+ A second suggestion is that it is hard to imagine an API that deduces
+@@ -40823,9 +41536,10 @@ problem as all elements are of type <code>T</code>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Update header &lt;utility&gt; synopsis in 20.3 [utility]
++Update header &lt;utility&gt; synopsis in 20.2 [utility]
+ </p>
+-<pre><em>// 20.2.3, tuple-like access to pair:</em>
++<pre>
++<em>// 20.2.3, tuple-like access to pair:</em>
+ template &lt;class T&gt; class tuple_size;
+ template &lt;<del>int</del><ins>size_t</ins> I, class T&gt; class tuple_element;
+
+@@ -40839,9 +41553,10 @@ template&lt;<del>int</del><ins>size_t</ins> I, class T1, class T2&gt;
+ const <del>P</del><ins>typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type </ins>&amp; get(const std::pair&lt;T1, T2&gt;&amp;);
+ </pre>
+ <p>
+-Update <strong>20.3.5 [pairs] Pairs</strong>
++Update <strong>20.3 [pairs] Pairs</strong>
+ </p>
+-<pre>template&lt;<del>int</del><ins>size_t</ins> I, class T1, class T2&gt;
++<pre>
++template&lt;<del>int</del><ins>size_t</ins> I, class T1, class T2&gt;
+ <del>P</del><ins>typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type </ins>&amp; get(pair&lt;T1, T2&gt;&amp;);
+ template&lt;<del>int</del><ins>size_t</ins> I, class T1, class T2&gt;
+ const <del>P</del><ins>typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type </ins>&amp; get(const pair&lt;T1, T2&gt;&amp;);
+@@ -40860,8 +41575,9 @@ template&lt;<del>int</del><ins>size_t</ins> I, class T1, class T2&gt;
+ <p>
+ Update header &lt;tuple&gt; synopsis in 20.4 [tuple] with a APIs as below:
+ </p>
+-<pre>template &lt;<del>int</del><ins>size_t</ins> I, class T&gt; class tuple_element; <em>// undefined</em>
+-template &lt;<del>int</del><ins>size_t</ins> I, class... Types&gt; class tuple_element&lt;I, tuple&lt;Types...&gt; &gt;;
++<pre>
++template &lt;<del>int</del><ins>size_t</ins> I, class T&gt; class tuple_element; <em>// undefined</em>
++template &lt;<del>int</del><ins>size_t</ins> I, class... Types> class tuple_element&lt;I, tuple&lt;Types...> >;
+
+ <em>// 20.3.1.4, element access:</em>
+ template &lt;<del>int</del><ins>size_t</ins> I, class... Types&gt;
+@@ -40887,15 +41603,18 @@ public:
+ <p>
+ Update <strong>20.4.2.6 [tuple.elem] Element access</strong>
+ </p>
+-<pre>template &lt;<del>int</del><ins>size_t</ins> I, class... types &gt;
++<pre>
++template &lt;<del>int</del><ins>size_t</ins> I, class... types &gt;
+ typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp; get(tuple&lt;Types...&gt;&amp; t);
+ </pre>
+-1 <em>Requires:</em> <code><del>0 &lt;= I and </del>I &lt; sizeof...(Types)</code>. The program is ill-formed if <code>I</code> is out of bounds.
+ <p>
++1 <em>Requires:</em> <code><del>0 &lt;= I and </del>I &lt; sizeof...(Types)</code>. The program is ill-formed if <code>I</code> is out of bounds.
++<p/>
+ 2 <em>Returns:</em> A reference to the <code>I</code>th element of <code>t</code>, where indexing is zero-based.
+ </p>
+ <ins><em>Throws:</em> Nothing.</ins>
+-<pre>template &lt;<del>int</del><ins>size_t</ins> I, class... types&gt;
++<pre>
++template &lt;<del>int</del><ins>size_t</ins> I, class... types&gt;
+ typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp; get(const tuple&lt;Types...&gt;&amp; t);
+ </pre>
+ <p>
+@@ -40910,10 +41629,11 @@ typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp; get(con
+
+
+ <p>
+-Update header &lt;array&gt; synopsis in 20.3 [utility]
++Update header &lt;array&gt; synopsis in 20.2 [utility]
+ </p>
+-<pre>template &lt;class T&gt; class tuple_size; <em>// forward declaration</em>
+-template &lt;<del>int</del><ins>size_t</ins> I, class T&gt; class tuple_element; <em>// forward declaration</em>
++<pre>
++template &lt;class T&gt; class tuple_size; <em>// forward declaration</em>
++template &lt;<del>int</del><ins>size_t</ins> I, class T> class tuple_element; <em>// forward declaration</em>
+ template &lt;class T, size_t N&gt;
+ struct tuple_size&lt;array&lt;T, N&gt; &gt;;
+ template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt;
+@@ -40925,9 +41645,10 @@ template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt;
+ </pre>
+
+ <p>
+-Update <strong>23.3.1.8 [array.tuple] Tuple interface to class template array</strong>
++Update <strong>23.3.2.9 [array.tuple] Tuple interface to class template array</strong>
+ </p>
+-<pre>tuple_element&lt;<ins>size_t </ins>I, array&lt;T, N&gt; &gt;::type
++<pre>
++tuple_element&lt;<ins>size_t </ins>I, array&lt;T, N&gt; &gt;::type
+ </pre>
+ <p>
+ 3 <em>Requires:</em> <code><del>0 &lt;= </del>I &lt; N.</code> The program is ill-formed if <code>I</code> is out of bounds.
+@@ -40935,7 +41656,8 @@ Update <strong>23.3.1.8 [array.tuple] Tuple interface to class template array</s
+ <p>
+ 4 <em>Value:</em> The type <code>T</code>.
+ </p>
+-<pre>template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt; T&amp; get(array&lt;T, N&gt;&amp; a);
++<pre>
++template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt; T&amp; get(array&lt;T, N&gt;&amp; a);
+ </pre>
+ <p>
+ 5 <em>Requires:</em> <code><del>0 &lt;= </del>I &lt; N</code>. The program is ill-formed if <code>I</code> is out of bounds.
+@@ -40946,7 +41668,8 @@ Update <strong>23.3.1.8 [array.tuple] Tuple interface to class template array</s
+ <p>
+ <ins><em>Throws:</em> Nothing.</ins>
+ </p>
+-<pre>template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt; const T&amp; get(const array&lt;T, N&gt;&amp; a);
++<pre>
++template &lt;<del>int</del><ins>size_t</ins> I, class T, size_t N&gt; const T&amp; get(const array&lt;T, N&gt;&amp; a);
+ </pre>
+ <p>
+ 6 <em>Requires:</em> <code><del>0 &lt;= </del>I &lt; N</code>. The program is ill-formed if <code>I</code> is out of bounds.
+@@ -40970,18 +41693,20 @@ for pair is also unnecessary.
+
+
+ <hr>
+-<h3><a name="776"></a>776. Undescribed assign function of std::array</h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="776"></a>776. Undescribed <tt>assign</tt> function of <tt>std::array</tt></h3>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The class template array synopsis in 23.3.1 [array]/3 declares a member
++The class template array synopsis in 23.3.2 [array] p. 3 declares a member
+ function
+ </p>
+
+-<blockquote><pre>void assign(const T&amp; u);
++<blockquote><pre>
++void assign(const T&amp; u);
+ </pre></blockquote>
+
+ <p>
+@@ -40992,12 +41717,12 @@ be derived by those.
+
+ <p>
+ I found only one reference to this function in the issue list,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#588">588</a> where the question is raised:
++<a href="lwg-closed.html#588">588</a> where the question is raised:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ what's the effect of calling <tt>assign(T&amp;)</tt> on a zero-sized array?
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ which does not answer the basic question of this issue.
+@@ -41012,7 +41737,7 @@ course such wording must be added.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Just after the section 23.3.1.4 [array.data] add the following new section:
++Just after the section 23.3.2.5 [array.data] add the following new section:
+ </p>
+
+ <p>
+@@ -41020,7 +41745,8 @@ Just after the section 23.3.1.4 [array.data] add the following new section:
+ </p>
+
+ <blockquote>
+-<pre>void fill(const T&amp; u);
++<pre>
++void fill(const T&amp; u);
+ </pre>
+
+ <p>
+@@ -41034,10 +41760,11 @@ section. If it had, then <tt>assign</tt> would naturally belong to it]
+ </p>
+
+ <p>
+-Change the synopsis in 23.3.1 [array]/3:
++Change the synopsis in 23.3.2 [array]/3:
+ </p>
+
+-<blockquote><pre>template &lt;class T, size_t N&gt;
++<blockquote><pre>
++template &lt;class T, size_t N&gt;
+ struct array {
+ ...
+ void <del>assign</del> <ins>fill</ins>(const T&amp; u);
+@@ -41064,17 +41791,17 @@ Set state to Review given substitution of "fill" for "assign".
+
+ <hr>
+ <h3><a name="777"></a>777. Atomics Library Issue</h3>
+-<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-01-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics.types.operations">active issues</a> in [atomics.types.operations].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-01-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The load functions are defined as
+ </p>
+
+-<blockquote><pre>C atomic_load(volatile A* object);
++<blockquote><pre>
++C atomic_load(volatile A* object);
+ C atomic_load_explicit(volatile A* object, memory_order);
+ C A::load(memory_order order = memory_order_seq_cst) volatile;
+ </pre></blockquote>
+@@ -41090,7 +41817,7 @@ post Bellevue Peter adds:
+
+ <blockquote>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#777">777</a> suggests making <tt>atomic_load</tt> operate on <tt>const</tt> objects. There is a
++Issue <a href="lwg-defects.html#777">777</a> suggests making <tt>atomic_load</tt> operate on <tt>const</tt> objects. There is a
+ subtle point here. Atomic loads do not generally write to the object, except
+ potentially for the <tt>memory_order_seq_cst</tt> constraint. Depending on the
+ architecture, a dummy write with the same value may be required to be issued
+@@ -41098,7 +41825,8 @@ by the atomic load to maintain sequential consistency. This, in turn, may
+ make the following code:
+ </p>
+
+-<blockquote><pre>const atomic_int x{};
++<blockquote><pre>
++const atomic_int x{};
+
+ int main()
+ {
+@@ -41127,7 +41855,8 @@ mutable, as is already the case with mutexes.
+ Add the <tt>const</tt> qualifier to <tt>*object</tt> and <tt>*this</tt>.
+ </p>
+
+-<blockquote><pre>C atomic_load(<ins>const</ins> volatile A* object);
++<blockquote><pre>
++C atomic_load(<ins>const</ins> volatile A* object);
+ C atomic_load_explicit(<ins>const</ins> volatile A* object, memory_order);
+ C A::load(memory_order order = memory_order_seq_cst) <ins>const</ins> volatile;
+ </pre></blockquote>
+@@ -41139,11 +41868,11 @@ C A::load(memory_order order = memory_order_seq_cst) <ins>const</ins> volatile;
+
+ <hr>
+ <h3><a name="778"></a>778. std::bitset does not have any constructor taking a string literal</h3>
+-<p><b>Section:</b> 20.5.1 [bitset.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-01-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#116">116</a></p>
++<p><b>Section:</b> 20.6.1 [bitset.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-01-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#116">116</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A small issue with <tt>std::bitset</tt>: it does not have any constructor
+@@ -41155,7 +41884,8 @@ we tried to enable uniform use of <tt>string</tt> and <tt>const char*</tt> in th
+ Suggestion: Add
+ </p>
+
+-<blockquote><pre>explicit bitset( const char* str );
++<blockquote><pre>
++explicit bitset( const char* str );
+ </pre></blockquote>
+
+ <p>
+@@ -41165,17 +41895,19 @@ to std::bitset.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to synopsis in 20.5 [template.bitset]
++Add to synopsis in 20.6 [template.bitset]
+ </p>
+
+-<blockquote><pre>explicit bitset( const char* str );
++<blockquote><pre>
++explicit bitset( const char* str );
+ </pre></blockquote>
+
+ <p>
+-Add to synopsis in 20.5.1 [bitset.cons]
++Add to synopsis in 20.6.1 [bitset.cons]
+ </p>
+
+-<blockquote><pre>explicit bitset( const char* str );
++<blockquote><pre>
++explicit bitset( const char* str );
+ </pre>
+ <p>
+ <i>Effects:</i> Constructs a <tt>bitset</tt> as if <tt>bitset(string(str))</tt>.
+@@ -41189,28 +41921,27 @@ Add to synopsis in 20.5.1 [bitset.cons]
+
+ <hr>
+ <h3><a name="779"></a>779. Resolution of #283 incomplete</h3>
+-<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a> did not resolve similar necessary changes for algorithm
+-<tt>remove_copy[_if]</tt>,
+-which seems to be an oversight.
++The resolution of <a href="lwg-defects.html#283">283</a> did not resolve similar necessary changes for algorithm
++<tt>remove_copy[_if]</tt>, which seems to be an oversight.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 25.3.8 [alg.remove]/p.6, replace the N2461 requires clause with:
++In 25.3.8 [alg.remove] p.6, replace the N2461 requires clause with:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <del>Type <tt>T</tt> is <tt>EqualityComparable</tt> (31).</del> The ranges <tt>[first,last)</tt>
+ and <tt>[result,result + (last - first))</tt> shall not overlap. <ins>The expression <tt>*result = *first</tt> shall be
+ valid.</ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -41218,13 +41949,13 @@ valid.</ins>
+
+
+ <hr>
+-<h3><a name="780"></a>780. <tt>std::merge()</tt> specification incorrect/insufficient</h3>
+-<p><b>Section:</b> 25.4.4 [alg.merge] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="780"></a>780. <tt>std::merge()</tt> specification incorrect&#47;insufficient</h3>
++<p><b>Section:</b> 25.4.4 [alg.merge] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Though issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#283">283</a> has fixed many open issues, it seems that some are still open:
++Though issue <a href="lwg-defects.html#283">283</a> has fixed many open issues, it seems that some are still open:
+ </p>
+
+ <p>
+@@ -41266,18 +41997,18 @@ Post Summit Alisdair adds:
+ <p>
+ Suggest:
+ </p>
+-<blockquote>
++<blockquote><p>
+ (where <tt>last</tt> is equal to <tt>next(result, distance(first1, last1) +
+ distance(first2, last2))</tt>, such that resulting range will be sorted in
+ non-decreasing order; that is, for every iterator <tt>i</tt> in <tt>[result,last)</tt> other
+ than <tt>result</tt>, the condition <tt>*i &lt; *prev(i)</tt> or, respectively, <tt>comp(*i,
+ *prev(i))</tt> will be <tt>false</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Note that this might still not be technically accurate in the case of
+ <tt>InputIterators</tt>, depending on other resolutions working their way through the
+-system (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1011">1011</a>).
++system (<a href="lwg-defects.html#1011">1011</a>).
+ </p>
+ </blockquote>
+
+@@ -41286,11 +42017,11 @@ Post Summit Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ If we want to use <tt>prev</tt> and <tt>next</tt> here (Note: <tt>merge</tt>
+-is sufficiently satisfied with <tt>InputIterator</tt>) we should instead *add* more to
+-25 [algorithms]/6, but I can currently not propose any good wording for this.
+-</blockquote>
++is sufficiently satisfied with <tt>InputIterator</tt>) we should instead <em>add</em> more to
++25 [algorithms] p. 6, but I can currently not propose any good wording for this.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -41298,7 +42029,7 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-Pete points out the existing wording in [algorithms]/4
++Pete points out the existing wording in [algorithms] p. 4
+ that permits the use of + in algorithm specifications.
+ </p>
+ <p>
+@@ -41314,9 +42045,9 @@ Move to Review.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-23 Daniel reopens:
+@@ -41328,10 +42059,10 @@ Move to Ready.
+ The proposed wording must be rephrased, because the part
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ for every iterator <tt>i</tt> in <tt>[result,last)</tt> other than <tt>result</tt>, the condition
+ <tt>*i &lt; *(i - 1)</tt> or, respectively, <tt>comp(*i, *(i - 1))</tt> will be <tt>false</tt>"
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ isn't meaningful, because the range <tt>[result,last)</tt> is that of a pure
+@@ -41427,7 +42158,7 @@ in <tt>[first,last)</tt> other than <tt>first</tt>, the condition <tt>*i &lt;
+ </blockquote>
+
+ <p>
+-Change 25.4.4 [alg.merge]/6+7 as indicated <i>[This ensures harmonization
++Change 25.4.4 [alg.merge] p. 6+7 as indicated <i>[This ensures harmonization
+ between <tt>inplace_merge</tt> and <tt>merge</tt>]</i>
+ </p>
+
+@@ -41458,10 +42189,10 @@ requirements (Table 33), and the the <tt>MoveAssignable</tt> requirements (Table
+
+ <hr>
+ <h3><a name="781"></a>781. <tt>std::complex</tt> should add missing C99 functions</h3>
+-<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A comparision of the N2461 header <tt>&lt;complex&gt;</tt> synopsis ([complex.syn])
+@@ -41471,12 +42202,13 @@ some complex functions that are missing in C++. These are:
+
+ <ol>
+ <li>
+-7.3.9.4: (required elements of the C99 library)<br>
++7.3.9.4: (required elements of the C99 library)<br/>
+ The <tt>cproj</tt> functions
+ </li>
+ <li>
+-7.26.1: (optional elements of the C99 library)<br>
+-<pre>cerf cerfc cexp2
++7.26.1: (optional elements of the C99 library)<br/>
++<pre>
++cerf cerfc cexp2
+ cexpm1 clog10 clog1p
+ clog2 clgamma ctgamma
+ </pre>
+@@ -41491,7 +42223,7 @@ function).
+
+ <p>
+ Please note also that the current entry <tt>polar</tt>
+-in 26.4.9 [cmplx.over]/1
++in 26.4.9 [cmplx.over] p. 1
+ should be removed from the mentioned overload list. It does not make sense to require that a
+ function already expecting <em>scalar</em> arguments
+ should cast these arguments into corresponding
+@@ -41505,7 +42237,8 @@ this function.
+ In 26.4.1 [complex.syn] add just between the declaration of <tt>conj</tt> and <tt>fabs</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);
++<blockquote><pre>
++template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);
+ <ins>template&lt;class T&gt; complex&lt;T&gt; proj(const complex&lt;T&gt;&amp;);</ins>
+ template&lt;class T&gt; complex&lt;T&gt; fabs(const complex&lt;T&gt;&amp;);
+ </pre></blockquote>
+@@ -41515,17 +42248,17 @@ In 26.4.7 [complex.value.ops] just after p.6 (return clause of <tt>conj</tt>) ad
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class T&gt; complex&lt;T&gt; proj(const complex&lt;T&gt;&amp; x);
++<pre>
++template&lt;class T&gt; complex&lt;T&gt; proj(const complex&lt;T&gt;&amp; x);
+ </pre>
+-<blockquote>
+-
++<blockquote><p>
+ <i>Effects:</i> Behaves the same as C99 function <tt>cproj</tt>, defined in
+ subclause 7.3.9.4."
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-In 26.4.9 [cmplx.over]/1, add one further entry <tt>proj</tt> to
++In 26.4.9 [cmplx.over] p. 1, add one further entry <tt>proj</tt> to
+ the overload list.
+ </p>
+
+@@ -41533,7 +42266,8 @@ the overload list.
+ <p>
+ The following function templates shall have additional overloads:
+ </p>
+-<blockquote><pre>arg norm
++<blockquote><pre>
++arg norm
+ conj <del>polar</del> <ins>proj</ins>
+ imag real
+ </pre></blockquote>
+@@ -41546,10 +42280,10 @@ imag real
+
+ <hr>
+ <h3><a name="782"></a>782. Extended <tt>seed_seq</tt> constructor is useless</h3>
+-<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-01-27 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-01-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Part of the resolution of n2423, issue 8 was the proposal to
+@@ -41557,7 +42291,8 @@ extend the <tt>seed_seq</tt> constructor accepting an input range
+ as follows (which is now part of N2461):
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator,
++<blockquote><pre>
++template&lt;class InputIterator,
+ size_t u = numeric_limits&lt;iterator_traits&lt;InputIterator&gt;::value_type&gt;::digits&gt;
+ seed_seq(InputIterator begin, InputIterator end);
+ </pre></blockquote>
+@@ -41604,19 +42339,20 @@ Proposed Resolution: Accept Solution A.
+ </blockquote>
+
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#803">803</a> claims to make this issue moot.
++Issue <a href="lwg-defects.html#803">803</a> claims to make this issue moot.
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+ In 26.5.7.1 [rand.util.seedseq]/2, class <tt>seed_seq</tt> synopsis replace:
+ </p>
+
+-<blockquote><pre>class seed_seq
++<blockquote><pre>
++class seed_seq
+ {
+ public:
+ ...
+@@ -41640,7 +42376,8 @@ In 26.5.7.1 [rand.util.seedseq]/2, class <tt>seed_seq</tt> synopsis <em>and</em>
+ member description between p.3 and p.4 replace:
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator<del>,
++<blockquote><pre>
++template&lt;class InputIterator<del>,
+ size_t u = numeric_limits&lt;iterator_traits&lt;InputIterator&gt;::value_type&gt;::digits</del>&gt;
+ seed_seq(InputIterator begin, InputIterator end);
+ <ins>template&lt;class InputIterator, size_t u&gt;
+@@ -41653,7 +42390,8 @@ class <tt>seed_seq</tt> declaration <em>and</em> in 26.5.7.1 [rand.util.seedseq]
+ after the class <tt>seed_seq</tt> definition add:
+ </p>
+
+-<blockquote><pre>template&lt;size_t u, class InputIterator&gt;
++<blockquote><pre>
++template&lt;size_t u, class InputIterator&gt;
+ seed_seq make_seed_seq(InputIterator begin, InputIterator end);
+ </pre></blockquote>
+
+@@ -41679,7 +42417,8 @@ In 26.5.7.1 [rand.util.seedseq], just after the last paragraph add:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;size_t u, class InputIterator&gt;
++<pre>
++template&lt;size_t u, class InputIterator&gt;
+ seed_seq make_seed_seq(InputIterator begin, InputIterator end);
+ </pre>
+ <blockquote>
+@@ -41702,10 +42441,10 @@ where <tt>u</tt> is used to construct an object <tt>s</tt> of implementation-def
+
+ <hr>
+ <h3><a name="783"></a>783. <tt>thread::id</tt> reuse</h3>
+-<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2008-02-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2008-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current working paper
+@@ -41753,7 +42492,7 @@ example:
+ </p>
+
+ <p>
+-<a href="http://www.decadentplace.org.uk/pipermail/cpp-threads/2006-August/001091.html">http://www.decadentplace.org.uk/pipermail/cpp-threads/2006-August/001091.html</a>
++<a href="http://www.decadent.org.uk/pipermail/cpp-threads/2006-August/001091.html">http://www.decadent.org.uk/pipermail/cpp-threads/2006-August/001091.html</a>
+ </p>
+ </blockquote>
+
+@@ -41787,10 +42526,10 @@ terminated thread that can no longer be joined.</ins>
+
+ <hr>
+ <h3><a name="786"></a>786. Thread library timed waits, UTC and monotonic clocks</h3>
+-<p><b>Section:</b> 20.11 [time] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Christopher Kohlhoff, Jeff Garland <b>Opened:</b> 2008-02-03 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time">issues</a> in [time].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.12 [time] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Christopher Kohlhoff, Jeff Garland <b>Opened:</b> 2008-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time">issues</a> in [time].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The draft C++0x thread library requires that the time points of type
+@@ -41799,7 +42538,7 @@ Universal Time (UTC) (section [datetime.system]). This can lead to
+ surprising behavior when a library user performs a duration-based wait,
+ such as <tt>condition_variable::timed_wait()</tt>. A complete explanation of the
+ problem may be found in the
+-<a href="http://www.opengroup.org/onlinepubs/009695399/xrat/xsh_chap02.html#tag_03_02_08_19">Rationale for the Monotonic Clock</a>
++<a href="http://pubs.opengroup.org/onlinepubs/009695399/xrat/xsh_chap02.html#tag_03_02_08_19">Rationale for the Monotonic Clock</a>
+ section in POSIX, but in summary:
+ </p>
+
+@@ -41904,27 +42643,27 @@ Change the constructor <tt>explicit system_time(time_t secs, nanoseconds ns
+ </p>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ Addressed by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.html">N2661: A Foundation to Sleep On</a>.
+-
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm">N2661: A Foundation to Sleep On</a>.
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="787"></a>787. complexity of <tt>binary_search</tt></h3>
+-<p><b>Section:</b> 25.4.3.4 [binary.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-09-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 25.4.3.4 [binary.search] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-09-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 25.4.3.4 [binary.search]/3 the complexity of <tt>binary_search</tt> is described as
++In 25.4.3.4 [binary.search] p. 3 the complexity of <tt>binary_search</tt> is described as
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ At most <tt>log(last - first) + 2</tt> comparisons.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This should be precised and brought in line with the nomenclature used for
+@@ -41934,9 +42673,8 @@ This should be precised and brought in line with the nomenclature used for
+ <p>
+ All existing libraries I'm aware of, delegate to
+ <tt>lower_bound</tt> (+ one further comparison). Since
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a>
+-has now WP status, the resolution of #787 should
+-be brought in-line with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#384">384</a> by changing the <tt>+ 2</tt>
++issue <a href="lwg-defects.html#384">384</a> has now WP status, the resolution of #787 should
++be brought in-line with <a href="lwg-defects.html#384">384</a> by changing the <tt>+ 2</tt>
+ to <tt>+ O(1)</tt>.
+ </p>
+
+@@ -41945,11 +42683,11 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alisdair prefers to apply an upper bound instead of O(1), but that would
+ require fixing for <tt>lower_bound</tt>, <tt>upper_bound</tt> etc. as well. If he really
+ cares about it, he'll send an issue to Howard.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -41958,20 +42696,20 @@ cares about it, he'll send an issue to Howard.
+ Change 25.4.3.4 [binary.search]/3
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Complexity:</i> At most <tt>log<ins><sub>2</sub></ins>(last - first) + <del>2</del> <ins><i>O</i>(1)</ins></tt> comparisons.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="788"></a>788. ambiguity in [istream.iterator]</h3>
+-<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-02-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="788"></a>788. Ambiguity in [istream.iterator]</h3>
++<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-02-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 287</b></p>
+@@ -41979,7 +42717,7 @@ Change 25.4.3.4 [binary.search]/3
+ <blockquote>
+ <p>
+ It is not clear what the initial state of an <tt>istream_iterator</tt> should be. Is
+-_value_ initialized by reading the stream, or default/value initialized? If
++_value_ initialized by reading the stream, or default&#47;value initialized? If
+ it is initialized by reading the stream, what happens if the initialization
+ is deferred until first dereference, when ideally the iterator value should
+ have been that of an end-of-stream iterator which is not safely
+@@ -41995,10 +42733,10 @@ the iterator takes on the end-of-stream value if the stream is empty.
+ <p>
+ The description of how an istream_iterator object becomes an
+ end-of-stream iterator is a) ambiguous and b) out of date WRT
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#468">468</a>:
++issue <a href="lwg-defects.html#468">468</a>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>istream_iterator</tt> reads (using <tt>operator&gt;&gt;</tt>) successive elements from the
+ input stream for which it was constructed. After it is constructed, and
+ every time <tt>++</tt> is used, the iterator reads and stores a value of <tt>T</tt>. If
+@@ -42014,7 +42752,7 @@ store things into istream iterators. The main peculiarity of the istream
+ iterators is the fact that <tt>++</tt> operators are not equality preserving,
+ that is, <tt>i == j</tt> does not guarantee at all that <tt>++i == ++j</tt>. Every time <tt>++</tt>
+ is used a new value is read.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ <tt>istream::operator void*()</tt> returns null if <tt>istream::fail()</tt> is <tt>true</tt>,
+@@ -42036,10 +42774,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Ready to Open for the purposes of using this issue to address NB UK 287.
+ Martin to handle.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -42062,7 +42800,7 @@ Move to Ready.
+ Change 24.6.1 [istream.iterator]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>istream_iterator</tt> reads (using <tt>operator&gt;&gt;</tt>) successive elements from the
+ input stream for which it was constructed. After it is constructed, and
+ every time <tt>++</tt> is used, the iterator reads and stores a value of <tt>T</tt>. If
+@@ -42079,7 +42817,7 @@ store things into istream iterators. The main peculiarity of the istream
+ iterators is the fact that <tt>++</tt> operators are not equality preserving,
+ that is, <tt>i == j</tt> does not guarantee at all that <tt>++i == ++j</tt>. Every time <tt>++</tt>
+ is used a new value is read.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -42087,10 +42825,10 @@ is used a new value is read.
+
+ <hr>
+ <h3><a name="789"></a>789. <tt>xor_combine_engine(result_type)</tt> should be explicit</h3>
+-<p><b>Section:</b> X [rand.adapt.xor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.adapt.xor">issues</a> in [rand.adapt.xor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [rand.adapt.xor] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.adapt.xor">issues</a> in [rand.adapt.xor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>xor_combine_engine(result_type)</tt> should be <tt>explicit</tt>. (Obvious oversight.)
+@@ -42101,14 +42839,14 @@ Bellevue:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Non-controversial. Bill is right, but Fermilab believes that this is
+ easy to use badly and hard to use right, and so it should be removed
+ entirely. Got into TR1 by well defined route, do we have permission to
+ remove stuff? Should probably check with Jens, as it is believed he is
+ the originator. Broad consensus that this is not a robust engine
+ adapter.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -42125,10 +42863,10 @@ Remove X [rand.adapt.xor] <tt>xor_combine_engine</tt>.
+
+ <hr>
+ <h3><a name="792"></a>792. <tt>piecewise_constant_distribution</tt> is undefined for a range with just one endpoint</h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>piecewise_constant_distribution</tt> is undefined for a range with just one
+@@ -42138,12 +42876,562 @@ endpoint. (Probably should be the same as an empty range.)
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 26.5.8.5.2 [rand.dist.samp.pconst] paragraph 3b:
++Change 26.5.8.6.2 [rand.dist.samp.pconst] paragraph 3b:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ b) If <tt>firstB == lastB</tt> <ins>or the sequence <tt>w</tt> has the length zero</ins>,
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="793"></a>793. <tt>discrete_distribution</tt> missing constructor</h3>
++<p><b>Section:</b> 26.5.8.6.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>discrete_distribution</tt> should have a constructor like:
++</p>
++
++<blockquote><pre>
++template&lt;class _Fn&gt;
++ discrete_distribution(result_type _Count, double _Low, double _High,
++ _Fn&amp; _Func);
++</pre></blockquote>
++
++<p>
++(Makes it easier to fill a histogram with function values over a range.)
++</p>
++
++<p><i>[
++Bellevue:
++]</i></p>
++
++
++<blockquote><p>
++How do you specify the function so that it does not return negative
++values? If you do it is a bad construction. This requirement is already
++there. Where in each bin does one evaluate the function? In the middle.
++Need to revisit tomorrow.
++</p></blockquote>
++
++<p><i>[
++Sophia Antipolis:
++]</i></p>
++
++
++<blockquote>
++<p>
++Bill is not requesting this.
++</p>
++<p>
++Marc Paterno: <tt>_Fn</tt> cannot return negative values at the points where the
++function is sampled. It is sampled in the middle of each bin. <tt>_Fn</tt> cannot
++return 0 everywhere it is sampled.
++</p>
++<p>
++Jens: lambda expressions are rvalues
++</p>
++<p>
++Add a library issue to provide an
++<tt>initializer_list&lt;double&gt;</tt> constructor for
++<tt>discrete_distribution</tt>.
++</p>
++<p>
++Marc Paterno: dislikes reference for <tt>_Fn</tt> parameter. Make it pass-by-value (to use lambda),
++use <tt>std::ref</tt> to wrap giant-state function objects.
++</p>
++<p>
++Daniel: See <tt>random_shuffle</tt>, pass-by-rvalue-reference.
++</p>
++<p>
++Daniel to draft wording.
++</p>
++</blockquote>
++
++<p><i>[
++Pre San Francisco, Daniel provided wording:
++]</i></p>
++
++
++<blockquote><p>
++The here proposed changes of the WP refer to the current state of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">N2691</a>.
++During the Sophia Antipolis meeting two different proposals came up
++regarding the functor argument type, either by value or by rvalue-reference.
++For consistence with existing conventions (state-free algorithms and the
++<tt>general_pdf_distribution</tt> c'tor signature) the author decided to propose a
++function argument that is provided by value. If severe concerns exists that
++stateful functions would be of dominant relevance, it should be possible to
++replace the two occurrences of <tt>Func</tt> by <tt>Func&amp;&amp;</tt> in this proposal as part
++of an editorial process.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><b>Non-concept version of the proposed resolution</b></p>
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.1 [rand.dist.samp.discrete]/1, class <tt>discrete_distribution</tt>, just
++<em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit discrete_distribution(const param_type&amp; parm);
++</pre></blockquote>
++
++<p>
++insert:
++</p>
++
++
++<blockquote><pre>
++template&lt;typename Func&gt;
++discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 insert a series of new paragraphs as part of the
++new member description::
++</p>
++<blockquote><pre>
++template&lt;typename Func&gt;
++discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
++</pre>
++
++<p>
++<i>Complexity:</i> Exactly nf invocations of fw.
++</p>
++<p>
++<i>Requires:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++fw shall be callable with one argument of type double, and shall
++return values of a type convertible to double;</li>
++
++<li>If nf &gt; 0, the relation <tt><i>x</i><sub><i>min</i></sub></tt> &lt; <tt><i>x</i><sub><i>max</i></sub></tt> shall hold, and for all sample values
++<tt><i>x</i><sub><i>k</i></sub></tt>, fw(<tt><i>x</i><sub><i>k</i></sub></tt>) shall return a weight value <tt><i>w</i><sub><i>k</i></sub></tt> that is non-negative, non-NaN,
++and non-infinity;</li>
++
++<li>The following relations shall hold: nf &ge; 0, and 0 &lt; S = <tt><i>w</i><sub><i>0</i></sub></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.</li>
++
++</ol>
++
++<p>
++<i>Effects:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and
++ consist of the single value <tt><i>w</i><sub><i>0</i></sub></tt> = 1.</li>
++
++<li>
++<p>Otherwise, sets n = nf, deltax = (<tt><i>x</i><sub><i>max</i></sub></tt> - <tt><i>x</i><sub><i>min</i></sub></tt>)/n
++and <tt><i>x</i><sub><i>cent</i></sub></tt> = <tt><i>x</i><sub><i>min</i></sub></tt> + 0.5 * deltax.</p>
++<p>
++For each k = 0, . . . ,n-1, calculates:</p>
++<p>
++<tt><i>x</i><sub><i>k</i></sub></tt> = <tt><i>x</i><sub><i>cent</i></sub></tt> + k * deltax
++<tt><i>w</i><sub><i>k</i></sub></tt> = fw(<tt><i>x</i><sub><i>k</i></sub></tt>)
++</p>
++</li>
++<li>
++<p>Constructs a discrete_distribution object with probabilities:</p>
++<blockquote><p>
++<tt><i>p</i><sub><i>k</i></sub></tt> = <tt><i>w</i><sub><i>k</i></sub></tt>/S for k = 0, . . . , n-1.
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++</li>
++</ol>
++
++<p><b>Concept version of the proposed resolution</b></p>
++
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.1 [rand.dist.samp.discrete]/1, class <tt>discrete_distribution</tt>, just
++<em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit discrete_distribution(const param_type&amp; parm);
++</pre></blockquote>
++
++<p>
++insert:
++</p>
++
++
++<blockquote><pre>
++template&lt;Callable&lt;auto, double&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 insert a series of new paragraphs as part of the
++new member description::
++</p>
++<blockquote><pre>
++template&lt;Callable&lt;auto, double&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++discrete_distribution(result_type nf, double xmin, double xmax, Func fw);
++</pre>
++
++<p>
++<i>Complexity:</i> Exactly nf invocations of fw.
++</p>
++<p>
++<i>Requires:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>If nf &gt; 0, the relation <tt><i>x</i><sub><i>min</i></sub></tt> &lt; <tt><i>x</i><sub><i>max</i></sub></tt> shall hold, and for all sample values
++<tt><i>x</i><sub><i>k</i></sub></tt>, fw(<tt><i>x</i><sub><i>k</i></sub></tt>) shall return a weight value <tt><i>w</i><sub><i>k</i></sub></tt> that is non-negative, non-NaN,
++and non-infinity;</li>
++
++<li>The following relations shall hold: nf &ge; 0, and 0 &lt; S = <tt><i>w</i><sub><i>0</i></sub></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.</li>
++
++</ol>
++
++<p>
++<i>Effects:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>If nf == 0, sets n = 1 and lets the sequence w have length n = 1 and
++ consist of the single value <tt><i>w</i><sub><i>0</i></sub></tt> = 1.</li>
++
++<li>
++<p>Otherwise, sets n = nf, deltax = (<tt><i>x</i><sub><i>max</i></sub></tt> - <tt><i>x</i><sub><i>min</i></sub></tt>)/n
++and <tt><i>x</i><sub><i>cent</i></sub></tt> = <tt><i>x</i><sub><i>min</i></sub></tt> + 0.5 * deltax.
++<p/>
++For each k = 0, . . . ,n-1, calculates:
++<p/>
++<tt><i>x</i><sub><i>k</i></sub></tt> = <tt><i>x</i><sub><i>cent</i></sub></tt> + k * deltax
++<tt><i>w</i><sub><i>k</i></sub></tt> = fw(<tt><i>x</i><sub><i>k</i></sub></tt>)
++</p>
++</li>
++<li>
++<p>Constructs a discrete_distribution object with probabilities:</p>
++<blockquote><p>
++<tt><i>p</i><sub><i>k</i></sub></tt> = <tt><i>w</i><sub><i>k</i></sub></tt>/S for k = 0, . . . , n-1.
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++</li>
++</ol>
++
++
++
++<p><b>Rationale:</b></p><p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="794"></a>794. <tt>piecewise_constant_distribution</tt> missing constructor</h3>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2008-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>piecewise_constant_distribution</tt> should have a constructor like:
++</p>
++
++<blockquote><pre>
++template&lt;class _Fn&gt;
++ piecewise_constant_distribution(size_t _Count,
++ _Ty _Low, _Ty _High, _Fn&amp; _Func);
++</pre></blockquote>
++
++<p>
++(Makes it easier to fill a histogram with function values over a range.
++The two (reference <a href="lwg-defects.html#793">793</a>) make a sensible replacement for
++<tt>general_pdf_distribution</tt>.)
++</p>
++
++<p><i>[
++Sophia Antipolis:
++]</i></p>
++
++
++<blockquote>
++<p>
++Marc: uses variable width of bins and weight for each bin. This is not
++giving enough flexibility to control both variables.
++</p>
++<p>
++Add a library issue to provide an constructor taking an
++<tt>initializer_list&lt;double&gt;</tt> and <tt>_Fn</tt> for <tt>piecewise_constant_distribution</tt>.
++</p>
++<p>
++Daniel to draft wording.
++</p>
++</blockquote>
++
++<p><i>[
++Pre San Francisco, Daniel provided wording.
++]</i></p>
++
++
++<blockquote><p>
++The here proposed changes of the WP refer to the current state of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">N2691</a>.
++For reasons explained in <a href="lwg-defects.html#793">793</a>, the author decided to propose a function
++argument that is provided by value. The issue proposes a c'tor signature,
++that does not take advantage of the full flexibility of
++<tt>piecewise_constant_distribution</tt>,
++because it restricts on a constant bin width, but the use-case seems to
++be popular enough to justify it's introduction.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><b>Non-concept version of the proposed resolution</b></p>
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
++just <em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit piecewise_constant_distribution(const param_type&amp; parm);
++</pre></blockquote>
++<p>
++insert:
++</p>
++<blockquote><pre>
++template&lt;typename Func&gt;
++piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 insert a new sequence of paragraphs nominated
++below as [p5_1], [p5_2],
++[p5_3], and [p5_4] as part of the new member description:
++</p>
++
++<blockquote><pre>
++template&lt;typename Func&gt;
++piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
++</pre>
++<blockquote>
++<p>
++[p5_1] <i>Complexity:</i> Exactly <tt>nf</tt> invocations of <tt>fw</tt>.
++</p>
++<p>
++[p5_2] <i>Requires:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li><tt>fw</tt> shall be callable with one argument of type <tt>RealType</tt>, and shall
++return values of a type convertible to double;
++</li>
++<li>
++For all sample values <tt><i>x<sub>k</sub></i></tt> defined below, fw(<tt><i>x<sub>k</sub></i></tt>) shall return a weight
++value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
++</li>
++<li>
++The following relations shall hold: <tt><i>x<sub>min</sub></i></tt> &lt; <tt><i>x<sub>max</sub></i></tt>, and
++0 &lt; S = <tt><i>w<sub>0</sub></i></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.
++</li>
++</ol>
++<p>
++[p5_3] <i>Effects:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++<p>If nf == 0,</p>
++ <ol style="list-style-type:lower-alpha">
++ <li>
++sets deltax = <tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>, and</li>
++<li> lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
++ value <tt><i>w<sub>0</sub></i></tt> = 1, and</li>
++<li> lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt><i>b<sub>0</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> and
++ <tt><i>b<sub>1</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt>
++</li>
++</ol>
++</li>
++<li>
++<p>Otherwise,</p>
++<ol style="list-style-type:lower-alpha">
++<li> sets <tt>n = nf</tt>, <tt>deltax = </tt>(<tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>)/n,
++ <tt><i>x<sub>cent</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + 0.5 * deltax, and
++</li>
++<li><p>lets the sequences <tt>w</tt> and <tt>b</tt> have length <tt>n</tt> and <tt>n+1</tt>, resp. and
++<p/>
++for each k = 0, . . . ,n-1, calculates:
++<p/>
++ <tt><i>dx<sub>k</sub></i></tt> = k * deltax
++ <tt><i>b<sub>k</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
++ <tt><i>x<sub>k</sub></i></tt> = <tt><i>x<sub>cent</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
++ <tt><i>w<sub>k</sub></i></tt> = fw(<tt><i>x<sub>k</sub></i></tt>),
++</p>
++<p> and</p>
++</li>
++<li> sets <tt><i>b<sub>n</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt></li>
++</ol>
++</li>
++<li>
++<p>
++Constructs a <tt>piecewise_constant_distribution</tt> object with
++the above computed sequence <tt>b</tt> as the interval boundaries
++and with the probability densities:
++</p>
++<blockquote><p>
++<tt><i>&rho;<sub>k</sub></i></tt> = <tt><i>w<sub>k</sub></i></tt>/(S * deltax) for k = 0, . . . , n-1.
++</p></blockquote>
++</li>
++</ol>
++<p>
++[p5_4] [<i>Note:</i> In this context, the subintervals [<tt><i>b<sub>k</sub></i></tt>, <tt><i>b<sub>k+1</sub></i></tt>) are commonly
++ known as the <i>bins</i> of a histogram. <i>-- end note</i>]
++ </p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++<p><b>Concept version of the proposed resolution</b></p>
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
++just <em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit piecewise_constant_distribution(const param_type&amp; parm);
++</pre></blockquote>
++<p>
++insert:
++</p>
++<blockquote><pre>
++template&lt;Callable&lt;auto, RealType&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 insert a new sequence of paragraphs nominated
++below as [p5_1], [p5_2],
++[p5_3], and [p5_4] as part of the new member description:
++</p>
++
++<blockquote><pre>
++template&lt;Callable&lt;auto, RealType&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++piecewise_constant_distribution(size_t nf, RealType xmin, RealType xmax, Func fw);
++</pre>
++<blockquote>
++<p>
++[p5_1] <i>Complexity:</i> Exactly <tt>nf</tt> invocations of <tt>fw</tt>.
++</p>
++<p>
++[p5_2] <i>Requires:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++For all sample values <tt><i>x<sub>k</sub></i></tt> defined below, fw(<tt><i>x<sub>k</sub></i></tt>) shall return a weight
++value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
++</li>
++<li>
++The following relations shall hold: <tt><i>x<sub>min</sub></i></tt> &lt; <tt><i>x<sub>max</sub></i></tt>, and
++0 &lt; S = <tt><i>w<sub>0</sub></i></tt>+. . .+<tt><i>w<sub>n-1</sub></i></tt>.
++</li>
++</ol>
++<p>
++[p5_3] <i>Effects:</i>
++</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++<p>If nf == 0,</p>
++ <ol style="list-style-type:lower-alpha">
++ <li>
++sets deltax = <tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>, and</li>
++<li> lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
++ value <tt><i>w<sub>0</sub></i></tt> = 1, and</li>
++<li> lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt><i>b<sub>0</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> and
++ <tt><i>b<sub>1</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt>
++</li>
++</ol>
++</li>
++<li>
++<p>Otherwise,</p>
++<ol style="list-style-type:lower-alpha">
++<li> sets <tt>n = nf</tt>, <tt>deltax = </tt>(<tt><i>x<sub>max</sub></i></tt> - <tt><i>x<sub>min</sub></i></tt>)/n,
++ <tt><i>x<sub>cent</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + 0.5 * deltax, and
++</li>
++<li><p>lets the sequences <tt>w</tt> and <tt>b</tt> have length <tt>n</tt> and <tt>n+1</tt>, resp. and
++<p/>
++for each k = 0, . . . ,n-1, calculates:
++ <tt><i>dx<sub>k</sub></i></tt> = k * deltax
++ <tt><i>b<sub>k</sub></i></tt> = <tt><i>x<sub>min</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
++ <tt><i>x<sub>k</sub></i></tt> = <tt><i>x<sub>cent</sub></i></tt> + <tt><i>dx<sub>k</sub></i></tt>
++ <tt><i>w<sub>k</sub></i></tt> = fw(<tt><i>x<sub>k</sub></i></tt>),
++</p>
++<p> and</p>
++</li>
++<li> sets <tt><i>b<sub>n</sub></i></tt> = <tt><i>x<sub>max</sub></i></tt></li>
++</ol>
++</li>
++<li>
++<p>
++Constructs a <tt>piecewise_constant_distribution</tt> object with
++the above computed sequence <tt>b</tt> as the interval boundaries
++and with the probability densities:
++</p>
++<blockquote><p>
++<tt><i>&rho;<sub>k</sub></i></tt> = <tt><i>w<sub>k</sub></i></tt>/(S * deltax) for k = 0, . . . , n-1.
++</p></blockquote>
++</li>
++</ol>
++<p>
++[p5_4] [<i>Note:</i> In this context, the subintervals [<tt><i>b<sub>k</sub></i></tt>, <tt><i>b<sub>k+1</sub></i></tt>) are commonly
++ known as the <i>bins</i> of a histogram. <i>-- end note</i>]
++ </p>
+ </blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>
++"Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
+
+
+
+@@ -42151,15 +43439,15 @@ b) If <tt>firstB == lastB</tt> <ins>or the sequence <tt>w</tt> has the length ze
+
+ <hr>
+ <h3><a name="798"></a>798. Refactoring of binders lead to interface breakage</h3>
+-<p><b>Section:</b> D.11 [depr.lib.binders] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-02-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [depr.lib.binders] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.lib.binders">issues</a> in [depr.lib.binders].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2521.pdf">N2521</a>
+ and its earlier predecessors have moved the old binders from
+-[lib.binders] to D.11 [depr.lib.binders] thereby introducing some renaming
++[lib.binders] to X [depr.lib.binders] thereby introducing some renaming
+ of the template parameter names (<tt>Operation -&gt; Fn</tt>). During this
+ renaming process the <em>protected</em> data member <tt>op</tt> was also renamed to
+ <tt>fn</tt>, which seems as an unnecessary interface breakage to me - even if
+@@ -42169,11 +43457,12 @@ this user access point is probably rarely used.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change D.11.1 [depr.lib.binder.1st]:
++Change [depr.lib.binder.1st]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Fn&gt;
++<pre>
++template &lt;class Fn&gt;
+ class binder1st
+ : public unary_function&lt;typename Fn::second_argument_type,
+ typename Fn::result_type&gt; {
+@@ -42201,11 +43490,12 @@ public:
+ </blockquote>
+
+ <p>
+-Change D.11.3 [depr.lib.binder.2nd]:
++Change [depr.lib.binder.2nd]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Fn&gt;
++<pre>
++template &lt;class Fn&gt;
+ class binder2nd
+ : public unary_function&lt;typename Fn::first_argument_type,
+ typename Fn::result_type&gt; {
+@@ -42238,11 +43528,96 @@ public:
+
+
+ <hr>
++<h3><a name="800"></a>800. Issues in 26.4.7.1 [rand.util.seedseq](6)</h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Stephan Tolksdorf <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The for-loop in the algorithm specification has <tt>n</tt> iterations, where <tt>n</tt> is
++defined to be <tt>end - begin</tt>, i.e. the number of supplied w-bit quantities.
++Previous versions of this algorithm and the general logic behind it
++suggest that this is an oversight and that in the context of the
++for-loop <tt>n</tt> should be the number of full 32-bit quantities in <tt>b</tt> (rounded
++upwards). If <tt>w</tt> is 64, the current algorithm throws away half of all bits
++in <tt>b</tt>. If <tt>w</tt> is 16, the current algorithm sets half of all elements in <tt>v</tt>
++to 0.
++</p>
++
++<p>
++There are two more minor issues:
++</p>
++
++<ul>
++<li>
++Strictly speaking <tt>end - begin</tt> is not defined since
++<tt>InputIterator</tt> is not required to be a random access iterator.
++</li>
++<li>
++Currently all integral types are allowed as input to the <tt>seed_seq</tt>
++constructor, including <tt>bool</tt>. IMHO allowing <tt>bool</tt>s unnecessarily
++complicates the implementation without any real benefit to the user.
++I'd suggest to exclude <tt>bool</tt>s as input.
++</li>
++</ul>
++
++<p><i>[
++Bellevue:
++]</i></p>
++
++
++<blockquote><p>
++Move to Open: Bill will try to propose a resolution by the next meeting.
++</p></blockquote>
++
++<p><i>[
++post Bellevue: Bill provided wording.
++]</i></p>
++
++
++<p>
++This issue is made moot if <a href="lwg-defects.html#803">803</a> is accepted.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Replace 26.5.7.1 [rand.util.seedseq] paragraph 6 with:
++</p>
++
++<blockquote>
++<p>
++<i>Effects:</i> Constructs a <tt>seed_seq</tt> object by effectively concatenating the
++low-order <tt>u</tt> bits of each of the elements of the supplied sequence <tt>[begin,
++end)</tt> in ascending order of significance to make a (possibly very large) unsigned
++binary number <tt>b</tt> having a total of <tt>n</tt> bits, and then carrying out the
++following algorithm:
++</p>
++
++<blockquote><p style="white-space: pre;">
++for( v.clear(); n &gt; 0; n -= 32 )
++ v.push_back(b mod 2<sup>32</sup>), b /= 2<sup>32</sup>;
++</p></blockquote>
++</blockquote>
++
++
++<p><b>Rationale:</b></p><p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>
++"Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
++
++
++
++
++<hr>
+ <h3><a name="801"></a>801. <tt>tuple</tt> and <tt>pair</tt> trivial members</h3>
+-<p><b>Section:</b> 20.4 [tuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple">issues</a> in [tuple].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.4 [tuple] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-02-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple">issues</a> in [tuple].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Classes with trivial special member functions are inherently more
+@@ -42271,7 +43646,8 @@ which prevents static initialization of the pair even when the
+ types are statically initializable. Changing the definition to
+ </p>
+
+-<blockquote><pre>pair() = default;
++<blockquote><pre>
++pair() = default;
+ </pre></blockquote>
+
+ <p>
+@@ -42294,7 +43670,8 @@ passing <tt>tuples</tt> in registers, the copy constructor should be
+ make explicitly <tt>default</tt>ed. The new declarations are:
+ </p>
+
+-<blockquote><pre>tuple() = default;
++<blockquote><pre>
++tuple() = default;
+ tuple(const tuple&amp;) = default;
+ </pre></blockquote>
+
+@@ -42339,19 +43716,19 @@ tabled until Alisdair's proposals are disposed of.
+ ]</i></p>
+
+
+-<blockquote>
+-This is partly solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1117">1117</a>.
+-</blockquote>
++<blockquote><p>
++This is partly solved by <a href="lwg-defects.html#1117">1117</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Wait for dust to settle from fixing exception safety problem
+ with rvalue refs.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-20 Alisdair adds:
+@@ -42388,9 +43765,9 @@ implied in the process (even if elided).
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as open. Alisdair to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+@@ -42410,45 +43787,306 @@ constexpr default constructors, but we're not sure.
+ ]</i></p>
+
+
++<blockquote><p>
++Daniel believes his pair&#47;tuple paper will resolve this issue. <tt>constexpr</tt>
++will allow static initialization, and he is already changing the move and copy
++constructors to be defaulted.
++</p></blockquote>
++
++<p><i>[
++2010-10-24 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++The proposed resolution of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>
++should resolve this issue.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="803"></a>803. Simplification of <tt>seed_seq::seq_seq</tt></h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Charles Karney <b>Opened:</b> 2008-02-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>seed_seq(InputIterator begin, InputIterator end);</tt> constructs a <tt>seed_seq</tt>
++object repacking the bits of supplied sequence <tt>[begin, end)</tt> into a
++32-bit vector.
++</p>
++<p>
++This repacking triggers several problems:
++</p>
++<ol>
++<li>
++Distinctness of the output of <tt>seed_seq::generate</tt> required the
++introduction of the initial "<tt>if (w &lt; 32) v.push_back(n);</tt>" (Otherwise
++the unsigned short vectors [1, 0] and [1] generate the same sequence.)
++</li>
++<li>
++Portability demanded the introduction of the template parameter <tt>u</tt>.
++(Otherwise some sequences could not be obtained on computers where no
++integer types are exactly 32-bits wide.)
++</li>
++<li>
++The description and algorithm have become unduly complicated.
++</li>
++</ol>
++<p>
++I propose simplifying this <tt>seed_seq</tt> constructor to be "32-bit only".
++Despite it's being simpler, there is NO loss of functionality (see
++below).
++</p>
++<p>
++Here's how the description would read
++</p>
++<blockquote>
++<p>
++26.5.7.1 [rand.util.seedseq] Class <tt>seed_seq</tt>
++</p>
++
++<blockquote>
++<pre>
++template&lt;class InputIterator&gt;
++ seed_seq(InputIterator begin, InputIterator end);
++</pre>
+ <blockquote>
+-Daniel believes his pair/tuple paper will resolve this issue. <tt>constexpr</tt> will allow static initialization, and he is already changing the move and copy constructors to be defaulted.
++<p>
++5 <i>Requires:</i> NO CHANGE
++</p>
++<p>
++6 <i>Effects:</i> Constructs a <tt>seed_seq</tt> object by
++</p>
++<blockquote><p style="white-space: pre;">
++for (InputIterator s = begin; s != end; ++s)
++ v.push_back((*s) mod 2<sup>32</sup>);
++</p></blockquote>
++</blockquote>
++</blockquote>
+ </blockquote>
+
++<p>
++Discussion:
++</p>
++<p>
++The chief virtues here are simplicity, portability, and generality.
++</p>
++<ul>
++<li>
++Simplicity &mdash; compare the above specification with the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a> proposal.
++</li>
++<li>
++Portability &mdash; with <tt>iterator_traits&lt;InputIterator&gt;::value_type =
++uint_least32_t</tt> the user is guaranteed to get the same behavior across
++platforms.
++</li>
++<li>
++Generality &mdash; any behavior that the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
++proposal can achieve can be
++obtained with this simpler proposal (albeit with a shuffling of bits
++in the input sequence).
++</li>
++</ul>
++<p>
++Arguments (and counter-arguments) against making this change (and
++retaining the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
++behavior) are:
++</p>
++<ul>
++<li>
++<p>
++The user can pass an array of <tt>unsigned char</tt> and <tt>seed_seq</tt> will nicely
++ repack it.
++</p>
++<p>
++ Response: So what? Consider the seed string "ABC". The
++ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
++ proposal results in
++</p>
++<blockquote><pre>
++v = { 0x3, 0x434241 };
++</pre></blockquote>
++<p>
++while the simplified proposal yields
++</p>
++<blockquote><pre>
++v = { 0x41, 0x42, 0x43 };
++</pre></blockquote>
++<p>
++The results produced by <tt>seed_seq::generate</tt> with the two inputs are
++different but nevertheless equivalently "mixed up" and this remains
++true even if the seed string is long.
++</p>
++</li>
++<li>
++<p>
++With long strings (e.g., with bit-length comparable to the number of
++ bits in the state), <tt>v</tt> is longer (by a factor of 4) with the simplified
++ proposal and <tt>seed_seq::generate</tt> will be slower.
++</p>
++<p>
++Response: It's unlikely that the efficiency of <tt>seed_seq::generate</tt> will
++ be a big issue. If it is, the user is free to repack the seed vector
++ before constructing <tt>seed_seq</tt>.
++</p>
++</li>
++<li>
++<p>
++A user can pass an array of 64-bit integers and all the bits will be
++ used.
++</p>
++<p>
++ Response: Indeed. However, there are many instances in the
++ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
++ where integers are silently coerced to a narrower width and this
++ should just be a case of the user needing to read the documentation.
++ The user can of course get equivalent behavior by repacking his seed
++ into 32-bit pieces. Furthermore, the unportability of the
++ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">n2461</a>
++ proposal with
++</p>
++<blockquote><pre>
++unsigned long s[] = {1, 2, 3, 4};
++seed_seq q(s, s+4);
++</pre></blockquote>
++<p>
++ which typically results in <tt>v = {1, 2, 3, 4}</tt> on 32-bit machines and in
++<tt>v = {1, 0, 2, 0, 3, 0, 4, 0}</tt> on 64-bit machines is a major pitfall for
++ unsuspecting users.
++</p>
++</li>
++</ul>
++
++<p>
++Note: this proposal renders moot issues <a href="lwg-defects.html#782">782</a> and <a href="lwg-defects.html#800">800</a>.
++</p>
++
+ <p><i>[
+-2010-10-24 Daniel adds:
++Bellevue:
++]</i></p>
++
++
++<blockquote><p>
++Walter needs to ask Fermilab for guidance. Defer till tomorrow. Bill likes the proposed resolution.
++</p></blockquote>
++
++<p><i>[
++Sophia Antipolis:
+ ]</i></p>
+
+
+ <blockquote>
+-The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> should resolve this issue.
++<p>
++Marc Paterno wants portable behavior between 32bit and 64bit machines;
++we've gone to significant trouble to support portability of engines and
++their values.
++</p>
++<p>
++Jens: the new algorithm looks perfectly portable
++</p>
++<p>
++Marc Paterno to review off-line.
++</p>
++<p>
++Modify the proposed resolution to read "Constructs a seed_seq object by the following algorithm ..."
++</p>
++<p>
++Disposition: move to review; unanimous consent.
++</p>
++<p>
++(moots <a href="lwg-defects.html#782">782</a> and <a href="lwg-defects.html#800">800</a>)
++</p>
+ </blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
++Change 26.5.7.1 [rand.util.seedseq]:
+ </p>
+
++<blockquote>
++<pre>
++template&lt;class InputIterator<del>,
++ size_t u = numeric_limits&lt;iterator_traits&lt;InputIterator&gt;::value_type&gt;::digits</del>&gt;
++ seed_seq(InputIterator begin, InputIterator end);
++</pre>
++<blockquote>
++<p>
++-5- <i>Requires:</i> <tt>InputIterator</tt> shall satisfy the requirements of an input iterator (24.1.1)
++such that <tt>iterator_traits&lt;InputIterator&gt;::value_type</tt> shall denote an integral type.
++</p>
++<p>
++-6- Constructs a <tt>seed_seq</tt> object by <ins>the following algorithm</ins> <del>rearranging some or all of the bits of the supplied sequence
++<tt>[begin,end)</tt> of w-bit quantities into 32-bit units, as if by the following: </del>
++</p>
++<p>
++<del>First extract the rightmost <tt>u</tt> bits from each of the <tt>n = end
++- begin</tt> elements of the supplied sequence and concatenate all the
++extracted bits to initialize a single (possibly very large) unsigned
++binary number, <tt>b = &sum;<sup>n-1</sup><sub>i=0</sub> (begin[i]
++mod 2<sup>u</sup>) &middot; 2<sup>w&middot;i</sup></tt> (in which the bits of each <tt>begin[i]</tt>
++are treated as denoting an unsigned quantity). Then carry out
++the following algorithm:</del>
++</p>
++<blockquote><p style="white-space: pre;"><del>
++v.clear();
++if ($w$ &lt; 32)
++ v.push_back($n$);
++for( ; $n$ &gt; 0; --$n$)
++ v.push_back(b mod 2<sup>32</sup>), b /= 2<sup>32</sup>;
++</del></p></blockquote>
++<blockquote>
++<p style="white-space: pre;"><ins>
++for (InputIterator s = begin; s != end; ++s)
++ v.push_back((*s) mod 2<sup>32</sup>);
++</ins></p>
++</blockquote>
++</blockquote>
++</blockquote>
++
++
++<p><b>Rationale:</b></p><p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>
++"Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
+
+
+
+
+ <hr>
+ <h3><a name="804"></a>804. Some problems with classes <tt>error_code</tt>/<tt>error_condition</tt></h3>
+-<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-02-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#syserr">issues</a> in [syserr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-02-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr">issues</a> in [syserr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+ 19.5.2.1 [syserr.errcode.overview]/1, class <tt>error_code</tt> and
+ 19.5.3.1 [syserr.errcondition.overview]/, class <tt>error_condition</tt> synopses
+ declare an expository data member <tt>cat_</tt>:
+ </p>
+-<blockquote><pre>const error_category&amp; cat_; // exposition only
++<blockquote><pre>
++const error_category&amp; cat_; // exposition only
+ </pre></blockquote>
+ <p>
+ which is used to define the semantics of several members. The decision
+@@ -42486,7 +44124,7 @@ The member function <tt>message</tt> throws clauses (
+ 19.5.3.4 [syserr.errcondition.observers]/6) guarantee "throws nothing",
+ although
+ they return a <tt>std::string</tt> by value, which might throw in out-of-memory
+-conditions (see related issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#771">771</a>).
++conditions (see related issue <a href="lwg-defects.html#771">771</a>).
+ </li>
+ </ol>
+
+@@ -42497,14 +44135,14 @@ Sophia Antipolis:
+
+ <blockquote>
+ <p>
+-Part A: NAD (editorial), cleared by the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>.
++Part A: NAD (editorial), cleared by the resolution of issue <a href="lwg-closed.html#832">832</a>.
+ </p>
+ <p>
+ Part B: Technically correct, save for typo. Rendered moot by the concept proposal
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2620.html">N2620</a>) NAD (editorial).
+ </p>
+ <p>
+-Part C: We agree; this is consistent with the resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721">721</a>.
++Part C: We agree; this is consistent with the resolution of issue <a href="lwg-closed.html#721">721</a>.
+ </p>
+ <p>
+ Howard: please ping Beman, asking him to clear away parts A and B from
+@@ -42512,7 +44150,7 @@ the wording in the proposed resolution, so it is clear to the editor
+ what needs to be applied to the working paper.
+ </p>
+ <p>
+-Beman provided updated wording. Since issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a> is not going
++Beman provided updated wording. Since issue <a href="lwg-closed.html#832">832</a> is not going
+ forward, the provided wording includes resolution of part A.
+ </p>
+ </blockquote>
+@@ -42529,7 +44167,8 @@ Resolution of part A:
+ Change 19.5.2.1 [syserr.errcode.overview] Class error_code overview synopsis as indicated:
+ </p>
+
+-<blockquote><pre>private:
++<blockquote><pre>
++private:
+ int val_; // exposition only
+ const error_category<del>&amp;</del><ins>*</ins> cat_; // exposition only
+ </pre></blockquote>
+@@ -42539,7 +44178,8 @@ Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors as i
+ </p>
+
+ <blockquote>
+-<pre>error_code();
++<pre>
++error_code();
+ </pre>
+ <blockquote>
+ <p>
+@@ -42552,7 +44192,8 @@ Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors as i
+ <i>Throws:</i> Nothing.
+ </p>
+ </blockquote>
+-<pre>error_code(int val, const error_category&amp; cat);
++<pre>
++error_code(int val, const error_category&amp; cat);
+ </pre>
+ <blockquote>
+ <p>
+@@ -42572,7 +44213,8 @@ Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as indicat
+ </p>
+
+ <blockquote>
+-<pre>void assign(int val, const error_category&amp; cat);
++<pre>
++void assign(int val, const error_category&amp; cat);
+ </pre>
+ <blockquote>
+ <p>
+@@ -42588,9 +44230,9 @@ Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as indicat
+ Change 19.5.2.4 [syserr.errcode.observers] Class error_code observers as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><pre>
+ const error_category&amp; category() const;
+-<blockquote>
++</pre><blockquote>
+ <p>
+ <i>Returns:</i> <tt><ins>*</ins>cat_</tt>.
+ </p>
+@@ -42604,7 +44246,8 @@ const error_category&amp; category() const;
+ Change 19.5.3.1 [syserr.errcondition.overview] Class error_condition overview synopsis as indicated:
+ </p>
+
+-<blockquote><pre>private:
++<blockquote><pre>
++private:
+ int val_; // exposition only
+ const error_category<del>&amp;</del><ins>*</ins> cat_; // exposition only
+ </pre></blockquote>
+@@ -42613,14 +44256,15 @@ Change 19.5.3.1 [syserr.errcondition.overview] Class error_condition overview sy
+ Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
+ </p>
+ <p><i>[
+-(If the proposed resolution of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#805">805</a> has already been applied, the
++(If the proposed resolution of issue <a href="lwg-defects.html#805">805</a> has already been applied, the
+ name <tt>posix_category</tt> will have been changed to <tt>generic_category</tt>. That has
+ no effect on this resolution.)
+ ]</i></p>
+
+
+ <blockquote>
+-<pre>error_condition();
++<pre>
++error_condition();
+ </pre>
+ <blockquote>
+ <p>
+@@ -42633,7 +44277,8 @@ no effect on this resolution.)
+ <i>Throws:</i> Nothing.
+ </p>
+ </blockquote>
+-<pre>error_condition(int val, const error_category&amp; cat);
++<pre>
++error_condition(int val, const error_category&amp; cat);
+ </pre>
+ <blockquote>
+ <p>
+@@ -42652,9 +44297,9 @@ no effect on this resolution.)
+ Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><pre>
+ void assign(int val, const error_category&amp; cat);
+-<blockquote>
++</pre><blockquote>
+ <p>
+ <i>Postconditions:</i> <tt>val_ == val</tt> and <tt>cat_ == <ins>&amp;</ins>cat</tt>.
+ </p>
+@@ -42668,9 +44313,9 @@ void assign(int val, const error_category&amp; cat);
+ Change 19.5.3.4 [syserr.errcondition.observers] Class error_condition observers as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><pre>
+ const error_category&amp; category() const;
+-<blockquote>
++</pre><blockquote>
+ <p>
+ <i>Returns:</i> <tt><ins>*</ins>cat_</tt>.
+ </p>
+@@ -42692,7 +44337,8 @@ In 19.5.1.2 [syserr.errcat.virtuals], remove the throws clause p. 10.
+ </p>
+
+ <blockquote>
+-<pre>virtual string message(int ev) const = 0;
++<pre>
++virtual string message(int ev) const = 0;
+ </pre>
+
+ <blockquote>
+@@ -42710,7 +44356,8 @@ In 19.5.2.4 [syserr.errcode.observers], remove the throws clause p. 8.
+ </p>
+
+ <blockquote>
+-<pre>string message() const;
++<pre>
++string message() const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -42727,7 +44374,8 @@ In 19.5.3.4 [syserr.errcondition.observers], remove the throws clause p. 6.
+ </p>
+
+ <blockquote>
+-<pre>string message() const;
++<pre>
++string message() const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -42748,23 +44396,24 @@ In 19.5.3.4 [syserr.errcondition.observers], remove the throws clause p. 6.
+
+ <hr>
+ <h3><a name="805"></a>805. <tt>posix_error::posix_errno</tt> concerns</h3>
+-<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-02-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#syserr">issues</a> in [syserr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-02-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr">issues</a> in [syserr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 19.5 [syserr]
+ </p>
+
+-<blockquote><pre>namespace posix_error {
++<blockquote><pre>
++namespace posix_error {
+ enum posix_errno {
+ address_family_not_supported, // EAFNOSUPPORT
+ ...
+ </pre></blockquote>
+
+ <p>
+-should rather use the new scoped-enum facility (7.2 [dcl.enum]),
++should rather use the new scoped-enum facility (7.2 [dcl.enum]),
+ which would avoid the necessity for a new <tt>posix_error</tt>
+ namespace, if I understand correctly.
+ </p>
+@@ -42796,7 +44445,8 @@ The wording for the Proposed resolution was provided by Beman Dawes.
+ Change System error support 19.5 [syserr] as indicated:
+ </p>
+
+-<blockquote><pre><del>namespace posix_error {</del>
++<blockquote><pre>
++<del>namespace posix_error {</del>
+ enum <del>posix_errno</del> <ins>class errc</ins> {
+ address_family_not_supported, // EAFNOSUPPORT
+ ...
+@@ -42817,12 +44467,12 @@ template &lt;&gt; struct is_error_condition_enum&lt;<del>posix_error::posix_errn
+ Change System error support 19.5 [syserr] :
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del>The <tt>is_error_code_enum</tt> and <tt>is_error_condition_enum</tt> templates may be
+ specialized for user-defined types to indicate that such a type is
+ eligible for class <tt>error_code</tt> and class <tt>error_condition</tt> automatic
+ conversions, respectively.</del>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change System error support 19.5 [syserr] and its subsections:
+@@ -42849,24 +44499,25 @@ change all instances of <tt>get_posix_category</tt> to <tt>get_generic_category<
+ Change Error category objects 19.5.1.5 [syserr.errcat.objects], paragraph 2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Remarks:</i> The object's <tt>default_error_condition</tt> and equivalent virtual
+ functions shall behave as specified for the class <tt>error_category</tt>. The
+ object's name virtual function shall return a pointer to the string
+ <del>"POSIX"</del> <ins>"generic"</ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change 19.5.2.5 [syserr.errcode.nonmembers] Class <tt>error_code</tt> non-member functions as indicated:
+ </p>
+
+ <blockquote>
+-<pre>error_code make_error_code(<del>posix_errno</del> <ins>errc</ins> e);
++<pre>
++error_code make_error_code(<del>posix_errno</del> <ins>errc</ins> e);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>error_code(<ins>static_cast&lt;int&gt;(</ins>e<ins>)</ins>, <del>posix</del><ins>generic</ins>_category)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -42874,19 +44525,20 @@ Change 19.5.3.5 [syserr.errcondition.nonmembers] Class <tt>error_condition</tt>
+ </p>
+
+ <blockquote>
+-<pre>error_condition make_error_condition(<del>posix_errno</del> <ins>errc</ins> e);
++<pre>
++error_condition make_error_condition(<del>posix_errno</del> <ins>errc</ins> e);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>error_condition(<ins>static_cast&lt;int&gt;(</ins>e<ins>)</ins>, <del>posix</del><ins>generic</ins>_category)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+
+ <p><b>Rationale:</b></p>
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th colspan="2">Names Considered</th>
+ </tr>
+
+@@ -42992,7 +44644,7 @@ name, given the existing <tt>errno</tt> and <tt>namespace std</tt> names, it see
+ intuitive. There are no uses of <tt>errc</tt> in the current C++ standard.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+
+
+
+@@ -43000,22 +44652,22 @@ intuitive. There are no uses of <tt>errc</tt> in the current C++ standard.
+
+ <hr>
+ <h3><a name="806"></a>806. <tt>unique_ptr::reset</tt> effects incorrect, too permissive</h3>
+-<p><b>Section:</b> 20.9.9.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.1.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>void unique_ptr::reset(T* p = 0)</tt> is currently specified as:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> If <tt>p == get()</tt> there are no effects. Otherwise <tt>get_deleter()(get())</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ There are two problems with this. One, if <tt>get() == 0</tt> and <tt>p != 0</tt>, the
+-deleter is called with a NULL pointer, and this is probably not what's
++deleter is called with a <tt>NULL</tt> pointer, and this is probably not what's
+ intended (the destructor avoids calling the deleter with 0.)
+ </p>
+
+@@ -43027,17 +44679,19 @@ self-resets in 2001 and there were no complaints.
+ </p>
+
+ <p>
+-One might think that self-resets are necessary for operator= to work; it's specified to perform
++One might think that self-resets are necessary for <tt>operator=</tt> to work; it's specified to perform
+ </p>
+
+-<blockquote><pre>reset( u.release() );
++<blockquote><pre>
++reset( u.release() );
+ </pre></blockquote>
+
+ <p>
+ and the self-assignment
+ </p>
+
+-<blockquote><pre>p = move(p);
++<blockquote><pre>
++p = move(p);
+ </pre></blockquote>
+
+ <p>
+@@ -43053,23 +44707,25 @@ scenario, as it definitely doesn't when <tt>p</tt> and <tt>q</tt> are separate.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 20.9.9.2.5 [unique.ptr.single.modifiers]:
++Change 20.8.1.2.5 [unique.ptr.single.modifiers]:
+ </p>
+
+ <blockquote>
+-<pre>void reset(T* p = 0);
++<pre>
++void reset(T* p = 0);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Effects:</i> If <tt><del>p ==</del> get()<ins> == 0</ins></tt> there are no effects. Otherwise <tt>get_deleter()(get())</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 20.9.9.3.3 [unique.ptr.runtime.modifiers]:
++Change 20.8.1.3.4 [unique.ptr.runtime.modifiers]:
+ </p>
+
+ <blockquote>
+-<pre>void reset(T* p = 0);
++<pre>
++void reset(T* p = 0);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -43086,13 +44742,14 @@ Change 20.9.9.3.3 [unique.ptr.runtime.modifiers]:
+
+ <hr>
+ <h3><a name="807"></a>807. <tt>tuple</tt> construction should not fail unless its element's construction fails</h3>
+-<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a> Added a throws clause to <tt>bind</tt> constructors. I believe the same throws clause
++<a href="lwg-defects.html#527">527</a> Added a throws clause to <tt>bind</tt> constructors. I believe the same throws clause
+ should be added to <tt>tuple</tt> except it ought to take into account move constructors as well.
+ </p>
+
+@@ -43115,17 +44772,17 @@ or assignment of one of the types in <tt>Types</tt> throws an exception.
+
+ <hr>
+ <h3><a name="808"></a>808. [forward] incorrect redundant specification</h3>
+-<p><b>Section:</b> 20.3.3 [forward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward">issues</a> in [forward].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.2.4 [forward] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward">issues</a> in [forward].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ p4 (forward) says:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Return type:</i> If <tt>T</tt> is an lvalue-reference type, an lvalue; otherwise, an rvalue.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ First of all, lvalue-ness and rvalue-ness are properties of an expression,
+@@ -43144,9 +44801,9 @@ have reference type, ever.)
+ <p>
+ Similar with move:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Return type: an rvalue.
+-</blockquote>
++</p></blockquote>
+ <p>
+ is just wrong and also redundant.
+ </p>
+@@ -43154,11 +44811,12 @@ is just wrong and also redundant.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.3.3 [forward] as indicated:
++Change 20.2.4 [forward] as indicated:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class T&gt; T&amp;&amp; forward(typename identity&lt;T&gt;::type&amp;&amp; t);
++<pre>
++template &lt;class T&gt; T&amp;&amp; forward(typename identity&lt;T&gt;::type&amp;&amp; t);
+ </pre>
+
+ <blockquote>
+@@ -43176,7 +44834,8 @@ In both cases, <tt>A2</tt> is deduced as double, so 1.414 is forwarded to <tt>A<
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp; t);
++<pre>
++template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp; t);
+ </pre>
+
+ <blockquote>
+@@ -43194,18 +44853,18 @@ In both cases, <tt>A2</tt> is deduced as double, so 1.414 is forwarded to <tt>A<
+
+
+ <hr>
+-<h3><a name="809"></a>809. std::swap should be overloaded for array types</h3>
+-<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-02-28 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="809"></a>809. <tt>std::swap</tt> should be overloaded for array types</h3>
++<p><b>Section:</b> 25.3.3 [alg.swap] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-02-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.swap">issues</a> in [alg.swap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ For the sake of generic programming, the header <code>&lt;algorithm&gt;</code> should provide an
+ overload of <code>std::swap</code> for array types:
+-</p><pre>template&lt;class T, size_t N&gt; void swap(T (&amp;a)[N], T (&amp;b)[N]);
++</p><pre>
++template&lt;class T, size_t N&gt; void swap(T (&amp;a)[N], T (&amp;b)[N]);
+ </pre>
+-<p></p>
+
+ <p>
+ It became apparent to me that this overload is missing, when I considered how to write a swap
+@@ -43213,11 +44872,14 @@ function for a generic wrapper class template.
+ (Actually I was thinking of Boost's <a href="http://www.boost.org/libs/utility/value_init.htm">value_initialized</a>.)
+ Please look at the following template, <code>W</code>, and suppose that is intended to be a very
+ <em>generic</em> wrapper:
+-</p><pre>template&lt;class T&gt; class W {
++</p>
++<pre>
++template&lt;class T&gt; class W {
+ public:
+- T data;
++ T data;
+ };
+ </pre>
++<p>
+ Clearly <code>W&lt;T&gt;</code> is <em>CopyConstructible and CopyAssignable</em>, and therefore
+ <em>Swappable</em>, whenever <code>T</code> is <em>CopyConstructible and CopyAssignable</em>.
+ Moreover, <code>W&lt;T&gt;</code> is <em>also</em> Swappable when <code>T</code> is an array type
+@@ -43227,26 +44889,31 @@ for the sake of efficiency and exception safety.
+ (E.g., <em>Scott Meyers, Effective C++, Third Edition, item 25: Consider support for a non-throwing
+ swap</em>.)
+ This function template is typically written as follows:
+-<pre>template&lt;class T&gt; void swap(W&lt;T&gt;&amp; x, W&lt;T&gt;&amp; y) {
++</p>
++<pre>
++template&lt;class T&gt; void swap(W&lt;T&gt;&amp; x, W&lt;T&gt;&amp; y) {
+ using std::swap;
+ swap(x.data, y.data);
+ }
+ </pre>
++<p>
+ Unfortunately, this will introduce an undesirable inconsistency, when <code>T</code> is an array.
+ For instance, <code>W&lt;std::string[8]&gt;</code> is Swappable, but the current Standard does not
+ allow calling the custom swap function that was especially written for <code>W</code>!
+-<pre>W&lt;std::string[8]&gt; w1, w2; // Two objects of a Swappable type.
++</p>
++<pre>
++W&lt;std::string[8]&gt; w1, w2; // Two objects of a Swappable type.
+ std::swap(w1, w2); // Well-defined, but inefficient.
+ using std::swap;
+ swap(w1, w2); // Ill-formed, just because ADL finds W's swap function!!!
+ </pre>
+-
++<p>
+ <code>W</code>'s <code>swap</code> function would try to call <code>std::swap</code> for an array,
+ <code>std::string[8]</code>, which is not supported by the Standard Library.
+ This issue is easily solved by providing an overload of <code>std::swap</code> for array types.
+ This swap function should be implemented in terms of swapping the elements of the arrays, so that
+ it would be non-throwing for arrays whose element types have a non-throwing swap.
+-<p></p>
++</p>
+
+ <p>
+ Note that such an overload of <code>std::swap</code> should also support <em>multi-dimensional</em>
+@@ -43255,30 +44922,32 @@ means of recursion.
+ </p>
+
+ <p>
+-For your information, there was a discussion on this issue at comp.lang.c++.moderated: <a href="http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/9341ebd3635c9c74">[Standard
++For your information, there was a discussion on this issue at comp.lang.c++.moderated: <a
++href="http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/9341ebd3635c9c74">[Standard
+ Library] Shouldn't std::swap be overloaded for C-style arrays?</a>
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add an extra condition to the definition of Swappable requirements [swappable] in 20.2.1 [utility.arg.requirements]:
++Add an extra condition to the definition of Swappable requirements [swappable] in 17.6.3.1 [utility.arg.requirements]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ - <tt>T</tt> is <tt>Swappable</tt> if <tt>T</tt> is an array type whose element type is <tt>Swappable</tt>.
+-</blockquote>
++</p></blockquote>
+ <p>
+ Add the following to 25.3.3 [alg.swap]:
+ </p>
+ <blockquote>
+-<pre>template&lt;class T, size_t N&gt; void swap(T (&amp;a)[N], T (&amp;b)[N]);
++<pre>
++template&lt;class T, size_t N&gt; void swap(T (&amp;a)[N], T (&amp;b)[N]);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> Type <code>T</code> shall be <tt>Swappable</tt>.
+-</blockquote>
+-<blockquote>
++</p></blockquote>
++<blockquote><p>
+ <i>Effects:</i> <code>swap_ranges(a, a + N, b);</code>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -43287,10 +44956,10 @@ Add the following to 25.3.3 [alg.swap]:
+
+ <hr>
+ <h3><a name="810"></a>810. Missing traits dependencies in operational semantics of extended manipulators</h3>
+-<p><b>Section:</b> 27.7.4 [ext.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-03-01 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.7.5 [ext.manip] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-03-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The recent draft (as well as the original proposal n2072) uses an
+@@ -43298,14 +44967,16 @@ operational semantic
+ for <tt>get_money</tt> ([ext.manip]/4) and <tt>put_money</tt> ([ext.manip]/6), which uses
+ </p>
+
+-<blockquote><pre>istreambuf_iterator&lt;charT&gt;
++<blockquote><pre>
++istreambuf_iterator&lt;charT&gt;
+ </pre></blockquote>
+
+ <p>
+ and
+ </p>
+
+-<blockquote><pre>ostreambuf_iterator&lt;charT&gt;
++<blockquote><pre>
++ostreambuf_iterator&lt;charT&gt;
+ </pre></blockquote>
+
+ <p>
+@@ -43338,47 +45009,52 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 27.7.4 [ext.manip]/4 within function <tt>f</tt> replace the first line
++In 27.7.5 [ext.manip]/4 within function <tt>f</tt> replace the first line
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits, class moneyT&gt;
++<blockquote><pre>
++template &lt;class charT, class traits, class moneyT&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, moneyT&amp; mon, bool intl) {
+ typedef istreambuf_iterator&lt;charT<ins>, traits</ins>&gt; Iter;
+ ...
+ </pre></blockquote>
+
+ <p>
+-In 27.7.4 [ext.manip]/5 remove the first template <tt>charT</tt> parameter:
++In 27.7.5 [ext.manip]/5 remove the first template <tt>charT</tt> parameter:
+ </p>
+
+-<blockquote><pre>template &lt;<del>class charT, </del>class moneyT&gt; unspecified put_money(const moneyT&amp; mon, bool intl = false<ins>)</ins>;
++<blockquote><pre>
++template &lt;<del>class charT, </del>class moneyT&gt; unspecified put_money(const moneyT&amp; mon, bool intl = false<ins>)</ins>;
+ </pre></blockquote>
+
+ <p>
+-In 27.7.4 [ext.manip]/6 within function <tt>f</tt> replace the first line
++In 27.7.5 [ext.manip]/6 within function <tt>f</tt> replace the first line
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits, class moneyT&gt;
++<blockquote><pre>
++template &lt;class charT, class traits, class moneyT&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, const moneyT&amp; mon, bool intl) {
+ typedef ostreambuf_iterator&lt;charT<ins>, traits</ins>&gt; Iter;
+ ...
+ </pre></blockquote>
+
+ <p>
+-In 27.7.4 [ext.manip]/8 within function <tt>f</tt> replace the first line
++In 27.7.5 [ext.manip]/8 within function <tt>f</tt> replace the first line
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, struct tm *tmb, const charT *fmt) {
+ typedef <ins>i</ins>streambuf_iterator&lt;charT<ins>, traits</ins>&gt; Iter;
+ ...
+ </pre></blockquote>
+
+ <p>
+-In 27.7.4 [ext.manip]/10 within function <tt>f</tt> replace the first line
++In 27.7.5 [ext.manip]/10 within function <tt>f</tt> replace the first line
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, const struct tm *tmb, const charT *fmt) {
+ typedef ostreambuf_iterator&lt;charT<ins>, traits</ins>&gt; Iter;
+ ...
+@@ -43388,7 +45064,8 @@ void f(basic_ios&lt;charT, traits&gt;&amp; str, const struct tm *tmb, const char
+ In 27.7 [iostream.format], Header <tt>&lt;iomanip&gt;</tt> synopsis change:
+ </p>
+
+-<blockquote><pre>template &lt;<del>class charT, </del>class moneyT&gt; T8 put_money(const moneyT&amp; mon, bool intl = false);
++<blockquote><pre>
++template &lt;<del>class charT, </del>class moneyT&gt; T8 put_money(const moneyT&amp; mon, bool intl = false);
+ </pre></blockquote>
+
+
+@@ -43397,12 +45074,13 @@ In 27.7 [iostream.format], Header <tt>&lt;iomanip&gt;</tt> synopsis change:
+
+ <hr>
+ <h3><a name="811"></a>811. <tt>pair</tt> of pointers no longer works with literal 0</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2008-03-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2008-03-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<blockquote><pre>#include &lt;utility&gt;
++<blockquote><pre>
++#include &lt;utility&gt;
+
+ int main()
+ {
+@@ -43420,7 +45098,8 @@ rvalue references into the language, long before variadic templates or
+ emplace came along:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
+ </pre></blockquote>
+
+ <p>
+@@ -43430,7 +45109,8 @@ constructor to only <tt>U</tt>'s and <tt>V</tt>'s that can properly construct "f
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2322.pdf">N2322</a>):
+ </p>
+
+-<blockquote><pre>template&lt;class U , class V &gt;
++<blockquote><pre>
++template&lt;class U , class V &gt;
+ requires Constructible&lt;T1, U&amp;&amp;&gt; &amp;&amp; Constructible&lt;T2, V&amp;&amp;&gt;
+ pair(U&amp;&amp; x , V&amp;&amp; y );
+ </pre></blockquote>
+@@ -43449,7 +45129,7 @@ Side question: Should pair interoperate with tuples? Can construct a
+ tuple of a pair, but not a pair from a two-element tuple.
+ </p>
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a>.
++Related to <a href="lwg-defects.html#885">885</a>.
+ </p>
+ </blockquote>
+
+@@ -43463,9 +45143,9 @@ Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as open. Howard to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-06 Howard provided wording.
+@@ -43485,10 +45165,10 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2770.pdf">N2770</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ The rationale is obsolete.
+@@ -43499,11 +45179,12 @@ The rationale is obsolete.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a paragraph to 20.3.5 [pairs]:
++Add a paragraph to 20.3 [pairs]:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
++<pre>
++template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
+ </pre>
+ <blockquote>
+ <p>
+@@ -43528,29 +45209,30 @@ resolution.</ins>
+
+ <hr>
+ <h3><a name="813"></a>813. "empty" undefined for <tt>shared_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2008-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2008-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Several places in 20.9.10.2 [util.smartptr.shared] refer to an "empty" <tt>shared_ptr</tt>.
++Several places in 20.8.2.2 [util.smartptr.shared] refer to an "empty" <tt>shared_ptr</tt>.
+ However, that term is nowhere defined. The closest thing we have to a
+ definition is that the default constructor creates an empty <tt>shared_ptr</tt>
+ and that a copy of a default-constructed <tt>shared_ptr</tt> is empty. Are any
+ other <tt>shared_ptr</tt>s empty? For example, is <tt>shared_ptr((T*) 0)</tt> empty? What
+ are the properties of an empty <tt>shared_ptr</tt>? We should either clarify this
+ term or stop using it.
+-</p><p>
+ </p>
++<p>
+ One reason it's not good enough to leave this term up to the reader's
+ intuition is that, in light of
+ <a href="http://www.open-std.org/JTC1/sc22/WG21/docs/papers/2007/n2351.htm">N2351</a>
+-and issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#711">711</a>, most readers'
++and issue <a href="lwg-defects.html#711">711</a>, most readers'
+ intuitive understanding is likely to be wrong. Intuitively one might
+ expect that an empty <tt>shared_ptr</tt> is one that doesn't store a pointer,
+ but, whatever the definition is, that isn't it.
+-<p></p>
++</p>
+
+ <p><i>[
+ Peter adds:
+@@ -43573,9 +45255,9 @@ completely specified by the last mutating operation on that instance.
+ Give me an example and I'll tell you whether the <tt>shared_ptr</tt> is empty or
+ not.
+ </p>
+-<blockquote>
++<blockquote><p>
+ (*) If it isn't, this is a legitimate defect.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -43625,15 +45307,16 @@ Terms can be useful without a definition. Consider the following
+ simplistic example. We have a type <tt>X</tt> with the following operations
+ defined:
+ </p>
+-<blockquote><pre>X x;
++<blockquote><pre>
++X x;
+ X x2(x);
+ X f(X x);
+ X g(X x1, X x2);
+ </pre></blockquote>
+ <p>
+-A default-constructed value is green.<br>
+-A copy has the same color as the original.<br>
+-<tt>f(x)</tt> returns a red value if the argument is green, a green value otherwise.<br>
++A default-constructed value is green.<br/>
++A copy has the same color as the original.<br/>
++<tt>f(x)</tt> returns a red value if the argument is green, a green value otherwise.<br/>
+ <tt>g(x1,x2)</tt> returns a green value if the arguments are of the same color, a red value otherwise.
+ </p>
+
+@@ -43656,16 +45339,16 @@ Alisdair's wording is fine.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Append the following sentance to 20.9.10.2 [util.smartptr.shared]
++Append the following sentance to 20.8.2.2 [util.smartptr.shared]
+ </p>
+-<blockquote>
++<blockquote><p>
+ The <code>shared_ptr</code> class template stores a pointer, usually obtained
+ via <code>new</code>. <code>shared_ptr</code> implements semantics of
+ shared ownership; the last remaining owner of the pointer is responsible for
+ destroying the object, or otherwise releasing the resources associated with
+ the stored pointer. <ins>A <code>shared_ptr</code> object that does not own
+ a pointer is said to be <i>empty</i>.</ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -43673,10 +45356,10 @@ a pointer is said to be <i>empty</i>.</ins>
+
+ <hr>
+ <h3><a name="814"></a>814. <tt>vector&lt;bool&gt;::swap(reference, reference)</tt> not defined</h3>
+-<p><b>Section:</b> 23.4.2 [vector.bool] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>vector&lt;bool&gt;::swap(reference, reference)</tt> has no definition.
+@@ -43687,9 +45370,9 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open. Alisdair to provide a resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Daniel provided wording.
+@@ -43700,15 +45383,15 @@ Post Summit Daniel provided wording.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Just after 23.4.2 [vector.bool]/5 add the following prototype and description:
++Just after 23.3.7 [vector.bool]/5 add the following prototype and description:
+ </p>
+
+ <blockquote>
+@@ -43733,10 +45416,10 @@ y = b;
+
+ <hr>
+ <h3><a name="815"></a>815. <tt>std::function</tt> and <tt>reference_closure</tt> do not use perfect forwarding</h3>
+-<p><b>Section:</b> 20.8.14.2.4 [func.wrap.func.inv] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-16 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.inv">issues</a> in [func.wrap.func.inv].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.4 [func.wrap.func.inv] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.inv">issues</a> in [func.wrap.func.inv].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>std::function</tt> and <tt>reference_closure</tt> should use "perfect forwarding" as
+@@ -43748,11 +45431,11 @@ Sophia Antipolis:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ According to Doug Gregor, as far as <tt>std::function</tt> is concerned, perfect
+ forwarding can not be obtained because of type erasure. Not everyone
+ agreed with this diagnosis of forwarding.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-01 Howard adds:
+@@ -43766,7 +45449,8 @@ requirement on <tt>function</tt>'s <tt>ArgTypes...</tt> is an unnecessary
+ restriction.
+ </p>
+
+-<blockquote><pre>template&lt;Returnable R, <b>CopyConstructible</b>... ArgTypes&gt;
++<blockquote><pre>
++template&lt;Returnable R, <b>CopyConstructible</b>... ArgTypes&gt;
+ class function&lt;R(ArgTypes...)&gt;
+ ...
+ </pre></blockquote>
+@@ -43778,7 +45462,8 @@ on <tt>ArgTypes</tt> in the first place was because of the nature of the
+ <i>invoke</i> member:
+ </p>
+
+-<blockquote><pre>template&lt;class R, class ...ArgTypes&gt;
++<blockquote><pre>
++template&lt;class R, class ...ArgTypes&gt;
+ R
+ function&lt;R(ArgTypes...)&gt;::operator()(ArgTypes... arg) const
+ {
+@@ -43801,7 +45486,8 @@ be removed from the template class <tt>function</tt>.
+ Furthermore we need to mandate that the <i>invoker</i> is coded as:
+ </p>
+
+-<blockquote><pre>template&lt;class R, class ...ArgTypes&gt;
++<blockquote><pre>
++template&lt;class R, class ...ArgTypes&gt;
+ R
+ function&lt;R(ArgTypes...)&gt;::operator()(ArgTypes... arg) const
+ {
+@@ -43826,7 +45512,8 @@ reference type <tt>ArgTypes</tt>, this will be a copy. The end result <em>must<
+ that the following is a valid program:
+ </p>
+
+-<blockquote><pre>#include &lt;functional&gt;
++<blockquote><pre>
++#include &lt;functional&gt;
+ #include &lt;memory&gt;
+ #include &lt;cassert&gt;
+
+@@ -43870,7 +45557,7 @@ and the second <tt>ArgType</tt> is <tt>int&amp;</tt>. Both <em>must</em> work!
+ in the 2009-05-01 comment of above mentioned issue Howard
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ Recommends to replace the <tt>CopyConstructible</tt> requirement by a
+ <tt>MoveConstructible</tt> requirement
+@@ -43886,7 +45573,8 @@ I'm fine with (a), but I think comment (b) is incorrect, at least in the
+ sense I read these sentences. Let's look at Howard's example code:
+ </p>
+
+-<blockquote><pre>function&lt;R(ArgTypes...)&gt;::operator()(ArgTypes... arg) const
++<blockquote><pre>
++function&lt;R(ArgTypes...)&gt;::operator()(ArgTypes... arg) const
+ {
+ if (f_ == 0)
+ throw bad_function_call();
+@@ -43906,20 +45594,20 @@ do so, if <tt>ArgTypes</tt> aren't at least <tt>MoveConstructible</tt>?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave this open and wait until concepts are removed from the Working
+ Draft so that we know how to write the proposed resolution in terms of
+ diffs to otherwise stable text.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as open. Howard to provide wording. Howard welcomes any help.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-12-12 Jonathan Wakely adds:
+@@ -43928,16 +45616,16 @@ Leave as open. Howard to provide wording. Howard welcomes any help.
+
+ <blockquote>
+ <p>
+-20.8.14.2 [func.wrap.func] says
++20.9.12.2 [func.wrap.func] says
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 A function object <tt>f</tt> of type <tt>F</tt> is Callable for argument
+ types <tt>T1, T2, ..., TN</tt> in <tt>ArgTypes</tt> and a return type
+ <tt>R</tt>, if, given lvalues <tt>t1, t2, ..., tN</tt> of types <tt>T1, T2, ...,
+ TN</tt>, respectively, <tt>INVOKE (f, t1, t2, ..., tN)</tt> is well formed
+ (20.7.2) and, if <tt>R</tt> is not <tt>void</tt>, convertible to <tt>R</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ N.B. lvalues, which means you can't use <tt>function&lt;R(T&amp;&amp;)&gt;</tt>
+@@ -43976,17 +45664,17 @@ otherwise"? I prefer the former, so I propose the following resolution for 815:
+ </p>
+
+ <p>
+-Edit 20.8.14.2 [func.wrap.func] paragraph 2:
++Edit 20.9.12.2 [func.wrap.func] paragraph 2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 A function object <tt>f</tt> of type <tt>F</tt> is Callable for argument
+ types <tt>T1, T2, ..., TN</tt> in <tt>ArgTypes</tt> and a return type
+ <tt>R</tt>, if, given <del>l</del>values <tt>t1, t2, ..., tN</tt> of types
+ <tt>T1, T2, ..., TN</tt>, respectively, <tt>INVOKE (f, t1, t2, ..., tN)</tt> is
+ well formed (20.7.2) and, if <tt>R</tt> is not <tt>void</tt>, convertible to
+ <tt>R</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -43994,18 +45682,18 @@ well formed (20.7.2) and, if <tt>R</tt> is not <tt>void</tt>, convertible to
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I don't like the reduction to "values" and prefer the alternative solution
+ suggested using "lvalues when Ti is an lvalue-reference and rvalues otherwise".
+ The reason why I dislike the shorter version is based on different usages of
+ "values" as part of defining the semantics of requirement tables via
+-expressions. E.g. 20.2.1 [utility.arg.requirements]/1 says "<tt>a</tt>,
++expressions. E.g. 17.6.3.1 [utility.arg.requirements]/1 says "<tt>a</tt>,
+ <tt>b</tt>, and <tt>c</tt> are values of type <tt>const T;</tt>" or similar in
+ 23.2.1 [container.requirements.general]/4 or /14 etc. My current reading
+ of all these parts is that <em>both</em> rvalues and lvalues are required to be
+ supported, but this interpretation would violate the intention of the suggested
+ fix of #815, if I correctly understand Jonathan's rationale.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-12-12 Howard adds:
+@@ -44013,9 +45701,9 @@ fix of #815, if I correctly understand Jonathan's rationale.
+
+
+ <blockquote>
+-<blockquote>
++<blockquote><p>
+ "lvalues when Ti is an lvalue-reference and rvalues otherwise"
+-</blockquote>
++</p></blockquote>
+ <p>
+ doesn't quite work here because the <tt>Ti</tt> aren't deduced. They are
+ specified by the <tt>function</tt> type. <tt>Ti</tt> might be <tt>const
+@@ -44041,7 +45729,7 @@ int&amp;</tt> (an lvalue reference) and a valid <tt>ti</tt> might be <tt>2</tt>
+
+
+ <p><i>[
+-2010-02-11 This issue is now addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>.
++2010-02-11 This issue is now addressed by <a href="lwg-defects.html#870">870</a>.
+ ]</i></p>
+
+
+@@ -44055,13 +45743,13 @@ c++std-lib. Rationale added below.
+
+ <p><b>Rationale:</b></p>
+ <p>
+-Addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a>.
++Addressed by <a href="lwg-defects.html#870">870</a>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Edit 20.8.14.2 [func.wrap.func] paragraph 2:
++Edit 20.9.12.2 [func.wrap.func] paragraph 2:
+ </p>
+
+ <blockquote>
+@@ -44084,13 +45772,13 @@ operand (5 [expr]),</ins> is well formed (20.7.2)<del> and, if
+
+ <hr>
+ <h3><a name="816"></a>816. Should <tt>bind()</tt>'s returned functor have a nofail copy ctor when <tt>bind()</tt> is nofail?</h3>
+-<p><b>Section:</b> 20.8.10.1.2 [func.bind.bind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2008-02-08 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.9.10.3 [func.bind.bind] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2008-02-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Library Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a> notes that <tt>bind(f, t1, ..., tN)</tt>
++Library Issue <a href="lwg-defects.html#527">527</a> notes that <tt>bind(f, t1, ..., tN)</tt>
+ should be nofail when <tt>f, t1, ..., tN</tt> have nofail copy ctors.
+ </p>
+ <p>
+@@ -44104,7 +45792,7 @@ implementation-defined exceptions unless otherwise specified, C++03
+ 17.4.4.8/3.)
+ </p>
+ <p>
+-Should the nofail guarantee requested by Library Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#527">527</a> be extended
++Should the nofail guarantee requested by Library Issue <a href="lwg-defects.html#527">527</a> be extended
+ to cover both calling <tt>bind()</tt> and copying the returned functor?
+ </p>
+
+@@ -44113,18 +45801,18 @@ Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <tt>tuple</tt> construction should probably have a similar guarantee.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Howard to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit, Anthony provided wording.
+@@ -44135,32 +45823,32 @@ Post Summit, Anthony provided wording.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Part of all of this issue appears to be rendered moot
+-by the proposed resolution to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a> (q.v.).
++by the proposed resolution to issue <a href="lwg-defects.html#817">817</a> (q.v.).
+ We recommend the issues be considered simultaneously
+ (or possibly even merged)
+ to ensure there is no overlap.
+-Move to Open, and likewise for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.
+-</blockquote>
++Move to Open, and likewise for issue <a href="lwg-defects.html#817">817</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a> (see below). Leave Open.
+-</blockquote>
++<blockquote><p>
++Related to <a href="lwg-defects.html#817">817</a> (see below). Leave Open.
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to Ready. Decoupling from issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.
+-</blockquote>
++<blockquote><p>
++Move to Ready. Decoupling from issue <a href="lwg-defects.html#817">817</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-11 Moved from Ready to Tentatively NAD Editorial, rationale added below.
+@@ -44171,13 +45859,13 @@ Move to Ready. Decoupling from issue <a href="http://www.open-std.org/jtc1/sc22/
+
+ <p><b>Rationale:</b></p>
+ <p>
+-This issue is solved as proposed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#817">817</a>.
++This issue is solved as proposed by <a href="lwg-defects.html#817">817</a>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new sentence to the end of paragraphs 2 and 4 of 20.8.10.1.2 [func.bind.bind]:
++Add a new sentence to the end of paragraphs 2 and 4 of 20.9.10.3 [func.bind.bind]:
+ </p>
+
+ <blockquote>
+@@ -44208,10 +45896,10 @@ in <tt>BoundArgs...</tt> throw an exception.</ins>
+
+ <hr>
+ <h3><a name="817"></a>817. <tt>bind</tt> needs to be moved</h3>
+-<p><b>Section:</b> 20.8.10.1.2 [func.bind.bind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-03-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.10.3 [func.bind.bind] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-03-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US 72, JP 38 and DE 21</b></p>
+
+@@ -44221,16 +45909,16 @@ requires only move construction of its contained functor and bound arguments.
+ That way move-only functors can be passed to objects such as <tt>thread</tt>.
+ </p>
+ <p>
+-This issue is related to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#816">816</a>.
++This issue is related to issue <a href="lwg-defects.html#816">816</a>.
+ </p>
+
+ <p>
+ US 72:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>bind</tt> should support move-only functors and bound arguments.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ JP 38:
+@@ -44244,7 +45932,8 @@ add the move requirement for bind's return type.
+ For example, assume following <tt>th1</tt> and <tt>th2</tt>,
+ </p>
+
+-<blockquote><pre>void f(vector&lt;int&gt; v) { }
++<blockquote><pre>
++void f(vector&lt;int&gt; v) { }
+
+ vector&lt;int&gt; v{ ... };
+ thread th1([v]{ f(v); });
+@@ -44270,20 +45959,20 @@ And also, add the <tt>MoveConstructible</tt> as well as <tt>CopyConstructible</t
+ DE 21
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The specification for bind claims twice that "the values and types for
+ the bound arguments v1, v2, ..., vN are determined as specified below".
+ No such specification appears to exist.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Howard to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Alisdair and Howard provided wording.
+@@ -44302,10 +45991,10 @@ a place to see the complete solution in one place.
+ <tt>bind</tt> needs to be "moved".
+ </li>
+ <li>
+-20.8.10.1.2 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798.
++20.9.10.3 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798.
+ </li>
+ <li>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a> argues for a way to pass by &amp;&amp; for
++Issue <a href="lwg-defects.html#929">929</a> argues for a way to pass by &amp;&amp; for
+ efficiency but retain the decaying behavior of pass by value for the
+ <tt>thread</tt> constructor. That same solution is applicable here.
+ </li>
+@@ -44333,18 +46022,18 @@ and recommend both issues be considered together
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution uses concepts. Leave Open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as Open. Howard to provide deconceptified wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-07 Howard updates wording.
+@@ -44364,22 +46053,23 @@ Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8 [function.objects] p2:
++Change 20.9 [function.objects] p2:
+ </p>
+
+-<blockquote><pre>template&lt;class F<del>n</del>, class... <del>Types</del> <ins>BoundArgs</ins>&gt;
++<blockquote><pre>
++template&lt;class F<del>n</del>, class... <del>Types</del> <ins>BoundArgs</ins>&gt;
+ <i>unspecified</i> bind(F<del>n</del><ins>&amp;&amp;</ins>, <del>Types</del> <ins>BoundArgs&amp;&amp;</ins>...);
+ template&lt;class R, class F<del>n</del>, class... <del>Types</del> <ins>BoundArgs</ins>&gt;
+ <i>unspecified</i> bind(F<del>n</del><ins>&amp;&amp;</ins>, <del>Types</del> <ins>BoundArgs&amp;&amp;</ins>...);
+ </pre></blockquote>
+
+ <p>
+-Change 20.8.2 [func.require]:
++Change 20.9.2 [func.require]:
+ </p>
+
+ <blockquote>
+ <p>
+-4 Every call wrapper (20.8.1 [func.def]) shall be
++4 Every call wrapper (20.9.1 [func.def]) shall be
+ <tt><del>Copy</del><ins>Move</ins>Constructible</tt>. A <i>simple call
+ wrapper</i> is a call wrapper that is <ins><tt>CopyConstructible</tt> and</ins>
+ <tt>CopyAssignable</tt> and whose copy constructor<ins>, move constructor</ins> and assignment operator do not
+@@ -44387,16 +46077,17 @@ throw exceptions. A <i>forwarding call wrapper</i> is a call wrapper that can be
+ called with an argument list. [<i>Note:</i> in a typical implementation
+ forwarding call wrappers have an overloaded function call operator of the form
+ </p>
+-<blockquote><pre>template&lt;class... <del>ArgTypes</del><ins>UnBoundsArgs</ins>&gt;
++<blockquote><pre>
++template&lt;class... <del>ArgTypes</del><ins>UnBoundsArgs</ins>&gt;
+ R operator()(<del>ArgTypes</del><ins>UnBoundsArgs</ins>&amp;&amp;... <ins>unbound_</ins>args) cv-qual;
+ </pre></blockquote>
+ <p>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+ <p>
+-Change 20.8.10.1.2 [func.bind.bind]:
++Change 20.9.10.3 [func.bind.bind]:
+ </p>
+
+ <blockquote>
+@@ -44436,7 +46127,8 @@ Let <tt>uj</tt> be the j<sup><i>th</i></sup> argument associated with <tt>Uj</tt
+ </ins></li>
+ </ul>
+
+-<pre>template&lt;class F, class... BoundArgs&gt;
++<pre>
++template&lt;class F, class... BoundArgs&gt;
+ <i>unspecified</i> bind(F<ins>&amp;&amp;</ins> f, BoundArgs<ins>&amp;&amp;</ins>... bound_args);
+ </pre>
+
+@@ -44450,12 +46142,12 @@ shall be <tt>true</tt>.</ins>
+ <tt>true</tt></ins>.
+ <del><tt>F</tt> and each <tt>Ti</tt> in
+ <tt>BoundArgs</tt> shall be CopyConstructible.</del>
+-<tt><i>INVOKE</i>(f<ins>d</ins>, w1, w2, ..., wN)</tt> (20.8.2 [func.require]) shall be a valid expression for some values
++<tt><i>INVOKE</i>(f<ins>d</ins>, w1, w2, ..., wN)</tt> (20.9.2 [func.require]) shall be a valid expression for some values
+ <i>w1, w2, ..., wN</i>, where <tt>N == sizeof...(bound_args)</tt>.
+ </p>
+ <p>
+ -2- <i>Returns:</i> A forwarding call wrapper <tt>g</tt> with a weak
+-result type (20.8.2 [func.require]). The effect of <tt>g(u1, u2,
++result type (20.9.2 [func.require]). The effect of <tt>g(u1, u2,
+ ..., uM)</tt> shall be <tt><i>INVOKE</i>(f<ins>d</ins>, v1, v2, ..., vN,
+ result_of&lt;F<ins>D</ins> <i>cv</i> (V1, V2, ..., VN)&gt;::type)</tt>, where
+ <i>cv</i> represents the <i>cv</i>-qualifiers of <tt>g</tt> and the
+@@ -44479,13 +46171,14 @@ requirements of <tt>MoveConstructible</tt>. If all of <tt>FD</tt> and
+ <tt>TiD</tt> satisfy the requirements of <tt>CopyConstructible</tt> then
+ the <i>unspecified</i> return type shall satisfy the requirements of
+ <tt>CopyConstructible</tt>. [<i>Note:</i> This implies that all of
+-<tt>FD</tt> and <tt>TiD</tt> shall be <tt>MoveConstructible</tt> —
++<tt>FD</tt> and <tt>TiD</tt> shall be <tt>MoveConstructible</tt> &mdash;
+ <i>end note</i>]
+ </ins>
+ </p>
+ </blockquote>
+
+-<pre>template&lt;class R, class F, class... BoundArgs&gt;
++<pre>
++template&lt;class R, class F, class... BoundArgs&gt;
+ <i>unspecified</i> bind(F<ins>&amp;&amp;</ins> f, BoundArgs<ins>&amp;&amp;</ins>... bound_args);
+ </pre>
+
+@@ -44527,7 +46220,7 @@ requirements of <tt>MoveConstructible</tt>. If all of <tt>FD</tt> and
+ <tt>TiD</tt> satisfy the requirements of <tt>CopyConstructible</tt> then
+ the <i>unspecified</i> return type shall satisfy the requirements of
+ <tt>CopyConstructible</tt>. [<i>Note:</i> This implies that all of
+-<tt>FD</tt> and <tt>TiD</tt> shall be <tt>MoveConstructible</tt> —
++<tt>FD</tt> and <tt>TiD</tt> shall be <tt>MoveConstructible</tt> &mdash;
+ <i>end note</i>]
+ </ins>
+ </p>
+@@ -44578,10 +46271,11 @@ is <tt>Ti<ins>D</ins> <i>cv</i> &amp;</tt>.
+
+ <hr>
+ <h3><a name="818"></a>818. wording for memory ordering</h3>
+-<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-03-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 29.3 [atomics.order] p1 says in the table that
+@@ -44589,14 +46283,14 @@ is <tt>Ti<ins>D</ins> <i>cv</i> &amp;</tt>.
+
+ <blockquote>
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Element</th><th>Meaning</th>
+ </tr>
+ <tr>
+ <td><tt>memory_order_acq_rel</tt></td>
+ <td>the operation has both acquire and release semantics</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -44610,7 +46304,7 @@ Then, p1 says in the table:
+
+ <blockquote>
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Element</th><th>Meaning</th>
+ </tr>
+ <tr>
+@@ -44618,7 +46312,7 @@ Then, p1 says in the table:
+ <td>the operation has both acquire and release semantics,
+ and, in addition, has sequentially-consistent operation ordering</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -44630,11 +46324,11 @@ constraints.
+ I'm then reading p2, where it says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>memory_order_seq_cst</tt> operations that load a value are acquire operations
+ on the affected locations. The <tt>memory_order_seq_cst</tt> operations that store a value
+ are release operations on the affected locations.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ That seems to imply that atomic reads only have acquire semantics. If that
+@@ -44665,10 +46359,10 @@ And why does 29.6 [atomics.types.operations] p9 for "load" say:
+ </p>
+
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The order argument shall not be <tt>memory_order_acquire</tt>
+ nor <tt>memory_order_acq_rel</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ (Since this is exactly the same restriction as for "store", it seems to be a typo.)
+@@ -44678,12 +46372,12 @@ nor <tt>memory_order_acq_rel</tt>.
+ And then: 29.6 [atomics.types.operations] p12:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ These operations are read-modify-write operations in the sense of the
+ "synchronizes with" definition (1.10 [intro.multithread]), so both such an operation and the
+ evaluation that produced the input value synchronize with any evaluation
+ that reads the updated value.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This is redundant with 1.10 [intro.multithread], see above for the reasoning.
+@@ -44710,7 +46404,7 @@ all of the atomics issues in one paper.
+
+ <p>
+ This issue is addressed in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.html">N2783</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.htm">N2783</a>.
+ </p>
+ </blockquote>
+
+@@ -44755,8 +46449,8 @@ remove table 136 in 29.3 [atomics.order].
+
+ <blockquote>
+ <table border="1">
+-<caption><del>Table 136 — memory_order effects</del></caption>
+-<tbody><tr><th><del>Element</del></th><th><del>Meaning</del></th></tr>
++<caption><del>Table 136 &mdash; memory_order effects</del></caption>
++<tr><th><del>Element</del></th><th><del>Meaning</del></th></tr>
+ <tr><td valign="top"><del><code>memory_order_relaxed</code></del></td>
+ <td valign="top"><del>the operation does not order memory</del></td></tr>
+ <tr><td valign="top"><del><code>memory_order_release</code></del></td>
+@@ -44782,7 +46476,7 @@ that are dependencies of this consume operation.</del></td></tr>
+ <tr><td valign="top"><del><code>memory_order_seq_cst</code></del></td>
+ <td valign="top"><del>the operation has both acquire and release semantics,
+ and, in addition, has sequentially-consistent operation ordering</del></td></tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -44811,7 +46505,7 @@ it can always be extended to an order
+ that does include lock and unlock operations,
+ since the ordering between those
+ is already included in the happens before ordering.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -44822,10 +46516,11 @@ is already included in the happens before ordering.
+
+ <hr>
+ <h3><a name="819"></a>819. rethrow_if_nested</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Looking at the wording I submitted for <tt>rethrow_if_nested</tt>, I don't think I
+@@ -44837,7 +46532,8 @@ The current wording says:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
++<pre>
++template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
+ </pre>
+ <blockquote>
+ <p>
+@@ -44859,18 +46555,18 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Alisdair was volunteered to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave as Open. Alisdair to provide wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-09 Alisdair provided wording.
+@@ -44887,9 +46583,9 @@ Leave as Open. Alisdair to provide wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -44898,15 +46594,16 @@ Moved to Ready for Pittsburgh.
+ Change 18.8.6 [except.nested], p8:
+ </p>
+
+-<blockquote><pre>template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
++<blockquote><pre>
++template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -8- <i>Effects:</i> <del>Calls <tt>e.rethrow_nested()</tt>
+ o</del><ins>O</ins>nly if <ins>the dynamic type of</ins> <tt>e</tt> is
+ publicly <ins>and unambiguously</ins> derived from
+ <tt>nested_exception</tt> <ins>this calls
+ <tt>dynamic_cast&lt;const nested_exception&amp;&gt;(e).rethrow_nested()</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -44916,11 +46613,10 @@ publicly <ins>and unambiguously</ins> derived from
+
+ <hr>
+ <h3><a name="820"></a>820. <tt>current_exception()</tt>'s interaction with throwing copy ctors</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2008-03-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2008-03-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ As of N2521, the Working Paper appears to be silent about what
+@@ -44962,11 +46658,11 @@ consistent and does not introduce any new problems.
+ However, the resolution of core issue 475 may relax this requirement:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The CWG agreed with the position that <tt>std::uncaught_exception()</tt> should
+ return <tt>false</tt> during the copy to the exception object and that <tt>std::terminate()</tt>
+ should not be called if that constructor exits with an exception.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Since throwing copy constructors will no longer call <tt>terminate()</tt>, option
+@@ -45026,16 +46722,18 @@ Pete will make the required editorial tweaks to rectify this.
+
+ <hr>
+ <h3><a name="821"></a>821. Minor cleanup : <tt>unique_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.9.3.3 [unique.ptr.runtime.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.1.3.4 [unique.ptr.runtime.modifiers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-03-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.runtime.modifiers">issues</a> in [unique.ptr.runtime.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Reading resolution of LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a> I noticed the following:
++Reading resolution of LWG issue <a href="lwg-defects.html#673">673</a> I noticed the following:
+ </p>
+
+ <blockquote>
+-<pre>void reset(<del>T*</del> <ins>pointer</ins> p = <del>0</del> <ins>pointer()</ins>);
++<pre>
++void reset(<del>T*</del> <ins>pointer</ins> p = <del>0</del> <ins>pointer()</ins>);
+ </pre>
+
+ <p>
+@@ -45055,11 +46753,12 @@ to be a stronger match than the deleted overload. Words...
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to class template definition in 20.9.9.3 [unique.ptr.runtime]
++Add to class template definition in 20.8.1.3 [unique.ptr.runtime]
+ </p>
+
+ <blockquote>
+-<pre>// modifiers
++<pre>
++// modifiers
+ pointer release();
+ void reset(pointer p = pointer());
+ <ins>void reset( nullptr_t );</ins>
+@@ -45069,11 +46768,12 @@ void swap(unique_ptr&amp;&amp; u);
+ </blockquote>
+
+ <p>
+-Update 20.9.9.3.3 [unique.ptr.runtime.modifiers]
++Update 20.8.1.3.4 [unique.ptr.runtime.modifiers]
+ </p>
+
+ <blockquote>
+-<pre>void reset(pointer p = pointer());
++<pre>
++void reset(pointer p = pointer());
+ <ins>void reset(nullptr_t);</ins>
+ </pre>
+
+@@ -45090,7 +46790,7 @@ templated overload. <i>-- end note</i>]</del>
+ </blockquote>
+
+ <p><i>[
+-Note this wording incorporates resolutions for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#806">806</a> (New) and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a> (Ready).
++Note this wording incorporates resolutions for <a href="lwg-defects.html#806">806</a> (New) and <a href="lwg-defects.html#673">673</a> (Ready).
+ ]</i></p>
+
+
+@@ -45100,14 +46800,14 @@ Note this wording incorporates resolutions for <a href="http://www.open-std.org/
+
+ <hr>
+ <h3><a name="823"></a>823. <tt>identity&lt;void&gt;</tt> seems broken</h3>
+-<p><b>Section:</b> 20.3.3 [forward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Walter Brown <b>Opened:</b> 2008-04-09 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward">issues</a> in [forward].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.2.4 [forward] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Walter Brown <b>Opened:</b> 2008-04-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward">issues</a> in [forward].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ N2588 seems to have added an <tt>operator()</tt> member function to the
+-<tt>identity&lt;&gt;</tt> helper in 20.3.3 [forward]. I believe this change makes it no
++<tt>identity&lt;&gt;</tt> helper in 20.2.4 [forward]. I believe this change makes it no
+ longer possible to instantiate <tt>identity&lt;void&gt;</tt>, as it would require
+ forming a reference-to-<tt>void</tt> type as this <tt>operator()</tt>'s parameter type.
+ </p>
+@@ -45143,17 +46843,17 @@ Alberto provided proposed wording.
+ <p>
+ This issue became closed, because the <tt>ReferentType</tt> requirement
+ fixed the problem - this is no longer the case. In retrospective it seems
+-to be that the root of current issues around <tt>std::identity</tt> (823, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#700">700</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>)
++to be that the root of current issues around <tt>std::identity</tt> (823, <a href="lwg-defects.html#700">700</a>,
++<a href="lwg-defects.html#939">939</a>)
+ is that it was standardized as something very different (an unconditional
+ type mapper) than traditional usage indicated (a function object that should
+ derive from <tt>std::unary_function)</tt>, as the SGI definition does. This issue could
+-be solved, if <tt>std::identity</tt> is removed (one proposal of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>), but until this
++be solved, if <tt>std::identity</tt> is removed (one proposal of <a href="lwg-defects.html#939">939</a>), but until this
+ has been decided, this issue should remain open. An alternative for
+ removing it, would be, to do the following:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ Let <tt>identity</tt> stay as a <em>real</em> function object, which would
+@@ -45161,7 +46861,8 @@ now properly
+ derive from <tt>unary_function</tt>:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct identity : unary_function&lt;T, T&gt; {
++<blockquote><pre>
++template &lt;class T&gt; struct identity : unary_function&lt;T, T&gt; {
+ const T&amp; operator()(const T&amp;) const;
+ };
+ </pre></blockquote>
+@@ -45171,10 +46872,11 @@ derive from <tt>unary_function</tt>:
+ <p>
+ Invent (if needed) a generic type wrapper (corresponding to concept
+ <tt>IdentityOf</tt>),
+-e.g. <tt>identity_of</tt>, and move it's prototype description back to 20.3.3 [forward]:
++e.g. <tt>identity_of</tt>, and move it's prototype description back to 20.2.4 [forward]:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct identity_of {
++<blockquote><pre>
++template &lt;class T&gt; struct identity_of {
+ typedef T type;
+ };
+ </pre></blockquote>
+@@ -45192,18 +46894,19 @@ instead of <tt>identity</tt>.
+ ]</i></p>
+
+
+-<blockquote>
+-Mark as <del>NAD Editorial</del><ins>Resolved</ins>, fixed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#939">939</a>.
+-</blockquote>
++<blockquote><p>
++Mark as <del>NAD Editorial</del><ins>Resolved</ins>, fixed by <a href="lwg-defects.html#939">939</a>.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change definition of <tt>identity</tt> in 20.3.3 [forward], paragraph 2, to:
++Change definition of <tt>identity</tt> in 20.2.4 [forward], paragraph 2, to:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; struct identity {
++<blockquote><pre>
++template &lt;class T&gt; struct identity {
+ typedef T type;
+
+ <ins>requires ReferentType&lt;T&gt;</ins>
+@@ -45211,7 +46914,8 @@ Change definition of <tt>identity</tt> in 20.3.3 [forward], paragraph 2, to:
+ };
+ </pre></blockquote>
+ <p>...</p>
+-<blockquote><pre> <ins>requires ReferentType&lt;T&gt;</ins>
++<blockquote><pre>
++ <ins>requires ReferentType&lt;T&gt;</ins>
+ const T&amp; operator()(const T&amp; x) const;
+ </pre></blockquote>
+
+@@ -45232,10 +46936,10 @@ than <tt>cv void</tt> which aren't referent types (<tt>int[]</tt>, perhaps?).
+
+ <hr>
+ <h3><a name="824"></a>824. rvalue ref issue with <tt>basic_string</tt> inserter</h3>
+-<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-04-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.io">issues</a> in [string.io].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-04-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the current working paper, the <tt>&lt;string&gt;</tt> header synopsis at the end of
+@@ -45243,7 +46947,8 @@ In the current working paper, the <tt>&lt;string&gt;</tt> header synopsis at the
+ for <tt>basic_string</tt>.
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_ostream&lt;charT, traits&gt;&amp;
+ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;&amp; os,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
+@@ -45253,7 +46958,8 @@ for <tt>basic_string</tt>.
+ The definition in 21.4.8.9 [string.io] lists two:
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_ostream&lt;charT, traits&gt;&amp;
+ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
+@@ -45275,7 +46981,8 @@ signatures in 21.4.8.9 [string.io] should be deleted.
+ Delete the first of the two signatures in 21.4.8.9 [string.io]:
+ </p>
+
+-<blockquote><pre><del>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++<del>template&lt;class charT, class traits, class Allocator&gt;
+ basic_ostream&lt;charT, traits&gt;&amp;
+ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; str);</del>
+@@ -45291,11 +46998,82 @@ template&lt;class charT, class traits, class Allocator&gt;
+
+
+ <hr>
++<h3><a name="825"></a>825. Missing rvalues reference stream insert&#47;extract operators?</h3>
++<p><b>Section:</b> 19.5.2.1 [syserr.errcode.overview], 20.8.2.2.11 [util.smartptr.shared.io], 22.4.8 [facets.examples], 20.6.4 [bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.9 [re.submatch] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-04-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses UK 220</b></p>
++
++<p>
++Should the following use rvalues references to stream in insert/extract operators?
++</p>
++
++<ul>
++<li>19.5.2.1 [syserr.errcode.overview]</li>
++<li>20.8.2.2.11 [util.smartptr.shared.io]</li>
++<li>22.4.8 [facets.examples]</li>
++<li>20.6.4 [bitset.operators]</li>
++<li>26.4.6 [complex.ops]</li>
++<li>Doubled signatures in 27.6 [stream.buffers] for character inserters
++(ref 27.7.3.6.4 [ostream.inserters.character])
+++ definition 27.7.3.6.4 [ostream.inserters.character]</li>
++<li>28.9 [re.submatch]</li>
++</ul>
++
++<p><i>[
++Sophia Antipolis
++]</i></p>
++
++
++<blockquote><p>
++Agree with the idea in the issue, Alisdair to provide wording.
++</p></blockquote>
++
++<p><i>[
++Daniel adds 2009-02-14:
++]</i></p>
++
++
++<blockquote><p>
++The proposal given in the paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2831.html">N2831</a>
++apparently resolves this issue.
++</p></blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++The cited paper is an earlier version of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html">N2844</a>,
++which changed the rvalue reference binding rules.
++That paper includes generic templates
++<tt>operator&lt;&lt;</tt> and <tt>operator&gt;&gt;</tt>
++that adapt rvalue streams.
++</p>
++<p>
++We therefore agree with Daniel's observation. Move to <del>NAD Editorial</del><ins>Resolved</ins>.
++</p>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="827"></a>827. <tt>constexpr shared_ptr::shared_ptr()?</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-11 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Would anyone object to making the default constructor of <tt>shared_ptr</tt> (and
+@@ -45346,11 +47124,11 @@ literal types. Otherwise this should be closed as NAD.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ If Alisdair's 2009-05-01 comment is correct, wouldn't that also make
+ <tt>constexpr mutex()</tt> useless, because this class has a non-trivial
+-destructor? (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#828">828</a>)
+-</blockquote>
++destructor? (<a href="lwg-defects.html#828">828</a>)
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-21 Alisdair adds:
+@@ -45376,32 +47154,35 @@ Recommend we declare the default constructor <tt>constexpr</tt> as the issue sug
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.html">N2994</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.10.2 [util.smartptr.shared] and 20.9.10.2.1 [util.smartptr.shared.const]:
++Change 20.8.2.2 [util.smartptr.shared] and 20.8.2.2.1 [util.smartptr.shared.const]:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> shared_ptr();
++<blockquote><pre>
++<ins>constexpr</ins> shared_ptr();
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.10.3 [util.smartptr.weak] and 20.9.10.3.1 [util.smartptr.weak.const]:
++Change 20.8.2.3 [util.smartptr.weak] and 20.8.2.3.1 [util.smartptr.weak.const]:
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> weak_ptr();
++<blockquote><pre>
++<ins>constexpr</ins> weak_ptr();
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.10.4 [util.smartptr.enab] (2 places):
++Change 20.8.2.5 [util.smartptr.enab] (2 places):
+ </p>
+
+-<blockquote><pre><ins>constexpr</ins> enable_shared_from_this();
++<blockquote><pre>
++<ins>constexpr</ins> enable_shared_from_this();
+ </pre></blockquote>
+
+
+@@ -45410,12 +47191,117 @@ Change 20.9.10.4 [util.smartptr.enab] (2 places):
+
+
+ <hr>
++<h3><a name="828"></a>828. Static initialization for <tt>std::mutex</tt>?</h3>
++<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-04-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.]
++</p>
++<p>
++Currently <tt>std::mutex</tt> doesn't support static initialization. This is a
++regression with respect to <tt>pthread_mutex_t</tt>, which does. I believe that
++we should strive to eliminate such regressions in expressive power where
++possible, both to ease migration and to not provide incentives to (or
++force) people to forego the C++ primitives in favor of pthreads.
++</p>
++
++<p><i>[
++Sophia Antipolis:
++]</i></p>
++
++
++<blockquote>
++<p>
++We believe this is implementable on POSIX, because the initializer-list
++feature and the constexpr feature make this work. Double-check core
++language about static initialization for this case. Ask core for a core
++issue about order of destruction of statically-initialized objects wrt.
++dynamically-initialized objects (should come afterwards). Check
++non-POSIX systems for implementability.
++</p>
++<p>
++If ubiquitous implementability cannot be assured, plan B is to introduce
++another constructor, make this constexpr, which is
++conditionally-supported. To avoid ambiguities, this new constructor needs
++to have an additional parameter.
++</p>
++</blockquote>
++
++<p><i>[
++Post Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Jens: constant initialization seems to be ok core-language wise
++</p>
++<p>
++Consensus: Defer to threading experts, in particular a Microsoft platform expert.
++</p>
++<p>
++Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams,
++Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker,
++Peter Dimov to alert them of this issue.
++</p>
++<p>
++Lawrence: What about header file shared with C? The initialization syntax is different in C and C++.
++</p>
++<p>
++Recommend Keep in Review
++</p>
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++Keep in Review status pending feedback from members of the Concurrency subgroup.
++</p></blockquote>
++
++<p><i>[
++See related comments from Alisdair and Daniel in <a href="lwg-defects.html#827">827</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 30.4.1.2.1 [thread.mutex.class]:
++</p>
++
++<blockquote><pre>
++class mutex {
++public:
++ <ins>constexpr</ins> mutex();
++ ...
++</pre></blockquote>
++
++
++
++
++
++<hr>
+ <h3><a name="829"></a>829. current_exception wording unclear about exception type</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-04-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-04-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>Consider this code:</p>
+
+@@ -45507,14 +47393,14 @@ creates a new copy each time it is called.
+
+
+ <hr>
+-<h3><a name="834"></a>834. Unique_ptr::pointer requirements underspecified</h3>
+-<p><b>Section:</b> 20.9.9.2 [unique.ptr.single] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="834"></a>834. <tt>unique_ptr::pointer</tt> requirements underspecified</h3>
++<p><b>Section:</b> 20.8.1.2 [unique.ptr.single] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#673">673</a> (including recent updates by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#821">821</a>) proposes a useful
++Issue <a href="lwg-defects.html#673">673</a> (including recent updates by <a href="lwg-defects.html#821">821</a>) proposes a useful
+ extension point for <tt>unique_ptr</tt> by granting support for an optional
+ <tt>deleter_type::pointer</tt> to act as pointer-like replacement for <tt>element_type*</tt>
+ (In the following: <tt>pointer</tt>).
+@@ -45530,20 +47416,19 @@ impact on at least two key features of <tt>unique_ptr</tt>:
+ </ol>
+
+ <p>
+-<tt>Unique_ptr</tt> specification makes great efforts to require that essentially *all*
++The <tt>unique_ptr</tt> specification makes great efforts to require that essentially <em>all</em>
+ operations cannot throw and therefore adds proper wording to the affected
+ operations of the deleter as well. If user-provided <tt>pointer</tt>-emulating types
+-("smart pointers") will be allowed, either *all* throw-nothing clauses have to
++("smart pointers") will be allowed, either <em>all</em> throw-nothing clauses have to
+ be replaced by weaker "An exception is thrown only if <tt>pointer</tt>'s {op} throws
+ an exception"-clauses or it has to be said explicitly that all used
+-operations of
+-<tt>pointer</tt> are required *not* to throw. I understand the main focus of <tt>unique_ptr</tt>
+-to be as near as possible to the advantages of native pointers which cannot
++operations of <tt>pointer</tt> are required <em>not</em> to throw. I understand the main
++focus of <tt>unique_ptr</tt> to be as near as possible to the advantages of native pointers which cannot
+ fail and thus strongly favor the second choice. Also, the alternative position
+ would make it much harder to write safe and simple template code for
+ <tt>unique_ptr</tt>. Additionally, I assume that a general statement need to be given
+ that all of the expressions of <tt>pointer</tt> used to define semantics are required to
+-be well-formed and well-defined (also as back-end for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#762">762</a>).
++be well-formed and well-defined (also as back-end for <a href="lwg-defects.html#762">762</a>).
+ </p>
+
+ <p><i>[
+@@ -45566,9 +47451,9 @@ Howard will go through and enumerate the individual requirements wrt. <tt>pointe
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-15 Alisdair pulls from Ready:
+@@ -45585,11 +47470,11 @@ fully baked yet.
+ For reference the proposed resolution is to add the following words:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>unique_ptr&lt;T, D&gt;::pointer</tt>'s operations shall be
+ well-formed, shall have well defined behavior, and shall not throw
+ exceptions.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This leaves me with a big question : which operations?
+@@ -45608,21 +47493,21 @@ certain concept, and so nail down the interactions.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I volunteer to prepare a more fine-grained solution, but I would like
+ to ask for feedback that helps me doing so. If this question is asked
+ early in the meeting I might be able to fix it within the week, but I
+ cannot promise that now.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave in open. Daniel to provide wording as already suggested.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-12-22 Daniel provided wording and rationale.
+@@ -45647,12 +47532,12 @@ This might be a convincing argument to isolate the common subset into one
+ requirement. The reason I did not do that is basically because we might find out
+ that they are either over-constraining or under-constraining at this late point
+ of specification. Note also that as a result of the idea of a general
+-requirement set I added the requirement
++requirement set I added the requirement:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A default-initialized object may have a singular value
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ even though this does not play a relevant role for <tt>unique_ptr</tt>.
+@@ -45679,13 +47564,13 @@ Solved by
+
+ <li>
+ <p>
+-Change 20.9.9.2 [unique.ptr.single]/1 as indicated: <i>[The intent is to
++Change 20.8.1.2 [unique.ptr.single] p. 1 as indicated: <i>[The intent is to
+ replace the coupling between <tt>T*</tt> and the deleter's <tt>operator()</tt>
+ by a coupling between <tt>unique_ptr&lt;T, D&gt;::pointer</tt> and this
+ <tt>operator()</tt>]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 - The default type for the template parameter <tt>D</tt> is
+ <tt>default_delete</tt>. A client-supplied template argument <tt>D</tt> shall be
+ a function pointer or functor for which, given a value <tt>d</tt> of type
+@@ -45694,12 +47579,12 @@ a function pointer or functor for which, given a value <tt>d</tt> of type
+ expression <tt>d(ptr)</tt> is valid and has the effect of deallocating the
+ pointer as appropriate for that deleter. <tt>D</tt> may also be an
+ lvalue-reference to a deleter.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2 [unique.ptr.single]/3 as indicated:
++Change 20.8.1.2 [unique.ptr.single] p. 3 as indicated:
+ </p>
+
+ <blockquote>
+@@ -45712,7 +47597,7 @@ type <tt>unique_ptr&lt;T, D&gt;::pointer</tt> shall <del>be</del> <ins>satisfy
+ the requirements of <tt>EqualityComparable</tt>,
+ <tt>DefaultConstructible</tt>,</ins> <tt>CopyConstructible</tt> <del>(Table 34)
+ and</del><ins>,</ins> <tt>CopyAssignable</tt> <del>(Table 36)</del><ins>,
+-<tt>Swappable</tt>, and <tt>Destructible</tt> (20.2.1 [utility.arg.requirements]). A default-initialized object may have a
++<tt>Swappable</tt>, and <tt>Destructible</tt> (17.6.3.1 [utility.arg.requirements]). A default-initialized object may have a
+ singular value. A value-initialized object produces the null value of the type.
+ The null value shall be equivalent only to itself. An object of this type can be
+ copy-initialized with a value of type <tt>nullptr_t</tt>, compared for equality
+@@ -45726,15 +47611,15 @@ exception.
+ </ins>
+ </p>
+ <p><ins>
+-[<i>Note:</i> Given an allocator type <tt>X</tt> (20.2.5 [allocator.requirements]), the types <tt>X::pointer</tt>,
++[<i>Note:</i> Given an allocator type <tt>X</tt> (17.6.3.5 [allocator.requirements]), the types <tt>X::pointer</tt>,
+ <tt>X::const_pointer</tt>, <tt>X::void_pointer</tt>, and
+ <tt>X::const_void_pointer</tt> may be used as <tt>unique_ptr&lt;T,
+-D&gt;::pointer</tt> — <i>end note</i>]
++D&gt;::pointer</tt> &mdash; <i>end note</i>]
+ </ins></p>
+
+ <p><ins>
+ In addition to being available via inclusion of the <tt>&lt;utility&gt;</tt>
+-header, the <tt>swap</tt> function template in 20.3.2 [utility.swap] is
++header, the <tt>swap</tt> function template in 20.2.2 [utility.swap] is
+ also available within the definition of <tt>unique_ptr</tt>'s <tt>swap</tt>
+ function.
+ </ins></p>
+@@ -45743,13 +47628,14 @@ function.
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/2+3 as indicated: <i>[The first
++Change 20.8.1.2.1 [unique.ptr.single.ctor] p. 2+3 as indicated: <i>[The first
+ change ensures that we explicitly say, how the stored pointer is initialized.
+ This is important for a <tt>constexpr</tt> function, because this may make a
+ difference for user-defined pointer-like types]</i>
+ </p>
+
+-<blockquote><pre>constexpr unique_ptr();
++<blockquote><pre>
++constexpr unique_ptr();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -45767,12 +47653,13 @@ value-initializing the stored pointer</ins>.
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/6+7 as indicated: <i>[This is a
++Change 20.8.1.2.1 [unique.ptr.single.ctor] p. 6+7 as indicated: <i>[This is a
+ step-by-fix to ensure consistency to the changes of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2976.html">N2976</a>]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr(pointer p);
++<blockquote><pre>
++unique_ptr(pointer p);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -45792,12 +47679,13 @@ deleter <tt>D</tt>.
+
+ <li>
+ <p>
+-Insert a new effects clause in 20.9.9.2.1 [unique.ptr.single.ctor] just
++Insert a new effects clause in 20.8.1.2.1 [unique.ptr.single.ctor] just
+ before p. 14: <i>[The intent is to fix the current lack of specification in
+ which way the stored pointer is initialized]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr(pointer p, <i><del>implementation-defined</del> <ins>see below</ins></i> d1);
++<blockquote><pre>
++unique_ptr(pointer p, <i><del>implementation-defined</del> <ins>see below</ins></i> d1);
+ unique_ptr(pointer p, <i><del>implementation-defined</del> <ins>see below</ins></i> d2);
+ </pre>
+ <blockquote>
+@@ -45819,12 +47707,13 @@ then <tt>get_deleter()</tt> returns a reference to the lvalue <tt>d</tt>.
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/18+22 as indicated: <i>[The intent
++Change 20.8.1.2.1 [unique.ptr.single.ctor] p. 18+22 as indicated: <i>[The intent
+ is to clarify that the moved-from source must contain a null pointer, there is
+ no other choice left]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr(unique_ptr&amp;&amp; u);
++<blockquote><pre>
++unique_ptr(unique_ptr&amp;&amp; u);
+ </pre>
+ <blockquote>
+ <p>
+@@ -45842,7 +47731,8 @@ lvalue deleter.
+
+ </blockquote>
+
+-<pre>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -45865,32 +47755,34 @@ the internally stored deleter which was constructed from
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/20 as indicated: <i>[With the
++Change 20.8.1.2.1 [unique.ptr.single.ctor] p. 20 as indicated: <i>[With the
+ possibility of user-defined pointer-like types the implication does only exist,
+ if those are built-in pointers. Note that this change should also be applied
+-with the acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>]</i>
++with the acceptance of <a href="lwg-defects.html#950">950</a>]</i>
+ </p>
+
+-<blockquote><pre>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 20 - <i>Requires:</i> If <tt>D</tt> is not a reference type, construction of the
+ deleter <tt>D</tt> from an rvalue of type <tt>E</tt> shall be well formed and
+ shall not throw an exception. If <tt>D</tt> is a reference type, then <tt>E</tt>
+ shall be the same type as <tt>D</tt> (diagnostic required). <tt>unique_ptr&lt;U,
+ E&gt;::pointer</tt> shall be implicitly convertible to <tt>pointer</tt>.
+ <del>[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt> are
+-complete types. — <i>end note</i>]</del>
+-</blockquote>
++complete types. &mdash; <i>end note</i>]</del>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2.2 [unique.ptr.single.dtor]/2 as indicated:
++Change 20.8.1.2.2 [unique.ptr.single.dtor] p. 2 as indicated:
+ </p>
+
+-<blockquote><pre>~unique_ptr();
++<blockquote><pre>
++~unique_ptr();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -45904,12 +47796,13 @@ are no effects. Otherwise <tt>get_deleter()(get())</tt>.
+
+ <li>
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn]/3+8 as indicated: <i>[The intent is to
++Change 20.8.1.2.3 [unique.ptr.single.asgn] p. 3+8 as indicated: <i>[The intent is to
+ clarify that the moved-from source must contain a null pointer, there
+ is no other choice left]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr&amp; operator=(unique_ptr&amp;&amp; u);
++<blockquote><pre>
++unique_ptr&amp; operator=(unique_ptr&amp;&amp; u);
+ </pre>
+ <blockquote>
+ <p>[..]</p>
+@@ -45917,11 +47810,12 @@ is no other choice left]</i>
+ 3 - <i>Postconditions:</i> This <tt>unique_ptr</tt> now owns the pointer which <tt>u</tt>
+ owned, and <tt>u</tt> no longer owns it<ins>, <tt>u.get() == nullptr</tt></ins>.
+ [<i>Note:</i> If <tt>D</tt> is a reference type, then the referenced lvalue deleters
+-are move assigned. — <i>end note</i>]
++are move assigned. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -45938,13 +47832,14 @@ nullptr</tt></ins>.
+
+ <li>
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn]/6 as indicated: <i>[With the
++Change 20.8.1.2.3 [unique.ptr.single.asgn] p. 6 as indicated: <i>[With the
+ possibility of user-defined pointer-like types the implication does only exist,
+ if those are built-in pointers. Note that this change should also be applied
+-with the acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>]</i>
++with the acceptance of <a href="lwg-defects.html#950">950</a>]</i>
+ </p>
+
+-<blockquote><pre>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+ <blockquote>
+ <p>[..]</p>
+@@ -45953,7 +47848,7 @@ with the acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-
+ <tt>D</tt> shall not throw an exception. <tt>unique_ptr&lt;U,
+ E&gt;::pointer</tt> shall be implicitly convertible to <tt>pointer</tt>.
+ <del>[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt> are
+-complete types. — <i>end note</i>]</del>
++complete types. &mdash; <i>end note</i>]</del>
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -45961,11 +47856,12 @@ complete types.
+
+ <li>
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn] before p. 11 and p. 12 as
++Change 20.8.1.2.3 [unique.ptr.single.asgn] before p. 11 and p. 12 as
+ indicated: <i>[The first change is a simple typo fix]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr&amp; operator=(nullptr_t<del>}</del><ins>)</ins>;
++<blockquote><pre>
++unique_ptr&amp; operator=(nullptr_t<del>}</del><ins>)</ins>;
+ </pre>
+
+ <blockquote>
+@@ -45982,10 +47878,11 @@ indicated: <i>[The first change is a simple typo fix]</i>
+
+ <li>
+ <p>
+-Change 20.9.9.2.4 [unique.ptr.single.observers]/1+4+12 as indicated:
++Change 20.8.1.2.4 [unique.ptr.single.observers] p. 1+4+12 as indicated:
+ </p>
+
+-<blockquote><pre>typename add_lvalue_reference&lt;T&gt;::type operator*() const;
++<blockquote><pre>
++typename add_lvalue_reference&lt;T&gt;::type operator*() const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -46000,7 +47897,8 @@ an exception.</ins>
+
+ </blockquote>
+
+-<pre>pointer operator-&gt;() const;
++<pre>
++pointer operator-&gt;() const;
+ </pre>
+
+ <blockquote>
+@@ -46014,32 +47912,34 @@ an exception.</ins>
+
+ </blockquote>
+
+-<pre>explicit operator bool() const;
++<pre>
++explicit operator bool() const;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 12 - <i>Returns:</i> <tt>get() != <del>0</del><ins>nullptr</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2.5 [unique.ptr.single.modifiers]/1 as indicated:
++Change 20.8.1.2.5 [unique.ptr.single.modifiers] p. 1 as indicated:
+ </p>
+
+-<blockquote><pre>pointer release();
++<blockquote><pre>
++pointer release();
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 1 - <i>Postcondition:</i> <tt>get() == <del>0</del> <ins>nullptr</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2.5 [unique.ptr.single.modifiers]/9 as indicated: <i>[The
++Change 20.8.1.2.5 [unique.ptr.single.modifiers] p. 9 as indicated: <i>[The
+ intent is to ensure that potentially user-defined swaps are used. A side-step
+ fix and harmonization with the specification of the the deleter is realized.
+ Please note the additional requirement in bullet 2 of this proposed resolution
+@@ -46047,7 +47947,8 @@ regarding the availability of the generic <tt>swap</tt> templates within the
+ member <tt>swap</tt> function.]</i>
+ </p>
+
+-<blockquote><pre>void swap(unique_ptr&amp; u);
++<blockquote><pre>
++void swap(unique_ptr&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -46069,53 +47970,55 @@ shall not throw an exception under <tt>swap</tt>.
+
+ <li>
+ <p>
+-Change 20.9.9.3.2 [unique.ptr.runtime.observers]/1 as indicated:
++Change 20.8.1.3.3 [unique.ptr.runtime.observers] p. 1 as indicated:
+ </p>
+
+-<blockquote><pre>T&amp; operator[](size_t i) const;
++<blockquote><pre>
++T&amp; operator[](size_t i) const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <tt>i &lt;</tt> the size of the array to which the stored
+ pointer points. <ins>The variable definition <tt>T&amp; t = get()[i]</tt> shall
+ be well formed, shall have well-defined behavior, and shall not exit via an
+ exception.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.3.3 [unique.ptr.runtime.modifiers]/1 as indicated:
++Change 20.8.1.3.4 [unique.ptr.runtime.modifiers] p. 1 as indicated:
+ </p>
+
+-<blockquote><pre>void reset(pointer p = pointer());
++<blockquote><pre>
++void reset(pointer p = pointer());
+ void reset(nullptr_t p);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 1 - <i>Effects:</i> If <tt>get() == <del>0</del> <ins>nullptr</ins></tt> there
+ are no effects. Otherwise <tt>get_deleter()(get())</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.4 [unique.ptr.special] as indicated: <i>[We don't add the
++Change 20.8.1.5 [unique.ptr.special] as indicated: <i>[We don't add the
+ relational operators to the basic requirement set, therefore we need special
+ handling here]</i>
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+ <blockquote>
+ <p>
+-<ins><i>Requires:</i> The variable definition <tt>bool b = x.get() ==
+-y.get();</tt> shall be well formed, shall have well-defined behavior, and shall
+-not exit via an exception.</ins>
++<ins><i>Requires:</i> The variable definition <tt>bool b = x.get() == y.get();</tt> shall be
++well formed, shall have well-defined behavior, and shall not exit via an exception.</ins>
+ </p>
+
+ <p>
+@@ -46127,7 +48030,8 @@ not exit via an exception.</ins>
+ </ins></p>
+ </blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+@@ -46147,7 +48051,8 @@ an exception.</ins>
+ </ins></p>
+ </blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+@@ -46167,7 +48072,8 @@ an exception.</ins>
+ </ins></p>
+ </blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+@@ -46187,7 +48093,8 @@ an exception.</ins>
+ </ins></p>
+ </blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+@@ -46207,7 +48114,8 @@ an exception.</ins>
+ </ins></p>
+ </blockquote>
+
+-<pre>template &lt;class T1, class D1, class T2, class D2&gt;
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
+ bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
+ </pre>
+
+@@ -46239,16 +48147,16 @@ an exception.</ins>
+
+
+ <hr>
+-<h3><a name="835"></a>835. tying two streams together (correction to DR 581)</h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="835"></a>835. Tying two streams together (correction to DR 581)</h3>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+ The fix for
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#581">581</a>,
++issue <a href="lwg-defects.html#581">581</a>,
+ now integrated into the working paper, overlooks a couple of minor
+ problems.
+
+@@ -46275,7 +48183,8 @@ recursion for <code>std::cerr &lt;&lt; std::flush;</code>
+
+ </p>
+ <blockquote>
+- <pre>#include &lt;iostream&gt;
++ <pre>
++#include &lt;iostream&gt;
+
+ int main ()
+ {
+@@ -46291,10 +48200,10 @@ int main ()
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-26 Daniel adds:
+@@ -46304,7 +48213,7 @@ Move to Review.
+ <blockquote>
+ <p>
+ I think that the most recently suggested change in
+-27.7.2.4 [ostream::sentry] need some further word-smithing. As
++27.7.3.4 [ostream::sentry] need some further word-smithing. As
+ written, it would make the behavior undefined, if under
+ conditions when <tt>pubsync()</tt> should be called, but when
+ in this scenario <tt>os.rdbuf()</tt> returns 0.
+@@ -46314,11 +48223,11 @@ This case is explicitly handled in <tt>flush()</tt> and needs to be
+ taken care of. My suggested fix is:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If <tt>((os.flags() &amp; ios_base::unitbuf) &amp;&amp; !uncaught_exception()</tt>
+ <ins><tt>&amp;&amp; os.rdbuf() != 0</tt></ins>) is true, calls <del><tt>os.flush()</tt></del>
+ <ins><tt>os.rdbuf()-&gt;pubsync()</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Two secondary questions are:
+@@ -46362,20 +48271,20 @@ Move back to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This proposed wording is written to match the outcome
+-of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a>.
+-</blockquote>
++of <a href="lwg-closed.html#397">397</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open. Martin to propose updated wording that will also resolve
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">397</a> consistently.
+-</blockquote>
++issue <a href="lwg-closed.html#397">397</a> consistently.
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-15 Martin provided wording.
+@@ -46387,9 +48296,9 @@ issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#397">
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -46398,38 +48307,38 @@ Moved to Ready for Pittsburgh.
+ <ol>
+ <li>
+ <p>
+-Just before 27.5.4.2 [basic.ios.members]/2 insert a new paragraph:
++Just before 27.5.5.3 [basic.ios.members] p. 2 insert a new paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins><i>Requires:</i> If <tt>(tiestr != 0)</tt> is <tt>true</tt>,
+ <tt>tiestr</tt> must not be reachable by traversing the linked list of tied
+ stream objects starting from <tt>tiestr-&gt;tie()</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 27.7.2.4 [ostream::sentry]/4 as indicated:
++Change 27.7.3.4 [ostream::sentry] p. 4 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If <tt>((os.flags() &amp; ios_base::unitbuf) &amp;&amp; !uncaught_exception()
+ <ins>&amp;&amp; os.good()</ins>)</tt> is <tt>true</tt>, calls
+ <del><tt>os.flush()</tt></del> <ins><tt>os.rdbuf()-&gt;pubsync()</tt>. If that
+ function returns -1 sets <tt>badbit</tt> in <tt>os.rdstate()</tt> without
+ propagating an exception</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Add after 27.7.2.4 [ostream::sentry] p17, the following paragraph:
++Add after 27.7.3.4 [ostream::sentry] p17, the following paragraph:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins><i>Throws:</i> Nothing.</ins>
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+@@ -46442,14 +48351,14 @@ Add after 27.7.2.4 [ostream::sentry] p17, the following paragraph:
+
+ <hr>
+ <h3><a name="836"></a>836.
+- effects of <code>money_base::space</code> and
++ Effects of <code>money_base::space</code> and
+ <code>money_base::none</code> on <code>money_get</code>
+ </h3>
+-<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#670">670</a></p>
++<p><b>Section:</b> 22.4.6.1.2 [locale.money.get.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#locale.money.get.virtuals">issues</a> in [locale.money.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#670">670</a></p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -46457,13 +48366,13 @@ Add after 27.7.2.4 [ostream::sentry] p17, the following paragraph:
+ In paragraph 2, 22.4.6.1.2 [locale.money.get.virtuals] specifies the following:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ Where <code>space</code> or <code>none</code> appears in the format
+ pattern, except at the end, optional white space (as recognized
+ by <code>ct.is</code>) is consumed after any required space.
+
+- </blockquote>
++ </p></blockquote>
+ <p>
+
+ This requirement can be (and has been) interpreted two mutually
+@@ -46492,20 +48401,20 @@ allowed but not required.
+ The other is that:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ where either <code>money_base::space</code> or <code>money_base::none</code> appears in the format, white space is optional.
+
+- </blockquote>
++ </p></blockquote>
+
+ <p><i>[
+ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Martin will revise the proposed resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -46518,9 +48427,10 @@ There is a noun missing from the proposed resolution. It's not clear
+ that the last sentence would be helpful, even if the word were not
+ missing:
+ </p>
+-<blockquote>
+-In either case, any required MISSINGWORD followed by all optional whitespace (as recognized by ct.is()) is consumed.
+-</blockquote>
++<blockquote><p>
++In either case, any required MISSINGWORD followed by all optional whitespace
++(as recognized by <tt>ct.is()</tt>) is consumed.
++</p></blockquote>
+ <p>
+ Strike this sentence and move to Review.
+ </p>
+@@ -46536,9 +48446,9 @@ Howard: done.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -46547,11 +48457,11 @@ Move to Ready.
+
+ I propose to change the text to make it clear that the first
+ interpretation is intended, that is, to make following change to
+-22.4.6.1.2 [locale.money.get.virtuals], p2:
++22.4.6.1.2 [locale.money.get.virtuals], p. 2:
+
+ </p>
+
+- <blockquote>
++ <blockquote><p>
+
+ When <code><ins>money_base::</ins>space</code>
+ or <code><ins>money_base::</ins>none</code> appears <ins>as the last
+@@ -46565,19 +48475,19 @@ initial elements of the format pattern, white space is allowed but not
+ required.</ins>
+ If <code>(str.flags() &amp; str.showbase)</code> is <code>false</code>, ...
+
+- </blockquote>
++ </p></blockquote>
+
+
+
+
+ <hr>
+ <h3><a name="838"></a>838.
+- can an <i>end-of-stream</i> iterator become a <i>non-end-of-stream</i> one?
++ Can an <i>end-of-stream</i> iterator become a <i>non-end-of-stream</i> one?
+ </h3>
+-<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 24.6.1 [istream.iterator] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator">issues</a> in [istream.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -46587,19 +48497,19 @@ From message c++std-lib-20003...
+ <p>
+
+ The description of <code>istream_iterator</code> in
+-24.6.1 [istream.iterator], p1 specifies that objects of the
++24.6.1 [istream.iterator], p. 1 specifies that objects of the
+ class become the <i>end-of-stream</i> (EOS) iterators under the
+-following condition (see also issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#788">788</a> another problem
++following condition (see also issue <a href="lwg-defects.html#788">788</a> another problem
+ with this paragraph):
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ If the end of stream is reached (<code>operator void*()</code> on the
+ stream returns <code>false</code>), the iterator becomes equal to
+ the <i>end-of-stream</i> iterator value.
+
+- </blockquote>
++ </p></blockquote>
+ <p>
+
+ One possible implementation approach that has been used in practice is
+@@ -46644,7 +48554,8 @@ assertions in the program below expected to pass?
+
+ </p>
+ <blockquote>
+- <pre> sstream strm ("1 ");
++ <pre>
++ sstream strm ("1 ");
+ istream_iterator eos;
+ istream_iterator it (strm);
+ int i;
+@@ -46686,9 +48597,9 @@ that no reference is made to exposition only members of
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -46710,7 +48621,7 @@ To this end we propose to change 24.6.1 [istream.iterator], p1,
+ as follows:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ The result of operator-&gt; on an end<ins>-</ins>of<ins>-</ins>stream
+ is not defined. For any other iterator value a <code>const T*</code>
+@@ -46718,7 +48629,7 @@ is returned.<ins> Invoking <code>operator++()</code> on
+ an <i>end-of-stream</i> iterator is undefined.</ins> It is impossible
+ to store things into istream iterators...
+
+- </blockquote>
++ </p></blockquote>
+ <p>
+
+ Add pre/postconditions to the member function descriptions of <code>istream_iterator</code> like so:
+@@ -46727,32 +48638,34 @@ Add pre/postconditions to the member function descriptions of <code>istream_iter
+ <blockquote>
+
+ <pre>istream_iterator();</pre>
+-
+-<i>Effects</i>: Constructs the <i>end-of-stream</i> iterator.<br>
++<p>
++<i>Effects</i>: Constructs the <i>end-of-stream</i> iterator.<br/>
+ <ins><i>Postcondition</i>: <code>in_stream == 0</code>.</ins>
+-
++</p>
+ <pre>istream_iterator(istream_type &amp;s);</pre>
+-
++<p>
+ <i>Effects</i>: Initializes <code>in_stream</code> with &amp;s. value
+ may be initialized during construction or the first time it is
+-referenced.<br>
++referenced.<br/>
+ <ins><i>Postcondition</i>: <code>in_stream == &amp;s</code>.</ins>
+-
++</p>
+ <pre>istream_iterator(const istream_iterator &amp;x);</pre>
+-
+-<i>Effects</i>: Constructs a copy of <code>x</code>.<br>
++<p>
++<i>Effects</i>: Constructs a copy of <code>x</code>.<br/>
+ <ins><i>Postcondition</i>: <code>in_stream == x.in_stream</code>.</ins>
+-
++</p>
+ <pre>istream_iterator&amp; operator++();</pre>
+-
+-<ins><i>Requires</i>: <code>in_stream != 0</code>.</ins><br>
++<p>
++<ins><i>Requires</i>: <code>in_stream != 0</code>.</ins><br/>
+ <i>Effects</i>: <code>*in_stream &gt;&gt; value</code>.
+-
++</p>
+ <pre>istream_iterator&amp; operator++(int);</pre>
+-
+-<ins><i>Requires</i>: <code>in_stream != 0</code>.</ins><br>
++<p>
++<ins><i>Requires</i>: <code>in_stream != 0</code>.</ins><br/>
+ <i>Effects</i>:
+- <blockquote><pre>istream_iterator tmp (*this);
++</p>
++<blockquote><pre>
++istream_iterator tmp (*this);
+ *in_stream &gt;&gt; value;
+ return tmp;
+ </pre>
+@@ -46763,17 +48676,18 @@ return tmp;
+
+
+ <hr>
+-<h3><a name="842"></a>842. ConstructibleAsElement and bit containers</h3>
+-<p><b>Section:</b> 23.2 [container.requirements], 23.4.2 [vector.bool], 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="842"></a>842. <tt>ConstructibleAsElement</tt> and bit containers</h3>
++<p><b>Section:</b> 23.2 [container.requirements], 23.3.7 [vector.bool], 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-23.2 [container.requirements]/p3 says:
++23.2 [container.requirements] p. 3 says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Objects stored in these components shall be constructed using
+ <tt>construct_element</tt> (20.6.9). For each operation that inserts an
+ element of type <tt>T</tt> into a container (<tt>insert</tt>,
+@@ -46784,11 +48698,11 @@ with a scoped allocator of type <tt>A</tt> (i.e., an allocator for which
+ <tt>is_scoped_allocator&lt;A&gt;::value</tt> is <tt>true</tt>), then
+ <tt>construct_element</tt> may pass an inner allocator argument to
+ <tt>T</tt>'s constructor. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-However <tt>vector&lt;bool, A&gt;</tt> (23.4.2 [vector.bool]) and <tt>bitset&lt;N&gt;</tt>
+-(20.5 [template.bitset]) store bits, not <tt>bool</tt>s, and <tt>bitset&lt;N&gt;</tt>
++However <tt>vector&lt;bool, A&gt;</tt> (23.3.7 [vector.bool]) and <tt>bitset&lt;N&gt;</tt>
++(20.6 [template.bitset]) store bits, not <tt>bool</tt>s, and <tt>bitset&lt;N&gt;</tt>
+ does not even have an allocator. But these containers are governed by this clause. Clearly this
+ is not implementable.
+ </p>
+@@ -46796,10 +48710,10 @@ is not implementable.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 23.2 [container.requirements]/p3:
++Change 23.2 [container.requirements] p. 3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Objects stored in these components shall be constructed using
+ <tt>construct_element</tt> (20.6.9)<ins>, unless otherwise specified</ins>.
+ For each operation that inserts an
+@@ -46811,20 +48725,20 @@ with a scoped allocator of type <tt>A</tt> (i.e., an allocator for which
+ <tt>is_scoped_allocator&lt;A&gt;::value</tt> is <tt>true</tt>), then
+ <tt>construct_element</tt> may pass an inner allocator argument to
+ <tt>T</tt>'s constructor. <i>-- end note</i>]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.4.2 [vector.bool]/p2:
++Change 23.3.7 [vector.bool]/p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Unless described below, all operations have the same requirements and semantics as the primary <tt>vector</tt> template,
+ except that operations dealing with the <tt>bool</tt> value type map to bit values in the container storage<ins>,
+ and <tt>construct_element</tt> (23.2 [container.requirements]) is not used to construct these values</ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Move 20.5 [template.bitset] to clause 20.
++Move 20.6 [template.bitset] to clause 20.
+ </p>
+
+
+@@ -46834,9 +48748,9 @@ Move 20.5 [template.bitset] to clause 20.
+
+ <hr>
+ <h3><a name="843"></a>843. Reference Closure</h3>
+-<p><b>Section:</b> X [func.referenceclosure.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-06-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> X [func.referenceclosure.cons] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-06-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>std::reference_closure</tt> type has a deleted copy assignment operator
+@@ -46862,7 +48776,8 @@ The semantics of assignment are effectively obtained by use of the
+ default destructor and default copy assignment operator via
+ </p>
+
+-<blockquote><pre>x.~reference_closure(); new (x) reference_closure(y);
++<blockquote><pre>
++x.~reference_closure(); new (x) reference_closure(y);
+ </pre></blockquote>
+
+ <p>
+@@ -46878,7 +48793,8 @@ replace the <tt>=delete</tt> in the copy assignment operator in the synopsis
+ with <tt>=default</tt>.
+ </p>
+
+-<blockquote><pre>template&lt;class R , class... ArgTypes &gt;
++<blockquote><pre>
++template&lt;class R , class... ArgTypes &gt;
+ class reference_closure&lt;R (ArgTypes...)&gt; {
+ public:
+ ...
+@@ -46892,7 +48808,8 @@ add the member function description
+ </p>
+
+ <blockquote>
+-<pre>reference_closure&amp; operator=(const reference_closure&amp; f)
++<pre>
++reference_closure&amp; operator=(const reference_closure&amp; f)
+ </pre>
+ <blockquote>
+ <p>
+@@ -46912,10 +48829,10 @@ add the member function description
+
+ <hr>
+ <h3><a name="844"></a>844. <tt>complex pow</tt> return type is ambiguous</h3>
+-<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current working draft is in an inconsistent state.
+@@ -46925,17 +48842,17 @@ The current working draft is in an inconsistent state.
+ 26.4.8 [complex.transcendentals] says that:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>pow(complex&lt;float&gt;(), int())</tt> returns a <tt>complex&lt;float&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ 26.4.9 [cmplx.over] says that:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>pow(complex&lt;float&gt;(), int())</tt> returns a <tt>complex&lt;double&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Sophia Antipolis:
+@@ -46946,14 +48863,14 @@ Sophia Antipolis:
+ <p>
+ Since <tt>int</tt> promotes to <tt>double</tt>, and C99 doesn't have an <tt>int</tt>-based
+ overload for <tt>pow</tt>, the C99 result is <tt>complex&lt;double&gt;</tt>, see also C99
+-7.22, see also library issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#550">550</a>.
++7.22, see also library issue <a href="lwg-defects.html#550">550</a>.
+ </p>
+ <p>
+ Special note: ask P.J. Plauger.
+ </p>
+-<blockquote>
++<blockquote><p>
+ Looks fine.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -46962,7 +48879,8 @@ Looks fine.
+ Strike this <tt>pow</tt> overload in 26.4.1 [complex.syn] and in 26.4.8 [complex.transcendentals]:
+ </p>
+
+-<blockquote><pre><del>template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp; x, int y);</del>
++<blockquote><pre>
++<del>template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp; x, int y);</del>
+ </pre></blockquote>
+
+
+@@ -46971,14 +48889,15 @@ Strike this <tt>pow</tt> overload in 26.4.1 [complex.syn] and in 26.4.8 [complex
+
+ <hr>
+ <h3><a name="845"></a>845. atomics cannot support aggregate initialization</h3>
+-<p><b>Section:</b> X [atomics.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types">issues</a> in [atomics.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The atomic classes (and class templates) are required to support aggregate
+-initialization (29.5.1 [atomics.types.integral]p2 / 29.5.2 [atomics.types.address]p1)
++initialization (X [atomics.types.integral] p. 2 &#47; X [atomics.types.address] p. 1)
+ yet also have user declared constructors, so cannot be aggregates.
+ </p>
+ <p>
+@@ -46997,14 +48916,16 @@ Jens adds:
+ <p>
+ Note that
+ </p>
+-<blockquote><pre>atomic_itype a1 = { 5 };
++<blockquote><pre>
++atomic_itype a1 = { 5 };
+ </pre></blockquote>
+ <p>
+ would be aggregate-initialization syntax (now coming under the disguise
+ of brace initialization), but would be ill-formed, because the corresponding
+ constructor for atomic_itype is explicit. This works, though:
+ </p>
+-<blockquote><pre>atomic_itype a2 { 6 };
++<blockquote><pre>
++atomic_itype a2 { 6 };
+ </pre></blockquote>
+
+ </blockquote>
+@@ -47024,7 +48945,7 @@ Lawrence will provide wording.
+ </p>
+ <p>
+ This issue is addressed in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.html">N2783</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.htm">N2783</a>.
+ </p>
+ </blockquote>
+
+@@ -47032,7 +48953,7 @@ This issue is addressed in
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-within the synopsis in 29.5.1 [atomics.types.integral] edit as follows.
++within the synopsis in X [atomics.types.integral] edit as follows.
+ </p>
+
+ <blockquote><pre><code>
+@@ -47048,10 +48969,10 @@ typedef struct atomic_<var>itype</var> {
+ </code></pre></blockquote>
+
+ <p>
+-edit 29.5.1 [atomics.types.integral] paragraph 2 as follows.
++edit X [atomics.types.integral] paragraph 2 as follows.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The atomic integral types shall have standard layout.
+ They shall each have a trivial default constructor,
+ a constexpr <del>explicit</del> value constructor,
+@@ -47059,10 +48980,10 @@ a deleted copy constructor,
+ a deleted copy assignment operator,
+ and a trivial destructor.
+ They shall each support aggregate initialization syntax.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-within the synopsis of 29.5.2 [atomics.types.address] edit as follows.
++within the synopsis of X [atomics.types.address] edit as follows.
+ </p>
+
+ <blockquote><pre><code>
+@@ -47074,10 +48995,10 @@ typedef struct atomic_address {
+ </code></pre></blockquote>
+
+ <p>
+-edit 29.5.2 [atomics.types.address] paragraph 1 as follows.
++edit X [atomics.types.address] paragraph 1 as follows.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The type <code>atomic_address</code> shall have standard layout.
+ It shall have a trivial default constructor,
+ a constexpr <del>explicit</del> value constructor,
+@@ -47085,7 +49006,7 @@ a deleted copy constructor,
+ a deleted copy assignment operator,
+ and a trivial destructor.
+ It shall support aggregate initialization syntax.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ within the synopsis of 29.5 [atomics.types.generic] edit as follows.
+@@ -47111,12 +49032,12 @@ template &lt;&gt; struct atomic&lt;T*&gt; : atomic_address {
+ edit 29.5 [atomics.types.generic] paragraph 2 as follows.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Specializations of the <code>atomic</code> template
+ shall have a deleted copy constructor,
+ a deleted copy assignment operator,
+ and a constexpr <del>explicit</del> value constructor.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -47125,14 +49046,14 @@ and a constexpr <del>explicit</del> value constructor.
+
+ <hr>
+ <h3><a name="846"></a>846. No definition for constructor</h3>
+-<p><b>Section:</b> X [atomics.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types">issues</a> in [atomics.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-06-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The atomic classes and class templates (29.5.1 [atomics.types.integral] /
+-29.5.2 [atomics.types.address]) have a constexpr
++The atomic classes and class templates (X [atomics.types.integral] &#47;
++X [atomics.types.address]) have a constexpr
+ constructor taking a value of the appropriate type for that atomic.
+ However, neither clause provides semantics or a definition for this
+ constructor. I'm not sure if the initialization is implied by use of
+@@ -47152,7 +49073,7 @@ Lawrence will provide wording.
+ </p>
+ <p>
+ This issue is addressed in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.html">N2783</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2783.htm">N2783</a>.
+ </p>
+ </blockquote>
+
+@@ -47175,7 +49096,7 @@ constexpr <var>A</var>::<var>A</var>(<var>C</var> desired);
+ Initializes the object with the value <code>desired</code>.
+ [<i>Note:</i>
+ Construction is not atomic.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </dd>
+ </dl>
+ </blockquote>
+@@ -47186,10 +49107,10 @@ Construction is not atomic.
+
+ <hr>
+ <h3><a name="847"></a>847. string exception safety guarantees</h3>
+-<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Hervé Brönnimann <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.require">issues</a> in [string.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Herv&eacute; Br&ouml;nnimann <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In March, on comp.lang.c++.moderated, I asked what were the
+@@ -47200,12 +49121,12 @@ member throws exception). The closest the current draft comes to
+ offering any guarantees is 21.4 [basic.string], para 3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The class template <tt>basic_string</tt> conforms to the requirements
+ for a Sequence Container (23.1.1), for a Reversible Container (23.1),
+ and for an Allocator-aware container (91). The iterators supported by
+ <tt>basic_string</tt> are random access iterators (24.1.5).
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ However, the chapter 23 only says, on the topic of exceptions: 23.2 [container.requirements],
+@@ -47228,7 +49149,7 @@ I take it as saying that this paragraph has *no* implication on
+ <tt>std::basic_string</tt>, as <tt>basic_string</tt> isn't defined in Clause 23 and
+ this paragraph does not define a *requirement* of Sequence
+ nor Reversible Container, just of the models defined in Clause 23.
+-In addition, LWG Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#718">718</a> proposes to remove 23.2 [container.requirements], para 3.
++In addition, LWG Issue <a href="lwg-closed.html#718">718</a> proposes to remove 23.2 [container.requirements], para 3.
+ </p>
+
+ <p>
+@@ -47254,29 +49175,29 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Implementors will study this to confirm that it is actually possible.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Daniel adds 2009-02-14:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution of paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2815.html">N2815</a>
+ interacts with this issue (the paper does not refer to this issue).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -47308,39 +49229,41 @@ or add paragraphs to Effects clauses wherever appropriate.
+
+
+ <hr>
+-<h3><a name="848"></a>848. missing <tt>std::hash</tt> specializations for <tt>std::bitset/std::vector&lt;bool&gt;</tt></h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<h3><a name="848"></a>848. Missing <tt>std::hash</tt> specializations for <tt>std::bitset&#47;std::vector&lt;bool&gt;</tt></h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Thorsten Ottosen <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In the current working draft, <tt>std::hash&lt;T&gt;</tt> is specialized for builtin
+ types and a few other types. Bitsets seems like one that is missing from
+ the list, not because it cannot not be done by the user, but because it
+ is hard or impossible to write an efficient implementation that works on
+-32bit/64bit chunks at a time. For example, <tt>std::bitset</tt> is too much
++32bit&#47;64bit chunks at a time. For example, <tt>std::bitset</tt> is too much
+ encapsulated in this respect.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following to the synopsis in 20.8 [function.objects]/2:
++Add the following to the synopsis in 20.9 [function.objects]/2:
+ </p>
+
+-<blockquote><pre>template&lt;class Allocator&gt; struct hash&lt;std::vector&lt;bool,Allocator&gt;&gt;;
++<blockquote><pre>
++template&lt;class Allocator&gt; struct hash&lt;std::vector&lt;bool,Allocator&gt;&gt;;
+ template&lt;size_t N&gt; struct hash&lt;std::bitset&lt;N&gt;&gt;;
+ </pre></blockquote>
+
+ <p>
+-Modify the last sentence of 20.8.15 [unord.hash]/1 to end with:
++Modify the last sentence of 20.9.13 [unord.hash]/1 to end with:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... and <tt>std::string</tt>, <tt>std::u16string</tt>, <tt>std::u32string</tt>, <tt>std::wstring</tt>,
+ <tt>std::error_code</tt>, <tt>std::thread::id</tt>, <tt>std::bitset</tt>, <tt>and std::vector&lt;bool&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -47349,13 +49272,13 @@ Modify the last sentence of 20.8.15 [unord.hash]/1 to end with:
+
+ <hr>
+ <h3><a name="850"></a>850. Should <tt>shrink_to_fit</tt> apply to <tt>std::deque</tt>?</h3>
+-<p><b>Section:</b> 23.3.2.2 [deque.capacity] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.3.3.3 [deque.capacity] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-06-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#755">755</a> added a <tt>shrink_to_fit</tt> function to <tt>std::vector</tt> and <tt>std::string</tt>.
++Issue <a href="lwg-defects.html#755">755</a> added a <tt>shrink_to_fit</tt> function to <tt>std::vector</tt> and <tt>std::string</tt>.
+ It did not yet deal with <tt>std::deque</tt>, because of the fundamental
+ difference between <tt>std::deque</tt> and the other two container types. The
+ need for <tt>std::deque</tt> may seem less evident, because one might think that
+@@ -47366,50 +49289,52 @@ blocks that's bounded by a small constant.
+ The container overhead can in fact be arbitrarily large (i.e. is not
+ necessarily O(N) where N is the number of elements currently held by the
+ <tt>deque</tt>). As Bill Plauger noted in a reflector message, unless the map of
+-block pointers is shrunk, it must hold at least maxN/B pointers where
++block pointers is shrunk, it must hold at least maxN&frasl;B pointers where
+ maxN is the maximum of N over the lifetime of the <tt>deque</tt> since its
+ creation. This is independent of how the map is implemented
+ (<tt>vector</tt>-like circular buffer and all), and maxN bears no relation to N,
+ the number of elements it currently holds.
+ </p>
+ <p>
+-Hervé Brönnimann reports a situation where a <tt>deque</tt> of requests grew very
++Herv&eacute; Br&ouml;nnimann reports a situation where a <tt>deque</tt> of requests grew very
+ large due to some temporary backup (the front request hanging), and the
+ map of the <tt>deque</tt> grew quite large before getting back to normal. Just
+ to put some color on it, assuming a <tt>deque</tt> with 1K pointer elements in
+ steady regime, that held, at some point in its lifetime, maxN=10M
+ pointers, with one block holding 128 elements, the spine must be at
+-least (maxN / 128), in that case 100K. In that case, shrink-to-fit
++least (maxN &frasl; 128), in that case 100K. In that case, shrink-to-fit
+ would allow to reuse about 100K which would otherwise never be reclaimed
+ in the lifetime of the <tt>deque</tt>.
+ </p>
+ <p>
+-An added bonus would be that it *allows* implementations to hang on to
++An added bonus would be that it <em>allows</em> implementations to hang on to
+ empty blocks at the end (but does not care if they do or not). A
+ <tt>shrink_to_fit</tt> would take care of both shrinks, and guarantee that at
+ most O(B) space is used in addition to the storage to hold the N
+-elements and the N/B block pointers.
++elements and the N&frasl;B block pointers.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-To Class template deque 23.3.2 [deque] synopsis, add:
++To class template <tt>deque</tt> 23.3.3 [deque] synopsis, add:
+ </p>
+-<blockquote><pre>void shrink_to_fit();
++<blockquote><pre>
++void shrink_to_fit();
+ </pre></blockquote>
+
+ <p>
+-To deque capacity 23.3.2.2 [deque.capacity], add:
++To deque capacity 23.3.3.3 [deque.capacity], add:
+ </p>
+-<blockquote><pre>void shrink_to_fit();
++<blockquote><pre>
++void shrink_to_fit();
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Remarks:</i> <tt>shrink_to_fit</tt> is a non-binding request to reduce memory
+ use. [<i>Note:</i> The request is non-binding to allow latitude for
+-implementation-specific optimizations. -- <i>end note</i>]
+-</blockquote>
++implementation-specific optimizations. &mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+
+@@ -47418,25 +49343,27 @@ implementation-specific optimizations. -- <i>end note</i>]
+
+ <hr>
+ <h3><a name="852"></a>852. unordered containers <tt>begin(n)</tt> mistakenly <tt>const</tt></h3>
+-<p><b>Section:</b> 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2008-06-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord">issues</a> in [unord].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2008-06-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 3 of the four unordered containers the local <tt>begin</tt> member is mistakenly declared <tt>const</tt>:
+ </p>
+
+-<blockquote><pre>local_iterator begin(size_type n) const;
++<blockquote><pre>
++local_iterator begin(size_type n) const;
+ </pre></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in 23.7.1 [unord.map], 23.7.2 [unord.multimap], and 23.7.4 [unord.multiset]:
++Change the synopsis in 23.5.4 [unord.map], 23.5.5 [unord.multimap], and 23.5.7 [unord.multiset]:
+ </p>
+
+-<blockquote><pre>local_iterator begin(size_type n)<del> const</del>;
++<blockquote><pre>
++local_iterator begin(size_type n)<del> const</del>;
+ </pre></blockquote>
+
+
+@@ -47445,13 +49372,14 @@ Change the synopsis in 23.7.1 [unord.map], 23.7.2 [unord.multimap], and 23.7.4 [
+
+ <hr>
+ <h3><a name="853"></a>853. <tt>to_string</tt> needs updating with <tt>zero</tt> and <tt>one</tt></h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#396">396</a> adds defaulted arguments to the <tt>to_string</tt> member, but neglects to update
++Issue <a href="lwg-defects.html#396">396</a> adds defaulted arguments to the <tt>to_string</tt> member, but neglects to update
+ the three newer <tt>to_string</tt> overloads.
+ </p>
+
+@@ -47460,10 +49388,10 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Daniel found problems with the wording and provided fixes. Moved from Ready
+ to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+@@ -47488,18 +49416,19 @@ Recommend Tentatively Ready.
+ </blockquote>
+
+ <p><i>[
+-2009-05-09: See alternative solution in issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1113">1113</a>.
++2009-05-09: See alternative solution in issue <a href="lwg-defects.html#1113">1113</a>.
+ ]</i></p>
+
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+-<p>replace in 20.5 [template.bitset]/1 (class <tt>bitset</tt>)
++<p>replace in 20.6 [template.bitset]/1 (class <tt>bitset</tt>)
+ </p>
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ basic_string&lt;charT, traits, allocator&lt;charT&gt; &gt;
+ to_string(<ins>charT zero = charT('0'), charT one = charT('1')</ins>) const;
+ template &lt;class charT&gt;
+@@ -47511,43 +49440,46 @@ basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;
+ </li>
+ <li>
+ <p>
+-replace in 20.5.2 [bitset.members]/37
++replace in 20.6.2 [bitset.members]/37
+ </p>
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ basic_string&lt;charT, traits, allocator&lt;charT&gt; &gt;
+ to_string(<ins>charT zero = charT('0'), charT one = charT('1')</ins>) const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 37 <i>Returns:</i> <tt>to_string&lt;charT, traits, allocator&lt;charT&gt; &gt;(<ins>zero, one</ins>)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ <li>
+ <p>
+-replace in 20.5.2 [bitset.members]/38
++replace in 20.6.2 [bitset.members]/38
+ </p>
+
+-<blockquote><pre>template &lt;class charT&gt;
++<blockquote><pre>
++template &lt;class charT&gt;
+ basic_string&lt;charT, char_traits&lt;charT&gt;, allocator&lt;charT&gt; &gt;
+ to_string(<ins>charT zero = charT('0'), charT one = charT('1')</ins>) const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 38 <i>Returns:</i> <tt>to_string&lt;charT, char_traits&lt;charT&gt;, allocator&lt;charT&gt; &gt;(<ins>zero, one</ins>)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-replace in 20.5.2 [bitset.members]/39
++replace in 20.6.2 [bitset.members]/39
+ </p>
+
+-<blockquote><pre>basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;
++<blockquote><pre>
++basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;
+ to_string(<ins>char zero = '0', char one = '1'</ins>) const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 39 <i>Returns:</i> <tt>to_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt;(<ins>zero, one</ins>)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -47560,10 +49492,10 @@ replace in 20.5.2 [bitset.members]/39
+
+ <hr>
+ <h3><a name="854"></a>854. <tt>default_delete</tt> converting constructor underspecified</h3>
+-<p><b>Section:</b> 20.9.9.1.2 [unique.ptr.dltr.dflt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.dltr.dflt">issues</a> in [unique.ptr.dltr.dflt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.1.1.2 [unique.ptr.dltr.dflt] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-06-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.dltr.dflt">issues</a> in [unique.ptr.dltr.dflt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ No relationship between <tt>U</tt> and <tt>T</tt> in the converting constructor for <tt>default_delete</tt> template.
+@@ -47591,14 +49523,15 @@ I believe the current proposed wording
+ (<tt>requires Convertible&lt;U*, T*&gt; &amp;&amp; HasVirtualDestructor&lt;T&gt;</tt>) does so:
+ </p>
+
+-<blockquote><pre>#include &lt;memory&gt;
++<blockquote><pre>
++#include &lt;memory&gt;
+
+ int main()
+ {
+ std::unique_ptr&lt;int&gt; p1(new int(1));
+ std::unique_ptr&lt;const int&gt; p2(move(p1));
+ int i = *p2;
+-<font color="#C80000">// *p2 = i; // should not compile</font>
++<span style="color:#C80000">// *p2 = i; // should not compile</span>
+ }
+ </pre></blockquote>
+
+@@ -47632,9 +49565,9 @@ Recommend Keep in Review.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Keep in Review status for the reasons cited.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -47661,18 +49594,19 @@ Move back to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add after 20.9.9.1.2 [unique.ptr.dltr.dflt], p1:
++Add after 20.8.1.1.2 [unique.ptr.dltr.dflt], p1:
+ </p>
+
+-<blockquote><pre>template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp; other);
++<blockquote><pre>
++template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp; other);
+ </pre>
+ <blockquote>
+ <p>
+@@ -47692,10 +49626,11 @@ if and only if <tt>U*</tt> is implicitly convertible to <tt>T*</tt>.
+
+ <hr>
+ <h3><a name="856"></a>856. Removal of <tt>aligned_union</tt></h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-06-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2008-06-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ With the arrival of extended unions
+@@ -47708,17 +49643,19 @@ the "extended unions" core-language facility.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Remove the following signature from 20.7.2 [meta.type.synop]:
++Remove the following signature from 20.10.2 [meta.type.synop]:
+ </p>
+-<blockquote><pre>template &lt;std::size_t Len, class... Types&gt; struct aligned_union;
++<blockquote><pre>
++template &lt;std::size_t Len, class... Types&gt; struct aligned_union;
+ </pre></blockquote>
+
+ <p>
+-Remove the second row from table 51 in 20.7.7.6 [meta.trans.other],
++Remove the second row from table 51 in 20.10.7.6 [meta.trans.other],
+ starting with:
+ </p>
+
+-<blockquote><pre>template &lt;std::size_t Len,
++<blockquote><pre>
++template &lt;std::size_t Len,
+ class... Types&gt;
+ struct aligned_union;
+ </pre></blockquote>
+@@ -47729,10 +49666,10 @@ struct aligned_union;
+
+ <hr>
+ <h3><a name="857"></a>857. <tt>condition_variable::time_wait</tt> return <tt>bool</tt> error prone</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-06-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-06-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The meaning of the <tt>bool</tt> returned by <tt>condition_variable::timed_wait</tt> is so
+@@ -47742,14 +49679,16 @@ people have independently stumbled on this issue.
+ <p>
+ It might be simpler to change the return type to a scoped enum:
+ </p>
+-<blockquote><pre>enum class timeout { not_reached, reached };
++<blockquote><pre>
++enum class timeout { not_reached, reached };
+ </pre></blockquote>
+
+ <p>
+ That's the same cost as returning a <tt>bool</tt>, but not subject to mistakes. Your example below would be:
+ </p>
+
+-<blockquote><pre>if (cv.wait_until(lk, time_limit) == timeout::reached )
++<blockquote><pre>
++if (cv.wait_until(lk, time_limit) == timeout::reached )
+ throw time_out();
+ </pre></blockquote>
+
+@@ -47790,9 +49729,9 @@ Howard to provide wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -47802,7 +49741,8 @@ Change Condition variables 30.5 [thread.condition], Header
+ condition_variable synopsis, as indicated:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ class condition_variable;
+ class condition_variable_any;
+
+@@ -47811,10 +49751,11 @@ condition_variable synopsis, as indicated:
+ </pre></blockquote>
+
+ <p>
+-Change Class condition_variable 30.5.1 [thread.condition.condvar] as indicated:
++Change class <tt>condition_variable</tt> 30.5.1 [thread.condition.condvar] as indicated:
+ </p>
+
+-<blockquote><pre>class condition_variable {
++<blockquote><pre>
++class condition_variable {
+ public:
+ ...
+ template &lt;class Clock, class Duration&gt;
+@@ -47900,7 +49841,7 @@ cannot be achieved.
+
+ <ul>
+ <li>
+-<tt>operation_not_permitted</tt> — if the thread does not own the lock.
++<tt>operation_not_permitted</tt> &mdash; if the thread does not own the lock.
+ </li>
+ <li>
+ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+@@ -47908,7 +49849,8 @@ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+ </ul>
+ </blockquote>
+
+-<pre>template &lt;class Rep, class Period&gt;
++<pre>
++template &lt;class Rep, class Period&gt;
+ <del>bool</del> <ins>cv_status</ins> wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+
+@@ -47917,7 +49859,8 @@ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+ <p>
+ -21- <i><del>Effects</del> <ins>Returns</ins>:</i>
+ </p>
+-<blockquote><pre>wait_until(lock, chrono::monotonic_clock::now() + rel_time)
++<blockquote><pre>
++wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+ </pre></blockquote>
+ <p>
+ <del>-22- <i>Returns:</i> <tt>false</tt> if the call is returning because the time
+@@ -47926,13 +49869,14 @@ otherwise <tt>true</tt>.</del>
+ </p>
+
+ <p><i>[
+-This part of the wording may conflict with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> in detail, but does
++This part of the wording may conflict with <a href="lwg-defects.html#859">859</a> in detail, but does
+ not do so in spirit. If both issues are accepted, there is a logical merge.
+ ]</i></p>
+
+ </blockquote>
+
+-<pre>template &lt;class Clock, class Duration, class Predicate&gt;
++<pre>
++template &lt;class Clock, class Duration, class Predicate&gt;
+ bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
+ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
+ Predicate pred);
+@@ -47942,7 +49886,8 @@ not do so in spirit. If both issues are accepted, there is a logical merge.
+ <p>
+ -23- <i>Effects:</i>
+ </p>
+-<blockquote><pre>while (!pred())
++<blockquote><pre>
++while (!pred())
+ if (<del>!</del>wait_until(lock, abs_time) <ins>== cv_status::timeout</ins>)
+ return pred();
+ return true;
+@@ -47956,7 +49901,7 @@ return true;
+ -25- [<i>Note:</i>
+ The returned value indicates whether the predicate evaluates to
+ <tt>true</tt> regardless of whether the timeout was triggered.
+-— <i>end note</i>].
++&mdash; <i>end note</i>].
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -47965,7 +49910,8 @@ The returned value indicates whether the predicate evaluates to
+ Change Class condition_variable_any 30.5.2 [thread.condition.condvarany] as indicated:
+ </p>
+
+-<blockquote><pre>class condition_variable_any {
++<blockquote><pre>
++class condition_variable_any {
+ public:
+ ...
+ template &lt;class Lock, class Clock, class Duration&gt;
+@@ -48044,7 +49990,8 @@ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+ </ul>
+ </blockquote>
+
+-<pre>template &lt;class Lock, class Rep, class Period&gt;
++<pre>
++template &lt;class Lock, class Rep, class Period&gt;
+ <del>bool</del> <ins>cv_status</ins> wait_for(Lock&amp; lock,
+ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+
+@@ -48054,7 +50001,8 @@ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+ <p>
+ -18- <i><del>Effects</del> <ins>Returns</ins>:</i>
+ </p>
+-<blockquote><pre>wait_until(lock, chrono::monotonic_clock::now() + rel_time)
++<blockquote><pre>
++wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+ </pre></blockquote>
+
+ <p>
+@@ -48064,14 +50012,15 @@ otherwise <tt>true</tt>.</del>
+ </p>
+
+ <p><i>[
+-This part of the wording may conflict with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a> in detail, but does
++This part of the wording may conflict with <a href="lwg-defects.html#859">859</a> in detail, but does
+ not do so in spirit. If both issues are accepted, there is a logical merge.
+ ]</i></p>
+
+
+ </blockquote>
+
+-<pre>template &lt;class Lock, class Clock, class Duration, class Predicate&gt;
++<pre>
++template &lt;class Lock, class Clock, class Duration, class Predicate&gt;
+ bool wait_until(Lock&amp; lock,
+ const chrono::time_point&lt;Clock, Duration&gt;&amp; <del>rel_time</del> <ins>abs_time</ins>,
+ Predicate pred);
+@@ -48081,7 +50030,8 @@ not do so in spirit. If both issues are accepted, there is a logical merge.
+ <p>
+ -20- <i>Effects:</i>
+ </p>
+-<blockquote><pre>while (!pred())
++<blockquote><pre>
++while (!pred())
+ if (<del>!</del>wait_until(lock, abs_time) <ins>== cv_status::timeout</ins>)
+ return pred();
+ return true;
+@@ -48095,7 +50045,7 @@ return true;
+ -22- [<i>Note:</i>
+ The returned value indicates whether the predicate evaluates to
+ <tt>true</tt> regardless of whether the timeout was triggered.
+-— <i>end note</i>].
++&mdash; <i>end note</i>].
+ </p>
+ </blockquote>
+
+@@ -48108,18 +50058,18 @@ The returned value indicates whether the predicate evaluates to
+
+ <hr>
+ <h3><a name="858"></a>858. Wording for Minimal Support for Garbage Collection</h3>
+-<p><b>Section:</b> 20.9.11 [util.dynamic.safety] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-06-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.7.4 [util.dynamic.safety] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The first sentence of the Effects clause for <tt>undeclare_reachable</tt> seems
+ to be missing some words. I can't parse
+ </p>
+-<blockquote>
++<blockquote><p>
+ ... for all non-null <tt>p</tt> referencing the argument is no longer declared reachable...
+-</blockquote>
++</p></blockquote>
+ <p>
+ I take it the intent is that <tt>undeclare_reachable</tt> should be called only
+ when there has been a corresponding call to <tt>declare_reachable</tt>. In
+@@ -48159,7 +50109,7 @@ to clarify the intent.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.9.11 [util.dynamic.safety]
++In 20.7.4 [util.dynamic.safety]
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2670.htm">N2670</a>,
+ Minimal Support for Garbage Collection)
+ </p>
+@@ -48167,31 +50117,31 @@ Minimal Support for Garbage Collection)
+ Add at the beginning, before paragraph 39
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A complete object is <i>declared reachable</i> while the number of calls
+ to <tt>declare_reachable</tt> with an argument referencing the object exceeds the
+ number of <tt>undeclare_reachable</tt> calls with pointers to the same complete
+ object.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change paragraph 42 (Requires clause for <tt>undeclare_reachable</tt>)
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If <tt>p</tt> is not null, <del><tt>declare_reachable(p)</tt> was previously called</del>
+ <ins>the complete object referenced by <tt>p</tt> shall have
+ been previously declared reachable</ins>, and shall
+ be live <ins>(3.8 [basic.life])</ins> from the time of the call until the last <tt>undeclare_reachable(p)</tt>
+ call on the object.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change the first sentence in paragraph 44 (Effects clause for
+ <tt>undeclare_reachable</tt>):
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i>
+ <del>Once the number of calls to
+ <tt>undeclare_reachable(p)</tt> equals the number of calls to
+@@ -48206,7 +50156,7 @@ referenced by <tt>p</tt> is no longer declared reachable, then
+ dereferencing any pointer to <tt>q</tt> that is not safely derived
+ results in undefined behavior.
+ </ins> ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Change the final note:
+@@ -48230,16 +50180,16 @@ note</i>]
+
+ <hr>
+ <h3><a name="859"></a>859. Monotonic Clock is Conditionally Supported?</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p>Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#958">958</a>, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#959">959</a>.</p>
++<p>Related to <a href="lwg-defects.html#958">958</a>, <a href="lwg-closed.html#959">959</a>.</p>
+
+ <p>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.html">N2661</a>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm">N2661</a>
+ says that there is a class named <tt>monotonic_clock</tt>. It also says that this
+ name may be a synonym for <tt>system_clock</tt>, and that it's conditionally
+ supported. So the actual requirement is that it can be monotonic or not,
+@@ -48253,7 +50203,8 @@ variants of <tt>wait_for</tt> explicitly use <tt>monotonic_clock::now()</tt>. Wh
+ meaning of an effects clause that says
+ </p>
+
+-<blockquote><pre>wait_until(lock, chrono::monotonic_clock::now() + rel_time)
++<blockquote><pre>
++wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+ </pre></blockquote>
+
+ <p>
+@@ -48267,20 +50218,20 @@ San Francisco:
+
+ <blockquote>
+ <p>
+-Nick: maybe instead of saying that chrono::monotonic_clock is
++Nick: maybe instead of saying that <tt>chrono::monotonic_clock</tt> is
+ conditionally supported, we could say that it's always there, but not
+ necessarily supported..
+ </p>
+ <p>
+ Beman: I'd prefer a typedef that identifies the best clock to use for
+-wait_for locks.
++<tt>wait_for</tt> locks.
+ </p>
+ <p>
+ Tom: combine the two concepts; create a duration clock type, but keep
+ the is_monotonic test.
+ </p>
+ <p>
+-Howard: if we create a duration_clock type, is it a typedef or an
++Howard: if we create a <tt>duration_clock</tt> type, is it a typedef or an
+ entirely true type?
+ </p>
+ <p>
+@@ -48313,11 +50264,11 @@ And paragraph 2 of 30.2.4 [thread.req.timing] has the words strongly encouraging
+ implementations to use monotonic clocks for <tt>sleep_for</tt>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 The member functions whose names end in <tt>_for</tt> take an argument that
+ specifies a relative time. Implementations should use a monotonic clock to
+ measure time for these functions.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I believe the approach taken in describing the effects of <tt>sleep_for</tt>
+@@ -48342,7 +50293,7 @@ Move to Ready.
+ </blockquote>
+
+ <p><i>[
+-2009-07-21 Beman added the requested wording changes to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>.
++2009-07-21 Beman added the requested wording changes to <a href="lwg-defects.html#962">962</a>.
+ ]</i></p>
+
+
+@@ -48354,7 +50305,8 @@ Change 30.5.1 [thread.condition.condvar], p21-22:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Rep, class Period&gt;
++<pre>
++template &lt;class Rep, class Period&gt;
+ bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+ </pre>
+@@ -48371,7 +50323,8 @@ arguments supplied by all concurrently waiting threads (via <tt>wait</tt>,
+ <p>
+ 21 <i>Effects:</i>
+ </p>
+-<blockquote><pre><del>wait_until(lock, chrono::monotonic_clock::now() + rel_time)</del>
++<blockquote><pre>
++<del>wait_until(lock, chrono::monotonic_clock::now() + rel_time)</del>
+ </pre></blockquote>
+ <ul>
+ <li><ins>
+@@ -48406,7 +50359,7 @@ duration specified by <tt>rel_time</tt> has elapsed, otherwise <tt>true</tt>.
+ </p>
+
+ <p><i>[
+-This part of the wording may conflict with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#857">857</a> in detail, but does
++This part of the wording may conflict with <a href="lwg-defects.html#857">857</a> in detail, but does
+ not do so in spirit. If both issues are accepted, there is a logical merge.
+ ]</i></p>
+
+@@ -48436,7 +50389,8 @@ Change 30.5.1 [thread.condition.condvar], p26-p29:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Rep, class Period, class Predicate&gt;
++<pre>
++template &lt;class Rep, class Period, class Predicate&gt;
+ bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
+ Predicate pred);
+@@ -48454,7 +50408,8 @@ arguments supplied by all concurrently waiting threads (via <tt>wait</tt>,
+ <p>
+ <i>26 Effects:</i>
+ </p>
+-<blockquote><pre><del>wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))</del>
++<blockquote><pre>
++<del>wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))</del>
+ </pre>
+ <ul>
+ <li><ins>
+@@ -48527,14 +50482,16 @@ Change 30.5.2 [thread.condition.condvarany], p18-19:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Lock, class Rep, class Period&gt;
++<pre>
++template &lt;class Lock, class Rep, class Period&gt;
+ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+ </pre>
+ <blockquote>
+ <p>
+ 18 <i>Effects:</i>
+ </p>
+-<blockquote><pre><del>wait_until(lock, chrono::monotonic_clock::now() + rel_time)</del>
++<blockquote><pre>
++<del>wait_until(lock, chrono::monotonic_clock::now() + rel_time)</del>
+ </pre></blockquote>
+
+ <ul>
+@@ -48590,7 +50547,8 @@ Change 30.5.2 [thread.condition.condvarany], p23-p26:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Lock, class Rep, class Period, class Predicate&gt;
++<pre>
++template &lt;class Lock, class Rep, class Period, class Predicate&gt;
+ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
+ </pre>
+ <blockquote>
+@@ -48606,7 +50564,8 @@ arguments supplied by all concurrently waiting threads (via <tt>wait</tt>,
+ <p>
+ <i>23 Effects:</i>
+ </p>
+-<blockquote><pre><del>wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))</del>
++<blockquote><pre>
++<del>wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))</del>
+ </pre>
+ <ul>
+ <li><ins>
+@@ -48682,10 +50641,10 @@ equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+
+ <hr>
+ <h3><a name="860"></a>860. Floating-Point State</h3>
+-<p><b>Section:</b> 26 [numerics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-06-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#numerics">issues</a> in [numerics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 26 [numerics] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-06-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numerics">issues</a> in [numerics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There are a number of functions that affect the floating point state.
+@@ -48767,7 +50726,7 @@ commentary.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ If I understand the history correctly, Nick, as the Posix liaison,
+ should probably get a veto on this, since I think it came from Posix (?)
+ via WG14 and should probably really be addressed there (?). But I think
+@@ -48775,16 +50734,16 @@ we are basically in agreement that there is no other sane way to do
+ this, and hence we don't have to worry too much about stepping on toes.
+ As far as I can tell, this same issue also exists in the latest Posix
+ standard (?).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -48810,21 +50769,22 @@ calling thread.
+
+
+ <hr>
+-<h3><a name="861"></a>861. Incomplete specification of EqualityComparable for std::forward_list</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-06-24 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="861"></a>861. Incomplete specification of <tt>EqualityComparable</tt> for <tt>std::forward_list</tt></h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-06-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 89, Container requirements, defines <tt>operator==</tt> in terms of the container
+ member function <tt>size()</tt> and the algorithm <tt>std::equal</tt>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>==</tt> is an equivalence relation. <tt>a.size() == b.size() &amp;&amp;
+ equal(a.begin(), a.end(), b.begin()</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The new container <tt>forward_list</tt> does not provide a <tt>size</tt> member function
+@@ -48841,7 +50801,7 @@ because of the special design choices of <tt>forward_list</tt>.
+ I propose to apply one of the following resolutions, which are described as:
+ </p>
+
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ Provide a definition, which is optimal for this special container without
+ previous size test. This choice prevents two <tt>O(N)</tt> calls of <tt>std::distance()</tt>
+@@ -48880,9 +50840,9 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Martin provided wording for Option C.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -48911,21 +50871,21 @@ Howard: Commented out options A and B.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark NAD Editorial. Addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Reopened.
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>
+ was rejected in full committee on procedural grounds.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-01-30 Howard updated Table numbers.
+@@ -48937,9 +50897,9 @@ was rejected in full committee on procedural grounds.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -48957,16 +50917,16 @@ Option (C):
+ In 23.2.1 [container.requirements.general] change Table 90 -- Container requirements as indicated:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ Change the text in the Assertion/note column in the row for "<tt>X u</tt>;"
+ as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ post: <tt>u.<del>size() == 0</del><ins>empty() == true</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -48975,9 +50935,9 @@ Change the text in the Assertion/note column in the row for "<tt>X();</tt>"
+ as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>X().<del>size() == 0</del><ins>empty() == true</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -48985,12 +50945,12 @@ as follows:
+ Change the text in the Operational Semantics column in the row for
+ "<tt>a == b</tt>" as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>==</tt> is an equivalence relation.
+ <tt><del>a.size()</del><ins>distance(a.begin(), a.end())</ins> ==
+ <del>b.size()</del><ins>distance(b.begin(), b.end())</ins> &amp;&amp;
+ equal(a.begin(), a.end(), b.begin())</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -48998,9 +50958,9 @@ equal(a.begin(), a.end(), b.begin())</tt>
+ Add text in the Ass./Note/pre-/post-condition column in the row for
+ "<tt>a == b</tt>" as follows:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Requires:</i> <tt>T</tt> is <tt>EqualityComparable</tt>
+-</ins></blockquote>
++</ins></p></blockquote>
+ </li>
+
+ <li>
+@@ -49009,9 +50969,9 @@ Change the text in the Operational Semantics column in the row for
+ "<tt>a.size()</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt><del>a.end() - a.begin()</del><ins>distance(a.begin(), a.end())</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49020,10 +50980,10 @@ Change the text in the Operational Semantics column in the row for
+ "<tt>a.max_size()</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt><del>size()</del><ins>distance(begin(), end())</ins></tt> of the largest
+ possible container
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49032,90 +50992,90 @@ Change the text in the Operational Semantics column in the row for
+ "<tt>a.empty()</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt><del>a.size() == 0</del><ins>a.begin() == a.end()</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+
+ <li>
+ <p>
+-In 23.2.1 [container.requirements.general] change Table 93 -- Allocator-aware container requirements as indicated:
++In 23.2.1 [container.requirements.general] change Table 93 &mdash; Allocator-aware container requirements as indicated:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for "<tt>X() /
++Change the text in the Assertion&#47;note column in the row for "<tt>X() &#47;
+ X u;</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <tt>A</tt> is <tt>DefaultConstructible</tt> post: <tt><del>u.size() ==
+ 0</del><ins>u.empty() == true</ins></tt>, <tt>get_allocator() == A()</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for "<tt>X(m) /
++Change the text in the Assertion&#47;note column in the row for "<tt>X(m) &#47;
+ X u(m);</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ post: <tt><del>u.size() == 0</del><ins>u.empty() == true</ins>,
+ get_allocator() == m</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+
+ <li>
+ <p>
+-In 23.2.3 [sequence.reqmts] change Table 94 -- Sequence container requirements as indicated:
++In 23.2.3 [sequence.reqmts] change Table 94 &mdash; Sequence container requirements as indicated:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for "<tt>X(n,
+-t) / X a(n, t)</tt>" as follows:
++Change the text in the Assertion&#47;note column in the row for "<tt>X(n,
++t) &#47; X a(n, t)</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ post: <tt><del>size()</del><ins>distance(begin(), end())</ins> == n [..]</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for "<tt>X(i,
+-j) / X a(i, j)</tt>" as follows:
++Change the text in the Assertion&#47;note column in the row for "<tt>X(i,
++j) &#47; X a(i, j)</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] post: <del><tt>size() ==</tt> distance between <tt>i</tt> and
+ <tt>j</tt></del><ins><tt>distance(begin(), end()) == distance(i, j)</tt></ins> [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for
++Change the text in the Assertion&#47;note column in the row for
+ "<tt>a.clear()</tt>" as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt><ins>a.</ins>erase(<ins>a.</ins>begin(), <ins>a.</ins>end())</tt> post:
+ <tt><del>size() == 0</del><ins>a.empty() == true</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+
+ <li>
+ <p>
+-In 23.2.4 [associative.reqmts] change Table 96 -- Associative container requirements as indicated:
++In 23.2.4 [associative.reqmts] change Table 96 &mdash; Associative container requirements as indicated:
+ </p>
+
+ <p><i>[
+@@ -49127,18 +51087,18 @@ for all tables and adds some missing objects
+ ]</i></p>
+
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+
+ <li>
+ <p>
+-Change the text in the Complexity column in the row for <tt>X(i,j,c)/X
+-a(i,j,c);</tt> as follows:
++Change the text in the Complexity column in the row for <tt>X(i,j,c)&#47;Xa(i,j,c);</tt>
++as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>N</tt> log <tt>N</tt> in general (<tt>N</tt> <ins><tt> == distance(i,
+ j)</tt></ins><del>is the distance from <tt>i</tt> to <tt>j</tt></del>); ...
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+@@ -49147,10 +51107,10 @@ j)</tt></ins><del>is the distance from <tt>i</tt> to <tt>j</tt></del>); ...
+ Change the text in the Complexity column in the row for
+ "<tt>a.insert(i, j)</tt>" as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>N log(<ins>a.</ins>size() + N)</tt> <del>(<tt>N</tt> is the distance from <tt>i</tt> to
+ <tt>j</tt>)</del><ins> where <tt>N == distance(i, j)</tt></ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49158,9 +51118,9 @@ Change the text in the Complexity column in the row for
+ Change the text in the Complexity column in the row for
+ "<tt>a.erase(k)</tt>" as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>log(<ins>a.</ins>size()) + <ins>a.</ins>count(k)</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49169,23 +51129,23 @@ Change the text in the Complexity column in the row for
+ "<tt>a.erase(q1, q2)</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>log(<ins>a.</ins>size()) + N</tt> where <tt>N</tt> <del>is the distance from <tt>q1</tt>
+ to <tt>q2</tt></del>
+ <ins><tt>== distance(q1, q2)</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for
++Change the text in the Assertion&#47;note column in the row for
+ "<tt>a.clear()</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt><ins>a.</ins>erase(a.begin(),a.end())</tt> post: <tt><del>size() ==
+ 0</del><ins>a.empty() == true</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49194,9 +51154,9 @@ Change the text in the Complexity column in the row for "<tt>a.clear()</tt>"
+ as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ linear in <tt><ins>a.</ins>size()</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49205,32 +51165,32 @@ Change the text in the Complexity column in the row for
+ "<tt>a.count(k)</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>log(<ins>a.</ins>size()) + <ins>a.</ins>count(k)</tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+
+ <li>
+ <p>
+-In 23.2.5 [unord.req] change Table 98 -- Unordered associative container requirements as indicated:
++In 23.2.5 [unord.req] change Table 98 &mdash; Unordered associative container requirements as indicated:
+ </p>
+ <p><i>[
+ The same rational as for Table 96 applies here
+ ]</i></p>
+
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+-Change the text in the Assertion/note column in the row for
++Change the text in the Assertion&#47;note column in the row for
+ "<tt>a.clear()</tt>" as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] Post: <tt>a.<del>size() == 0</del><ins>empty() == true</ins></tt>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+@@ -49245,12 +51205,12 @@ Change the text in the Assertion/note column in the row for
+
+ <hr>
+ <h3><a name="865"></a>865. More algorithms that throw away information</h3>
+-<p><b>Section:</b> 25.3.6 [alg.fill], 25.3.7 [alg.generate] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-07-13 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25.3.6 [alg.fill], 25.3.7 [alg.generate] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-07-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In regard to library defect <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#488">488</a> I found some more algorithms which
++In regard to library defect <a href="lwg-defects.html#488">488</a> I found some more algorithms which
+ unnecessarily throw away information. These are typically algorithms,
+ which sequentially write into an <tt>OutputIterator</tt>, but do not return the
+ final value of this output iterator. These cases are:
+@@ -49268,8 +51228,8 @@ void generate_n(OutputIterator first, Size n, Generator gen);</pre></li>
+ <p>
+ In both cases the minimum requirements on the iterator are
+ <tt>OutputIterator</tt>, which means according to the requirements of
+-24.2.4 [output.iterators]/2 that only single-pass iterations are guaranteed.
+-So, if users of <tt>fill_n</tt> and <tt>generate_n</tt> have *only* an <tt>OutputIterator</tt>
++24.2.4 [output.iterators] p. 2 that only single-pass iterations are guaranteed.
++So, if users of <tt>fill_n</tt> and <tt>generate_n</tt> have <em>only</em> an <tt>OutputIterator</tt>
+ available, they have no chance to continue pushing further values
+ into it, which seems to be a severe limitation to me.
+ </p>
+@@ -49304,10 +51264,10 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We have a consensus for moving forward on this issue, but Daniel needs
+ to deconceptify it.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-25 Daniel provided non-concepts wording.
+@@ -49319,9 +51279,9 @@ to deconceptify it.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -49334,7 +51294,8 @@ Replace the current declaration of <tt>fill_n</tt> in 25 [algorithms]/2, header
+ <tt>&lt;algorithm&gt;</tt> synopsis and in 25.3.6 [alg.fill] by
+ </p>
+
+-<blockquote><pre>template&lt;class OutputIterator, class Size, class T&gt;
++<blockquote><pre>
++template&lt;class OutputIterator, class Size, class T&gt;
+ <del>void</del><ins>OutputIterator</ins> fill_n(OutputIterator first, Size n, const T&amp; value);
+ </pre></blockquote>
+
+@@ -49342,10 +51303,10 @@ Replace the current declaration of <tt>fill_n</tt> in 25 [algorithms]/2, header
+ Just after the effects clause add a new returns clause saying:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins><i>Returns:</i> For <tt>fill_n</tt> and positive <tt>n</tt>, returns <tt>first + n</tt>. Otherwise
+ returns <tt>first</tt> for <tt>fill_n</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49354,7 +51315,8 @@ Replace the current declaration of <tt>generate_n</tt> in 25 [algorithms]/2,
+ header <tt>&lt;algorithm&gt;</tt> synopsis and in 25.3.7 [alg.generate] by
+ </p>
+
+-<blockquote><pre>template&lt;class OutputIterator, class Size, class Generator&gt;
++<blockquote><pre>
++template&lt;class OutputIterator, class Size, class Generator&gt;
+ <del>void</del><ins>OutputIterator</ins> generate_n(OutputIterator first, Size n, Generator gen);
+ </pre></blockquote>
+
+@@ -49362,10 +51324,10 @@ header <tt>&lt;algorithm&gt;</tt> synopsis and in 25.3.7 [alg.generate] by
+ Just after the effects clause add a new returns clause saying:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>For <tt>generate_n</tt> and positive <tt>n</tt>, returns <tt>first + n</tt>. Otherwise
+ returns <tt>first</tt> for <tt>generate_n</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -49377,31 +51339,33 @@ returns <tt>first</tt> for <tt>generate_n</tt>.</ins>
+
+ <hr>
+ <h3><a name="866"></a>866. Qualification of placement new-expressions</h3>
+-<p><b>Section:</b> 20.9.8 [specialized.algorithms], 20.9.10.2.6 [util.smartptr.shared.create] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7.12 [specialized.algorithms], 20.8.2.2.6 [util.smartptr.shared.create] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a> replaced "<tt>new</tt>" with "<tt>::new</tt>" in the placement
+-new-expression in 20.9.5.1 [allocator.members]. I believe the rationale
+-given in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a> applies also to the following other contexts:
++LWG issue <a href="lwg-defects.html#402">402</a> replaced "<tt>new</tt>" with "<tt>::new</tt>" in the placement
++new-expression in 20.7.9.1 [allocator.members]. I believe the rationale
++given in <a href="lwg-defects.html#402">402</a> applies also to the following other contexts:
+ </p>
+ <ul>
+ <li>
+ <p>
+-in 20.9.8 [specialized.algorithms], all four algorithms <tt>unitialized_copy</tt>,
++in 20.7.12 [specialized.algorithms], all four algorithms <tt>unitialized_copy</tt>,
+ <tt>unitialized_copy_n</tt>, <tt>unitialized_fill</tt> and <tt>unitialized_fill_n</tt> use
+ the unqualified placement new-expression in some variation of the form:
+ </p>
+-<blockquote><pre>new (static_cast&lt;void*&gt;(&amp;*result)) typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++<blockquote><pre>
++new (static_cast&lt;void*&gt;(&amp;*result)) typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
+ </pre></blockquote>
+ </li>
+ <li>
+ <p>
+-in 20.9.10.2.6 [util.smartptr.shared.create] there is a reference to the unqualified placement new-expression:
++in 20.8.2.2.6 [util.smartptr.shared.create] there is a reference to the unqualified placement new-expression:
+ </p>
+-<blockquote><pre>new (pv) T(std::forward&lt;Args&gt;(args)...),
++<blockquote><pre>
++new (pv) T(std::forward&lt;Args&gt;(args)...),
+ </pre></blockquote>
+ </li>
+ </ul>
+@@ -49425,20 +51389,20 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Detlef: If we move this to Ready, it's likely that we'll forget about
+ the side comment about the <tt>HasPlacementNew</tt> concept.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Daniel: <tt>HasPlacementNew</tt> has been removed from
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2774.pdf">N2774 (Foundational Concepts)</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -49448,16 +51412,16 @@ Replace "<tt>new</tt>" with "<tt>::new</tt>" in:
+ </p>
+ <ul>
+ <li>
+-20.9.8.2 [uninitialized.copy], paragraphs 1 and 3
++20.7.12.2 [uninitialized.copy], paragraphs 1 and 3
+ </li>
+ <li>
+-20.9.8.3 [uninitialized.fill] paragraph 1
++20.7.12.3 [uninitialized.fill] paragraph 1
+ </li>
+ <li>
+-20.9.8.4 [uninitialized.fill.n] paragraph 1
++20.7.12.4 [uninitialized.fill.n] paragraph 1
+ </li>
+ <li>
+-20.9.10.2.6 [util.smartptr.shared.create] once in paragraph 1 and twice in paragraph 2.
++20.8.2.2.6 [util.smartptr.shared.create] once in paragraph 1 and twice in paragraph 2.
+ </li>
+ </ul>
+
+@@ -49467,11 +51431,12 @@ Replace "<tt>new</tt>" with "<tt>::new</tt>" in:
+
+
+ <hr>
+-<h3><a name="868"></a>868. default construction and value-initialization</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-22 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="868"></a>868. Default construction and value-initialization</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-07-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The term "default constructed" is often used in wording that predates
+@@ -49479,12 +51444,12 @@ the introduction of the concept of value-initialization. In a few such
+ places the concept of value-initialization is more correct than the
+ current wording (for example when the type involved can be a built-in)
+ so a replacement is in order. Two of such places are already covered by
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#867">867</a>. This issue deliberately addresses the hopefully
++issue <a href="lwg-closed.html#867">867</a>. This issue deliberately addresses the hopefully
+ non-controversial changes in the attempt of being approved more quickly.
+ A few other occurrences (for example in <tt>std::tuple</tt>,
+ <tt>std::reverse_iterator</tt> and <tt>std::move_iterator</tt>) are left to separate
+-issues. For <tt>std::reverse_iterator</tt>, see also issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>. This issue is
+-related with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#724">724</a>.
++issues. For <tt>std::reverse_iterator</tt>, see also issue <a href="lwg-closed.html#408">408</a>. This issue is
++related with issue <a href="lwg-defects.html#724">724</a>.
+ </p>
+
+ <p><i>[
+@@ -49499,7 +51464,7 @@ Dennett will review the library and provide a complete list and will
+ double-check the vocabulary.
+ </p>
+ <p>
+-This issue relates to Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#886">886</a> tuple construction
++This issue relates to Issue <a href="lwg-defects.html#886">886</a> tuple construction
+ </p>
+ </blockquote>
+
+@@ -49525,7 +51490,7 @@ If wording is forthcoming, Howard will move it back to Review.
+
+ <blockquote>
+ <p>
+-Howard: Moved back to Review. Note that 20.2.1 [utility.arg.requirements]
++Howard: Moved back to Review. Note that 17.6.3.1 [utility.arg.requirements]
+ refers to a section that is not in the current working paper, but does refer to
+ a section that we expect to reappear after the de-concepts merge. This was a
+ point of confusion we did not recognize when we reviewed this issue in Frankfurt.
+@@ -49537,16 +51502,16 @@ of this nature and purposefully <em>not</em> treated:
+
+ <blockquote>
+ <p>
+-Places where changes are <u>not</u> being
++Places where changes are <span style="text-decoration:underline">not</span> being
+ proposed
+ </p>
+ <p>
+ In the following paragraphs, we are not proposing changes because
+ it's not clear whether we actually prefer value-initialization over
+-default-initialization (now partially covered by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1012">1012</a>):
++default-initialization (now partially covered by <a href="lwg-defects.html#1012">1012</a>):
+ </p>
+ <ul>
+- <li><p>20.9.9.2.1 [unique.ptr.single.ctor] para 3 e 7</p></li>
++ <li><p>20.8.1.2.1 [unique.ptr.single.ctor] para 3 e 7</p></li>
+ <li><p>24.5.1.3.1 [reverse.iter.cons] para 1</p></li>
+ <li><p>24.5.3.3.1 [move.iter.op.const] para 1</p></li>
+ </ul>
+@@ -49582,16 +51547,16 @@ of
+ <ol>
+ <li>
+ <p>
+-21.4.1 [string.require]/2:
++21.4.1 [string.require] p. 2:
+ </p>
+
+-<blockquote>
+-"[..] The <tt>Allocator</tt> object used shall be a copy of the <tt>Allocator&gt;</tt>
++<blockquote><p>
++"[..] The <tt>Allocator</tt> object used shall be a copy of the <tt>Allocator></tt>
+ object passed to the <tt>basic_string</tt> object's
+ constructor or, if the constructor does not take an <tt>Allocator</tt>
+ argument, a copy of a default-constructed
+ <tt>Allocator</tt> object."
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -49599,13 +51564,17 @@ argument, a copy of a default-constructed
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>,
+ 26.5.1.4 [rand.req.eng], Table 109, expression "<tt>T()</tt>":
+ </p>
+-<blockquote>
+-Pre-/post-condition: "Creates an engine with the same initial state as
++<blockquote><p>
++Pre-&#47;post-condition: "Creates an engine with the same initial state as
+ all other default-constructed engines of type <tt>X</tt>."
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-as well as in 26.5.5 [rand.predef]/1-9 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>), 26.5.7.1 [rand.util.seedseq]/3, 27.7.1.1.1 [istream.cons]/3, 27.7.2.2 [ostream.cons]/9 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>), 28.13 [re.grammar]/2, 30.3.1.4 [thread.thread.assign]/1 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>),
++as well as in 26.5.5 [rand.predef]/1-9 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>),
++26.5.7.1 [rand.util.seedseq]/3, 27.7.2.1.1 [istream.cons]/3,
++27.7.3.2 [ostream.cons]/9 (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>),
++28.13 [re.grammar]/2, 30.3.1.4 [thread.thread.assign]/1
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>),
+ </p>
+ <p><i>[
+ Candidates for the "the expression "default constructed" need not be
+@@ -49632,8 +51601,20 @@ this component does no longer exist.
+ <li>
+ <p>
+ I also suggest to add a short comment that all paragraphs in the
+-resolution whether they refer to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a> or to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a> numbering, because e.g. "Change 23.3.2.1 [deque.cons] para 5" is an <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a> coordinate, while "Change 23.3.2.2 [deque.capacity] para 1" is an <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a> coordinate. Even better would be to use one default document
+-for the numbering (probably <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>) and mention special cases (e.g. "Change 20.2.1 [utility.arg.requirements] para 2" as referring to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a> numbering).
++resolution whether they refer to <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf"
++>N2723</a> or to <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf"
++>N2914</a> numbering, because e.g. "Change 23.3.3.2 [deque.cons] para 5" is an <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf"
++>N2723</a> coordinate, while "Change 23.3.3.3 [deque.capacity] para 1" is an <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf"
++>N2914</a> coordinate. Even better would be to use one default document
++for the numbering (probably <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf"
++>N2914</a>) and mention special cases (e.g. "Change 17.6.3.1 [utility.arg.requirements] para 2" as referring to <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf"
++>N2723</a> numbering).
+ </p>
+ </li>
+ </ol>
+@@ -49672,18 +51653,18 @@ confusing enough without supporting further ill-defined terms.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to review in order to enable conflict resolution with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#704">704</a>.
+-</blockquote>
++<blockquote><p>
++Moved to review in order to enable conflict resolution with <a href="lwg-defects.html#704">704</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-26 Daniel harmonized the wording with the upcoming FCD.
+@@ -49696,9 +51677,9 @@ Moved to review in order to enable conflict resolution with <a href="http://www.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -49709,104 +51690,101 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.2.1 [utility.arg.requirements] para 2:
++Change 17.6.3.1 [utility.arg.requirements] para 2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 In general, a default constructor is
+ not required. Certain container class member function signatures
+-specify <del>the default constructor</del><ins>T()</ins>
+-as a default argument. T() shall be a well-defined expression (8.5)
++specify <del>the default constructor</del><ins><tt>T()</tt></ins>
++as a default argument. <tt>T()</tt> shall be a well-defined expression (8.5)
+ if one of those signatures is called using the default argument
+ (8.3.6).
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.3.2.1 [deque.cons] para 3:
++Change 23.3.3.2 [deque.cons] para 3:
+ </p>
+
+-<blockquote>
+-3 <i>Effects:</i> Constructs a deque with n
++<blockquote><p>
++3 <i>Effects:</i> Constructs a deque with <tt>n</tt>
+ <del>default constructed</del><ins>value-initialized</ins>
+ elements.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.3.2.2 [deque.capacity] para 1:
++Change 23.3.3.3 [deque.capacity] para 1:
+ </p>
+
+-<blockquote>
+-1 <i>Effects:</i> If sz &lt; size(), equivalent
+-to erase(begin() + sz, end());. If size() &lt; sz, appends sz -
+-size() <del>default
+-constructed</del><ins>value-initialized</ins>
++<blockquote><p>
++1 <i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent
++to <tt>erase(begin() + sz, end());</tt>. If <tt>size() &lt; sz</tt>,
++appends <tt>sz - size()</tt> <del>default constructed</del><ins>value-initialized</ins>
+ elements to the sequence.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.3.3.1 [forwardlist.cons] para 3:
++Change 23.3.4.2 [forwardlist.cons] para 3:
+ </p>
+
+-<blockquote>
+-3 <i>Effects:</i> Constructs a forward_list object with n <del>default
+-constructed</del><ins>value-initialized</ins>
+-elements.
+-</blockquote>
++<blockquote><p>
++3 <i>Effects:</i> Constructs a <tt>forward_list</tt> object with <tt>n</tt>
++<del>default constructed</del><ins>value-initialized</ins> elements.
++</p></blockquote>
+
+ <p>
+-Change 23.3.3.4 [forwardlist.modifiers] para 22:
++Change 23.3.4.5 [forwardlist.modifiers] para 22:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 22 <i>Effects:</i> [...] For the first signature
+ the inserted elements are <del>default
+ constructed</del><ins>value-initialized</ins>,
+-and for the second signature they are copies of c.
+-</blockquote>
++and for the second signature they are copies of <tt>c</tt>.
++</p></blockquote>
+
+ <p>
+-Change 23.3.4.1 [list.cons] para 3:
++Change 23.3.5.2 [list.cons] para 3:
+ </p>
+
+-<blockquote>
+-3 <i>Effects:</i> Constructs a list with n <del>default
++<blockquote><p>
++3 <i>Effects:</i> Constructs a <tt>list</tt> with <tt>n</tt> <del>default
+ constructed</del><ins>value-initialized</ins>
+ elements.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.3.4.2 [list.capacity] para 1:
++Change 23.3.5.3 [list.capacity] para 1:
+ </p>
+
+-<blockquote>
+-1 <i>Effects:</i> If sz &lt; size(), equivalent
+-to list&lt;T&gt;::iterator it = begin(); advance(it, sz); erase(it,
+-end());. If size() &lt; sz, appends sz - size() <del>default
+-constructed</del><ins>value-initialized</ins>
+-elements to the sequence.
+-</blockquote>
++<blockquote><p>
++1 <i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent
++to <tt>list&lt;T&gt;::iterator it = begin(); advance(it, sz); erase(it,
++end());</tt>. If <tt>size() &lt; sz</tt>, <tt>appends sz - size()</tt>
++<del>default constructed</del><ins>value-initialized</ins> elements to
++the sequence.
++</p></blockquote>
+
+ <p>
+-Change 23.4.1.1 [vector.cons] para 3:
++Change 23.3.6.2 [vector.cons] para 3:
+ </p>
+
+-<blockquote>
+-3 <i>Effects:</i> Constructs a vector with n
++<blockquote><p>
++3 <i>Effects:</i> Constructs a <tt>vector</tt> with <tt>n</tt>
+ <del>default constructed</del><ins>value-initialized</ins>
+ elements.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 23.4.1.2 [vector.capacity] para 9:
++Change 23.3.6.3 [vector.capacity] para 9:
+ </p>
+
+-<blockquote>
+-9 <i>Effects:</i> If sz &lt; size(), equivalent
+-to erase(begin() + sz, end());. If size() &lt; sz, appends sz -
+-size() <del>default
+-constructed</del><ins>value-initialized</ins>
++<blockquote><p>
++9 <i>Effects:</i> If <tt>sz &lt; size()</tt>, equivalent
++to <tt>erase(begin() + sz, end());</tt>. If <tt>size() &lt; sz</tt>, appends
++<tt>sz - size()</tt> <del>default constructed</del><ins>value-initialized</ins>
+ elements to the sequence.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -49815,17 +51793,18 @@ elements to the sequence.
+
+ <hr>
+ <h3><a name="869"></a>869. Bucket (local) iterators and iterating past end</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Sohail Somani <b>Opened:</b> 2008-07-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Sohail Somani <b>Opened:</b> 2008-07-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Is there any language in the current draft specifying the behaviour of the following snippet?
+ </p>
+
+-<blockquote><pre>unordered_set&lt;int&gt; s;
++<blockquote><pre>
++unordered_set&lt;int&gt; s;
+ unordered_set&lt;int&gt;::local_iterator it = s.end(0);
+
+ // Iterate past end - the unspecified part
+@@ -49842,19 +51821,19 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We believe that this is not a substantive change, but the proposed
+ change to the wording is clearer than what we have now.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -49866,12 +51845,12 @@ Change Table 97 "Unordered associative container requirements" in 23.2.5 [unord.
+ <blockquote>
+ <table border="1">
+ <caption>Table 97: Unordered associative container requirements</caption>
+-<tbody><tr>
+-<th>expression</th><th>return type</th><th>assertion/note pre/post-condition</th><th>complexity</th>
++<tr>
++<th>expression</th><th>return type</th><th>assertion&#47;note pre&#47;post-condition</th><th>complexity</th>
+ </tr>
+ <tr>
+ <td><tt>b.begin(n)</tt></td>
+-<td><tt>local_iterator</tt><br><tt>const_local_iterator</tt> for const <tt>b</tt>.</td>
++<td><tt>local_iterator</tt><br/><tt>const_local_iterator</tt> for const <tt>b</tt>.</td>
+ <td>Pre: n shall be in the range [0,b.bucket_count()). <del>Note: [b.begin(n), b.end(n)) is a
+ valid range containing all of the elements in the n<sup>th</sup> bucket.</del>
+ <ins><tt>b.begin(n)</tt> returns an iterator referring to the first element in the bucket.
+@@ -49880,12 +51859,12 @@ If the bucket is empty, then <tt>b.begin(n) == b.end(n)</tt>.</ins></td>
+ </tr>
+ <tr>
+ <td><tt>b.end(n)</tt></td>
+-<td><tt>local_iterator</tt><br><tt>const_local_iterator</tt> for const <tt>b</tt>.</td>
++<td><tt>local_iterator</tt><br/><tt>const_local_iterator</tt> for const <tt>b</tt>.</td>
+ <td>Pre: n shall be in the range <tt>[0, b.bucket_count())</tt>.
+ <ins><tt>b.end(n)</tt> returns an iterator which is the past-the-end value for the bucket.</ins></td>
+ <td>Constant</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -49894,35 +51873,32 @@ If the bucket is empty, then <tt>b.begin(n) == b.end(n)</tt>.</ins></td>
+
+
+ <hr>
+-<h3><a name="870"></a>870. Do unordered containers not support function pointers for predicate/hasher?</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-08-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="870"></a>870. Do unordered containers not support function pointers for predicate&#47;hasher?</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-08-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Good ol' associative containers allow both function pointers and
+-function objects as feasible
+-comparators, as described in 23.2.4 [associative.reqmts]/2:
++function objects as feasible comparators, as described in
++23.2.4 [associative.reqmts]&#47;2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Each associative container is parameterized on <tt>Key</tt> and an ordering
+-relation <tt>Compare</tt> that
+-induces a strict weak ordering (25.3) on elements of Key. [..]. The
+-object of type <tt>Compare</tt> is
+-called the comparison object of a container. This comparison object
+-may be a pointer to
++relation <tt>Compare</tt> that induces a strict weak ordering (25.3) on
++elements of Key. [..]. The object of type <tt>Compare</tt> is called the
++comparison object of a container. This comparison object may be a pointer to
+ function or an object of a type with an appropriate function call operator.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The corresponding wording for unordered containers is not so clear,
+-but I read it to disallow
+-function pointers for the hasher and I miss a clear statement for the
+-equality predicate, see
+-23.2.5 [unord.req]/3+4+5:
++but I read it to disallow function pointers for the hasher and I miss
++a clear statement for the equality predicate, see
++23.2.5 [unord.req]&#47;3+4+5:
+ </p>
+
+ <blockquote>
+@@ -49935,28 +51911,27 @@ equivalence relation on values of type <tt>Key</tt>.[..]
+ </p>
+ <p>
+ A hash function is a function object that takes a single argument of
+-type <tt>Key</tt> and returns a
+-value of type <tt>std::size_t</tt>.
++type <tt>Key</tt> and returns a value of type <tt>std::size_t</tt>.
+ </p>
+ <p>
+-Two values <tt>k1</tt> and <tt>k2</tt> of type <tt>Key</tt> are considered equal if the
+-container's equality function object
+-returns <tt>true</tt> when passed those values.[..]
++Two values <tt>k1</tt> and <tt>k2</tt> of type <tt>Key</tt> are considered
++equal if the container's equality function object returns <tt>true</tt>
++when passed those values.[..]
+ </p>
+ </blockquote>
+
+ <p>
+ and table 97 says in the column "assertion...post-condition" for the
+-expression X::hasher:
++expression <tt>X::hasher</tt>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>Hash</tt> shall be a unary function object type such that the expression
+ <tt>hf(k)</tt> has type <tt>std::size_t</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Note that 20.8 [function.objects]/1 defines as "Function objects are
++Note that 20.9 [function.objects]&#47;1 defines as "Function objects are
+ objects with an <tt>operator()</tt> defined.[..]"
+ </p>
+ <p>
+@@ -49975,15 +51950,16 @@ the following
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Ask Daniel to provide proposed wording that: makes it explicit that
+-function pointers are function objects at the beginning of 20.8 [function.objects]; fixes the "requirements" for typedefs in
+-20.8.4 [refwrap] to instead state that the function objects
++function pointers are function objects at the beginning of
++20.9 [function.objects]; fixes the "requirements" for typedefs in
++20.9.4 [refwrap] to instead state that the function objects
+ defined in that clause have these typedefs, but not that these typedefs
+ are requirements on function objects; remove the wording that explicitly
+ calls out that associative container comparators may be function
+ pointers.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-12-19 Daniel updates wording and rationale.
+@@ -50001,14 +51977,14 @@ pointers.
+
+ <p>
+ The below provided wording also affects some part of the library which is
+-involved with <em>callable types</em> (20.8.1 [func.def]/3). Reason for
++involved with <em>callable types</em> (20.9.1 [func.def]&#47;3). Reason for
+ this is that <em>callable objects</em> do have a lot in common with <em>function
+ objects</em>. A simple formula seems to be:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ callable objects = function objects + pointers to member
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The latter group is excluded from function objects because of the
+@@ -50023,15 +51999,15 @@ between the above subset of callable objects and function objects which seem to
+ be unintended: Backed by the Santa Cruz outcome function objects should include
+ both function pointers and "object[s] with an operator() defined". This clearly
+ excludes class types with a conversion function to a function pointer or all
+-similar conversion function situations described in 13.3 [over.match]/2
++similar conversion function situations described in 13.3 [over.match]&#47;2
+ b. 2. In contrast to this, the wording for callable types seems to be less
+-constrained (20.8.1 [func.def]/3):
++constrained (20.9.1 [func.def]/3):
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A callable type is a [..] class type whose objects can appear immediately to the
+ left of a function call operator.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The rationale given in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1673.html#fn2">N1673</a>
+@@ -50041,17 +52017,17 @@ functions as well. To me the current wording of callable types can be read
+ either way and I suggest to make the intention more explicit by replacing
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] class type whose objects can appear immediately to the left of a function
+ call operator
+-</blockquote>
+-
++</p></blockquote>
++<p>
+ by
+-
+-<blockquote>
++</p>
++<blockquote><p>
+ [..] class type whose objects can appear as the leftmost subexpression of a
+ function call expression 5.2.2 [expr.call].
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ and to use the same definition for the class type part of <em>function
+@@ -50062,21 +52038,22 @@ conversion function to e.g. pointer to function from being used in algorithms.
+ <p>
+ Now this last term "function objects" itself brings us to a third unsatisfactory
+ state: The term is used both for objects (e.g. "Function objects are
+-objects[..]" in 20.8 [function.objects]/1) and for types (e.g. "Each
++objects[..]" in 20.9 [function.objects]&#47;1) and for types (e.g. "Each
+ unordered associative container is parameterized [..] by a function object Hash
+-that acts as a hash function [..]" in 23.2.5 [unord.req]/3). This
++that acts as a hash function [..]" in 23.2.5 [unord.req]&#47;3). This
+ impreciseness should be fixed and I suggest to introduce the term <em>function
+ object type</em> as the counter part to <em>callable type</em>. This word seems
+ to be a quite natural choice, because the library already uses it here and there
+ (e.g. "Hash shall be a unary function object type such that the expression
+ <tt>hf(k)</tt> has type <tt>std::size_t</tt>." in Table 98, "<tt>X::hasher</tt>"
+-or "Requires: <tt>T</tt> shall be a function object type [..]" in 20.8.14.2.5 [func.wrap.func.targ]/3).
++or "Requires: <tt>T</tt> shall be a function object type [..]" in
++20.9.12.2.5 [func.wrap.func.targ]&#47;3).
+ </p>
+
+ <p>
+ Finally I would like to add that part of the issue 870 discussion related to the
+-requirements for typedefs in 20.8.4 [refwrap] during the Santa Cruz
+-meeting is now handled by the new issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1290">1290</a>.
++requirements for typedefs in 20.9.4 [refwrap] during the Santa Cruz
++meeting is now handled by the new issue <a href="lwg-defects.html#1290">1290</a>.
+ </p>
+
+ <p>
+@@ -50089,10 +52066,10 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This is fixed by
+-<a href="" ref="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2776.pdf">N2776</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2776.pdf">N2776</a>.
++</p></blockquote>
+
+ </blockquote>
+
+@@ -50104,107 +52081,111 @@ This is fixed by
+
+ <li>
+ <p>
+-Change 20.8 [function.objects]/1 as indicated:
++Change 20.9 [function.objects]&#47;1 as indicated:
+ </p>
+
+ <blockquote>
+ <p>
+ 1 <del>Function objects are objects with an <tt>operator()</tt>
+ defined.</del> <ins>An object type (3.9 [basic.types]) that can be the
+-type of the <em>postfix-expression</em> in a function call (5.2.2 [expr.call], 13.3.1.1 [over.match.call]) is called a <em>function
++type of the <em>postfix-expression</em> in a function call (5.2.2 [expr.call],
++13.3.1.1 [over.match.call]) is called a <em>function
+ object type</em><sup>*</sup>. A <em>function object</em> is an object of a
+ <em>function object type</em>.</ins> In the places where one would expect to
+-pass a pointer to a function to an algorithmic template (Clause 25 [algorithms]), the interface is specified to accept <del>an object with
++pass a pointer to a function to an algorithmic template (Clause 25 [algorithms]),
++the interface is specified to accept <del>an object with
+ an <tt>operator()</tt> defined</del><ins>a function object</ins>. This not only
+ makes algorithmic templates work with pointers to functions, but also enables
+ them to work with arbitrary function objects.
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ * Such a type is either a function pointer or a class type which often has a
+ member <tt>operator()</tt>, but in some cases it can omit that member and
+ provide a conversion to a pointer to function.
+-</ins></blockquote>
++</ins></p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.1 [func.def]/3 as indicated: <i>[The intent is to make the
++Change 20.9.1 [func.def]&#47;3 as indicated: <i>[The intent is to make the
+ commonality of callable types and function object
+ types more explicit and to get rid of wording redundancies]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 A <i>callable type</i> is <del>a pointer to function,</del> a pointer to
+ member <del>function, a pointer to member data,</del> or a <del>class type whose
+ objects can appear immediately to the left of a function call operator</del>
+-<ins><em>function object type</em> (20.8 [function.objects])</ins>.
+-</blockquote>
++<ins><em>function object type</em> (20.9 [function.objects])</ins>.
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.10 [bind]/1 as indicated:
++Change [bind]&#47;1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 The function template <tt>bind</tt> returns an object that binds a
+ <del>function</del> <ins>callable</ins> object passed as an argument to
+ additional arguments.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.10.1 [func.bind]/1 as indicated:
++Change 20.9.10 [func.bind]&#47;1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 This subclause describes a uniform mechanism for binding arguments of
+ <del>function</del> <ins>callable</ins> objects.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.14 [func.wrap]/1 as indicated:
++Change 20.9.12 [func.wrap]&#47;1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 This subclause describes a polymorphic wrapper class that encapsulates
+ arbitrary <del>function</del> <ins>callable</ins> objects.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.14.2 [func.wrap.func]/2 as indicated <i>[The reason for this
+-change is that 20.8.14.2 [func.wrap.func]/1 clearly says that all callable
++Change 20.9.12.2 [func.wrap.func]&#47;2 as indicated <i>[The reason for this
++change is that 20.9.12.2 [func.wrap.func]&#47;1 clearly says that all callable
+ types may be wrapped by <tt>std::function</tt> and current implementations
+ indeed do provide support for pointer to members as well. One further suggested
+ improvement is to set the below definition of Callable in italics]</i>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 A <del>function</del><ins>callable</ins> object <tt>f</tt> of type <tt>F</tt>
+ is <del>Callable</del> <ins><em>Callable</em></ins> for argument types
+ <del><tt>T1, T2, ..., TN</tt> in</del> <tt>ArgTypes</tt> and <del>a</del> return
+ type <tt>R</tt><del>,</del> if<del>, given lvalues <tt>t1, t2, ..., tN</tt> of
+ types <tt>T1, T2, ..., TN</tt>, respectively,</del> <ins>the expression</ins>
+ <tt><i>INVOKE</i>(f, <ins>declval&lt;ArgTypes&gt;()..., R</ins><del>t1, t2, ...,
+-tN</del>)</tt><ins>, considered as an unevaluated operand (5 [expr]),</ins> is well formed (20.7.2)<del> and, if <tt>R</tt> is not
+-<tt>void</tt>, convertible to <tt>R</tt></del>.
+-</blockquote>
++tN</del>)</tt><ins>, considered as an unevaluated operand (5 [expr]),</ins>
++is well formed (20.7.2)<del> and, if <tt>R</tt> is not <tt>void</tt>, convertible
++to <tt>R</tt></del>.
++</p></blockquote>
+ </li>
+
+
+
+ <li>
+ <p>
+-Change 20.8.14.2.1 [func.wrap.func.con]/7 as indicated:
++Change 20.9.12.2.1 [func.wrap.func.con]&#47;7 as indicated:
+ </p>
+
+-<blockquote><pre>function(const function&amp; f);
++<blockquote><pre>
++function(const function&amp; f);
+ template &lt;class A&gt; function(allocator_arg_t, const A&amp; a, const function&amp; f);
+ </pre>
+ <blockquote>
+@@ -50218,7 +52199,7 @@ exception thrown by the copy constructor of the stored <del>function</del>
+ avoid the use of dynamically allocated memory for small <del>function</del>
+ <ins>callable</ins> objects, e.g., where <tt>f</tt>'s target is an object
+ holding only a pointer or reference to an object and a member function pointer.
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -50226,10 +52207,11 @@ holding only a pointer or reference to an object and a member function pointer.
+
+ <li>
+ <p>
+-Change 20.8.14.2.1 [func.wrap.func.con]/11 as indicated:
++Change 20.9.12.2.1 [func.wrap.func.con]&#47;11 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function(F f);
++<blockquote><pre>
++template&lt;class F&gt; function(F f);
+ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
+ </pre>
+ <blockquote>
+@@ -50238,7 +52220,7 @@ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f)
+ 11 [..] [<i>Note:</i> implementations are encouraged to avoid the use of dynamically
+ allocated memory for small <del>function</del> <ins>callable</ins> objects, for
+ example, where <tt>f</tt>'s target is an object holding only a pointer or
+-reference to an object and a member function pointer. — <i>end note</i>]
++reference to an object and a member function pointer. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -50246,10 +52228,11 @@ reference to an object and a member function pointer.
+
+ <li>
+ <p>
+-Change 20.8.14.2.4 [func.wrap.func.inv]/3 as indicated:
++Change 20.9.12.2.4 [func.wrap.func.inv]&#47;3 as indicated:
+ </p>
+
+-<blockquote><pre>R operator()(ArgTypes... args) const
++<blockquote><pre>
++R operator()(ArgTypes... args) const
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -50263,17 +52246,18 @@ exception thrown by the wrapped <del>function</del> <ins>callable</ins> object.
+
+ <li>
+ <p>
+-Change 20.8.14.2.5 [func.wrap.func.targ]/3 as indicated:
++Change 20.9.12.2.5 [func.wrap.func.targ]&#47;3 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;typename T&gt; T* target();
++<blockquote><pre>
++template&lt;typename T&gt; T* target();
+ template&lt;typename T&gt; const T* target() const;
+ </pre>
+ <blockquote>
+ <p>...</p>
+ <p>
+ 3 <i>Requires:</i> <tt>T</tt> shall be a <del>function object</del> type that is
+-Callable (20.8.14.2 [func.wrap.func]) for parameter types <tt>ArgTypes</tt>
++Callable (20.9.12.2 [func.wrap.func]) for parameter types <tt>ArgTypes</tt>
+ and return type <tt>R</tt>.
+ </p>
+ </blockquote>
+@@ -50282,44 +52266,45 @@ and return type <tt>R</tt>.
+
+ <li>
+ <p>
+-Change 23.2.4 [associative.reqmts]/2 as indicated: <i>[The suggested
++Change 23.2.4 [associative.reqmts]&#47;2 as indicated: <i>[The suggested
+ removal seems harmless, because 25.4 [alg.sorting]1 already clarifies
+ that <tt>Compare</tt> is a function object type. Nevertheless it is recommended,
+ because the explicit naming of "pointer to function" is misleading]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 Each associative container is parameterized on <tt>Key</tt> and an ordering
+-relation <tt>Compare</tt> that induces a strict weak ordering (25.4 [alg.sorting]) on elements of <tt>Key</tt>. In addition, <tt>map</tt>
+-and <tt>multimap</tt> associate an arbitrary type <tt>T</tt> with the
+-<tt>Key</tt>. The object of type <tt>Compare</tt> is called the comparison
+-object of a container. <del>This comparison object may be a pointer to function
+-or an object of a type with an appropriate function call operator.</del>
+-</blockquote>
++relation <tt>Compare</tt> that induces a strict weak ordering (25.4 [alg.sorting])
++on elements of <tt>Key</tt>. In addition, <tt>map</tt> and <tt>multimap</tt>
++associate an arbitrary type <tt>T</tt> with the <tt>Key</tt>. The object of type
++<tt>Compare</tt> is called the comparison object of a container. <del>This
++comparison object may be a pointer to function or an object of a type with an
++appropriate function call operator.</del>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.2.5 [unord.req]/3 as indicated:
++Change 23.2.5 [unord.req]&#47;3 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 Each unordered associative container is parameterized by <tt>Key</tt>, by a
+ function object <ins>type</ins> <tt>Hash</tt> that acts as a hash function for
+ values of type <tt>Key</tt>, and by a binary predicate <tt>Pred</tt> that
+ induces an equivalence relation on values of type Key. [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 25.1 [algorithms.general]/7 as indicated: <i>[The intent is to
+-bring this part in sync with 20.8 [function.objects]]</i>
++Change 25.1 [algorithms.general]&#47;7 as indicated: <i>[The intent is to
++bring this part in sync with 20.9 [function.objects]]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 7 The <tt>Predicate</tt> parameter is used whenever an algorithm expects a
+-function object <ins>(20.8 [function.objects])</ins> that when applied
++function object <ins>(20.9 [function.objects])</ins> that when applied
+ to the result of dereferencing the corresponding iterator returns a value
+ testable as <tt>true</tt>. In other words, if an algorithm takes <tt>Predicate
+ pred</tt> as its argument and <tt>first</tt> as its iterator argument, it should
+@@ -50327,15 +52312,15 @@ work correctly in the construct <tt>if (pred(*first)){...}</tt>. The function
+ object <tt>pred</tt> shall not apply any nonconstant function through the
+ dereferenced iterator. <del>This function object may be a pointer to function,
+ or an object of a type with an appropriate function call operator.</del>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.2 [unique.ptr.single]/1 as indicated:
++Change 20.8.1.2 [unique.ptr.single]&#47;1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 The default type for the template parameter <tt>D</tt> is
+ <tt>default_delete</tt>. A client-supplied template argument <tt>D</tt> shall be
+ a function <del>pointer or functor</del> <ins>object type</ins> for which, given
+@@ -50343,7 +52328,7 @@ a value <tt>d</tt> of type <tt>D</tt> and a pointer <tt>ptr</tt> of type
+ <tt>T*</tt>, the expression <tt>d(ptr)</tt> is valid and has the effect of
+ deallocating the pointer as appropriate for that deleter. <tt>D</tt> may also be
+ an lvalue-reference to a deleter.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ </ol>
+@@ -50356,22 +52341,22 @@ an lvalue-reference to a deleter.
+
+
+ <hr>
+-<h3><a name="871"></a>871. Iota's requirements on T are too strong</h3>
+-<p><b>Section:</b> 26.7.5 [numeric.iota] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-08-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="871"></a>871. Iota's requirements on <tt>T</tt> are too strong</h3>
++<p><b>Section:</b> 26.7.6 [numeric.iota] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-08-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to the recent WP
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">N2691</a>,
+-26.7.5 [numeric.iota]/1, the requires clause
++26.7.6 [numeric.iota]/1, the requires clause
+ of <tt>std::iota</tt> says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>T</tt> shall meet the requirements of <tt>CopyConstructible</tt> and <tt>Assignable</tt> types, and
+ shall be convertible to <tt>ForwardIterator</tt>'s value type.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Neither <tt>CopyConstructible</tt> nor <tt>Assignable</tt> is needed, instead <tt>MoveConstructible</tt>
+@@ -50381,9 +52366,8 @@ artifact from comparing it with similar numerical algorithms like <tt>accumulate
+
+ <p>
+ Note: If this function will be conceptualized, the here proposed
+-<tt>MoveConstructible</tt>
+-requirement can be removed, because this is an implied requirement of
+-function arguments, see
++<tt>MoveConstructible</tt> requirement can be removed, because this
++is an implied requirement of function arguments, see
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2710.pdf">N2710</a>/[temp.req.impl]/3, last bullet.
+ </p>
+
+@@ -50392,42 +52376,42 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Issue pulled by author prior to review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-30 Daniel reopened:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ with the absence of concepts, this issue (closed) is valid again and I
+ suggest to reopen it.
+ I also revised by proposed resolution based on N2723 wording:
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Change 'convertible' to 'assignable', Move To Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the first sentence of 26.7.5 [numeric.iota]/1:
++Change the first sentence of 26.7.6 [numeric.iota]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <tt>T</tt> shall <del>meet the requirements of <tt>CopyConstructible</tt> and
+ <tt>Assignable</tt> types, and shall</del> be
+ assignable to <tt>ForwardIterator</tt>'s value type. [..]
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -50438,15 +52422,16 @@ assignable to <tt>ForwardIterator</tt>'s value type. [..]
+
+ <hr>
+ <h3><a name="872"></a>872. <tt>move_iterator::operator[]</tt> has wrong return type</h3>
+-<p><b>Section:</b> 24.5.3.3.12 [move.iter.op.index] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2008-08-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 24.5.3.3.12 [move.iter.op.index] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2008-08-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>move_iterator</tt>'s <tt>operator[]</tt> is declared as:
+ </p>
+
+-<blockquote><pre>reference operator[](difference_type n) const;
++<blockquote><pre>
++reference operator[](difference_type n) const;
+ </pre></blockquote>
+
+ <p>
+@@ -50454,7 +52439,7 @@ This has the same problem that <tt>reverse_iterator</tt>'s <tt>operator[]</tt> u
+ have: if the underlying iterator's <tt>operator[]</tt> returns a proxy, the
+ implicit conversion to <tt>value_type&amp;&amp;</tt> could end up referencing a temporary
+ that has already been destroyed. This is essentially the same issue that
+-we dealt with for <tt>reverse_iterator</tt> in DR <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#386">386</a>.
++we dealt with for <tt>reverse_iterator</tt> in DR <a href="lwg-defects.html#386">386</a>.
+ </p>
+
+ <p><i>[
+@@ -50467,20 +52452,20 @@ we dealt with for <tt>reverse_iterator</tt> in DR <a href="http://www.open-std.o
+ ]</i></p>
+
+
+-<blockquote>
+-I recommend closing this as a duplicate of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a> which addresses
++<blockquote><p>
++I recommend closing this as a duplicate of <a href="lwg-closed.html#1051">1051</a> which addresses
+ this issue for both <tt>move_iterator</tt> and <tt>reverse_iterator</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to Ready. Note that if <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a> is reopened, it may yield a
+-better resolution, but <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1051">1051</a> is currently marked NAD.
+-</blockquote>
++<blockquote><p>
++Move to Ready. Note that if <a href="lwg-closed.html#1051">1051</a> is reopened, it may yield a
++better resolution, but <a href="lwg-closed.html#1051">1051</a> is currently marked NAD.
++</p></blockquote>
+
+
+
+@@ -50490,7 +52475,8 @@ In 24.5.3.1 [move.iterator] and 24.5.3.3.12 [move.iter.op.index], change the dec
+ <tt>move_iterator</tt>'s <tt>operator[]</tt> to:
+ </p>
+
+-<blockquote><pre><del>reference</del> <ins><i>unspecified</i></ins> operator[](difference_type n) const;
++<blockquote><pre>
++<del>reference</del> <ins><i>unspecified</i></ins> operator[](difference_type n) const;
+ </pre></blockquote>
+
+
+@@ -50501,20 +52487,345 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ NAD Editorial, see
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2777.pdf">N2777</a>.
++</p></blockquote>
++
++
++
++
++<hr>
++<h3><a name="874"></a>874. Missing <tt>initializer_list</tt> constructor for <tt>discrete_distribution</tt></h3>
++<p><b>Section:</b> 26.5.8.6.1 [rand.dist.samp.discrete] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.discrete">issues</a> in [rand.dist.samp.discrete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++During the Sophia Antipolis meeting it was decided to separate from <a href="lwg-defects.html#793">793</a> a
++subrequest that adds initializer list support to <tt>discrete_distribution</tt>, specifically,
++the issue proposed to add a c'tor taking a <tt>initializer_list&lt;double&gt;</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++In 26.5.8.6.1 [rand.dist.samp.discrete] p. 1, class <tt>discrete_distribution</tt>,
++just <em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit discrete_distribution(const param_type&amp; parm);
++</pre></blockquote>
++
++<p>
++insert
++</p>
++
++<blockquote><pre>
++discrete_distribution(initializer_list&lt;double&gt; wl);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 of the same section insert a new
++paragraph as part of the new member description:
++</p>
++
++<blockquote><pre>
++discrete_distribution(initializer_list&lt;double&gt; wl);
++</pre>
++
++<blockquote><p>
++<i>Effects:</i> Same as <tt>discrete_distribution(wl.begin(), wl.end())</tt>.
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++<p><b>Rationale:</b></p><p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a>
++"Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
++
++
++
++
++<hr>
++<h3><a name="875"></a>875. Missing <tt>initializer_list</tt> constructor for <tt>piecewise_constant_distribution</tt></h3>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++During the Sophia Antipolis meeting it was decided to separate from
++<a href="lwg-defects.html#794">794</a> a subrequest that adds initializer list support to
++<tt>piecewise_constant_distribution</tt>, specifically, the issue proposed
++to add a c'tor taking a <tt>initializer_list&lt;double&gt;</tt> and a <tt>Callable</tt> to evaluate
++weight values. For consistency with the remainder of this class and
++the remainder of the <tt>initializer_list</tt>-aware library the author decided to
++change the list argument type to the template parameter <tt>RealType</tt>
++instead. For the reasoning to use <tt>Func</tt> instead of <tt>Func&amp;&amp;</tt> as c'tor
++function argument see issue <a href="lwg-defects.html#793">793</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p><b>Non-concept version of the proposed resolution</b></p>
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
++just <em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit piecewise_constant_distribution(const param_type&amp; parm);
++</pre></blockquote>
++
++<p>
++insert
++</p>
++
++<blockquote><pre>
++template&lt;typename Func&gt;
++piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 of the same section insert a series of
++new paragraphs nominated below as [p5_1], [p5_2], and [p5_3]
++as part of the new member description:
++</p>
++
++<blockquote><pre>
++template&lt;typename Func&gt;
++piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
++</pre>
++
++<blockquote>
++
++<p>
++[p5_1] <i>Complexity:</i> Exactly <tt>nf = max(bl.size(), 1) - 1</tt> invocations of <tt>fw</tt>.
++</p>
++
++<p>
++[p5_2] <i>Requires:</i>
++</p>
++
++<ol style="list-style-type:lower-alpha">
++<li>
++<tt>fw</tt> shall be callable with one argument of type <tt>RealType</tt>, and shall
++ return values of a type convertible to <tt>double</tt>;
++</li>
++<li>
++The relation <tt>0 &lt; S = w<sub>0</sub>+. . .+w<sub>n-1</sub></tt> shall hold.
++For all sampled values <tt><i>x<sub>k</sub></i></tt> defined below, <tt>fw(<i>x<sub>k</sub></i>)</tt> shall return a weight
++ value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
++</li>
++<li>
++If <tt>nf &gt; 0</tt> let <tt>b<sub><i>k</i></sub> = *(bl.begin() + k), k = 0, . . . , bl.size()-1</tt> and the
++following relations shall hold for <tt>k = 0, . . . , nf-1: b<sub><i>k</i></sub> &lt; b<sub><i>k+1</i></sub></tt>.
++</li>
++</ol>
++
++<p>
++[p5_3] <i>Effects:</i>
++</p>
++
++<ol style="list-style-type:lower-alpha">
++<li>
++<p>If <tt>nf == 0</tt>,</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
++ value <tt>w<sub>0</sub> = 1</tt>, and
++</li>
++<li>
++lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt>b<sub>0</sub> = 0</tt> and <tt>b<sub>1</sub> = 1</tt>.
++</li>
++</ol>
++</li>
++
++<li>
++<p>Otherwise,</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++sets <tt>n = nf</tt>, and <tt>[bl.begin(), bl.end())</tt> shall form the sequence <tt>b</tt> of
++length <tt>n+1</tt>, and
++</li>
++<li>
++<p>lets the sequences <tt>w</tt> have length <tt>n</tt> and for each <tt>k = 0, . . . ,n-1</tt>,
++ calculates:</p>
++<blockquote><p style="white-space: pre;">
++x<sub><i>k</i></sub> = 0.5*(b<sub><i>k+1</i></sub> + b<sub><i>k</i></sub>)
++w<sub><i>k</i></sub> = fw(x<sub><i>k</i></sub>)
++</p></blockquote>
++</li>
++</ol>
++</li>
++
++<li>
++<p>
++Constructs a <tt>piecewise_constant_distribution</tt> object with
++the above computed sequence <tt>b</tt> as the interval boundaries
++and with the probability densities:
++</p>
++<blockquote><p style="white-space: pre;">
++&rho;<sub><i>k</i></sub> = w<sub><i>k</i></sub>/(S * (b<sub><i>k+1</i></sub> - b<sub><i>k</i></sub>)) for k = 0, . . . , n-1.
++</p></blockquote>
++
++</li>
++</ol>
++
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++<p><b>Concept version of the proposed resolution</b></p>
++
++<ol>
++<li>
++<p>
++In 26.5.8.6.2 [rand.dist.samp.pconst]/1, class <tt>piecewise_constant_distribution</tt>,
++just <em>before</em> the member declaration
++</p>
++
++<blockquote><pre>
++explicit piecewise_constant_distribution(const param_type&amp; parm);
++</pre></blockquote>
++
++<p>
++insert
++</p>
++
++<blockquote><pre>
++template&lt;Callable&lt;auto, RealType&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Between p.4 and p.5 of the same section insert a series of
++new paragraphs nominated below as [p5_1], [p5_2], and [p5_3]
++as part of the new member description:
++</p>
++
++<blockquote><pre>
++template&lt;Callable&lt;auto, RealType&gt; Func&gt;
++ requires Convertible&lt;Func::result_type, double&gt;
++piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, Func fw);
++</pre>
++
++<blockquote>
++
++<p>
++[p5_1] <i>Complexity:</i> Exactly <tt>nf = max(bl.size(), 1) - 1</tt> invocations of <tt>fw</tt>.
++</p>
++
++<p>
++[p5_2] <i>Requires:</i>
++</p>
++
++<ol style="list-style-type:lower-alpha">
++<li>
++The relation <tt>0 &lt; S = w<sub>0</sub>+. . .+w<sub>n-1</sub></tt> shall hold.
++For all sampled values <tt><i>x<sub>k</sub></i></tt> defined below, <tt>fw(<i>x<sub>k</sub></i>)</tt> shall return a weight
++ value <tt><i>w<sub>k</sub></i></tt> that is non-negative, non-NaN, and non-infinity;
++</li>
++<li>
++If <tt>nf &gt; 0</tt> let <tt>b<sub><i>k</i></sub> = *(bl.begin() + k), k = 0, . . . , bl.size()-1</tt> and the
++following relations shall hold for <tt>k = 0, . . . , nf-1: b<sub><i>k</i></sub> &lt; b<sub><i>k+1</i></sub></tt>.
++</li>
++</ol>
++
++<p>
++[p5_3] <i>Effects:</i>
++</p>
++
++<ol style="list-style-type:lower-alpha">
++<li>
++<p>If <tt>nf == 0</tt>,</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++lets the sequence <tt>w</tt> have length <tt>n = 1</tt> and consist of the single
++ value <tt>w<sub>0</sub> = 1</tt>, and
++</li>
++<li>
++lets the sequence <tt>b</tt> have length <tt>n+1</tt> with <tt>b<sub>0</sub> = 0</tt> and <tt>b<sub>1</sub> = 1</tt>.
++</li>
++</ol>
++</li>
++
++<li>
++<p>Otherwise,</p>
++<ol style="list-style-type:lower-alpha">
++<li>
++sets <tt>n = nf</tt>, and <tt>[bl.begin(), bl.end())</tt> shall form the sequence <tt>b</tt> of
++length <tt>n+1</tt>, and
++</li>
++<li>
++<p>lets the sequences <tt>w</tt> have length <tt>n</tt> and for each <tt>k = 0, . . . ,n-1</tt>,
++ calculates:</p>
++<blockquote><p style="white-space: pre;">
++x<sub><i>k</i></sub> = 0.5*(b<sub><i>k+1</i></sub> + b<sub><i>k</i></sub>)
++w<sub><i>k</i></sub> = fw(x<sub><i>k</i></sub>)
++</p></blockquote>
++</li>
++</ol>
++</li>
++
++<li>
++<p>
++Constructs a <tt>piecewise_constant_distribution</tt> object with
++the above computed sequence <tt>b</tt> as the interval boundaries
++and with the probability densities:
++</p>
++<blockquote><p style="white-space: pre;">
++&rho;<sub><i>k</i></sub> = w<sub><i>k</i></sub>/(S * (b<sub><i>k+1</i></sub> - b<sub><i>k</i></sub>)) for k = 0, . . . , n-1.
++</p></blockquote>
++
++</li>
++</ol>
++
++</blockquote>
+ </blockquote>
++</li>
++</ol>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">N2836</a> "Wording Tweaks for Concept-enabled Random Number Generation in C++0X".
++</p>
++
+
+
+
+
+ <hr>
+ <h3><a name="876"></a>876. <tt>basic_string</tt> access operations should give stronger guarantees</h3>
+-<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.string">issues</a> in [basic.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-08-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ During the Sophia Antipolis meeting it was decided to split-off some
+@@ -50584,7 +52895,7 @@ San Francisco:
+ <blockquote>
+ <p>
+ We oppose part 1 of the issue but hope to address <tt>size()</tt> in
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#877">877</a>.
++issue <a href="lwg-active.html#877">877</a>.
+ </p>
+ <p>
+ We do not support part B. 4 of the issue because of the breaking API change.
+@@ -50595,12 +52906,12 @@ We support part A. 2 of the issue.
+ <p>
+ On support part A. 3 of the issue:
+ </p>
+-<blockquote>
+-Pete's broader comment: now that we know that basic_string will be a
++<blockquote><p>
++Pete's broader comment: now that we know that <tt>basic_string</tt> will be a
+ block of contiguous memory, we should just rewrite its specification
+ with that in mind. The expression of the specification will be simpler
+ and probably more correct as a result.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -50621,15 +52932,15 @@ Howard: Commented out part B.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <ol>
+ <li>
+ <p>In 21.4.4 [string.capacity], just after p. 1 add a new paragraph:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> Nothing.
+-</blockquote>
++</p></blockquote>
+
+ </li>
+ <li>
+@@ -50639,7 +52950,7 @@ In 21.4.5 [string.access] <em>replace</em> p. 1 by the following <em>4</em> para
+
+ <blockquote>
+ <p>
+-<i>Requires:</i> <tt>pos &#8804; size()</tt>.
++<i>Requires:</i> <tt>pos &le; size()</tt>.
+ </p>
+ <p>
+ <i>Returns:</i> If <tt>pos &lt; size()</tt>, returns <tt>*(begin() + pos)</tt>. Otherwise, returns
+@@ -50684,10 +52995,10 @@ in <tt>[0, size()]</tt>.
+
+ <hr>
+ <h3><a name="878"></a>878. <tt>forward_list</tt> preconditions</h3>
+-<p><b>Section:</b> 23.3.3 [forwardlist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-08-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.4 [forwardlist] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2008-08-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+
+@@ -50696,23 +53007,23 @@ a <tt>forward_list::iterator</tt> (denoted <tt>position</tt> in the
+ function signatures) argument have the following precondition:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ <i>Requires:</i> <tt>position</tt> is dereferenceable or equal
+ to <tt>before_begin()</tt>.
+
+- </blockquote>
++ </p></blockquote>
+ <p>
+
+ I believe what's actually intended is this:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ <i>Requires:</i> <tt>position</tt> is in the range
+ [<tt>before_begin()</tt>, <tt>end()</tt>).
+
+- </blockquote>
++ </p></blockquote>
+ <p>
+
+ That is, when it's dereferenceable, <tt>position</tt> must point
+@@ -50725,9 +53036,9 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Robert suggested alternate proposed wording which had large support.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+@@ -50750,32 +53061,111 @@ With that minor update, Recommend Tentatively Ready.
+
+ Change the <i>Requires</i> clauses
+ [forwardlist] , p21, p24, p26, p29, and,
+-23.3.3.5 [forwardlist.ops], p39, p43, p47
++23.3.4.6 [forwardlist.ops], p39, p43, p47
+ as follows:
+
+ </p>
+- <blockquote>
++ <blockquote><p>
+
+ <i>Requires:</i> <tt>position</tt> is <ins><tt>before_begin()</tt> or is a</ins>
+ dereferenceable
+ <ins>iterator in the range <tt>[begin(), end())</tt></ins>
+ <del>or equal to <tt>before_begin()</tt></del>. ...
+
+- </blockquote>
++ </p></blockquote>
+
+
+
+
+ <hr>
+-<h3><a name="881"></a>881. shared_ptr conversion issue</h3>
+-<p><b>Section:</b> 20.9.10.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-08-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="880"></a>880. Missing atomic exchange parameter</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#942">942</a></p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>atomic_exchange</tt> and <tt>atomic_exchange_explicit</tt> functions seem to
++be inconsistently missing parameters.
++</p>
++
++<p><i>[
++Post Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Lawrence: Need to write up a list for Pete with details.
++</p>
++<p>
++Detlef: Should not be New, we already talked about in Concurrency group.
++</p>
++<p>
++Recommend Open.
++</p>
++</blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote>
++<p>
++Lawrence will handle all issues relating to atomics in a single paper.
++</p>
++<p>
++LWG will defer discussion on atomics until that paper appears.
++</p>
++<p>
++Move to Open.
++</p>
++</blockquote>
++
++<p><i>[
++2009-08-17 Handled by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add the appropriate parameters. For example,
++</p>
++
++<blockquote><pre>
++bool atomic_exchange(volatile atomic_bool*<ins>, bool</ins>);
++bool atomic_exchange_explicit(volatile atomic_bool*, bool<ins>, memory_order</ins>);
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="881"></a>881. <tt>shared_ptr</tt> conversion issue</h3>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ We've changed <tt>shared_ptr&lt;Y&gt;</tt> to not convert to <tt>shared_ptr&lt;T&gt;</tt> when <tt>Y*</tt>
+-doesn't convert to <tt>T*</tt> by resolving issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a>. This only fixed the
++doesn't convert to <tt>T*</tt> by resolving issue <a href="lwg-defects.html#687">687</a>. This only fixed the
+ converting copy constructor though.
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2351.htm">N2351</a>
+ later added move support, and
+@@ -50787,10 +53177,10 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We might be able to move this to NAD, Editorial once shared_ptr is
+ conceptualized, but we want to revisit this issue to make sure.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+@@ -50813,21 +53203,22 @@ This issue now represents the favored format for specifying constrained template
+ We need to change the Requires clause of the move constructor:
+ </p>
+
+-<blockquote><pre>shared_ptr(shared_ptr&amp;&amp; r);
++<blockquote><pre>
++shared_ptr(shared_ptr&amp;&amp; r);
+ template&lt;class Y&gt; shared_ptr(shared_ptr&lt;Y&gt;&amp;&amp; r);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <del>For the second constructor <tt>Y*</tt> shall be
+ convertible to <tt>T*</tt>.</del>
+ <ins>
+ The second constructor shall not participate in overload resolution
+ unless <tt>Y*</tt> is convertible to <tt>T*</tt>.
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-in order to actually make the example in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#687">687</a> compile
++in order to actually make the example in <a href="lwg-defects.html#687">687</a> compile
+ (it now resolves to the move constructor).
+ </p>
+
+@@ -50838,10 +53229,10 @@ in order to actually make the example in <a href="http://www.open-std.org/jtc1/s
+
+ <hr>
+ <h3><a name="882"></a>882. <tt>duration</tt> non-member arithmetic requirements</h3>
+-<p><b>Section:</b> 20.11.3.5 [time.duration.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#CD1">CD1</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-09-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#CD1">CD1</a> status.</p>
++<p><b>Section:</b> 20.12.5.5 [time.duration.nonmember] <b>Status:</b> <a href="lwg-active.html#CD1">CD1</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-09-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#CD1">CD1</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm">N2661</a>
+@@ -50851,38 +53242,41 @@ arithmetic:
+
+ <blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> Let <tt>CR</tt> represent the <tt>common_type</tt> of <tt>Rep1</tt> and
+ <tt>Rep2</tt>. Both <tt>Rep1</tt> and <tt>Rep2</tt> shall be implicitly convertible
+ to CR, diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> Let <tt>CR</tt> represent the <tt>common_type</tt> of
+ <tt>Rep1</tt> and <tt>Rep2</tt>. Both <tt>Rep1</tt> and <tt>Rep2</tt>
+ shall be implicitly convertible to <tt>CR</tt>, diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> Let <tt>CR</tt> represent the <tt>common_type</tt> of
+ <tt>Rep1</tt> and <tt>Rep2</tt>. Both <tt>Rep1</tt> and <tt>Rep2</tt> shall be
+ implicitly convertible to <tt>CR</tt>, and <tt>Rep2</tt> shall not be an
+ instantiation of <tt>duration</tt>, diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -50891,9 +53285,9 @@ During transcription into the working paper, the requirements clauses on these
+ three functions was changed to:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <tt>CR(Rep1, Rep2)</tt> shall exist. Diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This is a non editorial change with respect to
+@@ -50905,7 +53299,8 @@ fine for most expressions as long as there exists a <tt>common_type</tt> special
+ relating the user written representation and the arithmetic type. For example:
+ </p>
+
+-<blockquote><pre>class saturate
++<blockquote><pre>
++class saturate
+ {
+ public:
+ explicit saturate(long long i);
+@@ -50939,7 +53334,8 @@ implicit convertibility is required between the rhs and the lhs's representation
+ for the member <tt>*=</tt> operator:
+ </p>
+
+-<blockquote><pre>template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
++<blockquote><pre>
++template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
+ class duration {
+ public:
+ ...
+@@ -50957,7 +53353,8 @@ The last line does not (and should not) compile. And we want non-member multipl
+ to have the same behavior as member arithmetic:
+ </p>
+
+-<blockquote><pre>my_ms = my_ms * saturate(2); // ok, rhs is lhs's representation
++<blockquote><pre>
++my_ms = my_ms * saturate(2); // ok, rhs is lhs's representation
+ my_ms = my_ms * 2; // <em>should be</em> error, 2 is not implicitly convertible to saturate
+ </pre></blockquote>
+
+@@ -50976,61 +53373,64 @@ as specified by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm">N2661</a>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> ... <em>Both</em> <tt>Rep1</tt> and <tt>Rep2</tt> shall be implicitly convertible
+ to CR, diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ It is not necessary for both <tt>Rep</tt>s to be <i>implicitly</i> convertible to
+ the <tt>CR</tt>. It is only necessary for the rhs <tt>Rep</tt> to be implicitly
+ convertible to the <tt>CR</tt>. The <tt>Rep</tt> within the <tt>duration</tt>
+ should be allowed to only be explicitly convertible to the <tt>CR</tt>. The
+-explicit-conversion-requirement is covered under 20.11.3.7 [time.duration.cast].
++explicit-conversion-requirement is covered under 20.12.5.7 [time.duration.cast].
+ </p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the requirements clauses under 20.11.3.5 [time.duration.nonmember]:
++Change the requirements clauses under 20.12.5.5 [time.duration.nonmember]:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <del><tt>CR(Rep1, Rep2)</tt> shall exist.</del>
+ <ins><tt>Rep2</tt> shall be implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.</ins>
+ Diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Require<ins>s</ins><del>d behavior</del>:</i> <del><tt>CR(Rep1, Rep2)</tt> shall exist.</del>
+ <ins><tt>Rep1</tt> shall be implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.</ins>
+ Diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <del><tt>CR(Rep1, Rep2)</tt> shall exist</del>
+ <ins><tt>Rep2</tt> shall be implicitly convertible to <tt>CR(Rep1, Rep2)</tt></ins>
+ and <tt>Rep2</tt> shall not
+ be an instantiation of <tt>duration</tt>. Diagnostic required.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -51040,10 +53440,11 @@ be an instantiation of <tt>duration</tt>. Diagnostic required.
+
+ <hr>
+ <h3><a name="883"></a>883. swap circular definition</h3>
+-<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#containers">issues</a> in [containers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -51058,11 +53459,11 @@ San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
+-Robert to propose a resolution along the lines of "Postcondition: "a =
+-b, b = a" This will be a little tricky for the hash containers, since
+-they don't have <tt>operator==</tt>.
+-</blockquote>
++<blockquote><p>
++Robert to propose a resolution along the lines of "Postcondition: "a = b, b = a"
++This will be a little tricky for the hash containers, since they don't have
++<tt>operator==</tt>.
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Anthony Williams provided proposed wording.
+@@ -51074,9 +53475,9 @@ Post Summit Anthony Williams provided proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready with minor edits (which have been made).
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -51089,7 +53490,7 @@ replace the postcondition of <tt>a.swap(b)</tt> with the following:
+ <blockquote>
+ <table border="1">
+ <caption>Table 80 -- Container requirements</caption>
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+@@ -51111,29 +53512,30 @@ replace the postcondition of <tt>a.swap(b)</tt> with the following:
+ <ins>Exchange the contents of <tt>a</tt> and <tt>b</tt>.</ins></td>
+ <td>(Note A)</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+ Remove the reference to swap from the paragraph following the table.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Notes: the algorithms <del><tt>swap()</tt>, </del><tt>equal()</tt> and
+ <tt>lexicographical_compare()</tt> are defined in Clause 25. ...
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="884"></a>884. shared_ptr swap</h3>
+-<p><b>Section:</b> 20.9.10.2.4 [util.smartptr.shared.mod] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="884"></a>884. <tt>shared_ptr</tt> swap</h3>
++<p><b>Section:</b> 20.8.2.2.4 [util.smartptr.shared.mod] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<blockquote><pre>#include &lt;memory&gt;
++<blockquote><pre>
++#include &lt;memory&gt;
+ #include &lt;cassert&gt;
+
+ struct A { };
+@@ -51158,7 +53560,8 @@ unavoidable, or not worth worrying about?
+ This calls the lvalue/rvalue swap overload for <tt>shared_ptr</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt; void swap( shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp;&amp; b );
++<blockquote><pre>
++template&lt;class T&gt; void swap( shared_ptr&lt;T&gt; &amp; a, shared_ptr&lt;T&gt; &amp;&amp; b );
+ </pre></blockquote>
+
+ <p>
+@@ -51179,21 +53582,22 @@ eliminate the rvalue swap overloads altogether. The original motivation
+ was:
+ </p>
+
+-<blockquote><pre>vector&lt;A&gt; v = ...;
++<blockquote><pre>
++vector&lt;A&gt; v = ...;
+ ...
+ swap(v, vector&lt;A&gt;(v));
+ </pre></blockquote>
+-
++<p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1690.html#Improved%20swap%20Interface">N1690</a>.
+-
++</p>
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to <del>NAD Editorial</del><ins>Resolved</ins>.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -51207,13 +53611,14 @@ Recommend <del>NAD Editorial</del><ins>Resolved</ins>, fixed by
+
+
+ <hr>
+-<h3><a name="885"></a>885. pair assignment</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="885"></a>885. <tt>pair</tt> assignment</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<blockquote><pre>20.2.3 pairs
++<blockquote><pre>
++20.2.3 pairs
+ Missing assignemnt operator:
+ template&lt;class U , class V&gt;
+ requires CopyAssignable&lt;T1, U&gt; &amp;&amp; CopyAssignable&lt;T2, V&gt;
+@@ -51241,7 +53646,7 @@ San Francisco:
+ Would be NAD if better ctors fixed it.
+ </p>
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>.
++Related to <a href="lwg-defects.html#811">811</a>.
+ </p>
+ </blockquote>
+
+@@ -51250,33 +53655,33 @@ post San Francisco:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Possibly NAD Editorial, solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2770.pdf">N2770</a>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-25 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#885">885</a> was something I reported while reviewing the library concepts
++<blockquote><p>
++Issue <a href="lwg-defects.html#885">885</a> was something I reported while reviewing the library concepts
+ documents ahead of San Francisco. The missing operator was added as part of
+ the paper adopted at that meeting
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2770.pdf">N2770</a>)
+ and I can confirm this operator is
+ present in the current working paper. I recommend NAD.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We agree with the intent, but we need to wait for the dust to settle on concepts.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-11 Stefanus provided wording.
+@@ -51292,19 +53697,21 @@ We agree with the intent, but we need to wait for the dust to settle on concepts
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add the following declaration 20.3.5.2 [pairs.pair], before the
++Add the following declaration 20.3.2 [pairs.pair], before the
+ declaration of <tt>pair&amp; operator=(pair&amp;&amp; p);</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p);
+ </pre></blockquote>
+
+ <p>
+-Add the following description to 20.3.5.2 [pairs.pair] after paragraph 11 (before
++Add the following description to 20.3.2 [pairs.pair] after paragraph 11 (before
+ the description of <tt>pair&amp; operator=(pair&amp;&amp; p);)</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair&amp; operator=(const pair&lt;U, V&gt;&amp; p);
+ </pre>
+ <blockquote>
+ <p>
+@@ -51328,18 +53735,19 @@ satisfy the requirements of <tt>CopyAssignable</tt> from <tt>V</tt>.
+
+
+ <hr>
+-<h3><a name="886"></a>886. tuple construction</h3>
+-<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="886"></a>886. <tt>tuple</tt> construction</h3>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 20.4.2.1 [tuple.cnstr]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Default initializes each element.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Could be clarified to state each "non-trivial" element. Otherwise
+@@ -51374,7 +53782,7 @@ Request resolution text from Alisdair.
+ </p>
+
+ <p>
+-This issue relates to Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#868">868</a> default construction and value-initialization.
++This issue relates to Issue <a href="lwg-defects.html#868">868</a> default construction and value-initialization.
+ </p>
+ </blockquote>
+
+@@ -51389,11 +53797,12 @@ Note: This <em>IS</em> a change of semantic from TR1, although one the room agre
+ with during the discussion. To preserve TR1 semantics, this would have been
+ worded:
+ </p>
+-<blockquote><pre>requires DefaultConstructible&lt;Types&gt;... tuple();
++<blockquote><pre>
++requires DefaultConstructible&lt;Types&gt;... tuple();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -2- <i>Effects:</i> Default-initializes each non-trivial element.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -51404,9 +53813,9 @@ worded:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -51415,7 +53824,8 @@ Move to Ready.
+ Change p2 in Construction 20.4.2.1 [tuple.cnstr]:
+ </p>
+
+-<blockquote><pre>requires DefaultConstructible&lt;Types&gt;... tuple();
++<blockquote><pre>
++requires DefaultConstructible&lt;Types&gt;... tuple();
+ </pre>
+ <blockquote>
+ <p>
+@@ -51430,12 +53840,11 @@ Change p2 in Construction 20.4.2.1 [tuple.cnstr]:
+
+
+ <hr>
+-<h3><a name="888"></a>888. this_thread::yield too strong</h3>
+-<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#thread.thread.this">active issues</a> in [thread.thread.this].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="888"></a>888. <tt>this_thread::yield</tt> too strong</h3>
++<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I never thought I'd say this, but <tt>this_thread::yield</tt> seems to be too
+@@ -51454,9 +53863,9 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -51466,13 +53875,266 @@ Change 30.3.2 [thread.thread.this]/3:
+ </p>
+
+ <blockquote>
+-<pre>void this_thread::yield();
++<pre>
++void this_thread::yield();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Offers the <del>operating system</del> <ins>implementation</ins>
+ the opportunity to <ins>re</ins>schedule.
+ <del>another thread.</del>
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="889"></a>889. <tt>thread::id</tt> comparisons</h3>
++<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Lawrence Crowl <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 324</b></p>
++
++<p>
++The <tt>thread::id</tt> type supports the full set of comparison operators. This
++is substantially more than is required for the associative containers that
++justified them. Please place an issue against the threads library.
++</p>
++
++<p><i>[
++San Francisco:
++]</i></p>
++
++
++<blockquote>
++<p>
++Would depend on proposed extension to POSIX, or non-standard extension.
++What about hash? POSIX discussing op. POSIX not known to be considering
++support needed for hash, op.
++</p>
++<p>
++Group expresses support for putting ids in both unordered and ordered containers.
++</p>
++</blockquote>
++
++<p><i>[
++post San Francisco:
++]</i></p>
++
++
++<blockquote>
++<p>
++Howard: It turns out the current working paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
++<i>already has</i> <tt>hash&lt;thread::id&gt;</tt>
++(20.9 [function.objects], 20.9.13 [unord.hash]). We simply
++overlooked it in the meeting. It is a good thing we voted in favor of it
++(again). :-)
++</p>
++<p>
++Recommend NAD.
++</p>
++
++</blockquote>
++
++<p><i>[
++Post Summit:
++]</i></p>
++
++
++<blockquote><p>
++Recommend to close as NAD. For POSIX, see if we need to add a function to
++convert <tt>pthread_t</tt> to integer.
++</p></blockquote>
++
++<p><i>[
++Post Summit, Alisdair adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++The recommendation for LWG-889/UK-324 is NAD, already specified.
++</p>
++<p>
++It is not clear to me that the specification is complete.
++</p>
++<p>
++In particular, the synopsis of <tt>&lt;functional&gt;</tt> in
++20.9 [function.objects] does not mention <tt>hash&lt; thread::id&gt;</tt>
++nor <tt>hash&lt; error_code &gt;</tt>, although their existence is
++implied by 20.9.13 [unord.hash], p1.
++</p>
++<p>
++I am fairly uncomfortable putting the declaration for the
++<tt>thread_id</tt> specialization into <tt>&lt;functional&gt;</tt> as
++<tt>id</tt> is a nested class inside <tt>std::thread</tt>, so it implies
++that <tt>&lt;functional&gt;</tt> would require the definition of the
++<tt>thread</tt> class template in order to forward declared
++<tt>thread::id</tt> and form this specialization.
++</p>
++<p>
++It seems better to me that the dependency goes the other way around
++(<tt>&lt;thread&gt;</tt> will more typically make use of
++<tt>&lt;functional&gt;</tt> than vice-versa) and the
++<tt>hash&lt;thread::id&gt;</tt> specialization be declared in the
++<tt>&lt;thread&gt;</tt> header.
++</p>
++<p>
++I think <tt>hash&lt;error_code&gt;</tt> could go into either
++<tt>&lt;system_error&gt;</tt> or <tt>&lt;functional&gt;</tt> and have no
++immediate preference either way. However, it should clearly appear in
++the synopsis of one of these two.
++</p>
++<p>
++Recommend moving 889 back to open, and tying in a reference to UK-324.
++</p>
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++Howard observes that <tt>thread::id</tt> need not be a nested class;
++it could be a <tt>typedef</tt> for a more visible type.
++</p></blockquote>
++
++<p><i>[
++2009-05-24 Alisdair adds:
++]</i></p>
++
++<blockquote><p>
++I do not believe this is correct. <tt>thread::id</tt> is explicitly documents as a
++nested class, rather than as an unspecified typedef analogous to an
++iterator. If the intent is that this is not implemented as a nested class
++(under the as-if freedoms) then this is a novel form of standardese.
++</p></blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Decided we want to move hash specialization for thread_id to the thread
++header. Alisdair to provide wording.
++</p></blockquote>
++
++<p><i>[
++2009-07-28 Alisdair provided wording, moved to Review.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Add a strike for <tt>hash&lt;thread::id&gt;</tt>. Move to Ready
++</p></blockquote>
++
++<p><i>[
++2009-11-13 The proposed wording of <a href="lwg-defects.html#1182">1182</a> is a superset of the
++wording in this issue.
++]</i></p>
++
++
++<p><i>[
++2010-02-09 Moved from Ready to Open:
++]</i></p>
++
++
++<blockquote>
++<p>
++Issue <a href="lwg-defects.html#1182">1182</a> is not quite a superset of this issue and it is controversial
++whether or not the note:
++</p>
++
++<blockquote><p>
++hash template specialization allows <tt>thread::id</tt> objects to be used as keys in
++unordered containers.
++</p></blockquote>
++
++<p>
++should be added to the WP.
++</p>
++
++
+ </blockquote>
++
++<p><i>[
++2010-02-09 Objections to moving this to <del>NAD Editorial</del><ins>Resolved</ins>, addressed by <a href="lwg-defects.html#1182">1182</a> have been removed. Set to Tentatively <del>NAD Editorial</del><ins>Resolved</ins>.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="lwg-defects.html#1182">1182</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Remove the following prototype from the synopsis in
++20.9 [function.objects]:
++</p>
++
++<blockquote><pre><del>
++template &lt;&gt; struct hash&lt;std::thread::id&gt;;
++</del></pre></blockquote>
++
++<p>
++Add to 30.3 [thread.threads], p1 Header <tt>&lt;thread&gt;</tt> synopsis:
++</p>
++
++<blockquote><pre>
++<ins>template &lt;class T&gt; struct hash;
++template &lt;&gt; struct hash&lt;thread::id&gt;;</ins>
++</pre></blockquote>
++
++<p>
++Add template specialization below class definition in 30.3.1.1 [thread.thread.id]
++</p>
++
++<blockquote><pre>
++<ins>template &lt;&gt;
++struct hash&lt;thread::id&gt; : public unary_function&lt;thread::id, size_t&gt; {
++ size_t operator()(thread::id val) const;
++};</ins>
++</pre></blockquote>
++
++<p>
++Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence:
++</p>
++
++<blockquote><p>
++[<i>Note:</i> Relational operators allow <tt>thread::id</tt> objects to be used
++as keys in associative containers.
++<ins><tt>hash</tt> template specialization allows <tt>thread::id</tt> objects to be used as keys
++in unordered containers.</ins>
++&mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>
++Add new paragraph to end of 30.3.1.1 [thread.thread.id]
++</p>
++
++<blockquote><pre>
++<ins>template &lt;&gt; struct hash&lt;thread::id&gt;;</ins>
++</pre>
++<blockquote><p><ins>
++An explicit specialization of the class template hash (20.9.13 [unord.hash])
++shall be provided for the type <tt>thread::id</tt>.
++</ins></p></blockquote>
+ </blockquote>
+
+
+@@ -51481,16 +54143,18 @@ the opportunity to <ins>re</ins>schedule.
+
+ <hr>
+ <h3><a name="890"></a>890. Improving <tt>&lt;system_error&gt;</tt> initialization</h3>
+-<p><b>Section:</b> 19.5.1 [syserr.errcat] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-09-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 19.5.1 [syserr.errcat] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2008-09-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr.errcat">issues</a> in [syserr.errcat].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>static const error_category</tt> objects <tt>generic_category</tt> and
+ <tt>system_category</tt> in header <tt>&lt;system_error&gt;</tt> are currently declared:
+ </p>
+
+-<blockquote><pre>const error_category&amp; get_generic_category();
++<blockquote><pre>
++const error_category&amp; get_generic_category();
+ const error_category&amp; get_system_category();
+
+ static const error_category&amp; generic_category = get_generic_category();
+@@ -51528,7 +54192,7 @@ still suffer much the same problems.
+
+ <p>
+ The original plan was to eliminate these problems by applying the C++0x
+-<tt>constexpr</tt> feature. See LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#832">832</a>. However, that approach turned out
++<tt>constexpr</tt> feature. See LWG issue <a href="lwg-closed.html#832">832</a>. However, that approach turned out
+ to be unimplementable, since it would require a <tt>constexpr</tt> object of a
+ class with virtual functions, and that is not allowed by the core
+ language.
+@@ -51583,7 +54247,7 @@ like to see <tt>get_*</tt> functions instead.
+
+ <p>
+ Beman: The proposed resolution has been reworked to remove the file-scope
+-static objects, per Martin's suggestions. The <tt>get_</tt> prefix has been
++static objects, per Martin&#39;s suggestions. The <tt>get_</tt> prefix has been
+ eliminated from the function names as no longer necessary and to conform with
+ standard library naming practice.
+ </p>
+@@ -51595,16 +54259,16 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agreement that this is wise and essential, text provided works and has
+ been implemented. Seems to be widespread consensus. Move to Tentative Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<p>Change 17.6.4.14 [value.error.codes] Value of error codes as indicated:</p>
++<p>Change 17.6.5.14 [value.error.codes] Value of error codes as indicated:</p>
+ <blockquote>
+ <p>Certain functions in the C++ standard library report errors via a
+ <tt>std::error_code</tt> (19.4.2.2) object. That object's <tt>category()</tt> member shall
+@@ -51627,7 +54291,8 @@ Change 19.5.1.1 [syserr.errcat.overview] Class <tt>error_category</tt> overview
+ </p>
+
+ <blockquote>
+-<pre>const error_category&amp; <del>get_</del>generic_category();
++<pre>
++const error_category&amp; <del>get_</del>generic_category();
+ const error_category&amp; <del>get_</del>system_category();
+
+ <del>static storage-class-specifier const error_category&amp; generic_category = get_generic_category();
+@@ -51657,7 +54322,8 @@ object's <tt>name</tt> virtual function shall return a pointer to the string
+ </p>
+ </blockquote>
+
+-<pre>const error_category&amp; <del>get_</del>system_category();
++<pre>
++const error_category&amp; <del>get_</del>system_category();
+ </pre>
+
+ <blockquote>
+@@ -51671,7 +54337,7 @@ specified for class <tt>error_category</tt>. The object's <tt>name</tt> virtual
+ shall return a pointer to the string <tt>"system"</tt>. The object's
+ <tt>default_error_condition</tt> virtual function shall behave as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ If the argument <tt>ev</tt> corresponds to a POSIX <tt>errno</tt> value <tt>posv</tt>, the function
+ shall return <tt>error_condition(posv, generic_category<ins>()</ins>)</tt>. Otherwise, the
+ function shall return <tt>error_condition(ev, system_category<ins>()</ins>)</tt>. What
+@@ -51679,13 +54345,13 @@ constitutes correspondence for any given operating system is
+ unspecified. [<i>Note:</i> The number of potential system error codes is large
+ and unbounded, and some may not correspond to any POSIX <tt>errno</tt> value.
+ Thus implementations are given latitude in determining correspondence.
+-<i>-- end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+ </blockquote>
+
+-<p>Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors
++<p>Change 19.5.2.2 [syserr.errcode.constructors] Class <tt>error_code</tt> constructors
+ as indicated:</p>
+ <blockquote>
+ <pre>error_code();</pre>
+@@ -51694,7 +54360,7 @@ as indicated:</p>
+ <p><i>Postconditions:</i> <code>val_ == 0 </code>and <code>cat_ == &amp;system_category</code><tt><ins>()</ins></tt>.</p>
+ </blockquote>
+ </blockquote>
+-<p>Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as
++<p>Change 19.5.2.3 [syserr.errcode.modifiers] Class <tt>error_code</tt> modifiers as
+ indicated:</p>
+ <blockquote>
+ <pre>void clear();</pre>
+@@ -51703,7 +54369,7 @@ indicated:</p>
+ system_category</code><tt><ins>()</ins></tt>.</p>
+ </blockquote>
+ </blockquote>
+-<p>Change 19.5.2.5 [syserr.errcode.nonmembers] Class error_code non-member
++<p>Change 19.5.2.5 [syserr.errcode.nonmembers] Class <tt>error_code</tt> non-member
+ functions as indicated:</p>
+ <blockquote>
+ <pre>error_code make_error_code(errc e);</pre>
+@@ -51711,7 +54377,7 @@ functions as indicated:</p>
+ <p><i>Returns:</i> <code>error_code(static_cast&lt;int&gt;(e), generic_category</code><tt><ins>()</ins></tt><code>)</code>.</p>
+ </blockquote>
+ </blockquote>
+-<p>Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition
++<p>Change 19.5.3.2 [syserr.errcondition.constructors] Class <tt>error_condition</tt>
+ constructors as indicated:</p>
+ <blockquote>
+ <pre>error_condition();</pre>
+@@ -51720,7 +54386,7 @@ constructors as indicated:</p>
+ <p><i>Postconditions:</i> <code>val_ == 0</code> and <code>cat_ == &amp;generic_category</code><tt><ins>()</ins></tt>.</p>
+ </blockquote>
+ </blockquote>
+-<p>Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition
++<p>Change 19.5.3.3 [syserr.errcondition.modifiers] Class <tt>error_condition</tt>
+ modifiers as indicated:</p>
+ <blockquote>
+ <pre>void clear();</pre>
+@@ -51729,7 +54395,7 @@ modifiers as indicated:</p>
+ generic_category</code><tt><ins>()</ins></tt>.</p>
+ </blockquote>
+ </blockquote>
+-<p>Change 19.5.3.5 [syserr.errcondition.nonmembers] Class error_condition
++<p>Change 19.5.3.5 [syserr.errcondition.nonmembers] Class <tt>error_condition</tt>
+ non-member functions as indicated:</p>
+ <blockquote>
+ <pre>error_condition make_error_condition(errc e);</pre>
+@@ -51737,7 +54403,7 @@ non-member functions as indicated:</p>
+ <p><i>Returns:</i> <tt>error_condition(static_cast&lt;int&gt;(e), generic_category<ins>()</ins>)</tt>.</p>
+ </blockquote>
+ </blockquote>
+- <p>Change 27.5 [iostreams.base] Iostreams base classes, Header &lt;ios&gt;
++ <p>Change 27.5 [iostreams.base] Iostreams base classes, Header <tt>&lt;ios&gt;</tt>
+ synopsis as indicated:</p>
+ <blockquote>
+ <pre>concept_map ErrorCodeEnum&lt;io_errc&gt; { };
+@@ -51745,18 +54411,18 @@ error_code make_error_code(io_errc e);
+ error_condition make_error_condition(io_errc e);
+ <del>storage-class-specifier</del> const error_category&amp; iostream_category<ins>()</ins>;</pre>
+ </blockquote>
+-<p>Change 27.5.2.1.1 [ios::failure] Class ios_base::failure, paragraph 2 as
++<p>Change 27.5.3.1.1 [ios::failure] Class ios_base::failure, paragraph 2 as
+ indicated:</p>
+ <blockquote>
+-<p>When throwing ios_base::failure exceptions, implementations should provide
+-values of ec that identify the specific reason for the failure. [ Note: Errors
++<p>When throwing <tt>ios_base::failure</tt> exceptions, implementations should provide
++values of <tt>ec</tt> that identify the specific reason for the failure. [ <i>Note</i>: Errors
+ arising from the operating system would typically be reported as <tt>
+ system_category</tt><tt><ins>()</ins></tt> errors with an error value of the
+ error number reported by the operating system. Errors arising from within the
+ stream library would typically be reported as <tt>error_code(io_errc::stream,
+-iostream_category<ins>()</ins>)</tt>. --end note ]</p>
++iostream_category<ins>()</ins>)</tt>. &mdash; <i>end note</i> ]</p>
+ </blockquote>
+-<p>Change 27.5.5.5 [error.reporting] Error reporting as indicated:</p>
++<p>Change 27.5.6.5 [error.reporting] Error reporting as indicated:</p>
+ <blockquote>
+ <pre>error_code make_error_code(io_errc e);</pre>
+ <blockquote>
+@@ -51779,7 +54445,7 @@ iostream_category<ins>()</ins>)</tt>. --end note ]</p>
+ </p>
+ <p><i>Remarks:</i> The object's default_error_condition and equivalent virtual functions shall
+ behave as specified for the class error_category. The object's name virtual
+-function shall return a pointer to the string "iostream".</p>
++function shall return a pointer to the string &quot;iostream&quot;.</p>
+ </blockquote>
+ </blockquote>
+
+@@ -51790,11 +54456,11 @@ function shall return a pointer to the string "iostream".</p>
+
+
+ <hr>
+-<h3><a name="891"></a>891. std::thread, std::call_once issue</h3>
+-<p><b>Section:</b> 30.3.1.2 [thread.thread.constr], 30.4.4.2 [thread.once.callonce] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="891"></a>891. <tt>std::thread</tt>, <tt>std::call_once</tt> issue</h3>
++<p><b>Section:</b> 30.3.1.2 [thread.thread.constr], 30.4.4.2 [thread.once.callonce] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I notice that the vararg overloads of <tt>std::thread</tt> and <tt>std::call_once</tt>
+@@ -51809,7 +54475,8 @@ There are two problems with this.
+ First, the specification (and implementation) in terms of <tt>std::bind</tt> allows, for example:
+ </p>
+
+-<blockquote><pre>std::thread th( f, 1, std::bind( g ) );
++<blockquote><pre>
++std::thread th( f, 1, std::bind( g ) );
+ </pre></blockquote>
+
+ <p>
+@@ -51820,27 +54487,27 @@ which executes <tt>f( 1, g() )</tt> in a thread. This can be useful. The
+ Second, assuming that we don't want the above, the specification has copied the wording
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>INVOKE(func, w1, w2, ..., wN)</tt> (20.6.2) shall be a valid
+ expression for some values <tt>w1, w2, ..., wN</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ but this is not needed since we know that our argument list is args; it should simply be
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>INVOKE(func, args...)</tt> (20.6.2) shall be a valid expression
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit Anthony provided proposed wording.
+@@ -51852,21 +54519,21 @@ Post Summit Anthony provided proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open. Await decision for thread variadic constructor.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-See proposed wording for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a> for this, for the formulation
+-on how to solve this. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#929">929</a> modifies the thread constructor to
++<blockquote><p>
++See proposed wording for <a href="lwg-defects.html#929">929</a> for this, for the formulation
++on how to solve this. <a href="lwg-defects.html#929">929</a> modifies the thread constructor to
+ have "pass by value" behavior with pass by reference efficiency through the use
+ of the <tt>decay</tt> trait. This same formula would be useful for <tt>call_once</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-11 Anthony updates wording.
+@@ -51884,10 +54551,10 @@ of the <tt>decay</tt> trait. This same formula would be useful for <tt>call_onc
+ Modify 30.4.4.2 [thread.once.callonce] p1-p2 with the following:
+ </p>
+
+-<blockquote>
+-<pre>template&lt;class Callable, class ...Args&gt;
+- void call_once(once_flag&amp; flag, Callable<ins>&amp;&amp;</ins> func, Args&amp;&amp;... args);</pre>
+-<blockquote>
++<blockquote><pre>
++template&lt;class Callable, class ...Args&gt;
++ void call_once(once_flag&amp; flag, Callable<ins>&amp;&amp;</ins> func, Args&amp;&amp;... args);
++</pre><blockquote>
+
+ <p><ins>
+ Given a function as follows:
+@@ -51901,12 +54568,13 @@ template&lt;typename T&gt; typename decay&lt;T&gt;::type decay_copy(T&amp;&amp;
+ <p>
+ 1 <i>Requires:</i> <del>The template parameters</del> <tt>Callable</tt> and each
+ <tt>Ti</tt> in <tt>Args</tt> shall <del>be <tt>CopyConstructible</tt> if an
+-lvalue and otherwise</del> <ins>satisfy the</ins>
+-<tt>MoveConstructible</tt> <ins>requirements</ins>.
++lvalue and otherwise</del> <ins>satisfy the</ins> <tt>MoveConstructible</tt>
++<ins>requirements</ins>.
+ <tt><i>INVOKE</i>(<ins>decay_copy(std::forward&lt;Callable&gt;(</ins>func<ins>)</ins>,
+ <del>w1, w2, ..., wN</del>
+-<ins>decay_copy(std::forward&lt;Args&gt;(args))...</ins>)</tt> (20.8.2 [func.require]) shall be a valid expression<del> for some values <tt>w1,
+-w2, ..., wN</tt>, where <tt>N == sizeof...(Args)</tt></del>.
++<ins>decay_copy(std::forward&lt;Args&gt;(args))...</ins>)</tt> (20.9.2 [func.require])
++shall be a valid expression<del> for some values <tt>w1, w2, ..., wN</tt>, where
++<tt>N == sizeof...(Args)</tt></del>.
+ </p>
+
+ <p>
+@@ -51936,12 +54604,12 @@ throwing an exception. If an exception is thrown it is propagated to the caller.
+
+
+ <hr>
+-<h3><a name="893"></a>893. std::mutex issue</h3>
+-<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#905">905</a></p>
++<h3><a name="893"></a>893. <tt>std::mutex</tt> issue</h3>
++<p><b>Section:</b> 30.4.1.2.1 [thread.mutex.class] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.class">issues</a> in [thread.mutex.class].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#905">905</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.4.1.2.1 [thread.mutex.class]/27 (in
+@@ -51993,9 +54661,9 @@ calls <tt>lock()</tt> or <tt>try_lock()</tt> on that object, or"
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review. Alisdair to provide note.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-31 Alisdair provided note.
+@@ -52007,9 +54675,9 @@ Move to Review. Alisdair to provide note.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-18 Peter Opens:
+@@ -52021,12 +54689,12 @@ Moved to Ready.
+ I don't believe that the proposed note:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> a program may deadlock if the thread that owns a <tt>mutex</tt>
+ object calls <tt>lock()</tt> or <tt>try_lock()</tt> on that object. If the program can
+ detect the deadlock, a <tt>resource_deadlock_would_occur</tt> error condition may
+-be observed. — <i>end note</i>]
+-</blockquote>
++be observed. &mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ is entirely correct. "or <tt>try_lock()</tt>" should be removed, because
+@@ -52084,12 +54752,12 @@ Strike 30.4.1.2.1 [thread.mutex.class] paragraph 3 bullet 2:
+ Add the following note after p3 30.4.1.2.1 [thread.mutex.class]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> a program may deadlock if the thread that owns a <tt>mutex</tt>
+ object calls <tt>lock()</tt> on that object. If the implementation can detect the
+ deadlock, a <tt>resource_deadlock_would_occur</tt> error condition may be
+-observed. — <i>end note</i>]
+-</blockquote>
++observed. &mdash; <i>end note</i>]
++</p></blockquote>
+
+
+
+@@ -52098,10 +54766,11 @@ observed.
+
+ <hr>
+ <h3><a name="894"></a>894. longjmp and destructors</h3>
+-<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Lawrence Crowl, Alisdair Meredith <b>Opened:</b> 2008-09-17 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Lawrence Crowl, Alisdair Meredith <b>Opened:</b> 2008-09-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The interaction between <tt>longjmp</tt> and exceptions seems unnecessarily
+@@ -52114,7 +54783,7 @@ restrictive and not in keeping with existing practice.
+ Edit paragraph 4 of 18.10 [support.runtime] as follows:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The function signature <tt>longjmp(jmp_buf jbuf, int val)</tt> has more
+ restricted behavior in this International Standard. A
+ <tt>setjmp/longjmp</tt> call pair has undefined behavior if replacing the
+@@ -52122,7 +54791,7 @@ restricted behavior in this International Standard. A
+ <tt>throw</tt> would <del>destroy</del>
+ <ins>invoke any non-trivial destructors for</ins>
+ any automatic objects.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -52130,10 +54799,11 @@ any automatic objects.
+
+ <hr>
+ <h3><a name="896"></a>896. Library thread safety issue</h3>
+-<p><b>Section:</b> 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2008-09-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2008-09-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It is unclear whether <tt>shared_ptr</tt> is thread-safe in the sense that
+@@ -52207,17 +54877,17 @@ attempts to <tt>make shared_ptr</tt> thread-unsafe.
+ <p>
+ I'd mildly prefer if
+ </p>
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> This is true in spite of that fact that such functions often
+ modify <tt>use_count()</tt> <i>--end note</i>]
+-</blockquote>
++</p></blockquote>
+ <p>
+ is changed to
+ </p>
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> This is true in spite of that fact that such functions often
+ cause a change in <tt>use_count()</tt> <i>--end note</i>]
+-</blockquote>
++</p></blockquote>
+ <p>
+ (or something along these lines) to emphasise that <tt>use_count()</tt> is not,
+ conceptually, a variable, but a return value.
+@@ -52250,11 +54920,11 @@ Hans to improve wording in consultation with Pete. Leave Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready. Ask Editor to clear up wording a little when integrating to
+ make it clear that the portion after the first comma only applies for
+ the presence of data races.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-24 Hans adds:
+@@ -52271,13 +54941,13 @@ doesn't say the right thing.
+ I suspect we really want to say something along the lines of:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For purposes of determining the presence of a data race, member
+ functions access and modify only the <tt>shared_ptr</tt> and
+ <tt>weak_ptr</tt> objects themselves and not objects they refer to.
+ Changes in <tt>use_count()</tt> do not reflect modifications that can
+ introduce data races.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ But I think this needs further discussion by experts to make sure this
+@@ -52309,7 +54979,7 @@ and preserved the previous wording here:
+ Make it explicitly thread-safe, in this weak sense, as I believe was intended:
+ </p>
+ <p>
+-Insert in 20.9.10.2 [util.smartptr.shared], before p5:
++Insert in 20.8.2.2 [util.smartptr.shared], before p5:
+ </p>
+ <blockquote>
+ <p>
+@@ -52338,43 +55008,382 @@ anywhere else, since nothing else has the problem with the modified
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Insert a new paragraph at the end of 20.9.10.2 [util.smartptr.shared]:
++Insert a new paragraph at the end of 20.8.2.2 [util.smartptr.shared]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For purposes of determining the presence of a data race, member functions access
+ and modify only the <tt>shared_ptr</tt> and <tt>weak_ptr</tt> objects themselves
+ and not objects they refer to. Changes in <tt>use_count()</tt> do not reflect
+ modifications that can introduce data races.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="897"></a>897. Forward_list issues... Part 2</h3>
++<p><b>Section:</b> 23.3.4.5 [forwardlist.modifiers] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++This issue was split off from <a href="lwg-closed.html#892">892</a> at the request of the LWG.
++</p>
++
++<p><i>[
++San Francisco:
++]</i></p>
++
++
++<blockquote>
++<p>
++This issue is more complicated than it looks.
++</p>
++<p>
++paragraph 47: replace each <tt>(first, last) with (first, last]</tt>
++</p>
++<p>
++add a statement after paragraph 48 that complexity is O(1)
++</p>
++<p>
++remove the complexity statement from the first overload of splice_after
++</p>
++<p>
++We may have the same problems with other modifiers, like erase_after.
++Should it require that all iterators in the range (position, last] be
++dereferenceable?
++</p>
+ </blockquote>
+
++<p>
++There are actually 3 issues here:
++</p>
++
++<ol>
++<li>
++<p>
++What value should <tt>erase_after</tt> return? With <tt>list</tt>, code often
++looks like:
++</p>
++<blockquote><pre>
++for (auto i = l.begin(); i != l.end();)
++{
++ // inspect *i and decide if you want to erase it
++ // ...
++ if (I want to erase *i)
++ i = l.erase(i);
++ else
++ ++i;
++}
++</pre></blockquote>
++<p>
++I.e. the iterator returned from <tt>erase</tt> is useful for setting up the
++logic for operating on the next element. For <tt>forward_list</tt> this might
++look something like:
++</p>
++<blockquote><pre>
++auto i = fl.before_begin();
++auto ip1 = i;
++for (++ip1; ip1 != fl.end(); ++ip1)
++{
++ // inspect *(i+1) and decide if you want to erase it
++ // ...
++ if (I want to erase *(i+1))
++ i = fl.erase_after(i);
++ else
++ ++i;
++ ip1 = i;
++}
++</pre></blockquote>
++<p>
++In the above example code, it is convenient if <tt>erase_after</tt> returns
++the element <i>prior</i> to the erased element (range) instead of the element
++<i>after</i> the erase element (range).
++</p>
++<p>
++Existing practice:
++</p>
++<ul>
++<li>SGI slist returns an iterator referencing the element <i>after</i> the erased range.</li>
++<li>CodeWarrior slist returns an iterator referencing the element <i>before</i> the erased range.</li>
++</ul>
++<p>
++There is not a strong technical argument for either solution over the other.
++</p>
++</li>
++
++<li>
++<p>
++With all other containers, operations always work on the range
++<tt>[first, last)</tt> and/or <i>prior to</i> the given <tt>position</tt>.
++</p>
++<p>
++With <tt>forward_list</tt>, operations sometimes work on the range
++<tt>(first, last]</tt> and/or <i>after</i> the given <tt>position</tt>.
++</p>
++<p>
++This is simply due to the fact that in order to operate on
++<tt>*first</tt> (with <tt>forward_list</tt>) one needs access to
++<tt>*(first-1)</tt>. And that's not practical with
++<tt>forward_list</tt>. So the operating range needs to start with <tt>(first</tt>,
++not <tt>[first</tt> (as the current working paper says).
++</p>
++<p>
++Additionally, if one is interested in splicing the range <tt>(first, last)</tt>,
++then (with <tt>forward_list</tt>), one needs practical (constant time) access to
++<tt>*(last-1)</tt> so that one can set the <i>next</i> field in this node to
++the proper value. As this is not possible with <tt>forward_list</tt>, one must
++specify the last element of interest instead of one past the last element of
++interest. The syntax for doing this is to pass <tt>(first, last]</tt> instead
++of <tt>(first, last)</tt>.
++</p>
++<p>
++With <tt>erase_after</tt> we have a choice of either erasing the range
++<tt>(first, last]</tt> <em>or</em> <tt>(first, last)</tt>. Choosing the latter
++enables:
++</p>
++<blockquote><pre>
++x.erase_after(pos, x.end());
++</pre></blockquote>
++
++<p>
++With the former, the above statement is inconvenient or expensive due to the lack
++of constant time access to <tt>x.end()-1</tt>. However we could introduce:
++</p>
++
++<blockquote><pre>
++iterator erase_to_end(const_iterator position);
++</pre></blockquote>
++
++<p>
++to compensate.
++</p>
++
++<p>
++The advantage of the former (<tt>(first, last]</tt>) for <tt>erase_after</tt>
++is a consistency with <tt>splice_after</tt> which uses <tt>(first, last]</tt>
++as the specified range. But this either requires the addition of <tt>erase_to_end</tt>
++or giving up such functionality.
++</p>
++
++</li>
++
++<li>
++As stated in the discussion of <a href="lwg-closed.html#892">892</a>, and reienforced by point 2 above,
++a <tt>splice_after</tt> should work on the source range <tt>(first, last]</tt>
++if the operation is to be <i>&#927;</i>(1). When splicing an entire list <tt>x</tt> the
++algorithm needs <tt>(x.before_begin(), x.end()-1]</tt>. Unfortunately <tt>x.end()-1</tt>
++is not available in constant time unless we specify that it must be. In order to
++make <tt>x.end()-1</tt> available in constant time, the implementation would have
++to dedicate a pointer to it. I believe the design of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2543.htm">N2543</a>
++intended a nominal overhead of <tt>foward_list</tt> of 1 pointer. Thus splicing
++one <i>entire</i> <tt>forward_list</tt> into another can not be <i>&#927;</i>(1).
++</li>
++</ol>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++We agree with the proposed resolution.
++</p>
++<p>
++Move to Review.
++</p>
++</blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote>
++<p>
++We may need a new issue to correct splice_after, because it may no
++longer be correct to accept an rvalues as an argument. Merge may be
++affected, too. This might be issue <a href="lwg-defects.html#1133">1133</a>. (Howard: confirmed)
++</p>
++<p>
++Move this to Ready, but the Requires clause of the second form of
++splice_after should say "(first, last)," not "(first, last]" (there are
++three occurrences). There was considerable discussion on this. (Howard: fixed)
++</p>
++<p>
++Alan suggested removing the "foward_last&lt;T. Alloc&gt;&amp;&amp; x"
++parameter from the second form of splice_after, because it is redundant.
++PJP wanted to keep it, because it allows him to check for bad ranges
++(i.e. "Granny knots").
++</p>
++<p>
++We prefer to keep <tt>x</tt>.
++</p>
++<p>
++Beman. Whenever we deviate from the customary half-open range in the
++specification, we should add a non-normative comment to the standard
++explaining the deviation. This clarifies the intention and spares the
++committee much confusion in the future.
++</p>
++<p>
++Alan to write a non-normative comment to explain the use of fully-closed ranges.
++</p>
++<p>
++Move to Ready, with the changes described above. (Howard: awaiting note from Alan)
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>, addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2988.pdf">N2988</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Wording below assumes issue <a href="lwg-defects.html#878">878</a> is accepted, but this issue is
++independent of that issue.
++</p>
++
++<p>
++Change 23.3.4.5 [forwardlist.modifiers]:
++</p>
++
++<blockquote>
++<pre>
++iterator erase_after(const_iterator position);
++</pre>
++<blockquote>
++<p>
++<i>Requires:</i> The iterator following <tt>position</tt> is dereferenceable.
++</p>
++<p>
++<i>Effects:</i> Erases the element pointed to by the iterator following <tt>position</tt>.
++</p>
++<p>
++<i>Returns:</i> <del>An iterator pointing to the element following the one that was erased, or <tt>end()</tt> if no such
++element exists</del>
++<ins>An iterator equal to <tt>position</tt></ins>.
++</p>
++</blockquote>
++
++
++<pre>
++iterator erase_after(const_iterator position, <ins>const_</ins>iterator last);
++</pre>
++<blockquote>
++<p>
++<i>Requires:</i> All iterators in the range
++<tt><del>[</del><ins>(</ins>position,last)</tt>
++are dereferenceable.
++</p>
++<p>
++<i>Effects:</i> Erases the elements in the range
++<tt><del>[</del><ins>(</ins>position,last)</tt>.
++</p>
++<p>
++<i>Returns:</i> <ins>An iterator equal to <tt>position</tt></ins> <del><tt>last</tt></del>
++</p>
++</blockquote>
++</blockquote>
++
++<p>
++Change 23.3.4.6 [forwardlist.ops]:
++</p>
++
++<blockquote>
++<pre>
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++<i>Requires:</i> <tt>position</tt> is <tt>before_begin()</tt> or a
++dereferenceable iterator in the range <tt>[begin(), end))</tt>. <tt>&amp;x != this</tt>.
++</p>
++<p>
++<i>Effects:</i> Inserts the contents of <tt>x</tt> after <tt>position</tt>, and
++<tt>x</tt> becomes empty. Pointers and references to
++the moved elements of <tt>x</tt> now refer to those same elements but as members of <tt>*this</tt>.
++Iterators referring to the moved elements will continue to refer to their elements,
++but they now behave as iterators into <tt>*this</tt>, not into <tt>x</tt>.
++</p>
++<p>
++<i>Throws:</i> Nothing.
++</p>
++<p>
++<i>Complexity:</i> <del><i>&#927;</i>(1)</del> <ins><i>&#927;</i>(<tt>distance(x.begin(), x.end())</tt>)</ins>
++</p>
++</blockquote>
++
++<p>...</p>
++
++<pre>
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x,
++ const_iterator first, const_iterator last);
++</pre>
++<blockquote>
++<p>
++<i>Requires:</i> <tt>position</tt> is <tt>before_begin()</tt> or a
++dereferenceable iterator in the range <tt>[begin(), end))</tt>.
++<tt>(first,last)</tt> is a valid range in
++<tt>x</tt>, and all iterators in the range
++<tt>(first,last)</tt> are dereferenceable.
++<tt>position</tt> is not an iterator in the range <tt>(first,last)</tt>.
++</p>
++<p>
++<i>Effects:</i> Inserts elements in the range <tt>(first,last)</tt>
++after <tt>position</tt> and removes the elements from <tt>x</tt>.
++Pointers and references to the moved elements of <tt>x</tt> now refer to
++those same elements but as members of <tt>*this</tt>. Iterators
++referring to the moved elements will continue to refer to their
++elements, but they now behave as iterators into <tt>*this</tt>, not into
++<tt>x</tt>.
++</p>
++<p>
++<ins><i>Complexity:</i> <i>&#927;</i>(1).</ins>
++</p>
++</blockquote>
++
++</blockquote>
++
++
+
+
+
+
+ <hr>
+ <h3><a name="898"></a>898. Small contradiction in n2723 to forward to committee</h3>
+-<p><b>Section:</b> 23.3.3.5 [forwardlist.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Arch Robison <b>Opened:</b> 2008-09-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Arch Robison <b>Opened:</b> 2008-09-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I ran across a small contradiction in working draft n2723.
+ </p>
+ <blockquote>
+ <p>
+-23.3.3 [forwardlist]p2: A <tt>forward_list</tt> satisfies all of the
++23.3.4 [forwardlist]p2: A <tt>forward_list</tt> satisfies all of the
+ requirements of a container (table 90), except that the <tt>size()</tt> member
+ function is not provided.
+ </p>
+ <p>
+-23.3.3.5 [forwardlist.ops]p57: <i>Complexity:</i> At most <tt>size() + x.size() - 1</tt>
++23.3.4.6 [forwardlist.ops]p57: <i>Complexity:</i> At most <tt>size() + x.size() - 1</tt>
+ comparisons.
+ </p>
+ </blockquote>
+ <p>
+-Presumably 23.3.3.5 [forwardlist.ops]p57 needs to be rephrased to not use
++Presumably 23.3.4.6 [forwardlist.ops]p57 needs to be rephrased to not use
+ <tt>size()</tt>, or note that it is used there only for sake of notational convenience.
+ </p>
+
+@@ -52398,13 +55407,14 @@ Move to Tentatively Ready.
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>Change 23.3.3.5 [forwardlist.ops],
++<p><i>Change 23.3.4.6 [forwardlist.ops],
+ forward_list operations, paragraph 19, merge complexity as indicated:
+ </i></p>
+-<blockquote><i>Complexity:</i> At most <tt><del>size() + x.size()</del>
++<blockquote><p>
++<i>Complexity:</i> At most <tt><del>size() + x.size()</del>
+ <ins>distance(begin(), end()) + distance(x.begin(), x.end())</ins> - 1</tt>
+ comparisons.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -52412,43 +55422,43 @@ comparisons.
+
+ <hr>
+ <h3><a name="899"></a>899. Adjusting <tt>shared_ptr</tt> for <tt>nullptr_t</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.2 [util.smartptr.shared.dest] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.dest">issues</a> in [util.smartptr.shared.dest].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.2 [util.smartptr.shared.dest] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2008-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.dest">issues</a> in [util.smartptr.shared.dest].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ James Dennett, message c++std-lib-22442:
+ </p>
+-<blockquote>
++<blockquote><p>
+ The wording below addresses one case of this, but opening an
+ issue to address the need to sanity check uses of the term "pointer"
+-in 20.9.10.2 [util.smartptr.shared] would be a good thing.
+-</blockquote>
++in 20.8.2.2 [util.smartptr.shared] would be a good thing.
++</p></blockquote>
+ <p>
+ There's one more reference, in <tt>~shared_ptr;</tt> we can apply your suggested change to it, too. That is:
+ </p>
+ <p>
+-Change 20.9.10.2.2 [util.smartptr.shared.dest]/1 second bullet from:
++Change 20.8.2.2.2 [util.smartptr.shared.dest]/1 second bullet from:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Otherwise, if *this owns a pointer p and a deleter d, d(p) is called.
+-</blockquote>
++</p></blockquote>
+ <p>
+ to:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Otherwise, if *this owns an object p and a deleter d, d(p) is called.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -52457,8 +55467,8 @@ Batavia (2009-05):
+ <blockquote>
+ <p>
+ Peter Dimov notes the analogous change has already been made
+-to "the new nullptr_t taking constructors
+-in 20.9.10.2.1 [util.smartptr.shared.const] p9-13."
++to "the new <tt>nullptr_t</tt> taking constructors
++in 20.8.2.2.1 [util.smartptr.shared.const] p9-13."
+ </p>
+ <p>
+ We agree with the proposed resolution.
+@@ -52469,7 +55479,7 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.10.2.2 [util.smartptr.shared.dest]/1 second bullet:
++Change 20.8.2.2.2 [util.smartptr.shared.dest] p1 second bullet:
+ </p>
+ <blockquote>
+ <ul>
+@@ -52487,38 +55497,38 @@ deleter <tt>d</tt>, <tt>d(p)</tt> is called.
+
+
+ <hr>
+-<h3><a name="900"></a>900. stream move-assignment</h3>
+-<p><b>Section:</b> 27.9.1.8 [ifstream.assign] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-09-20 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="900"></a>900. Stream move-assignment</h3>
++<p><b>Section:</b> 27.9.1.8 [ifstream.assign] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2008-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-It
+-appears that we have an issue similar to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#675">675</a> regarding the move-assignment of
+-stream types. For example, when assigning to an <tt>std::ifstream</tt>,
+-<tt>ifstream1</tt>, it seems preferable to close the file originally held by
+-<tt>ifstream1</tt>:
++It appears that we have an issue similar to issue <a href="lwg-defects.html#675">675</a> regarding the move-assignment of
++stream types. For example, when assigning to an <tt>std::ifstream</tt>, <tt>ifstream1</tt>, it
++seems preferable to close the file originally held by <tt>ifstream1</tt>:
+ </p>
+
+-<blockquote><pre>ifstream1 = std::move(ifstream2);
++<blockquote><pre>
++ifstream1 = std::move(ifstream2);
+ </pre></blockquote>
+
+ <p>
+ The current Draft
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>)
+-specifies that the move-assignment of
+-stream types like <tt>ifstream</tt> has the same effect as a swap:
++specifies that the move-assignment of stream types like <tt>ifstream</tt> has the
++same effect as a swap:
+ </p>
+
+ <blockquote>
+ <p>
+ Assign and swap 27.9.1.8 [ifstream.assign]
+ </p>
+-<pre>basic_ifstream&amp; operator=(basic_ifstream&amp;&amp; rhs);
++<pre>
++basic_ifstream&amp; operator=(basic_ifstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> <tt>swap(rhs)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -52539,9 +55549,9 @@ Move to Open pending specific wording to be supplied by Howard.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Howard is going to write wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-26 Howard provided wording.
+@@ -52553,144 +55563,152 @@ Howard is going to write wording.
+ ]</i></p>
+
+
+-<blockquote>
+-Note: The proposed change of 27.9.1.3 [filebuf.assign]/1 depends on the
+-resolution of LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1204">1204</a>, which allows implementations to assume that
++<blockquote><p>
++Note: The proposed change of 27.9.1.3 [filebuf.assign] p1 depends on the
++resolution of LWG <a href="lwg-defects.html#1204">1204</a>, which allows implementations to assume that
+ <tt>*this</tt> and <tt>rhs</tt> refer to different objects.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Leave as Open. Too closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#911">911</a> to move on at this time.
+-</blockquote>
++<blockquote><p>
++Leave as Open. Too closely related to <a href="lwg-defects.html#911">911</a> to move on at this time.
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 27.8.1.2 [stringbuf.assign]/1:
++Change 27.8.2.2 [stringbuf.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_stringbuf&amp; operator=(basic_stringbuf&amp;&amp; rhs);
++<blockquote><pre>
++basic_stringbuf&amp; operator=(basic_stringbuf&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>After the move assignment <tt>*this</tt> reflects the same observable
+ state it would have if it had been move constructed from <tt>rhs</tt>
+-(27.8.1.1 [stringbuf.cons]).
++(27.8.2.1 [stringbuf.cons]).
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 27.8.2.2 [istringstream.assign]/1:
++Change 27.8.3.2 [istringstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_istringstream&amp; operator=(basic_istringstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_istringstream&amp; operator=(basic_istringstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 27.8.3.2 [ostringstream.assign]/1:
++Change 27.8.4.2 [ostringstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_ostringstream&amp; operator=(basic_ostringstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_ostringstream&amp; operator=(basic_ostringstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 27.8.5.1 [stringstream.assign]/1:
++Change 27.8.5.2 [stringstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_stringstream&amp; operator=(basic_stringstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_stringstream&amp; operator=(basic_stringstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 27.9.1.3 [filebuf.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_filebuf&amp; operator=(basic_filebuf&amp;&amp; rhs);
++<blockquote><pre>
++basic_filebuf&amp; operator=(basic_filebuf&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Begins by calling <tt>this-&gt;close()</tt>.
+ After the move assignment <tt>*this</tt> reflects the same observable
+ state it would have if it had been move constructed from <tt>rhs</tt>
+ (27.9.1.2 [filebuf.cons]).
+ </ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 27.9.1.8 [ifstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_ifstream&amp; operator=(basic_ifstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_ifstream&amp; operator=(basic_ifstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 27.9.1.12 [ofstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_ofstream&amp; operator=(basic_ofstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_ofstream&amp; operator=(basic_ofstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 27.9.1.16 [fstream.assign]/1:
+ </p>
+
+-<blockquote><pre>basic_fstream&amp; operator=(basic_fstream&amp;&amp; rhs);
++<blockquote><pre>
++basic_fstream&amp; operator=(basic_fstream&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del><tt>swap(rhs)</tt>.</del>
+ <ins>Move assigns the base and members of <tt>*this</tt> with the respective
+ base and members of <tt>rhs</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -52699,30 +55717,32 @@ base and members of <tt>rhs</tt>.</ins>
+
+
+ <hr>
+-<h3><a name="904"></a>904. result_of argument types</h3>
+-<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2008-09-10 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.ret">issues</a> in [func.ret].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="904"></a>904. <tt>result_of</tt> argument types</h3>
++<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2008-09-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.ret">issues</a> in [func.ret].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The WP and TR1 have the same text regarding the argument types of a
+ <tt>result_of</tt> expression:
+ </p>
+-<blockquote>
++<blockquote><p>
+ The values <tt>ti</tt> are lvalues when the corresponding type <tt>Ti</tt> is a
+ reference type, and rvalues otherwise.
+-</blockquote>
++</p></blockquote>
+ <p>
+ I read this to mean that this compiles:
+ </p>
+-<blockquote><pre>typedef int (*func)(int&amp;);
++<blockquote><pre>
++typedef int (*func)(int&amp;);
+ result_of&lt;func(int&amp;&amp;)&gt;::type i = 0;
+ </pre></blockquote>
+ <p>
+ even though this doesn't:
+ </p>
+-<blockquote><pre>int f(int&amp;);
++<blockquote><pre>
++int f(int&amp;);
+ f( std::move(0) );
+ </pre></blockquote>
+ <p>
+@@ -52733,7 +55753,8 @@ type" or am I missing something?
+ I later came up with this self-contained example which won't compile,
+ but I think it should:
+ </p>
+-<blockquote><pre>struct X {
++<blockquote><pre>
++struct X {
+ void operator()(int&amp;);
+ int operator()(int&amp;&amp;);
+ } x;
+@@ -52746,9 +55767,9 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -52757,11 +55778,11 @@ Recommend Tentatively Ready.
+ Change X [func.ret], p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... The values <tt>ti</tt> are lvalues
+ when the corresponding type <tt>Ti</tt> is a<ins>n</ins> <ins>lvalue-</ins>reference type,
+ and rvalues otherwise.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -52769,23 +55790,24 @@ and rvalues otherwise.
+
+ <hr>
+ <h3><a name="907"></a>907. Bitset's immutable element retrieval is inconsistently defined</h3>
+-<p><b>Section:</b> 20.5.2 [bitset.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.6.2 [bitset.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.members">issues</a> in [bitset.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current standard 14882::2003(E) as well as the current draft
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+-have in common a contradiction of the operational semantics
+-of member function test 20.5.2 [bitset.members]/56-58 and the immutable
+-member <tt>operator[]</tt> overload 20.5.2 [bitset.members]/64-66 (all references
++have in common a contradiction of the operational semantics of member function
++<tt>test</tt> 20.6.2 [bitset.members] p.56-58 and the immutable
++member <tt>operator[]</tt> overload 20.6.2 [bitset.members] p.64-66 (all references
+ are defined in terms of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>):
+ </p>
+
+ <ol>
+-<li><pre>bool test(size_t pos) const;
++<li><pre>
++bool test(size_t pos) const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -52801,7 +55823,8 @@ has the value one.
+ </p>
+ </blockquote>
+ </li>
+-<li><pre>constexpr bool operator[](size_t pos) const;
++<li><pre>
++constexpr bool operator[](size_t pos) const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -52821,13 +55844,13 @@ has the value one.
+ Three interpretations:
+ </p>
+
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ The <tt>operator[]</tt> overload is indeed allowed to throw an exception
+ (via <tt>test()</tt>, if <tt>pos</tt> corresponds to an invalid bit position) which does
+ not leave the call frame. In this case this function cannot be a
+ <tt>constexpr</tt> function, because <tt>test()</tt> is not, due to
+-5.19 [expr.const]/2, last bullet.
++5.20 [expr.const]/2, last bullet.
+ </li>
+ <li>
+ The intend was not to throw an exception in <tt>test</tt> in case of an
+@@ -52841,7 +55864,7 @@ is invalid.
+ </ol>
+
+ <p>
+-The problem became worse, because issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>
++The problem became worse, because issue <a href="lwg-defects.html#720">720</a>
+ recently voted into WP argued that member <tt>test</tt> logically must be
+ a <tt>constexpr</tt> function, because it was used to define the semantics
+ of another <tt>constexpr</tt> function (the <tt>operator[]</tt> overload).
+@@ -52852,19 +55875,20 @@ Three alternatives are proposed, corresponding to the three bullets
+ (A), (B), and (C), the author suggests to follow proposal (C).
+ </p>
+
+-<b>
++<p><b>
+ Proposed alternatives:
+-</b>
++</b></p>
+
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+ Remove the <tt>constexpr</tt> specifier in front of <tt>operator[]</tt> overload and
+-undo that of member <tt>test</tt> (assuming <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a> is accepted) in both the
+-class declaration 20.5 [template.bitset]/1 and in the member description
+-before 20.5.2 [bitset.members]/56 and before /64 to read:
++undo that of member <tt>test</tt> (assuming <a href="lwg-defects.html#720">720</a> is accepted) in both the
++class declaration 20.6 [template.bitset]/1 and in the member description
++before 20.6.2 [bitset.members]/56 and before /64 to read:
+ </p>
+-<blockquote><pre><del>constexpr</del> bool test(size_t pos) const;
++<blockquote><pre>
++<del>constexpr</del> bool test(size_t pos) const;
+ ..
+ <del>constexpr</del> bool operator[](size_t pos) const;
+ </pre></blockquote>
+@@ -52873,41 +55897,42 @@ before 20.5.2 [bitset.members]/56 and before /64 to read:
+ Change the throws clause of p. 65 to read:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> <del>nothing</del>
+ <ins><tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit
+ position</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+ Replace the throws clause p. 57 to read:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> <del><tt>out_of_range</tt> if <tt>pos</tt> does not correspond to a valid bit
+ position</del> <ins>nothing</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+ Undo the addition of the <tt>constexpr</tt> specifier to the <tt>test</tt> member
+-function in both class declaration 20.5 [template.bitset]/1 and in the
+-member description before 20.5.2 [bitset.members]/56, assuming that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>
++function in both class declaration 20.6 [template.bitset]/1 and in the
++member description before 20.6.2 [bitset.members]/56, assuming that <a href="lwg-defects.html#720">720</a>
+ was applied.
+ </p>
+
+-<blockquote><pre><del>constexpr</del> bool test(size_t pos) const;
++<blockquote><pre>
++<del>constexpr</del> bool test(size_t pos) const;
+ </pre></blockquote>
+
+ <p>
+ Change the returns clause p. 66 to read:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <del><tt>test(pos)</tt></del> <ins><tt>true</tt> if the bit at position <tt>pos</tt> in <tt>*this</tt>
+ has the value one, otherwise <tt>false</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -52929,34 +55954,37 @@ Recommend Review with option C.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<ol type="A" ,="" start="3">
++<ol style="list-style-type:upper-alpha">
++<li>[&hellip;]</li>
++<li>[&hellip;]</li>
+ <li>
+ <p>
+ Undo the addition of the <tt>constexpr</tt> specifier to the <tt>test</tt> member
+-function in both class declaration 20.5 [template.bitset]/1 and in the
+-member description before 20.5.2 [bitset.members]/56, assuming that <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#720">720</a>
++function in both class declaration 20.6 [template.bitset] p.1 and in the
++member description before 20.6.2 [bitset.members] p.56, assuming that <a href="lwg-defects.html#720">720</a>
+ was applied.
+ </p>
+
+-<blockquote><pre><del>constexpr</del> bool test(size_t pos) const;
++<blockquote><pre>
++<del>constexpr</del> bool test(size_t pos) const;
+ </pre></blockquote>
+
+ <p>
+ Change the returns clause p. 66 to read:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <del><tt>test(pos)</tt></del> <ins><tt>true</tt> if the bit at position <tt>pos</tt> in <tt>*this</tt>
+ has the value one, otherwise <tt>false</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -52966,11 +55994,101 @@ has the value one, otherwise <tt>false</tt></ins>.
+
+
+ <hr>
++<h3><a name="908"></a>908. Deleted assignment operators for atomic types must be volatile</h3>
++<p><b>Section:</b> X [atomics.types] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 90</b></p>
++
++<p>
++The deleted copy-assignment operators for the atomic types are not
++marked as volatile in N2723, whereas the assignment operators from the
++associated non-atomic types are. e.g.
++</p>
++<blockquote><pre>
++atomic_bool&amp; operator=(atomic_bool const&amp;) = delete;
++atomic_bool&amp; operator=(bool) volatile;
++</pre></blockquote>
++
++<p>
++This leads to ambiguity when assigning a non-atomic value to a
++non-volatile instance of an atomic type:
++</p>
++<blockquote><pre>
++atomic_bool b;
++b=false;
++</pre></blockquote>
++
++<p>
++Both assignment operators require a standard conversions: the
++copy-assignment operator can use the implicit <tt>atomic_bool(bool)</tt>
++conversion constructor to convert <tt>false</tt> to an instance of
++<tt>atomic_bool</tt>, or <tt>b</tt> can undergo a qualification conversion in order to
++use the assignment from a plain <tt>bool</tt>.
++</p>
++
++<p>
++This is only a problem once issue <a href="lwg-defects.html#845">845</a> is applied.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++<blockquote><p>
++Move to open. Assign to Lawrence. Related to US 90 comment.
++</p></blockquote>
++
++<p><i>[
++2009-08-17 Handled by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add volatile qualification to the deleted copy-assignment operator of
++all the atomic types:
++</p>
++
++<blockquote><pre>
++atomic_bool&amp; operator=(atomic_bool const&amp;) <ins>volatile</ins> = delete;
++atomic_itype&amp; operator=(atomic_itype const&amp;) <ins>volatile</ins> = delete;
++</pre></blockquote>
++
++<p>
++etc.
++</p>
++<p>
++This will mean that the deleted copy-assignment operator will require
++<i>two</i> conversions in the above example, and thus be a worse match than
++the assignment from plain <tt>bool</tt>.
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="909"></a>909. <tt>regex_token_iterator</tt> should use <tt>initializer_list</tt></h3>
+-<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.12.2 [re.tokiter] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2008-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.tokiter">issues</a> in [re.tokiter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 319</b></p>
+@@ -52992,16 +56110,16 @@ range type:
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We strongly recommend alternative B of the proposed resolution
+ in order that existing code not be broken.
+ With that understanding, move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><b>Original proposed wording:</b></p>
+
+-<ol type="A">
+-<li><br>
++<ol style="list-style-type:upper-alpha">
++<li><br/>
+ <ol>
+ <li>
+ <p>
+@@ -53009,7 +56127,8 @@ In 28.12.2 [re.tokiter]/6 and the list 28.12.2.1 [re.tokiter.cnstr]/10-11 change
+ constructor declaration:
+ </p>
+
+-<blockquote><pre><del>template &lt;std::size_t N&gt;</del>
++<blockquote><pre>
++<del>template &lt;std::size_t N&gt;</del>
+ regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type&amp; re,
+ <del>const int (&amp;submatches)[N]</del> <ins>initializer_list&lt;int&gt; submatches</ins>,
+@@ -53023,17 +56142,17 @@ regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ In 28.12.2.1 [re.tokiter.cnstr]/12 change the last sentence
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The third constructor initializes the member <tt>subs</tt> to hold
+ a copy of the sequence of integer values pointed to by the
+ iterator range <tt>[<del>&amp;</del>submatches<ins>.begin()</ins>,
+ <del>&amp;</del>submatches<ins>.end()</ins> <del>+ N</del>)</tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+
+-<li><br>
++<li><br/>
+ <ol>
+ <li>
+ <p>
+@@ -53042,7 +56161,8 @@ following constructor declaration between the already existing ones
+ accepting a <tt>std::vector</tt> and a C array of <tt>int</tt>, resp.:
+ </p>
+
+-<blockquote><pre>regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++<blockquote><pre>
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type&amp; re,
+ initializer_list&lt;int&gt; submatches,
+ regex_constants::match_flag_type m =
+@@ -53054,12 +56174,12 @@ accepting a <tt>std::vector</tt> and a C array of <tt>int</tt>, resp.:
+ In 28.12.2.1 [re.tokiter.cnstr]/12 change the last sentence
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The third <ins>and fourth</ins> constructor initialize<del>s</del> the member <tt>subs</tt>
+ to hold a copy of the sequence of integer values pointed to
+ by the iterator range <tt>[&amp;submatches,&amp;submatches + N)</tt>
+ <ins>and <tt>[submatches.begin(),submatches.end())</tt>, respectively</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+@@ -53070,9 +56190,9 @@ by the iterator range <tt>[&amp;submatches,&amp;submatches + N)</tt>
+
+ <p><b>Proposed resolution:</b></p>
+
+-<ol type="A" start="2">
+-
+-<li><br>
++<ol style="list-style-type:upper-alpha">
++<li>[&hellip;]</li>
++<li><br/>
+ <ol>
+ <li>
+ <p>
+@@ -53081,7 +56201,8 @@ following constructor declaration between the already existing ones
+ accepting a <tt>std::vector</tt> and a C array of <tt>int</tt>, resp.:
+ </p>
+
+-<blockquote><pre>regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++<blockquote><pre>
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
+ const regex_type&amp; re,
+ initializer_list&lt;int&gt; submatches,
+ regex_constants::match_flag_type m =
+@@ -53093,12 +56214,12 @@ accepting a <tt>std::vector</tt> and a C array of <tt>int</tt>, resp.:
+ In 28.12.2.1 [re.tokiter.cnstr]/12 change the last sentence
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The third <ins>and fourth</ins> constructor initialize<del>s</del> the member <tt>subs</tt>
+ to hold a copy of the sequence of integer values pointed to
+ by the iterator range <tt>[&amp;submatches,&amp;submatches + N)</tt>
+ <ins>and <tt>[submatches.begin(),submatches.end())</tt>, respectively</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+ </li>
+@@ -53111,10 +56232,10 @@ by the iterator range <tt>[&amp;submatches,&amp;submatches + N)</tt>
+
+
+ <hr>
+-<h3><a name="911"></a>911. I/O streams and <tt>move/swap</tt> semantic</h3>
+-<p><b>Section:</b> 27.7.1 [input.streams], 27.7.2 [output.streams] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-09-29 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="911"></a>911. I&#47;O streams and <tt>move&#47;swap</tt> semantic</h3>
++<p><b>Section:</b> 27.7.2 [input.streams], 27.7.3 [output.streams] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2008-09-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Class template <tt>basic_istream</tt>, <tt>basic_ostream</tt> and <tt>basic_iostream</tt>
+@@ -53125,7 +56246,8 @@ and <tt>Swappable</tt>. However, those class templates fail to fulfill the user
+ expectations. For example:
+ </p>
+
+-<blockquote><pre>std::ostream os(std::ofstream("file.txt"));
++<blockquote><pre>
++std::ostream os(std::ofstream("file.txt"));
+ assert(os.rdbuf() == 0); // buffer object is not moved to os, file.txt has been closed
+
+ std::vector&lt;std::ostream&gt; v;
+@@ -53259,29 +56381,30 @@ I've implemented this proposal and am living with it day to day.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Leave Open. Pablo expected to propose alternative wording which would rename
+ move construction, move assignment and swap, and may or may not make them
+-protected. This will impact issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>.
+-</blockquote>
++protected. This will impact issue <a href="lwg-defects.html#900">900</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-27.7.1.1 [istream]: make the following member functions protected:
++27.7.2.1 [istream]: make the following member functions protected:
+ </p>
+
+-<blockquote><pre>basic_istream(basic_istream&amp;&amp; rhs);
++<blockquote><pre>
++basic_istream(basic_istream&amp;&amp; rhs);
+ basic_istream&amp; operator=(basic_istream&amp;&amp; rhs);
+ void swap(basic_istream&amp; rhs);
+ </pre></blockquote>
+@@ -53290,28 +56413,31 @@ void swap(basic_istream&amp; rhs);
+ Ditto: remove the swap free function signature
+ </p>
+
+-<blockquote><pre><del>// swap:
++<blockquote><pre>
++<del>// swap:
+ template &lt;class charT, class traits&gt;
+ void swap(basic_istream&lt;charT, traits&gt;&amp; x, basic_istream&lt;charT, traits&gt;&amp; y);</del>
+ </pre></blockquote>
+
+ <p>
+-27.7.1.1.2 [istream.assign]: remove paragraph 4
++27.7.2.1.2 [istream.assign]: remove paragraph 4
+ </p>
+
+-<blockquote><pre><del>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++<del>template &lt;class charT, class traits&gt;
+ void swap(basic_istream&lt;charT, traits&gt;&amp; x, basic_istream&lt;charT, traits&gt;&amp; y);</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Effects:</i> <tt>x.swap(y)</tt>.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-27.7.1.5 [iostreamclass]: make the following member function protected:
++27.7.2.5 [iostreamclass]: make the following member function protected:
+ </p>
+
+-<blockquote><pre>basic_iostream(basic_iostream&amp;&amp; rhs);
++<blockquote><pre>
++basic_iostream(basic_iostream&amp;&amp; rhs);
+ basic_iostream&amp; operator=(basic_iostream&amp;&amp; rhs);
+ void swap(basic_iostream&amp; rhs);
+ </pre></blockquote>
+@@ -53320,27 +56446,30 @@ void swap(basic_iostream&amp; rhs);
+ Ditto: remove the swap free function signature
+ </p>
+
+-<blockquote><pre><del>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++<del>template &lt;class charT, class traits&gt;
+ void swap(basic_iostream&lt;charT, traits&gt;&amp; x, basic_iostream&lt;charT, traits&gt;&amp; y);</del>
+ </pre></blockquote>
+
+ <p>
+-27.7.1.5.3 [iostream.assign]: remove paragraph 3
++27.7.2.5.3 [iostream.assign]: remove paragraph 3
+ </p>
+
+-<blockquote><pre><del>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++<del>template &lt;class charT, class traits&gt;
+ void swap(basic_iostream&lt;charT, traits&gt;&amp; x, basic_iostream&lt;charT, traits&gt;&amp; y);</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Effects:</i> <tt>x.swap(y)</tt>.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-27.7.2.1 [ostream]: make the following member function protected:
++27.7.3.1 [ostream]: make the following member function protected:
+ </p>
+
+-<blockquote><pre>basic_ostream(basic_ostream&amp;&amp; rhs);
++<blockquote><pre>
++basic_ostream(basic_ostream&amp;&amp; rhs);
+ basic_ostream&amp; operator=(basic_ostream&amp;&amp; rhs);
+ void swap(basic_ostream&amp; rhs);
+ </pre></blockquote>
+@@ -53349,21 +56478,23 @@ void swap(basic_ostream&amp; rhs);
+ Ditto: remove the swap free function signature
+ </p>
+
+-<blockquote><pre><del>// swap:
++<blockquote><pre>
++<del>// swap:
+ template &lt;class charT, class traits&gt;
+ void swap(basic_ostream&lt;charT, traits&gt;&amp; x, basic_ostream&lt;charT, traits&gt;&amp; y);</del>
+ </pre></blockquote>
+
+ <p>
+-27.7.2.3 [ostream.assign]: remove paragraph 4
++27.7.3.3 [ostream.assign]: remove paragraph 4
+ </p>
+
+-<blockquote><pre><del>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++<del>template &lt;class charT, class traits&gt;
+ void swap(basic_ostream&lt;charT, traits&gt;&amp; x, basic_ostream&lt;charT, traits&gt;&amp; y);</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del><i>Effects:</i> <tt>x.swap(y)</tt>.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -53373,14 +56504,14 @@ template &lt;class charT, class traits&gt;
+
+ <hr>
+ <h3><a name="920"></a>920. Ref-qualification support in the library</h3>
+-<p><b>Section:</b> 20.8.13 [func.memfn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Bronek Kozicki <b>Opened:</b> 2008-10-06 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.memfn">issues</a> in [func.memfn].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1230">1230</a></p>
++<p><b>Section:</b> 20.9.11 [func.memfn] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Bronek Kozicki <b>Opened:</b> 2008-10-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.memfn">issues</a> in [func.memfn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1230">1230</a></p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Daniel Krügler wrote:
++Daniel Kr&uuml;gler wrote:
+ </p>
+
+ <blockquote>
+@@ -53388,7 +56519,8 @@ Daniel Kr
+ Shouldn't above list be completed for &amp;- and &amp;&amp;-qualified
+ member functions This would cause to add:
+ </p>
+-<blockquote><pre>template&lt;Returnable R, class T, CopyConstructible... Args&gt;
++<blockquote><pre>
++template&lt;Returnable R, class T, CopyConstructible... Args&gt;
+ unspecified mem_fn(R (T::* pm)(Args...) &amp;);
+ template&lt;Returnable R, class T, CopyConstructible... Args&gt;
+ unspecified mem_fn(R (T::* pm)(Args...) const &amp;);
+@@ -53443,18 +56575,18 @@ Committee Draft has been issued.
+ ]</i></p>
+
+
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1230">1230</a> has a similar proposed resolution
+-</blockquote>
++<blockquote><p>
++<a href="lwg-closed.html#1230">1230</a> has a similar proposed resolution
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -53462,11 +56594,12 @@ Move to Ready.
+ <ol>
+ <li>
+ <p>
+-Change 20.8 [function.objects]/2, header
++Change 20.9 [function.objects]/2, header
+ <tt>&lt;functional&gt;</tt> synopsis as follows:
+ </p>
+
+-<blockquote><pre>// 20.7.14, member function adaptors:
++<blockquote><pre>
++// 20.7.14, member function adaptors:
+ template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::*);
+
+ <ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::*)(Args...));</ins>
+@@ -53488,14 +56621,15 @@ template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::*);
+
+ <li>
+ <p>
+-Change the prototype list of 20.8.13 [func.memfn] as follows [NB: The
++Change the prototype list of 20.9.11 [func.memfn] as follows [NB: The
+ following text, most notably p.2 and p.3 which
+ discuss influence of the cv-qualification on the definition of the
+ base class's first template parameter remains
+ unchanged. ]:
+ </p>
+
+-<blockquote><pre>template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm);
++<blockquote><pre>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm);
+
+ <ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...));</ins>
+ <ins>template&lt;class R, class T, class ...Args&gt; <i>unspecified</i> mem_fn(R (T::* pm)(Args...) const);</ins>
+@@ -53516,13 +56650,13 @@ unchanged. ]:
+
+ <li>
+ <p>
+-Remove 20.8.13 [func.memfn]/5:
++Remove 20.9.11 [func.memfn]/5:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del><i>Remarks:</i> Implementations may implement <tt>mem_fn</tt> as a set of
+ overloaded function templates.</del>
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -53533,10 +56667,10 @@ overloaded function templates.</del>
+
+ <hr>
+ <h3><a name="921"></a>921. Rational Arithmetic should use template aliases</h3>
+-<p><b>Section:</b> 20.6.1 [ratio.ratio] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2008-10-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.11.3 [ratio.ratio] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2008-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The compile-time functions that operate on <tt>ratio&lt;N,D&gt;</tt> require the
+@@ -53545,14 +56679,16 @@ meta-programming style that predates the invention of template aliases.
+ Thus, multiplying three ratios <tt>a</tt>, <tt>b</tt>, and <tt>c</tt> requires the expression:
+ </p>
+
+-<blockquote><pre>ratio_multiply&lt;a, ratio_multiply&lt;b, c&gt;::type&gt;::type
++<blockquote><pre>
++ratio_multiply&lt;a, ratio_multiply&lt;b, c&gt;::type&gt;::type
+ </pre></blockquote>
+
+ <p>
+ The simpler expression:
+ </p>
+
+-<blockquote><pre>ratio_multiply&lt;a, ratio_multiply&lt;b, c&gt;&gt;
++<blockquote><pre>
++ratio_multiply&lt;a, ratio_multiply&lt;b, c&gt;&gt;
+ </pre></blockquote>
+
+ <p>
+@@ -53585,12 +56721,12 @@ Recommend Open.
+ <p>
+ Personally I'm <em>not</em> in favor for the addition of:
+ </p>
+-<blockquote><pre>typedef ratio type;
++<blockquote><pre>
++typedef ratio type;
+ </pre></blockquote>
+ <p>
+-For a reader of the
+-standard it's usage or purpose is unclear. I haven't seen similar examples
+-of attempts to satisfy non-feature complete compilers.
++For a reader of the standard it's usage or purpose is unclear. I haven't
++seen similar examples of attempts to satisfy non-feature complete compilers.
+ </p>
+ </blockquote>
+
+@@ -53613,48 +56749,49 @@ reviewers to decide.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Bill asks for additional discussion in the issue
+ that spells out more details of the implementation.
+-Howard points us to issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#948">948</a>
++Howard points us to issue <a href="lwg-defects.html#948">948</a>
+ which has at least most of the requested details.
+ Tom is strongly in favor of overflow-checking at compile time.
+ Pete points out that there is no change of functionality implied.
+ We agree with the proposed resolution,
+ but recommend moving the issue to Review
+ to allow time to improve the discussion if needed.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-21 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1121">1121</a> for a potentially incompatible proposal.
+-</blockquote>
++<blockquote><p>
++See <a href="lwg-active.html#1121">1121</a> for a potentially incompatible proposal.
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+
+
+- <ol start="0">
++ <ol>
+ <li>
+ <p>
+-In 20.6 [ratio]/3 change as indicated:
++In 20.11 [ratio] p.3 change as indicated:
+ </p>
+
+-<blockquote><pre>// ratio arithmetic
++<blockquote><pre>
++// ratio arithmetic
+ template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_add<ins> = <em>see below</em></ins>;
+ template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_subtract<ins> = <em>see below</em></ins>;
+ template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_multiply<ins> = <em>see below</em></ins>;
+@@ -53663,9 +56800,10 @@ template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_divi
+ </li>
+ <li>
+ <p>
+-In 20.6.1 [ratio.ratio], change as indicated:
++In 20.11.3 [ratio.ratio], change as indicated:
+ </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;intmax_t N, intmax_t D = 1&gt;
+ class ratio {
+ public:
+@@ -53678,10 +56816,11 @@ In 20.6.1 [ratio.ratio], change as indicated:
+ </li>
+ <li>
+ <p>
+-In 20.6.2 [ratio.arithmetic] change as indicated:
++In 20.11.4 [ratio.arithmetic] change as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_add<ins> = <em>see below</em></ins><del>{
++<blockquote><pre>
++template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_add<ins> = <em>see below</em></ins><del>{
+ typedef <em>see below</em> type;
+ }</del>;
+ </pre>
+@@ -53695,7 +56834,8 @@ has the value <tt>R1::den * R2::den</tt>.
+ </p>
+ </blockquote>
+ </blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_subtract<ins> = <em>see below</em></ins><del>{
++<blockquote><pre>
++template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_subtract<ins> = <em>see below</em></ins><del>{
+ typedef <em>see below</em> type;
+ }</del>;
+ </pre>
+@@ -53708,7 +56848,8 @@ has the value <tt>R1::den * R2::den</tt>.
+ </p>
+ </blockquote>
+ </blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_multiply<ins> = <em>see below</em></ins><del>{
++<blockquote><pre>
++template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_multiply<ins> = <em>see below</em></ins><del>{
+ typedef <em>see below</em> type;
+ }</del>;
+ </pre>
+@@ -53720,7 +56861,8 @@ where <tt>T1</tt> has the value <tt>R1::num * R2::num</tt> and <tt>T2</tt> has t
+ </p>
+ </blockquote>
+ </blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_divide<ins> = <em>see below</em></ins><del>{
++<blockquote><pre>
++template &lt;class R1, class R2&gt; <del>struct</del><ins>using</ins> ratio_divide<ins> = <em>see below</em></ins><del>{
+ typedef <em>see below</em> type;
+ }</del>;
+ </pre>
+@@ -53735,7 +56877,7 @@ where <tt>T1</tt> has the value <tt>R1::num * R2::den</tt> and <tt>T2</tt> has t
+ </li>
+ <li>
+ <p>
+-In 20.11.3.1 [time.duration.cons]/4 change as indicated:
++In 20.12.5.1 [time.duration.cons] p.4 change as indicated:
+ </p>
+ <blockquote>
+ <p>
+@@ -53746,7 +56888,7 @@ In 20.11.3.1 [time.duration.cons]/4 change as indicated:
+ </li>
+ <li>
+ <p>
+-In 20.11.3.7 [time.duration.cast]/2 change as indicated:
++In 20.12.5.7 [time.duration.cast] p.2 change as indicated:
+ </p>
+ <blockquote>
+ <p>
+@@ -53763,14 +56905,14 @@ ToDuration::period&gt;<del>::type</del></tt>, and [..]
+
+ <hr>
+ <h3><a name="922"></a>922. [func.bind.place] Number of placeholders</h3>
+-<p><b>Section:</b> B [implimits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Sohail Somani <b>Opened:</b> 2008-10-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> B [implimits] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Sohail Somani <b>Opened:</b> 2008-10-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE 24</b></p>
+
+ <p>
+-With respect to the section 20.8.10.1.3 [func.bind.place]:
++With respect to the section 20.9.10.4 [func.bind.place]:
+ </p>
+ <p>
+ TR1 dropped some suggested implementation quantities for the number of
+@@ -53791,17 +56933,17 @@ Recommend applying the proposed resolution from DE 24, with that
+ Tentatively Ready.
+ </p>
+ </blockquote>
+-
++<p>
+ <b>Original proposed resolution:</b>
+-
++</p>
+ <p>
+-Add 20.8.10.1.3 [func.bind.place]/2:
++Add 20.9.10.4 [func.bind.place] p.2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ While the exact number of placeholders (<tt>_M</tt>) is implementation defined,
+ this number shall be at least 10.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -53813,7 +56955,7 @@ Add to B [implimits]:
+
+ <ul>
+ <li>
+-Number of placeholders (20.8.10.1.3 [func.bind.place]) [10].
++Number of placeholders (20.9.10.4 [func.bind.place]) [10].
+ </li>
+ </ul>
+
+@@ -53823,23 +56965,226 @@ Number of placeholders (20.8.10.1.3 [func.bind.place]) [10].
+
+
+ <hr>
++<h3><a name="923"></a>923. atomics with floating-point </h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Right now, C++0x doesn't have <tt>atomic&lt;float&gt;</tt>. We're thinking of adding
++the words to support it for TR2 (note: that would be slightly post-C++0x). If we
++need it, we could probably add the words.
++</p>
++<p>
++<b>Proposed resolutions:</b> Using <tt>atomic&lt;FP&gt;::compare_exchange</tt> (weak or
++strong) should be either:
++</p>
++
++<ol>
++<li>
++ill-formed, or
++</li>
++<li>
++well-defined.
++</li>
++</ol>
++
++<p>
++I propose Option 1 for C++0x for expediency. If someone wants to argue
++for Option 2, they need to say what exactly they want <tt>compare_exchange</tt>
++to mean in this case (IIRC, C++0x doesn't even assume IEEE 754).
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open. Blocked until concepts for atomics are addressed.
++</p></blockquote>
++
++<p><i>[
++Post Summit Anthony adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++Recommend NAD. C++0x does have <tt>std::atomic&lt;float&gt;</tt>, and both
++<tt>compare_exchange_weak</tt> and <tt>compare_exchange_strong</tt> are well-defined in
++this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to:
++</p>
++
++<blockquote>
++<p>
++[<i>Note:</i> The effect of the compare-and-exchange operations is
++</p>
++<blockquote><pre>
++if (!memcmp(object,expected,sizeof(*object)))
++ *object = desired;
++else
++ *expected = *object;
++</pre></blockquote>
++
++<p>
++This may result in failed comparisons for values that compare equal if
++the underlying type has padding bits or alternate representations of
++the same value. <i>-- end note</i>]
++</p>
++</blockquote>
++
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the note in 29.6 [atomics.types.operations] paragraph 20 to:
++</p>
++
++<blockquote>
++<p>
++[<i>Note:</i> The effect of the compare-and-exchange operations is
++</p>
++<blockquote><pre>
++if (<del>*object == *expected</del> <ins>!memcmp(object,expected,sizeof(*object))</ins>)
++ *object = desired;
++else
++ *expected = *object;
++</pre></blockquote>
++
++<p><ins>
++This may result in failed comparisons for values that compare equal if
++the underlying type has padding bits or alternate representations of
++the same value.</ins> <i>-- end note</i>]
++</p>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="924"></a>924. structs with internal padding</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2008-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Right now, the <tt>compare_exchange_weak</tt> loop should rapidly converge on the
++padding contents. But <tt>compare_exchange_strong</tt> will require a bit more
++compiler work to ignore padding for comparison purposes.
++</p>
++<p>
++Note that this isn't a problem for structs with no padding, and we do
++already have one portable way to ensure that there is no padding that
++covers the key use cases: Have elements be the same type. I suspect that
++the greatest need is for a structure of two pointers, which has no
++padding problem. I suspect the second need is a structure of a pointer
++and some form of an integer. If that integer is <tt>intptr_t</tt>, there will be
++no padding.
++</p>
++<p>
++Related but separable issue: For unused bitfields, or other unused
++fields for that matter, we should probably say it's the programmer's
++responsibility to set them to zero or otherwise ensure they'll be
++ignored by <tt>memcmp</tt>.
++</p>
++
++<p>
++<b>Proposed resolution:</b> Using
++<tt>atomic&lt;struct-with-padding&gt;::compare_exchange_strong</tt> should be either:
++</p>
++
++<ol>
++<li>
++ill-formed, or
++</li>
++<li>
++well-defined.
++</li>
++</ol>
++
++<p>
++I propose Option 1 for C++0x for expediency, though I'm not sure how to
++say it. I would be happy with Option 2, which I believe would mean that
++<tt>compare_exchange_strong</tt> would be implemented to avoid comparing padding
++bytes, or something equivalent such as always zeroing out padding when
++loading/storing/comparing. (Either implementation might require compiler
++support.)
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open. Blocked until concepts for atomics are addressed.
++</p></blockquote>
++
++<p><i>[
++Post Summit Anthony adds:
++]</i></p>
++
++
++<blockquote><p>
++The resolution of LWG <a href="lwg-defects.html#923">923</a> should resolve this issue as well.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="925"></a>925. <tt>shared_ptr</tt>'s explicit conversion from <tt>unique_ptr</tt></h3>
+-<p><b>Section:</b> 20.9.10.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Rodolfo Lima <b>Opened:</b> 2008-10-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Rodolfo Lima <b>Opened:</b> 2008-10-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current working draft
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>),
+-section 20.9.10.2.1 [util.smartptr.shared.const] declares
++section 20.8.2.2.1 [util.smartptr.shared.const] declares
+ <tt>shared_ptr</tt>'s constructor that takes a rvalue reference to <tt>unique_ptr</tt> and
+ <tt>auto_ptr</tt> as being explicit, affecting several valid smart pointer use
+ cases that would take advantage of this conversion being implicit, for
+ example:
+ </p>
+
+-<blockquote><pre>class A;
++<blockquote><pre>
++class A;
+ std::unique_ptr&lt;A&gt; create();
+ void process(std::shared_ptr&lt;A&gt; obj);
+
+@@ -53857,7 +57202,8 @@ If <tt>unique_ptr</tt> to <tt>shared_ptr</tt> conversions are explicit, the abov
+ should be written:
+ </p>
+
+-<blockquote><pre>process(std::shared_ptr&lt;A&gt;(create())); // use case #1
++<blockquote><pre>
++process(std::shared_ptr&lt;A&gt;(create())); // use case #1
+ process(std::shared_ptr&lt;A&gt;(std::move(uobj))); // use case #2
+ </pre></blockquote>
+
+@@ -53893,11 +57239,12 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In both 20.9.10.2 [util.smartptr.shared] paragraph 1 and
+-20.9.10.2.1 [util.smartptr.shared.const] change:
++In both 20.8.2.2 [util.smartptr.shared] paragraph 1 and
++20.8.2.2.1 [util.smartptr.shared.const] change:
+ </p>
+
+-<blockquote><pre>template &lt;class Y&gt; <del>explicit</del> shared_ptr(auto_ptr&lt;Y&gt; &amp;&amp;r);
++<blockquote><pre>
++template &lt;class Y&gt; <del>explicit</del> shared_ptr(auto_ptr&lt;Y&gt; &amp;&amp;r);
+ template &lt;class Y, class D&gt; <del>explicit</del> shared_ptr(unique_ptr&lt;Y, D&gt; &amp;&amp;r);
+ </pre></blockquote>
+
+@@ -53908,10 +57255,10 @@ template &lt;class Y, class D&gt; <del>explicit</del> shared_ptr(unique_ptr&lt;Y
+
+ <hr>
+ <h3><a name="929"></a>929. Thread constructor</h3>
+-<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-10-23 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2008-10-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 323</b></p>
+@@ -53932,7 +57279,8 @@ parameters. In particular it prevents the passing of string literals.
+ Consequently a simple case such as
+ </p>
+
+-<blockquote><pre>void f(const char*);
++<blockquote><pre>
++void f(const char*);
+ std::thread t(f,"hello");
+ </pre></blockquote>
+
+@@ -53954,7 +57302,8 @@ The new signature of the <tt>thread</tt> constructor for a function and
+ arguments is thus:
+ </p>
+
+-<blockquote><pre>template&lt;typename F,typename... Args&gt;
++<blockquote><pre>
++template&lt;typename F,typename... Args&gt;
+ thread(F,Args... args);
+ </pre></blockquote>
+
+@@ -53977,21 +57326,22 @@ removes a <tt>move</tt> when passing in an lvalue.
+ </p>
+
+ <p>
+-This circumstance is very analogous to <tt>make_pair</tt> (20.3.5 [pairs])
++This circumstance is very analogous to <tt>make_pair</tt> (20.3 [pairs])
+ where we started with passing by const reference, changed to pass by value to
+ get pointer decay, and then changed to pass by rvalue reference, but modified with
+ <tt>decay&lt;T&gt;</tt> to retain the pass-by-value behavior. If we were to
+ apply the same solution here it would look like:
+ </p>
+
+-<blockquote><pre><del>template &lt;class F&gt; explicit thread(F f);</del>
++<blockquote><pre>
++<del>template &lt;class F&gt; explicit thread(F f);</del>
+ template &lt;class F, class ...Args&gt; thread(F&amp;&amp; f, Args&amp;&amp;... args);
+ </pre>
+ <blockquote>
+ <p>
+ -4- <i>Requires:</i> <tt>F</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall be <del><tt>CopyConstructible</tt>
+ if an lvalue and otherwise</del> <tt>MoveConstructible</tt>.
+-<tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.8.2 [func.require]) shall be a valid expression for
++<tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.9.2 [func.require]) shall be a valid expression for
+ some values <tt>w1, w2, ... , wN,</tt> where <tt>N == sizeof...(Args)</tt>.
+ </p>
+ <p>
+@@ -54002,7 +57352,8 @@ thread of execution, where <tt>t1, t2, ..., tN</tt> are the values in <tt>args..
+ the following objects in memory which is accessible to a new thread of execution
+ as if:</ins>
+ </p>
+-<blockquote><pre><ins>typename decay&lt;F&gt;::type g(std::forward&lt;F&gt;(f));</ins>
++<blockquote><pre>
++<ins>typename decay&lt;F&gt;::type g(std::forward&lt;F&gt;(f));</ins>
+ <ins>tuple&lt;typename decay&lt;Args&gt;::type...&gt; w(std::forward&lt;Args&gt;(args)...);</ins>
+ </pre></blockquote>
+ <p>
+@@ -54030,11 +57381,11 @@ Text referring to when <tt>terminate()</tt> is called was contributed by Ganesh.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution,
+ but would like the final sentence to be reworded
+ since "catchable" is not a term of art (and is used nowhere else).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -54047,7 +57398,7 @@ This is linked to
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2901.pdf">N2901</a>.
+ </p>
+ <p>
+-Howard to open a separate issue to remove (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>).
++Howard to open a separate issue to remove (<a href="lwg-closed.html#1176">1176</a>).
+ </p>
+ <p>
+ In Frankfurt there is no consensus for removing the variadic constructor.
+@@ -54059,10 +57410,10 @@ In Frankfurt there is no consensus for removing the variadic constructor.
+ ]</i></p>
+
+
+-<blockquote>
+-We want to move forward with this issue. If we later take it out via <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1176">1176</a>
++<blockquote><p>
++We want to move forward with this issue. If we later take it out via <a href="lwg-closed.html#1176">1176</a>
+ then that's ok too. Needs small group to improve wording.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+@@ -54079,7 +57430,8 @@ Modify the class definition of <tt>std::thread</tt> in 30.3.1 [thread.thread.cla
+ following signature:
+ </p>
+
+-<blockquote><pre><del>template&lt;class F&gt; explicit thread(F f);</del>
++<blockquote><pre>
++<del>template&lt;class F&gt; explicit thread(F f);</del>
+ template&lt;class F, class ... Args&gt; <ins>explicit</ins> thread(F&amp;&amp; f, Args&amp;&amp; ... args);
+ </pre></blockquote>
+
+@@ -54093,7 +57445,7 @@ following:
+ <p>
+ -4- <i>Requires:</i> <tt>F</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall be <del><tt>CopyConstructible</tt>
+ if an lvalue and otherwise</del> <tt>MoveConstructible</tt>.
+-<tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.8.2 [func.require]) shall be a valid expression for
++<tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.9.2 [func.require]) shall be a valid expression for
+ some values <tt>w1, w2, ... , wN,</tt> where <tt>N == sizeof...(Args)</tt>.
+ </p>
+ <p>
+@@ -54103,7 +57455,8 @@ thread of execution, where <tt>t1, t2, ..., tN</tt> are the values in <tt>args..
+ <ins>Constructs
+ the following objects:</ins>
+ </p>
+-<blockquote><pre><ins>typename decay&lt;F&gt;::type g(std::forward&lt;F&gt;(f));</ins>
++<blockquote><pre>
++<ins>typename decay&lt;F&gt;::type g(std::forward&lt;F&gt;(f));</ins>
+ <ins>tuple&lt;typename decay&lt;Args&gt;::type...&gt; w(std::forward&lt;Args&gt;(args)...);</ins>
+ </pre></blockquote>
+ <p>
+@@ -54138,7 +57491,8 @@ Modify the class definition of <tt>std::thread</tt> in 30.3.1 [thread.thread.cla
+ following signature:
+ </p>
+
+-<blockquote><pre><del>template&lt;class F&gt; explicit thread(F f);</del>
++<blockquote><pre>
++<del>template&lt;class F&gt; explicit thread(F f);</del>
+ template&lt;class F, class ... Args&gt; <ins>explicit</ins> thread(F&amp;&amp; f, Args&amp;&amp; ... args);
+ </pre></blockquote>
+
+@@ -54162,10 +57516,10 @@ template&lt;typename T&gt; typename decay&lt;T&gt;::type decay_copy(T&amp;&amp;
+ -4- <i>Requires:</i> <tt>F</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall
+ <del>be <tt>CopyConstructible</tt> if an lvalue and otherwise</del> <ins>satisfy
+ the</ins> <tt>MoveConstructible</tt> <ins>requirements</ins>.
+-<del><tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.8.2 [func.require])
++<del><tt><i>INVOKE</i>(f, w1, w2, ..., wN)</tt> (20.9.2 [func.require])
+ shall be a valid expression for some values <tt>w1, w2, ... , wN,</tt> where
+ <tt>N == sizeof...(Args)</tt>.</del>
+-<ins><tt><i>INVOKE</i>(decay_copy(std::forward&lt;F&gt;(f)), decay_copy(std::forward&lt;Args&gt;(args))...)</tt> (20.8.2 [func.require]) shall be a valid expression.</ins>
++<ins><tt><i>INVOKE</i>(decay_copy(std::forward&lt;F&gt;(f)), decay_copy(std::forward&lt;Args&gt;(args))...)</tt> (20.9.2 [func.require]) shall be a valid expression.</ins>
+ </p>
+
+ <p>
+@@ -54180,7 +57534,7 @@ decay_copy(std::forward&lt;Args&gt;(args))...)</tt> with the calls to <tt>decay_
+ the constructing thread. Any return value from this invocation is
+ ignored. [<i>Note:</i> this implies any exceptions not thrown from the
+ invocation of the copy of <tt>f</tt> will be thrown in the constructing thread,
+-not the new thread. — <i>end note</i>].
++not the new thread. &mdash; <i>end note</i>].
+ If the invocation of <tt><i>INVOKE</i>(decay_copy(std::forward&lt;F&gt;(f)),
+ decay_copy(std::forward&lt;Args&gt;(args))...)</tt> terminates with an uncaught
+ exception, <tt>std::terminate</tt> shall be called.
+@@ -54199,18 +57553,19 @@ invocation of <ins>the copy of</ins> <tt>f</tt>.
+
+ <hr>
+ <h3><a name="931"></a>931. type trait <tt>extent&lt;T, I&gt;</tt></h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Yechezkel Mett <b>Opened:</b> 2008-11-04 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Yechezkel Mett <b>Opened:</b> 2008-11-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The draft (N2798) says in 20.7.4.3 [meta.unary.prop] Table 44:
++The draft (N2798) says in 20.10.4.3 [meta.unary.prop] Table 44:
+ </p>
+ <blockquote>
+ <table border="1">
+ <caption>Table 44 -- Type property queries</caption>
+-<tbody><tr><th>Template</th><th>Value</th></tr>
++<tr><th>Template</th><th>Value</th></tr>
+ <tr>
+ <td>
+ <tt>template &lt;class T, unsigned I = 0&gt; struct extent;</tt>
+@@ -54222,7 +57577,7 @@ and <tt>T</tt> has type "array of unknown bound of <tt>U</tt>", then 0; otherwis
+ size of the <tt>I</tt>'th dimension of <tt>T</tt>
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -54260,14 +57615,14 @@ Recommend Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In Table 44 of 20.7.4.3 [meta.unary.prop], third row, column "Value",
++In Table 44 of 20.10.4.3 [meta.unary.prop], third row, column "Value",
+ change the cell content:
+ </p>
+
+ <blockquote>
+ <table border="1">
+ <caption>Table 44 -- Type property queries</caption>
+-<tbody><tr><th>Template</th><th>Value</th></tr>
++<tr><th>Template</th><th>Value</th></tr>
+ <tr>
+ <td>
+ <tt>template &lt;class T, unsigned I = 0&gt; struct extent;</tt>
+@@ -54280,7 +57635,7 @@ and <tt>T</tt> has type "array of unknown bound of <tt>U</tt>", then 0; otherwis
+ where indexing of <tt>I</tt> is zero-based.</ins>
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p><i>[
+@@ -54295,26 +57650,27 @@ Wording supplied by Daniel.
+
+ <hr>
+ <h3><a name="932"></a>932. <tt>unique_ptr(pointer p)</tt> for pointer deleter types</h3>
+-<p><b>Section:</b> 20.9.9.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-11-26 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.8.1.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-11-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses US 79</b></p>
+
+ <p>
+-20.9.9.2.1 [unique.ptr.single.ctor]/5 no longer requires for <tt>D</tt>
++20.8.1.2.1 [unique.ptr.single.ctor]/5 no longer requires for <tt>D</tt>
+ not to be a pointer type. I believe this restriction was accidently removed
+ when we relaxed the completeness reuqirements on <tt>T</tt>. The restriction
+ needs to be put back in. Otherwise we have a run time failure that could
+ have been caught at compile time:
+ </p>
+
+-<blockquote><pre>{
+-unique_ptr&lt;int, void(*)(void*)&gt; p1(malloc(sizeof(int))); <font color="#C80000">// should not compile</font>
+-} <font color="#C80000">// p1.~unique_ptr() dereferences a null function pointer</font>
+-unique_ptr&lt;int, void(*)(void*)&gt; p2(malloc(sizeof(int)), free); <font color="#C80000">// ok</font>
++<blockquote><pre>
++{
++unique_ptr&lt;int, void(*)(void*)&gt; p1(malloc(sizeof(int))); <span style="color:#C80000">// should not compile</span>
++} <span style="color:#C80000">// p1.~unique_ptr() dereferences a null function pointer</span>
++unique_ptr&lt;int, void(*)(void*)&gt; p2(malloc(sizeof(int)), free); <span style="color:#C80000">// ok</span>
+ </pre></blockquote>
+
+ <p><i>[
+@@ -54322,20 +57678,20 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+-improved for enable_if type constraining, possibly following Robert's
++improved for <tt>enable_if</tt> type constraining, possibly following Robert's
+ formula.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -54364,7 +57720,8 @@ The two constructors to which this issue applies are not easily constrained
+ with <tt>enable_if</tt> as they are not templated:
+ </p>
+
+-<blockquote><pre>unique_ptr();
++<blockquote><pre>
++unique_ptr();
+ explicit unique_ptr(pointer p);
+ </pre></blockquote>
+
+@@ -54375,7 +57732,8 @@ is insufficient motivation for such heroics. Here is the expected and
+ reasonable implementation for these constructors:
+ </p>
+
+-<blockquote><pre>unique_ptr()
++<blockquote><pre>
++unique_ptr()
+ : ptr_(pointer())
+ {
+ static_assert(!is_pointer&lt;deleter_type&gt;::value,
+@@ -54412,16 +57770,16 @@ the implementation from the Requires paragraph to a Remarks paragraph.
+ <p>
+ It is insufficient to require a diagnostic. This doesn't imply an
+ ill-formed program
+-as of 1.3.6 [defns.diagnostic] (a typical alternative would be a compiler
++as of 1.3 [defns.diagnostic] (a typical alternative would be a compiler
+ warning), but
+ exactly that seems to be the intend. I suggest to use the following
+ remark instead:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Remarks:</i> The program shall be ill-formed if this constructor is
+ instantiated when <tt>D</tt> is a pointer type or reference type.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Via the general standard rules of 1.4 [intro.compliance] the "diagnostic
+@@ -54435,21 +57793,21 @@ required" is implied.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-14 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We moved
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">N3073</a>
+ to the formal motions page in Pittsburgh which should obsolete this issue. I've
+ moved this issue to NAD Editorial, solved by N3073.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -54461,10 +57819,11 @@ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the description of the default constructor in 20.9.9.2.1 [unique.ptr.single.ctor]:
++Change the description of the default constructor in 20.8.1.2.1 [unique.ptr.single.ctor]:
+ </p>
+
+-<blockquote><pre>unique_ptr();
++<blockquote><pre>
++unique_ptr();
+ </pre>
+ <blockquote>
+ <p>
+@@ -54476,23 +57835,22 @@ not be a reference type or pointer type (diagnostic required).</del>
+ <p><ins>
+ <i>Remarks:</i> The program shall be ill-formed if this constructor is
+ instantiated when <tt>D</tt> is a pointer type or reference type.
+-
+ </ins></p>
+ </blockquote>
+ </blockquote>
+
+ <p>
+-Add after 20.9.9.2.1 [unique.ptr.single.ctor]/8:
++Add after 20.8.1.2.1 [unique.ptr.single.ctor]/8:
+ </p>
+
+-<blockquote><pre>unique_ptr(pointer p);
++<blockquote><pre>
++unique_ptr(pointer p);
+ </pre>
+ <blockquote>
+ <p>...</p>
+ <p><ins>
+ <i>Remarks:</i> The program shall be ill-formed if this constructor is
+ instantiated when <tt>D</tt> is a pointer type or reference type.
+-
+ </ins></p>
+ </blockquote>
+ </blockquote>
+@@ -54503,10 +57861,10 @@ instantiated when <tt>D</tt> is a pointer type or reference type.
+
+ <hr>
+ <h3><a name="934"></a>934. <tt>duration</tt> is missing <tt>operator%</tt></h3>
+-<p><b>Section:</b> 20.11.3 [time.duration] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Terry Golubiewski <b>Opened:</b> 2008-11-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration">issues</a> in [time.duration].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.5 [time.duration] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Terry Golubiewski <b>Opened:</b> 2008-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration">issues</a> in [time.duration].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses US 81</b></p>
+@@ -54518,7 +57876,8 @@ motivating example is converting a <tt>duration</tt> into a "broken-down"
+ time duration such as hours::minutes::seconds:
+ </p>
+
+-<blockquote><pre>class ClockTime
++<blockquote><pre>
++class ClockTime
+ {
+ typedef std::chrono::hours hours;
+ typedef std::chrono::minutes minutes;
+@@ -54542,30 +57901,30 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree except that there is a typo in the proposed resolution. The member
+-operators should be operator%=.
+-</blockquote>
++operators should be <tt>operator%=</tt>.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+ improved for enable_if type constraining, possibly following Robert's
+ formula.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+@@ -54574,9 +57933,9 @@ formula.
+
+ <blockquote>
+ <p>
+-Howard to open a separate issue (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>) to handle the removal of member
++Howard to open a separate issue (<a href="lwg-defects.html#1177">1177</a>) to handle the removal of member
+ functions from overload sets, provide wording, and possibly demonstrate
+-how this can be implemented using enable_if (see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a>).
++how this can be implemented using enable_if (see <a href="lwg-defects.html#947">947</a>).
+ </p>
+ <p>
+ Move to Ready.
+@@ -54587,10 +57946,11 @@ Move to Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to the synopsis in 20.11 [time]:
++Add to the synopsis in 20.12 [time]:
+ </p>
+
+-<blockquote><pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
+@@ -54599,10 +57959,11 @@ template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
+ </pre></blockquote>
+
+ <p>
+-Add to the synopsis of <tt>duration</tt> in 20.11.3 [time.duration]:
++Add to the synopsis of <tt>duration</tt> in 20.12.5 [time.duration]:
+ </p>
+
+-<blockquote><pre>template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
++<blockquote><pre>
++template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
+ class duration {
+ public:
+ ...
+@@ -54613,11 +57974,12 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Add to 20.11.3.3 [time.duration.arithmetic]:
++Add to 20.12.5.3 [time.duration.arithmetic]:
+ </p>
+
+ <blockquote>
+-<pre>duration&amp; operator%=(const rep&amp; rhs);
++<pre>
++duration&amp; operator%=(const rep&amp; rhs);
+ </pre>
+ <blockquote>
+ <p>
+@@ -54628,7 +57990,8 @@ Add to 20.11.3.3 [time.duration.arithmetic]:
+ </p>
+ </blockquote>
+
+-<pre>duration&amp; operator%=(const duration&amp; d);
++<pre>
++duration&amp; operator%=(const duration&amp; d);
+ </pre>
+ <blockquote>
+ <p>
+@@ -54641,12 +58004,13 @@ Add to 20.11.3.3 [time.duration.arithmetic]:
+ </blockquote>
+
+ <p>
+-Add to 20.11.3.5 [time.duration.nonmember]:
++Add to 20.12.5.5 [time.duration.nonmember]:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+@@ -54660,7 +58024,8 @@ Add to 20.11.3.5 [time.duration.nonmember]:
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
++<pre>
++template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
+ typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
+ operator%(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
+ </pre>
+@@ -54679,17 +58044,18 @@ Add to 20.11.3.5 [time.duration.nonmember]:
+
+ <hr>
+ <h3><a name="938"></a>938. <tt>default_delete&lt;T[]&gt;::operator()</tt> should only accept <tt>T*</tt></h3>
+-<p><b>Section:</b> 20.9.9.1.3 [unique.ptr.dltr.dflt1] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-12-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.1.1.3 [unique.ptr.dltr.dflt1] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Consider:
+ </p>
+
+-<blockquote><pre>derived* p = new derived[3];
++<blockquote><pre>
++derived* p = new derived[3];
+ std::default_delete&lt;base[]&gt; d;
+-d(p); <font color="#C80000">// should fail</font>
++d(p); <span style="color:#C80000">// should fail</span>
+ </pre></blockquote>
+
+ <p>
+@@ -54702,26 +58068,27 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 20.9.9.1.3 [unique.ptr.dltr.dflt1]:
++Add to 20.8.1.1.3 [unique.ptr.dltr.dflt1]:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class T&gt; struct default_delete&lt;T[]&gt; {
+ void operator()(T*) const;
+ <ins>template &lt;class U&gt; void operator()(U*) const = delete;</ins>
+@@ -54735,10 +58102,10 @@ Add to 20.9.9.1.3 [unique.ptr.dltr.dflt1]:
+
+ <hr>
+ <h3><a name="939"></a>939. Problem with <tt>std::identity</tt> and reference-to-temporaries</h3>
+-<p><b>Section:</b> 20.3.3 [forward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-12-11 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward">issues</a> in [forward].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.2.4 [forward] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2008-12-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward">issues</a> in [forward].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>std::identity</tt> takes an argument of type <tt>T const &amp;</tt>
+@@ -54761,7 +58128,8 @@ types
+ <p>
+ ii/ Provide an additional overload:
+ </p>
+-<blockquote><pre>template&lt; typename T &gt;
++<blockquote><pre>
++template&lt; typename T &gt;
+ template operator( U &amp; ) = delete;
+ </pre></blockquote>
+ <p>
+@@ -54838,7 +58206,8 @@ my latest reformulation of <tt>forward</tt>, which is due to comments suggested
+ at Summit, no longer uses <tt>identity</tt>. :-)
+ </p>
+
+-<blockquote><pre>template &lt;class T, class U,
++<blockquote><pre>
++template &lt;class T, class U,
+ class = typename enable_if
+ &lt;
+ !is_lvalue_reference&lt;T&gt;::value ||
+@@ -54860,7 +58229,7 @@ forward(U&amp;&amp; t)
+ </pre>
+
+ <p><i>[
+-The above code assumes acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1120">1120</a> for the definition of
++The above code assumes acceptance of <a href="lwg-active.html#1120">1120</a> for the definition of
+ <tt>remove_all</tt>. This is just to make the syntax a little more palatable.
+ Without this trait the above is still very implementable.
+ ]</i></p>
+@@ -54874,7 +58243,7 @@ Paper with rationale is on the way ... <i>really</i>, I promise this time! ;-)
+ </blockquote>
+
+ <p><i>[
+-2009-07-30 Daniel adds: See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#823">823</a> for an alternative resolution.
++2009-07-30 Daniel adds: See <a href="lwg-defects.html#823">823</a> for an alternative resolution.
+ ]</i></p>
+
+
+@@ -54883,26 +58252,28 @@ Paper with rationale is on the way ... <i>really</i>, I promise this time! ;-)
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready. Howard will update proposed wording to reflect current draft.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Strike from 20.3 [utility]:
++Strike from 20.2 [utility]:
+ </p>
+
+-<blockquote><pre><del>template &lt;class T&gt; struct identity;</del>
++<blockquote><pre>
++<del>template &lt;class T&gt; struct identity;</del>
+ </pre></blockquote>
+
+ <p>
+-Remove from 20.3.3 [forward]:
++Remove from 20.2.4 [forward]:
+ </p>
+
+ <blockquote>
+-<pre><del>template &lt;class T&gt; struct identity {
++<pre>
++<del>template &lt;class T&gt; struct identity {
+ typedef T type;
+
+ const T&amp; operator()(const T&amp; x) const;
+@@ -54910,10 +58281,248 @@ Remove from 20.3.3 [forward]:
+
+ <del>const T&amp; operator()(const T&amp; x) const;</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del>-2- <i>Returns:</i> <tt>x</tt></del>
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="940"></a>940. <tt>std::distance</tt></h3>
++<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Thomas <b>Opened:</b> 2008-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 270</b></p>
++
++<p>
++Regarding the <tt>std::distance</tt> - function, 24.4.4 [iterator.operations]
++p.4 says:
++</p>
++<blockquote><p>
++Returns the number of increments or decrements needed to get from first to last.
++</p></blockquote>
++<p>
++This sentence is completely silent about the sign of the return value.
++24.4.4 [iterator.operations] p.1 gives more information about the
++underlying operations, but again no inferences about the sign can be made.
++Strictly speaking, that is taking that sentence literally, I think this
++sentence even implies a positive return value in all cases, as the
++number of increments or decrements is clearly a ratio scale variable,
++with a natural zero bound.
++</p>
++<p>
++Practically speaking, my implementations did what common sense and
++knowledge based on pointer arithmetic forecasts, namely a positive sign
++for increments (that is, going from <tt>first</tt> to <tt>last</tt> by <tt>operator++</tt>), and a
++negative sign for decrements (going from <tt>first</tt> to <tt>last</tt> by <tt>operator--</tt>).
++</p>
++<p>
++Here are my two questions:
++</p>
++<p>
++First, is that paragraph supposed to be interpreted in the way what I
++called 'common sense', that is negative sign for decrements ? I am
++fairly sure that's the supposed behavior, but a double-check here in
++this group can't hurt.
++</p>
++<p>
++Second, is the present wording (2003 standard version - no idea about
++the draft for the upcoming standard) worth an edit to make it a bit more
++sensible, to mention the sign of the return value explicitly ?
++</p>
++
++<p><i>[
++Daniel adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++My first thought was that resolution <a href="lwg-closed.html#204">204</a> would already cover the
++issue report, but it seems that current normative wording is in
++contradiction to that resolution:
++</p>
++
++<p>
++Referring to
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>,
++24.4.4 [iterator.operations]/ p.4 says:
++</p>
++
++<blockquote><p>
++<i>Effects:</i> Returns the number of increments or decrements needed to get
++from <tt>first</tt> to <tt>last</tt>.
++</p></blockquote>
++
++<p>
++IMO the part " or decrements" is in contradiction to p. 5 which says
++</p>
++
++<blockquote><p>
++<i>Requires:</i> <tt>last</tt> shall be reachable from <tt>first</tt>.
++</p></blockquote>
++
++<p>
++because "reachable" is defined in X [iterator.concepts]/7 as
++</p>
++
++<blockquote><p>
++An iterator <tt>j</tt> is called reachable from an iterator <tt>i</tt> if and only if
++there is a finite sequence of applications of the expression <tt>++i</tt> that makes
++<tt>i == j</tt>.[..]
++</p></blockquote>
++
++<p>
++Here is wording that would be consistent with this definition of "reachable":
++</p>
++
++<p>
++Change 24.4.4 [iterator.operations] p4 as follows:
++</p>
++
++<blockquote><p>
++<i>Effects:</i> Returns the number of increments <del>or decrements</del>
++needed to get from <tt>first</tt> to <tt>last</tt>.
++</p></blockquote>
++
++</blockquote>
++
++<p>
++Thomas adds more discussion and an alternative view point
++<a href="http://groups.google.com/group/comp.std.c++/browse_thread/thread/e8e46dcda0a5d797#">here</a>.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++The proposed wording below was verbally agreed to. Howard provided.
++</p></blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++Pete reports that a recent similar change has been made
++for the <tt>advance()</tt> function.
++</p>
++<p>
++We agree with the proposed resolution.
++Move to Tentatively Ready.
++</p>
++</blockquote>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Moved from Tentatively Ready to Open only because the wording needs to be
++tweaked for concepts removal.
++</p></blockquote>
++
++<p><i>[
++2009-07 Frankfurt:
++]</i></p>
++
++
++<blockquote><p>
++Leave Open pending arrival of a post-Concepts WD.
++</p></blockquote>
++
++<p><i>[
++2009-10-14 Daniel provided de-conceptified wording.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Move to Ready, replacing the Effects clause in the proposed wording with
++"If InputIterator meets the requirements of random access iterator then
++returns (last - first), otherwise returns the number of increments
++needed to get from first to list.".
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Change 24.2.7 [random.access.iterators], Table 105 as indicated [This change is not
++essential but it simplifies the specification] for the row with expression "<tt>b - a</tt>"
++and the column Operational semantics:
++</p>
++
++<blockquote><pre>
++<del>(a &lt; b) ? </del>distance(a,b)
++<del>: -distance(b,a)</del>
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Change 24.4.4 [iterator.operations]/4+5 as indicated:
++</p>
++
++<blockquote><pre>
++template&lt;class InputIterator&gt;
++ typename iterator_traits&lt;InputIterator&gt;::difference_type
++ distance(InputIterator first, InputIterator last);
++</pre>
++<blockquote>
++<p>
++4 <i>Effects:</i> <ins>If <tt>InputIterator</tt> meets the requirements
++of random access iterator then returns <tt>(last - first)</tt>,
++otherwise</ins> <del>R</del><ins>r</ins>eturns the number of increments
++<del>or decrements</del> needed to get from <tt>first</tt> to
++<tt>last</tt>.
++</p>
++
++<p>
++5 <i>Requires:</i> <ins>If <tt>InputIterator</tt> meets the requirements
++of random access iterator then <tt>last</tt> shall be reachable from
++<tt>first</tt> or <tt>first</tt> shall be reachable from <tt>last</tt>,
++otherwise</ins> <tt>last</tt> shall be reachable from <tt>first</tt>.
++</p>
+ </blockquote>
+ </blockquote>
++</li>
++</ol>
++
++
++
+
+
+
+@@ -54922,14 +58531,14 @@ Remove from 20.3.3 [forward]:
+
+ <hr>
+ <h3><a name="943"></a>943. <tt>ssize_t</tt> undefined</h3>
+-<p><b>Section:</b> 29.5.2 [atomics.types.address] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> X [atomics.types.address] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is a row in "Table 122 - Atomics for standard typedef types"
+-in 29.5.1 [atomics.types.integral] with <tt>atomic_ssize_t</tt>
++in X [atomics.types.integral] with <tt>atomic_ssize_t</tt>
+ and <tt>ssize_t</tt>. Unless, I'm missing something <tt>ssize_t</tt>
+ is not defined by the standard.
+ </p>
+@@ -54939,44 +58548,127 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
+-Move to review. Proposed resolution: Remove the typedef. Note: ssize_t
++<blockquote><p>
++Move to review. Proposed resolution: Remove the typedef. Note: <tt>ssize_t</tt>
+ is a POSIX type.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Remove the row containing <tt>ssize_t</tt> from Table 119
+-"Atomics for standard typedef types" in 29.5.2 [atomics.types.address].
++"Atomics for standard typedef types" in X [atomics.types.address].
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="944"></a>944. <tt>atomic&lt;bool&gt;</tt> derive from <tt>atomic_bool</tt>?</h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Holger Grund <b>Opened:</b> 2008-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I think it's fairly obvious that <tt>atomic&lt;bool&gt;</tt> is supposed to be derived
++from <tt>atomic_bool</tt> (and otherwise follow the <tt>atomic&lt;integral&gt;</tt> interface),
++though I think the current wording doesn't support this. I raised this
++point along with <tt>atomic&lt;floating-point&gt;</tt> privately with Herb and I seem
++to recall it came up in the resulting discussion on this list. However,
++I don't see anything on the current libs issue list mentioning this
++problem.
++</p>
++
++<p>
++29.5 [atomics.types.generic]/3 reads
++</p>
++
++<blockquote><p>
++There are full specializations over the integral types on the atomic
++class template. For each integral type integral in the second column of
++table 121 or table 122, the specialization <tt>atomic&lt;integral&gt;</tt> shall be
++publicly derived from the corresponding atomic integral type in the
++first column of the table. These specializations shall have trivial
++default constructors and trivial destructors.
++</p></blockquote>
++
++<p>
++Table 121 does not include (<tt>atomic_bool</tt>, <tt>bool</tt>),
++so that this should probably be mentioned explicitly in the quoted paragraph.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open. Lawrence will draft a proposed resolution. Also, ask
++Howard to fix the title.
++</p></blockquote>
++
++<p><i>[
++Post Summit Anthony provided proposed wording.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Replace paragraph 3 in 29.5 [atomics.types.generic] with
+ </p>
+
++<blockquote><p>
++-3- There are full specializations over the integral types on the <tt>atomic</tt>
++class template. For each integral type <tt>integral</tt> in the second column of
++table 121 or table 122, the specialization <tt>atomic&lt;integral&gt;</tt> shall be
++publicly derived from the corresponding atomic integral type in the first
++column of the table.
++<ins>In addition, the specialization <tt>atomic&lt;bool&gt;</tt>
++shall be publicly derived from <tt>atomic_bool</tt>.</ins>
++These specializations shall have trivial default
++constructors and trivial destructors.
++</p></blockquote>
++
+
+
+
+
+ <hr>
+-<h3><a name="947"></a>947. duration arithmetic: contradictory requirements</h3>
+-<p><b>Section:</b> 20.11.3.5 [time.duration.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-20 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="947"></a>947. <tt>duration</tt> arithmetic: contradictory requirements</h3>
++<p><b>Section:</b> 20.12.5.5 [time.duration.nonmember] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2008-12-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.11.3.5 [time.duration.nonmember], paragraph 8 says that calling
+-<tt>dur / rep</tt>
+-when <tt>rep</tt> is an instantiation of <tt>duration</tt> requires a diagnostic.
+-That's followed by an <tt>operator/</tt> that takes two durations.
+-So <tt>dur1 / dur2</tt> is legal under the second version,
++In 20.12.5.5 [time.duration.nonmember], paragraph 8 says that calling
++<tt>dur / rep</tt> when <tt>rep</tt> is an instantiation of <tt>duration</tt>
++requires a diagnostic. That's followed by an <tt>operator/</tt> that takes
++two durations. So <tt>dur1 / dur2</tt> is legal under the second version,
+ but requires a diagnostic under the first.
+ </p>
+
+@@ -54985,17 +58677,17 @@ Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Please see the thread starting with c++std-lib-22980 for more information.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open, pending proposed wording (and preferably an implementation).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07-27 Howard adds:
+@@ -55004,15 +58696,16 @@ Move to Open, pending proposed wording (and preferably an implementation).
+
+ <blockquote>
+ <p>
+-I've addressed this issue under the proposed wording for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a> which
+-cleans up several places under 20.11.3 [time.duration] which used the
++I've addressed this issue under the proposed wording for <a href="lwg-defects.html#1177">1177</a> which
++cleans up several places under 20.12.5 [time.duration] which used the
+ phrase "diagnostic required".
+ </p>
+ <p>
+ For clarity's sake, here is an example implementation of the constrained <tt>operator/</tt>:
+ </p>
+
+-<blockquote><pre>template &lt;class _Duration, class _Rep, bool = __is_duration&lt;_Rep&gt;::value&gt;
++<blockquote><pre>
++template &lt;class _Duration, class _Rep, bool = __is_duration&lt;_Rep&gt;::value&gt;
+ struct __duration_divide_result
+ {
+ };
+@@ -55067,9 +58760,9 @@ The constrained <tt>operator%</tt> works identically.
+ ]</i></p>
+
+
+-<blockquote>
+-Mark <del>NAD Editorial</del><ins>Resolved</ins>, fixed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>.
+-</blockquote>
++<blockquote><p>
++Mark <del>NAD Editorial</del><ins>Resolved</ins>, fixed by <a href="lwg-defects.html#1177">1177</a>.
++</p></blockquote>
+
+
+
+@@ -55083,14 +58776,14 @@ Mark <del>NAD Editorial</del><ins>Resolved</ins>, fixed by <a href="http://www.o
+
+ <hr>
+ <h3><a name="948"></a>948. <tt>ratio</tt> arithmetic tweak</h3>
+-<p><b>Section:</b> 20.6.2 [ratio.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-12-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.11.4 [ratio.arithmetic] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2008-12-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2800.pdf">N2800</a>,
+-20.6.2 [ratio.arithmetic] lacks a paragraph from the proposal
++20.11.4 [ratio.arithmetic] lacks a paragraph from the proposal
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm">N2661</a>:
+ </p>
+
+@@ -55117,15 +58810,16 @@ For example:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class R1, class R2&gt; struct ratio_multiply {
++<pre>
++template &lt;class R1, class R2&gt; struct ratio_multiply {
+ typedef <i>see below</i>} type;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ The nested typedef type shall be a synonym for <tt>ratio&lt;T1, T2&gt;</tt> where
+ <tt>T1</tt> has the value <tt>R1::num * R2::num</tt> and <tt>T2</tt> has the
+ value <tt>R1::den * R2::den</tt>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -55134,7 +58828,8 @@ Consider the case where <tt>intmax_t</tt> is a 64 bit 2's complement signed inte
+ and we have:
+ </p>
+
+-<blockquote><pre>typedef std::ratio&lt;0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF0&gt; R1;
++<blockquote><pre>
++typedef std::ratio&lt;0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFF0&gt; R1;
+ typedef std::ratio&lt;8, 7&gt; R2;
+ typedef std::ratio_multiply&lt;R1, R2&gt;::type RT;
+ </pre></blockquote>
+@@ -55152,14 +58847,16 @@ by <tt>7</tt> obtaining <tt>0x1249249249249249 / 1</tt> and divide
+ then the exact result can then be computed without overflow:
+ </p>
+
+-<blockquote><pre>[0x7FFFFFFFFFFFFFFF/0x7FFFFFFFFFFFFFF0] * [8/7] = [0x1249249249249249/0x0FFFFFFFFFFFFFFE]
++<blockquote><pre>
++[0x7FFFFFFFFFFFFFFF/0x7FFFFFFFFFFFFFF0] * [8/7] = [0x1249249249249249/0x0FFFFFFFFFFFFFFE]
+ </pre></blockquote>
+
+ <p>
+ Example implmentation which accomplishes this:
+ </p>
+
+-<blockquote><pre>template &lt;class R1, class R2&gt;
++<blockquote><pre>
++template &lt;class R1, class R2&gt;
+ struct ratio_multiply
+ {
+ private:
+@@ -55176,22 +58873,22 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a paragraph prior to p1 in 20.6.2 [ratio.arithmetic]:
++Add a paragraph prior to p1 in 20.11.4 [ratio.arithmetic]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Implementations may use other algorithms to compute the indicated ratios to avoid overflow.
+ If overflow occurs, a diagnostic shall be issued.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -55199,12 +58896,12 @@ If overflow occurs, a diagnostic shall be issued.
+
+ <hr>
+ <h3><a name="949"></a>949. <tt>owner_less</tt></h3>
+-<p><b>Section:</b> 20.9.10.3.7 [util.smartptr.ownerless] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2008-12-30 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.4 [util.smartptr.ownerless] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2008-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.9.10.3.7 [util.smartptr.ownerless] (class template <tt>owner_less</tt>) says that
++20.8.2.4 [util.smartptr.ownerless] (class template <tt>owner_less</tt>) says that
+ <tt>operator()(x,y)</tt> shall return <tt>x.before(y)</tt>.
+ </p>
+ <p>
+@@ -55221,48 +58918,49 @@ Herve adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agreed with the typo, it should be "shall return <tt>x.owner_before(y)</tt>".
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.10.3.7 [util.smartptr.ownerless] p2:
++Change 20.8.2.4 [util.smartptr.ownerless] p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <tt>operator()(x,y)</tt> shall return
+ <tt>x.<ins>owner_</ins>before(y)</tt>. [<i>Note:</i> ...
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="950"></a>950. unique_ptr converting ctor shouldn't accept array form</h3>
+-<p><b>Section:</b> 20.9.9.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="950"></a>950. <tt>unique_ptr</tt> converting ctor shouldn't accept array form</h3>
++<p><b>Section:</b> 20.8.1.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>unique_ptr</tt>'s of array type should not convert to
+ <tt>unique_ptr</tt>'s which do not have an array type.
+ </p>
+
+-<blockquote><pre>struct Deleter
++<blockquote><pre>
++struct Deleter
+ {
+ void operator()(void*) {}
+ };
+@@ -55270,7 +58968,7 @@ Change 20.9.10.3.7 [util.smartptr.ownerless] p2:
+ int main()
+ {
+ unique_ptr&lt;int[], Deleter&gt; s;
+- unique_ptr&lt;int, Deleter&gt; s2(std::move(s)); <font color="#C80000">// should not compile</font>
++ unique_ptr&lt;int, Deleter&gt; s2(std::move(s)); <span style="color:#C80000">// should not compile</span>
+ }
+ </pre></blockquote>
+
+@@ -55298,22 +58996,22 @@ Recommend Review.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The post-Summit comments have been applied to the proposed resolution.
+ We now agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+-improved for enable_if type constraining, possibly following Robert's
++improved for <tt>enable_if</tt> type constraining, possibly following Robert's
+ formula.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-01 Howard updates wording and sets to Review.
+@@ -55325,9 +59023,9 @@ formula.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-27 Pete Opens:
+@@ -55339,10 +59037,10 @@ Move to Ready.
+ The proposed replacement text doesn't make sense.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ If <tt>D</tt> is a reference type, then <tt>E</tt> shall be the same type as
+ <tt>D</tt>, else this constructor shall not participate in overload resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This imposes two requirements. 1. If <tt>D</tt> is a reference type, <tt>E</tt>
+@@ -55353,10 +59051,10 @@ in the preceding paragraph that this constructor shall not throw an exception if
+ intention, but I can't parse this text any other way.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>U</tt> shall not be an array type, else this constructor shall not
+ participate in overload resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I don't know what this means.
+@@ -55452,11 +59150,12 @@ Solved by
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]:
++Change 20.8.1.2.1 [unique.ptr.single.ctor]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+ <blockquote>
+ <p>
+@@ -55466,7 +59165,7 @@ shall be well formed and shall not throw an exception. <del>If <tt>D</tt> is
+ a reference type, then <tt>E</tt> shall be the same type as <tt>D</tt>
+ (diagnostic required). <tt>unique_ptr&lt;U, E&gt;::pointer</tt> shall be
+ implicitly convertible to <tt>pointer</tt>. [<i>Note:</i> These requirements
+-imply that <tt>T</tt> and <tt>U</tt> are complete types. — <i>end note</i>]</del>
++imply that <tt>T</tt> and <tt>U</tt> are complete types. &mdash; <i>end note</i>]</del>
+ </p>
+
+ <p><ins>
+@@ -55477,18 +59176,19 @@ implicitly convertible to <tt>pointer</tt>, else this
+ constructor shall not participate in overload resolution. <tt>U</tt> shall not be
+ an array type, else this
+ constructor shall not participate in overload resolution. [<i>Note:</i> These requirements
+-imply that <tt>T</tt> and <tt>U</tt> are complete types. — <i>end note</i>]
++imply that <tt>T</tt> and <tt>U</tt> are complete types. &mdash; <i>end note</i>]
+ </ins></p>
+
+ </blockquote>
+ </blockquote>
+
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn]:
++Change 20.8.1.2.3 [unique.ptr.single.asgn]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+ <blockquote>
+ <p>
+@@ -55496,7 +59196,7 @@ Change 20.9.9.2.3 [unique.ptr.single.asgn]:
+ <tt>D</tt> shall not throw an exception. <del><tt>unique_ptr&lt;U,
+ E&gt;::pointer</tt> shall be implicitly convertible to <tt>pointer</tt>.
+ [<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt>
+-are complete types. — <i>end note</i>]</del>
++are complete types. &mdash; <i>end note</i>]</del>
+ </p>
+
+ <p><ins>
+@@ -55506,7 +59206,7 @@ operator shall not participate in overload resolution.
+ <tt>U</tt> shall not be an array type, else this
+ operator shall not participate in overload resolution.
+ [<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U</tt>
+-are complete types. — <i>end note</i>]
++are complete types. &mdash; <i>end note</i>]
+ </ins></p>
+
+ </blockquote>
+@@ -55519,17 +59219,17 @@ are complete types.
+
+ <hr>
+ <h3><a name="951"></a>951. Various threading bugs #1</h3>
+-<p><b>Section:</b> 20.11.2.1 [time.traits.is_fp] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.4.1 [time.traits.is_fp] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>.
++Related to <a href="lwg-defects.html#953">953</a>.
+ </p>
+
+ <p>
+-20.11.2.1 [time.traits.is_fp] says that the type <tt>Rep</tt> "is
++20.12.4.1 [time.traits.is_fp] says that the type <tt>Rep</tt> "is
+ assumed to be ... a class emulating an integral type." What are the
+ requirements for such a type?
+ </p>
+@@ -55538,9 +59238,9 @@ requirements for such a type?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <tt>IntegralLike</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -55548,7 +59248,7 @@ Batavia (2009-05):
+
+ <blockquote>
+ <p>
+-As with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#953">953</a>,
++As with issue <a href="lwg-defects.html#953">953</a>,
+ we recommend this issue be addressed in the context of providing concepts for the entire <tt>thread</tt> header.
+ </p>
+ <p>
+@@ -55566,8 +59266,8 @@ Move to Open.
+
+ <blockquote>
+ <p>
+-I have surveyed all clauses of 20.11.2.2 [time.traits.duration_values],
+-20.11.2.3 [time.traits.specializations] and 20.11.3 [time.duration].
++I have surveyed all clauses of 20.12.4.2 [time.traits.duration_values],
++20.12.4.3 [time.traits.specializations] and 20.12.5 [time.duration].
+ I can not find any clause which involves the use of a <tt>duration::rep</tt> type
+ where the requirements on the <tt>rep</tt> type are not clearly spelled out.
+ These requirements were carefully crafted to allow any arithmetic type, or
+@@ -55589,25 +59289,27 @@ on <tt>Rep</tt> are specified for each operation individually.
+ </p>
+
+ <p>
+-In 20.11.2.1 [time.traits.is_fp] p1:
++In 20.12.4.1 [time.traits.is_fp] p1:
+ </p>
+
+-<blockquote><pre>template &lt;class Rep&gt; struct treat_as_floating_point
++<blockquote><pre>
++template &lt;class Rep&gt; struct treat_as_floating_point
+ : is_floating_point&lt;Rep&gt; { };
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ The <tt>duration</tt> template uses the <tt>treat_as_floating_point</tt> trait to help
+ determine if a <tt>duration</tt> object can be converted to another <tt>duration</tt>
+ with a different tick period. If <tt>treat_as_floating_point&lt;Rep&gt;::value</tt> is
+ <tt>true</tt>, then <tt>Rep</tt> is a floating-point type and implicit conversions are
+ allowed among <tt>duration</tt>s. Otherwise, the implicit convertibility depends
+-on the tick periods of the <tt>duration</tt>s. If <tt>Rep</tt> is <u>a class type which
+-emulates a floating-point type</u>, the author of <tt>Rep</tt> can specialize
+-<tt>treat_as_floating_point</tt> so that <tt>duration</tt> will treat this <tt>Rep</tt> as if it
+-were a floating-point type. Otherwise <tt>Rep</tt> is assumed to be an integral
+-type or <u>a class emulating an integral type</u>.
+-</blockquote>
++on the tick periods of the <tt>duration</tt>s. If <tt>Rep</tt> is
++<span style="text-decoration:underline">a class type which emulates a floating-point type</span>,
++the author of <tt>Rep</tt> can specialize <tt>treat_as_floating_point</tt> so that
++<tt>duration</tt> will treat this <tt>Rep</tt> as if it were a floating-point type.
++Otherwise <tt>Rep</tt> is assumed to be an integral type or
++<span style="text-decoration:underline">a class emulating an integral type</span>.
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -55628,7 +59330,7 @@ but none has been pointed out).
+ I am amenable to improved wording of this paragraph (and any others), but do not have any
+ suggestions for improved wording at this time. I am <em>strongly</em> opposed to
+ changes which would significantly alter the semantics of the
+-specification under 20.11 [time] without firmly grounded and
++specification under 20.12 [time] without firmly grounded and
+ documented rationale, example implementation, testing, and user
+ experience which relates a positive experience.
+ </p>
+@@ -55643,9 +59345,9 @@ I recommend NAD unless someone wants to produce some clarifying wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Stefanus to provide wording to turn this into a note.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-11 Stefanus provided wording.
+@@ -55658,9 +59360,9 @@ Stefanus to provide wording to turn this into a note.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -55671,10 +59373,10 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.11.2.1 [time.traits.is_fp]/1:
++Change 20.12.4.1 [time.traits.is_fp]/1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 The <tt>duration</tt> template uses the <tt>treat_as_floating_point</tt> trait
+ to help determine if a <tt>duration</tt> object can be converted to another
+ <tt>duration</tt> with a different tick period. If
+@@ -55691,8 +59393,8 @@ class behaves like a floating point type, and thus allows division of one value
+ by another with acceptable loss of precision. If
+ <tt>treat_as_floating_point&lt;Rep&gt;::value</tt> is <tt>false</tt>,
+ <tt>Rep</tt> will be treated as if it behaved like an integral type for the
+-purpose of these conversions. — <i>end note</i>]</ins>
+-</blockquote>
++purpose of these conversions. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
+
+
+
+@@ -55701,18 +59403,18 @@ purpose of these conversions.
+
+ <hr>
+ <h3><a name="953"></a>953. Various threading bugs #3</h3>
+-<p><b>Section:</b> 20.11.1 [time.clock.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.12.3 [time.clock.req] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.
++Related to <a href="lwg-defects.html#951">951</a>.
+ </p>
+
+ <p>
+-20.11.1 [time.clock.req] says that a clock's <tt>rep</tt> member is "an
++20.12.3 [time.clock.req] says that a clock's <tt>rep</tt> member is "an
+ arithmetic type or a class emulating an arithmetic type." What are the
+ requirements for such a type?
+ </p>
+@@ -55722,9 +59424,9 @@ requirements for such a type?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ This wording was aimed directly at the <tt>ArithmeticLike</tt> concept.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -55753,21 +59455,21 @@ We look forward to proposed wording. Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
+-See commented dated 2009-08-01 in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.
+-</blockquote>
++<blockquote><p>
++See commented dated 2009-08-01 in <a href="lwg-defects.html#951">951</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Stefanus to provide wording to turn this into a note.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-2010-02-11 Stephanus provided wording for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a> which addresses
++2010-02-11 Stephanus provided wording for <a href="lwg-defects.html#951">951</a> which addresses
+ this issue as well.
+ ]</i></p>
+
+@@ -55778,9 +59480,9 @@ this issue as well.
+ ]</i></p>
+
+
+-<blockquote>
+-Move to <del>NAD Editorial</del><ins>Resolved</ins>, resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#951">951</a>.
+-</blockquote>
++<blockquote><p>
++Move to <del>NAD Editorial</del><ins>Resolved</ins>, resolved by <a href="lwg-defects.html#951">951</a>.
++</p></blockquote>
+
+
+
+@@ -55795,16 +59497,16 @@ Move to <del>NAD Editorial</del><ins>Resolved</ins>, resolved by <a href="http:/
+
+ <hr>
+ <h3><a name="954"></a>954. Various threading bugs #4</h3>
+-<p><b>Section:</b> 20.11.1 [time.clock.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.3 [time.clock.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Table 55 -- Clock Requirements (in 20.11.1 [time.clock.req])
++Table 55 &mdash; Clock Requirements (in 20.12.3 [time.clock.req])
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ the requirements for <tt>C1::time_point</tt> require <tt>C1</tt> and <tt>C2</tt>
+ to "refer to the same epoch", but "epoch" is not defined.
+@@ -55813,7 +59515,7 @@ to "refer to the same epoch", but "epoch" is not defined.
+ "Different clocks may share a <tt>time_point</tt> definition if it is
+ valid to compare their <tt>time_point</tt>s by comparing their
+ respective <tt>duration</tt>s." What does "valid" mean here? And, since
+-<tt>C1::rep</tt> is "**THE** representation type of the native
++<tt>C1::rep</tt> is "<em>THE</em> representation type of the native
+ <tt>duration</tt> and <tt>time_point</tt>" (emphasis added), there
+ doesn't seem to be much room for some other representation.
+ </li>
+@@ -55832,11 +59534,11 @@ it's a template. What is the required type?
+ ]</i></p>
+
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ "epoch" is purposefully not defined beyond the common English
+-<a href="http://www.dictionary.net/epoch">definition</a>. The C standard
++<a href="http://definitions.dictionary.net/epoch">definition</a>. The C standard
+ also chose not to define epoch, though POSIX did. I believe it is a strength
+ of the C standard that epoch is not defined. When it is known that two <tt>time_point</tt>s
+ refer to the same epoch, then a definition of the epoch is not needed to compare
+@@ -55851,22 +59553,22 @@ The <tt>time_point</tt> represents an offset (<tt>duration</tt>) from an epoch.
+ <p>
+ The sentence:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Different clocks
+ may share a <tt>time_point</tt>
+ definition if it is valid to
+ compare their <tt>time_point</tt>s by
+ comparing their respective
+ <tt>duration</tt>s.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ is redundant and could be removed. I believe the sentence which follows the above:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>C1</tt> and <tt>C2</tt> shall refer to the same epoch.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ is sufficient. If two clocks share the same epoch, then by definition, comparing
+@@ -55881,9 +59583,9 @@ desired that this value be usable in compile-time computation and branching.
+ <p>
+ This should probably instead be worded:
+ </p>
+-<blockquote>
++<blockquote><p>
+ An instantiation of <tt>ratio</tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -55909,11 +59611,11 @@ Move to Open pending proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ In regards to (d) I suggest to say "a specialization of ratio" instead of
+ "An instantiation of ratio". This seems to be the better matching standard
+ core language term for this kind of entity.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-25 Ganesh adds:
+@@ -55943,24 +59645,24 @@ which is part of ISO/IEC 18026 "Information technology -- Spatial Reference Mode
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<ol type="a">
++<ol>
+ <li>
+ <p>
+-Change 20.11.1 [time.clock.req] p1:
++Change 20.12.3 [time.clock.req] p1:
+ </p>
+-<blockquote>
++<blockquote><p>
+ -1- A clock is a bundle consisting of a native <tt>duration</tt>, a native <tt>time_point</tt>, and a function <tt>now()</tt> to get the
+ current <tt>time_point</tt>. <ins>The origin of the clock's <tt>time_point</tt> is referred to as the clock's <i>epoch</i> as defined in
+ section 6.3 of ISO/IEC 18026.</ins>
+ A clock shall meet the requirements in Table 45.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+@@ -55968,7 +59670,7 @@ Remove the sentence from the <tt>time_point</tt> row of the table "Clock Require
+ </p>
+ <table border="1">
+ <caption>Clock requirements</caption>
+-<tbody><tr>
++<tr>
+ <td>
+ <tt>C1::time_point</tt>
+ </td>
+@@ -55981,17 +59683,15 @@ The native <tt>time_point</tt> type of the clock.
+ <tt>C1</tt> and <tt>C2</tt> shall refer to the same epoch.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </li>
+-</ol>
+-<ol type="a" start="4">
+ <li>
+ <p>
+ Change the row starting with <tt>C1::period</tt> of the table "Clock Requirements":
+ </p>
+ <table border="1">
+ <caption>Clock requirements</caption>
+-<tbody><tr>
++<tr>
+ <td>
+ <tt>C1::period</tt>
+ </td>
+@@ -56002,7 +59702,7 @@ Change the row starting with <tt>C1::period</tt> of the table "Clock Requirement
+ The tick period of the clock in seconds.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+
+ </li>
+ </ol>
+@@ -56013,13 +59713,13 @@ The tick period of the clock in seconds.
+
+ <hr>
+ <h3><a name="956"></a>956. Various threading bugs #6</h3>
+-<p><b>Section:</b> 20.11.1 [time.clock.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.3 [time.clock.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.req">issues</a> in [time.clock.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.11.1 [time.clock.req] uses the word "native" in several places,
++20.12.3 [time.clock.req] uses the word "native" in several places,
+ but doesn't define it. What is a "native <tt>duration</tt>"?
+ </p>
+
+@@ -56028,21 +59728,21 @@ but doesn't define it. What is a "native <tt>duration</tt>"?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The standard uses "native" in several places without defining it (e.g.
+-2.14.3 [lex.ccon]). It is meant to mean "that which is defined
++2.13.3 [lex.ccon]). It is meant to mean "that which is defined
+ by the facility", or something along those lines. In this case it refers
+ to the nested <tt>time_point</tt> and <tt>duration</tt> types of the clock.
+ Better wording is welcome.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open pending proposed wording from Pete.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-23 Pete provides wording:
+@@ -56059,24 +59759,24 @@ Move to Open pending proposed wording from Pete.
+ I see that 30.4.1.3 [thread.timedmutex.requirements]/3 says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Precondition:</i> If the tick <tt>period</tt> of <tt>rel_time</tt> is not
+ exactly convertible to the native tick <tt>period</tt>, the <tt>duration</tt>
+ shall be rounded up to the nearest native tick <tt>period</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I would prefer to see that adapted as well. Following the same style as
+ the proposed resolution I come up with
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Precondition:</i> If the tick <tt>period</tt> of <tt>rel_time</tt> is not
+ exactly convertible to the <del>native</del> tick <tt>period</tt> <ins>of the
+ execution environment</ins>, the <tt>duration</tt> shall be rounded up to the
+ nearest <del>native</del> tick <tt>period</tt> <ins>of the execution
+ environment</ins>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -56090,9 +59790,9 @@ Post-Rapperswil, Howard provides wording:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording from Howard Hinnant after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -56104,7 +59804,7 @@ Adopted at 2010-11 Batavia
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 20.11.1 [time.clock.req]:
++Change 20.12.3 [time.clock.req]:
+ </p>
+
+ <blockquote>
+@@ -56121,8 +59821,8 @@ Table 56.
+ </p>
+
+ <table border="1">
+-<caption>Table 56 — Clock requirements</caption>
+-<tbody><tr><th>Expression</th> <th>Return type</th> <th>Operational semantics</th></tr>
++<caption>Table 56 &mdash; Clock requirements</caption>
++<tr><th>Expression</th> <th>Return type</th> <th>Operational semantics</th></tr>
+
+ <tr>
+ <td><tt>C1::rep</tt></td>
+@@ -56156,7 +59856,7 @@ C1::duration&gt;</tt></td>
+ <td colspan="3" align="center">...</td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -56166,13 +59866,13 @@ C1::duration&gt;</tt></td>
+
+ <hr>
+ <h3><a name="957"></a>957. Various threading bugs #7</h3>
+-<p><b>Section:</b> 20.11.5.1 [time.clock.system] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.system">issues</a> in [time.clock.system].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.7.1 [time.clock.system] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.system">issues</a> in [time.clock.system].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.11.5.1 [time.clock.system]: <tt>to_time_t</tt> is overspecified. It
++20.12.7.1 [time.clock.system]: <tt>to_time_t</tt> is overspecified. It
+ requires truncation, but should allow rounding. For example, suppose a
+ system has a clock that gives times in milliseconds, but <tt>time()</tt> rounds
+ those times to the nearest second. Then <tt>system_clock</tt> can't use any
+@@ -56190,57 +59890,59 @@ Post Summit Anthony Williams provided proposed wording.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Review pending input from Howard. and other stakeholders.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-23 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I am in favor of the wording provided by Anthony.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.11.5.1 [time.clock.system] replace paragraphs 3 and 4 with:
++In 20.12.7.1 [time.clock.system] replace paragraphs 3 and 4 with:
+ </p>
+
+ <blockquote>
+-<pre>time_t to_time_t(const time_point&amp; t);
++<pre>
++time_t to_time_t(const time_point&amp; t);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -3- <i>Returns:</i> A <tt>time_t</tt> object that represents the same
+ point in time as <tt>t</tt> when both values are <del>truncated</del>
+ <ins>restricted</ins> to the coarser of the precisions of
+ <tt>time_t</tt> and <tt>time_point</tt>. <ins> It is implementation
+ defined whether values are rounded or truncated to the required
+ precision.</ins>
+-</blockquote>
++</p></blockquote>
+
+-<pre>time_point from_time_t(time_t t);
++<pre>
++time_point from_time_t(time_t t);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Returns:</i> A <tt>time_point</tt> object that represents the
+ same point in time as <tt>t</tt> when both values are <del>truncated</del>
+ <ins>restricted</ins> to the
+ coarser of the precisions of <tt>time_t</tt> and <tt>time_point</tt>.
+ <ins>It is implementation defined whether values are
+ rounded or truncated to the required precision.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -56248,11 +59950,69 @@ rounded or truncated to the required precision.</ins>
+
+
+ <hr>
++<h3><a name="958"></a>958. Various threading bugs #8</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.5.1 [thread.condition.condvar]: the specification for <tt>wait_for</tt>
++with no predicate has an effects clause that says it calls <tt>wait_until</tt>,
++and a returns clause that sets out in words how to determine the return
++value. Is this description of the return value subtly different from the
++description of the value returned by <tt>wait_until</tt>? Or should the effects
++clause and the returns clause be merged?
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open. Associate with LWG <a href="lwg-defects.html#859">859</a> and any other monotonic-clock
++related issues.
++</p></blockquote>
++
++<p><i>[
++2009-08-01 Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++I believe that <a href="lwg-defects.html#859">859</a> (currently Ready) addresses this issue, and
++that this issue should be marked NAD, solved by <a href="lwg-defects.html#859">859</a> (assuming
++it moves to WP).
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark as <del>NAD Editorial</del><ins>Resolved</ins>, addressed by resolution
++of Issue <a href="lwg-defects.html#859">859</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="960"></a>960. Various threading bugs #10</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.4.1 [thread.mutex.requirements]: paragraph 4 is entitled
+@@ -56267,9 +60027,9 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Beman provided proposed wording.
+@@ -56281,10 +60041,10 @@ Beman provided proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready. Fix the proposed wording with "functions of type Mutex"
+--&gt; "functions of Mutex type"
+-</blockquote>
++-> "functions of Mutex type"
++</p></blockquote>
+
+
+
+@@ -56302,23 +60062,23 @@ functions of Mutex type shall be:</ins>
+ </p>
+ <ul>
+ <li>
+-<tt>not_enough_memory</tt> -- if there is not enough memory to construct
++<tt>not_enough_memory</tt> &mdash; if there is not enough memory to construct
+ the mutex object.
+ </li>
+ <li>
+-<tt>resource_unavailable_try_again</tt> -- if any native handle type
++<tt>resource_unavailable_try_again</tt> &mdash; if any native handle type
+ manipulated is not available.
+ </li>
+ <li>
+-<tt>operation_not_permitted</tt> -- if the thread does not have the
++<tt>operation_not_permitted</tt> &mdash; if the thread does not have the
+ necessary permission to change the state of the mutex object.
+ </li>
+ <li>
+-<tt>device_or_resource_busy</tt> -- if any native handle type
++<tt>device_or_resource_busy</tt> &mdash; if any native handle type
+ manipulated is already locked.
+ </li>
+ <li>
+-<tt>invalid_argument</tt> -- if any native handle type manipulated as
++<tt>invalid_argument</tt> &mdash; if any native handle type manipulated as
+ part of mutex construction is incorrect.
+ </li>
+ </ul>
+@@ -56330,10 +60090,10 @@ part of mutex construction is incorrect.
+
+ <hr>
+ <h3><a name="962"></a>962. Various threading bugs #12</h3>
+-<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.4.2.2.2 [thread.lock.unique.locking]: <tt>unique_lock::lock</tt> is
+@@ -56347,9 +60107,9 @@ to mean something more than that.
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Beman has volunteered to provide proposed wording.
+@@ -56358,7 +60118,7 @@ Beman has volunteered to provide proposed wording.
+
+ <p><i>[
+ 2009-07-21 Beman added wording to address 30.2.2 [thread.req.exception]
+-in response to the Frankfurt notes in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>.
++in response to the Frankfurt notes in <a href="lwg-defects.html#859">859</a>.
+ ]</i></p>
+
+
+@@ -56372,9 +60132,9 @@ in response to the Frankfurt notes in <a href="http://www.open-std.org/jtc1/sc22
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -56389,7 +60149,7 @@ system or other underlying API results in an error that prevents the library
+ function from <del>satisfying its postconditions or from returning a meaningful
+ value</del> <ins>meeting its specifications</ins>. <ins>Failure to
+ allocate storage shall be reported as described in
+-17.6.4.12 [res.on.exception.handling].</ins></p>
++17.6.5.12 [res.on.exception.handling].</ins></p>
+ </blockquote>
+
+ <p><i>Change thread assignment 30.3.1.5 [thread.thread.member], join(),
+@@ -56419,36 +60179,42 @@ postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [th
+ paragraph 3, as indicated:</i></p>
+ <blockquote>
+
+-<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
++<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be
++achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+ <p><i>Change unique_lock locking 30.4.2.2.2 [thread.lock.unique.locking],
+ paragraph 8, as indicated:</i></p>
+ <blockquote>
+
+-<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
++<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be
++achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+ <p><i>Change unique_lock locking 30.4.2.2.2 [thread.lock.unique.locking],
+ paragraph 13, as indicated:</i></p>
+ <blockquote>
+
+-<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
++<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be
++achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+ <p><i>Change unique_lock locking 30.4.2.2.2 [thread.lock.unique.locking],
+ paragraph 18, as indicated:</i></p>
+ <blockquote>
+
+-<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
++<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be
++achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+ <p><i>Change unique_lock locking 30.4.2.2.2 [thread.lock.unique.locking],
+ paragraph 22, as indicated:</i></p>
+ <blockquote>
+
+-<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
++<p><i>Throws:</i> <code>std::system_error</code> when <del>the postcondition cannot be
++achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+ <p><i>Change Function call_once 30.4.4.2 [thread.once.callonce], paragraph 4, as
+ indicated</i></p>
+ <blockquote>
+- <p><i>Throws:</i> <code>std::system_error</code> when <del>the effects cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>,
++ <p><i>Throws:</i> <code>std::system_error</code> when <del>the effects cannot be
++ achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>,
+ or any exception thrown by <code>func</code>.</p>
+ </blockquote>
+ <p><i>Change Class condition_variable 30.5.1 [thread.condition.condvar],
+@@ -56480,7 +60246,7 @@ paragraph 16, as indicated:</i></p>
+ postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+
+-<p><i>Assuming issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
++<p><i>Assuming issue <a href="lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
+ applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as
+ indicated:</i></p>
+ <blockquote>
+@@ -56493,7 +60259,7 @@ bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+ postcondition cannot be achieved</del> <ins>an exception is required ([thread.req.exception])</ins>.</p>
+ </blockquote>
+
+-<p><i>Assuming issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
++<p><i>Assuming issue <a href="lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
+ applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as
+ indicated:</i></p>
+ <blockquote>
+@@ -56507,7 +60273,7 @@ indicated:</i></p>
+ postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+
+-<p><i>Assuming issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
++<p><i>Assuming issue <a href="lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
+ applied to the working paper, change 30.5.2 [thread.condition.condvarany] as
+ indicated:</i></p>
+ <blockquote>
+@@ -56519,7 +60285,7 @@ indicated:</i></p>
+ postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [thread.req.exception])</ins>.</p>
+ </blockquote>
+
+-<p><i>Assuming issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
++<p><i>Assuming issue <a href="lwg-defects.html#859">859</a>, Monotonic Clock is Conditionally Supported?, has been
+ applied to the working paper, change 30.5.2 [thread.condition.condvarany] as
+ indicated:</i></p>
+ <blockquote>
+@@ -56538,10 +60304,10 @@ postcondition cannot be achieved</del> <ins>an exception is required (30.2.2 [th
+
+ <hr>
+ <h3><a name="963"></a>963. Various threading bugs #13</h3>
+-<p><b>Section:</b> 30.3.1.5 [thread.thread.member] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.member">issues</a> in [thread.thread.member].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.3.1.5 [thread.thread.member] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.member">issues</a> in [thread.thread.member].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.3.1.5 [thread.thread.member]: <tt>thread::detach</tt> is required to
+@@ -56554,10 +60320,10 @@ Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Due to a mistake on my part, 3 proposed resolutions appeared at approximately
+ the same time. They are all three noted below in the discussion.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Summit, proposed resolution:
+@@ -56569,7 +60335,8 @@ Summit, proposed resolution:
+ In 30.3.1.5 [thread.thread.member] change:
+ </p>
+
+-<blockquote><pre>void detach();
++<blockquote><pre>
++void detach();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -56598,10 +60365,10 @@ we can just use that.
+ This corresponds to the pthreads specification, where pthread_detach
+ fails if the thread is not joinable:
+ </p>
+-<blockquote>
++<blockquote><p>
+ EINVAL: The implementation has detected that the value specified by
+ thread does not refer to a joinable thread.
+-</blockquote>
++</p></blockquote>
+ <p>
+ Jonathan recommends this proposed wording:
+ </p>
+@@ -56610,7 +60377,8 @@ Jonathan recommends this proposed wording:
+ In 30.3.1.5 [thread.thread.member] change:
+ </p>
+
+-<blockquote><pre>void detach();
++<blockquote><pre>
++void detach();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -56643,7 +60411,8 @@ Anthony recommends this proposed wording:
+ In 30.3.1.5 [thread.thread.member] change:
+ </p>
+
+-<blockquote><pre>void detach();
++<blockquote><pre>
++void detach();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -56665,9 +60434,9 @@ In 30.3.1.5 [thread.thread.member] change:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Mark as Ready with proposed resolution from Summit.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -56677,7 +60446,8 @@ Mark as Ready with proposed resolution from Summit.
+ In 30.3.1.5 [thread.thread.member] change:
+ </p>
+
+-<blockquote><pre>void detach();
++<blockquote><pre>
++void detach();
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -56696,11 +60466,92 @@ In 30.3.1.5 [thread.thread.member] change:
+
+
+ <hr>
++<h3><a name="964"></a>964. Various threading bugs #14</h3>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The requirements for the constructor for <tt>condition_variable</tt> has several
++error conditions, but the requirements for the constructor for
++<tt>condition_variable_any</tt> has none. Is this difference intentional?
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open, pass to Howard. If this is intentional, a note may be
++helpful. If the error conditions are to be copied from
++<tt>condition_variable</tt>, this depends on LWG <a href="lwg-defects.html#965">965</a>.
++</p></blockquote>
++
++<p><i>[
++Post Summit Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++The original intention
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2447.htm#ConditionVariablesWording">N2447</a>)
++was to let the OS return whatever errors it was going to return, and for
++those to be translated into exceptions, for both
++<tt>condition_variable</tt> and <tt>condition_variable_any</tt>. I have not
++received any complaints about specific error conditions from vendors on
++non-POSIX platforms, but such complaints would not surprise me if they surfaced.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Leave open. Benjamin to provide wording.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote>
++<p>
++We don't have throw clauses for condition variables.
++</p>
++<p>
++This issue may be dependent on LWG <a href="lwg-defects.html#1268">1268</a>.
++</p>
++<p>
++Leave open. Detlef will coordinate with Benjamin.
++</p>
++<p>
++Consider merging LWG 964, <a href="lwg-defects.html#966">966</a>, and <a href="lwg-defects.html#1268">1268</a> into a
++single paper.
++</p>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Resolved 2011-03 Madrid meeting by paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278.htm">N3278</a>
++</p>
++
++
++
++
++
++<hr>
+ <h3><a name="965"></a>965. Various threading bugs #15</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.5.1 [thread.condition.condvar]: the constructor for
+@@ -56731,10 +60582,10 @@ C++ interface does not separate declaration from initialization.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -56758,11 +60609,241 @@ previously-initialized but as of yet undestroyed
+
+
+ <hr>
++<h3><a name="966"></a>966. Various threading bugs #16</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.5.1 [thread.condition.condvar]:
++<tt>condition_variable::wait</tt> and
++<tt>condition_variable::wait_until</tt> both have a postcondition that
++<tt>lock</tt> is locked by the calling thread, and a throws clause that
++requires throwing an exception if this postcondition cannot be achieved.
++How can the implementation detect that this <tt>lock</tt> can never be
++obtained?
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Move to open. Requires wording. Agreed this is an issue, and the
++specification should not require detecting deadlocks.
++</p></blockquote>
++
++<p><i>[
++2009-08-01 Howard provides wording.
++]</i></p>
++
++
++<blockquote>
++<p>
++The proposed wording is inspired by the POSIX spec which says:
++</p>
++
++<blockquote>
++<dl>
++<dt>[EINVAL]</dt>
++<dd>The value specified by cond or mutex is invalid.</dd>
++<dt>[EPERM]</dt>
++<dd>The mutex was not owned by the current thread at the time of the call.</dd>
++</dl>
++</blockquote>
++
++<p>
++I do not believe [EINVAL] is possible without memory corruption (which we don't
++specify). [EPERM] is possible if this thread doesn't own the mutex, which is
++listed as a precondition. "May" is used instead of "Shall" because not all
++OS's are POSIX.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Leave open, Detlef to provide improved wording.
++</p></blockquote>
++
++<p><i>[
++2009-10-23 Detlef Provided wording.
++]</i></p>
++
++
++<blockquote>
++<p>
++Detlef's wording put in Proposed resolution. Original wording here:
++</p>
++<blockquote>
++<p>
++Change 30.5.1 [thread.condition.condvar] p12, p19 and
++30.5.2 [thread.condition.condvarany] p10, p16:
++</p>
++
++<blockquote><p>
++<i>Throws:</i> <ins>May throw</ins> <tt>std::system_error</tt>
++<ins>
++if a precondition is not met.
++</ins>
++<del>when the effects or postcondition
++cannot be achieved.</del>
++</p></blockquote>
++</blockquote>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Leave open, Detlef to provide improved wording.
++</p></blockquote>
++
++<p><i>[
++2009-11-18 Anthony adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++<tt>condition_variable::wait</tt> takes a <tt>unique_lock&lt;mutex&gt;</tt>. We
++know whether or not a <tt>unique_lock</tt> owns a lock, through use of its
++<tt>owns_lock()</tt> member.
++</p>
++
++<p>
++I would like to propose the following resolution:
++</p>
++
++<blockquote>
++<p>
++Modify the first sentence of 30.5.1 [thread.condition.condvar] p9:
++</p>
++
++<blockquote><pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
++</pre>
++<blockquote><p>
++9 <i>Precondition:</i> <del><tt>lock</tt> is locked by the calling thread</del>
++<ins><tt>lock.owns_lock()</tt> is <tt>true</tt></ins>, and either
++</p><p>...</p>
++</blockquote>
++</blockquote>
++
++<p>
++Replace 30.5.1 [thread.condition.condvar] p11-13 with:
++</p>
++
++<blockquote><pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
++</pre>
++<blockquote>
++<p>...</p>
++<p>
++11 <i>Postcondition:</i> <del><tt>lock</tt> is locked by the calling
++thread</del> <ins><tt>lock.owns_lock()</tt> is <tt>true</tt></ins>.
++</p>
++
++<p>
++12 <i>Throws:</i> <tt>std::system_error</tt> <del>when the effects or
++postcondition cannot be achieved</del> <ins>if the implementation detects that
++the preconditions are not met or the effects cannot be achieved. Any exception
++thrown by <tt>lock.lock()</tt> or <tt>lock.unlock()</tt></ins>.
++</p>
++
++<p>
++13 <i>Error Conditions:</i> <ins>The error conditions are implementation
++defined.</ins>
++</p>
++
++<ul>
++<li><del>
++equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
++</del></li>
++</ul>
++
++</blockquote>
++</blockquote>
++</blockquote>
++</blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote>
++<p>
++There are heavy conflicts with adopted papers.
++</p>
++<p>
++This issue is dependent on LWG <a href="lwg-defects.html#1268">1268</a>.
++</p>
++<p>
++Leave open pending outstanding edits to the working draft. Detlef will provide
++wording.
++</p>
++<p>
++Possibly related to <a href="lwg-defects.html#964">964</a>.
++</p>
++
++</blockquote>
++
++<p><i>[2011-03-24 Madrid]</i></p>
++
++<p><b>Rationale:</b></p>
++<p>
++This has been resolved since filing, with the introduction of <tt>system_error</tt> to the thread specification.
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Replace 30.5.1 [thread.condition.condvar] p12, p19 and
++30.5.2 [thread.condition.condvarany] p10, p16:
++</p>
++
++<blockquote>
++<p><del>
++<i>Throws:</i> <tt>std::system_error</tt> when the effects or
++postcondition cannot be achieved.
++</del></p>
++<p><del>
++Error conditions:
++</del></p>
++<ul>
++<li><del>
++equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
++</del></li>
++</ul>
++
++<p><ins>
++<i>Throws:</i> It is implementation-defined whether a <tt>std::system_error</tt>
++with implementation-defined error condition is thrown if the
++precondition is not met.
++</ins></p>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="967"></a>967. Various threading bugs #17</h3>
+-<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.3.1.2 [thread.thread.constr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.constr">issues</a> in [thread.thread.constr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ the error handling for the constructor for <tt>condition_variable</tt>
+@@ -56781,19 +60862,19 @@ Beman has volunteered to provide proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
+-The proposed resolution assumes <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a> has been accepted and
++<blockquote><p>
++The proposed resolution assumes <a href="lwg-defects.html#962">962</a> has been accepted and
+ its proposed resolution applied to the working paper.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -56808,25 +60889,25 @@ paragraph 4, as indicated:</span></p>
+ <blockquote>
+
+ <ul>
+-<li><del> <code>not_enough_memory</code> — if there is not enough memory to construct
++<li><del> <code>not_enough_memory</code> &mdash; if there is not enough memory to construct
+ the mutex object.</del></li>
+
+-<li><code>resource_unavailable_try_again</code> — if any native handle type
++<li><code>resource_unavailable_try_again</code> &mdash; if any native handle type
+ manipulated is not available.</li>
+
+-<li><code>operation_not_permitted</code> — if the thread does not have the
++<li><code>operation_not_permitted</code> &mdash; if the thread does not have the
+ necessary permission to change the state of the mutex object.</li>
+
+-<li><code>device_or_resource_busy</code> — if any native handle type
++<li><code>device_or_resource_busy</code> &mdash; if any native handle type
+ manipulated is already locked.</li>
+
+-<li><code>invalid_argument</code> — if any native handle type manipulated as
++<li><code>invalid_argument</code> &mdash; if any native handle type manipulated as
+ part of mutex construction is incorrect.</li>
+ </ul>
+ </blockquote>
+ </blockquote>
+
+-<p><span style="font-style: italic">Change Class condition_variable 30.5.1 [thread.condition.condvar],
++<p><span style="font-style: italic">Change Class <tt>condition_variable</tt> 30.5.1 [thread.condition.condvar],
+ default constructor, as indicated:</span></p>
+ <blockquote>
+ <p><code>condition_variable();</code></p>
+@@ -56836,11 +60917,11 @@ default constructor, as indicated:</span></p>
+ <p><i>Error conditions:</i></p>
+ <blockquote>
+ <ul>
+- <li><del><code>not_enough_memory</code> — if a memory limitation prevents
++ <li><del><code>not_enough_memory</code> &mdash; if a memory limitation prevents
+ initialization.</del></li>
+- <li> <code>resource_unavailable_try_again</code> — if some non-memory
++ <li> <code>resource_unavailable_try_again</code> &mdash; if some non-memory
+ resource limitation prevents initialization.</li>
+- <li> <code>device_or_resource_busy</code> — if attempting to initialize a
++ <li> <code>device_or_resource_busy</code> &mdash; if attempting to initialize a
+ previously-initialized but as of yet undestroyed <code>condition_variable</code>.</li>
+ </ul>
+ </blockquote>
+@@ -56853,10 +60934,11 @@ default constructor, as indicated:</span></p>
+
+ <hr>
+ <h3><a name="968"></a>968. Various threading bugs #18</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-01-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.4.1 [thread.mutex.requirements]: several functions are
+@@ -56868,9 +60950,9 @@ permission ...". "The necessary permission" is not defined.
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to open.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><i>[
+@@ -56883,9 +60965,9 @@ Beman has volunteered to provide proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready with minor word-smithing in the example.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -56898,8 +60980,8 @@ Moved to Ready with minor word-smithing in the example.
+ specified to throw exceptions of type <code>system_error</code> (19.5.5). Such exceptions
+ shall be thrown if any of the <i>Error conditions</i> are detected or a call to an operating system or other underlying API
+ results in an error that prevents the library function from meeting its specifications.
+-<i>[Note:</i> See 17.6.4.12 [res.on.exception.handling] for exceptions thrown to report
+-storage allocation failures. <i>—end
++<i>[Note:</i> See 17.6.5.12 [res.on.exception.handling] for exceptions thrown to report
++storage allocation failures. <i>&mdash;end
+ note]</i></p>
+
+ <p><ins><i>[Example:</i></ins></p>
+@@ -56912,14 +60994,14 @@ operation_not_permitted</code> for a thread that does not have the privilege to
+ perform the operation. Assume that, during the execution of this function, an <code>errno</code>
+ of <code>EPERM</code> is reported by a POSIX API call used by the
+ implementation. Since POSIX specifies an <code>errno</code> of <code>EPERM</code>
+-when "the caller does not have the privilege to perform the operation",
++when &quot;the caller does not have the privilege to perform the operation&quot;,
+ the implementation maps <code>EPERM</code>&nbsp; to an <code>error_condition</code>
+ of <code>operation_not_permitted</code> (19.5 [syserr]) and an exception of type <code>
+ system_error</code> is thrown. </ins></p>
+
+ </blockquote>
+
+-<p><ins><i>—end example]</i></ins></p>
++<p><ins><i>&mdash;end example]</i></ins></p>
+
+ <p><span style="font-style: italic">Editorial note: For the sake of exposition,
+ the existing text above is shown with the changes proposed in issues 962 and 967. The
+@@ -56933,7 +61015,7 @@ paragraph 4, as indicated:</span></p>
+
+ <blockquote>
+
+-<p>— <code>operation_not_permitted</code> — if the thread does not have the
++<p>&mdash; <code>operation_not_permitted</code> &mdash; if the thread does not have the
+ <del>necessary permission to change the state of the mutex object</del> <ins>privilege to perform the operation</ins>.</p>
+
+ </blockquote>
+@@ -56943,7 +61025,7 @@ paragraph 12, as indicated:</span></p>
+
+ <blockquote>
+
+-<p>— <code>operation_not_permitted</code> — if the thread does not have the
++<p>&mdash; <code>operation_not_permitted</code> &mdash; if the thread does not have the
+ <del>necessary permission to change the state of the mutex</del> <ins>privilege to perform the operation</ins>.</p>
+
+ </blockquote>
+@@ -56954,16 +61036,18 @@ paragraph 12, as indicated:</span></p>
+
+
+ <hr>
+-<h3><a name="970"></a>970. addressof overload unneeded</h3>
+-<p><b>Section:</b> 20.9.8.1 [specialized.addressof] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-16 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="970"></a>970. <tt>addressof</tt> overload unneeded</h3>
++<p><b>Section:</b> 20.7.12.1 [specialized.addressof] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.addressof">issues</a> in [specialized.addressof].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.9.8.1 [specialized.addressof] specifies:
++20.7.12.1 [specialized.addressof] specifies:
+ </p>
+
+-<blockquote><pre>template &lt;ObjectType T&gt; T* addressof(T&amp; r);
++<blockquote><pre>
++template &lt;ObjectType T&gt; T* addressof(T&amp; r);
+ template &lt;ObjectType T&gt; T* addressof(T&amp;&amp; r);
+ </pre></blockquote>
+
+@@ -56978,18 +61062,18 @@ Post Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Recommend Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-18 Moved from Pending WP to WP. Confirmed in
+@@ -57000,10 +61084,11 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.8.1 [specialized.addressof]:
++Change 20.7.12.1 [specialized.addressof]:
+ </p>
+
+-<blockquote><pre>template &lt;ObjectType T&gt; T* addressof(T&amp; r);
++<blockquote><pre>
++template &lt;ObjectType T&gt; T* addressof(T&amp; r);
+ <del>template &lt;ObjectType T&gt; T* addressof(T&amp;&amp; r);</del>
+ </pre></blockquote>
+
+@@ -57014,17 +61099,19 @@ Change 20.9.8.1 [specialized.addressof]:
+
+ <hr>
+ <h3><a name="974"></a>974. <tt>duration&lt;double&gt;</tt> should not implicitly convert to <tt>duration&lt;int&gt;</tt></h3>
+-<p><b>Section:</b> 20.11.3.1 [time.duration.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-21 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.5.1 [time.duration.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-01-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.cons">issues</a> in [time.duration.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The following code should not compile because it involves implicit truncation
+ errors (against the design philosophy of the <tt>duration</tt> library).
+ </p>
+
+-<blockquote><pre>duration&lt;double&gt; d(3.5);
+-duration&lt;int&gt; i = d; <font color="#C80000">// implicit truncation, should not compile</font>
++<blockquote><pre>
++duration&lt;double&gt; d(3.5);
++duration&lt;int&gt; i = d; <span style="color:#C80000">// implicit truncation, should not compile</span>
+ </pre></blockquote>
+
+ <p>
+@@ -57051,42 +61138,43 @@ Move to Tentatively Ready.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+-improved for enable_if type constraining, possibly following Robert's
++improved for <tt>enable_if</tt> type constraining, possibly following Robert's
+ formula.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-01 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
+-Addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>.
+-</blockquote>
++<blockquote><p>
++Addressed by <a href="lwg-defects.html#1177">1177</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
+-Not completely addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>. Move to Ready.
+-</blockquote>
++<blockquote><p>
++Not completely addressed by <a href="lwg-defects.html#1177">1177</a>. Move to Ready.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.11.3.1 [time.duration.cons], p4:
++Change 20.12.5.1 [time.duration.cons], p4:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Rep2, class Period2&gt;
++<pre>
++template &lt;class Rep2, class Period2&gt;
+ duration(const duration&lt;Rep2, Period2&gt;&amp; d);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Requires:</i> <tt>treat_as_floating_point&lt;rep&gt;::value</tt>
+ shall be <tt>true</tt> or <ins>both</ins> <tt>ratio_divide&lt;Period2,
+ period&gt;::type::den</tt> shall be 1
+@@ -57096,8 +61184,8 @@ Diagnostic required.
+ [<i>Note:</i> This requirement prevents implicit truncation error when
+ converting between integral-based <tt>duration</tt> types. Such a
+ construction could easily lead to confusion about the value of the
+-<tt>duration</tt>. -- <i>end note</i>]
+-</blockquote>
++<tt>duration</tt>. &mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+
+@@ -57105,23 +61193,22 @@ construction could easily lead to confusion about the value of the
+
+
+ <hr>
+-<h3><a name="975"></a>975. <tt>is_convertible</tt> cannot be instantiated for non-convertible types</h3>
+-<p><b>Section:</b> 20.7.6 [meta.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-01-25 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="975"></a>975. <tt>is_convertible</tt> cannot be instantiated for non-convertible types</h3>
++<p><b>Section:</b> 20.10.6 [meta.rel] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-01-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.rel">issues</a> in [meta.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-
+-<b>Addresses UK 206</b>
++<p><b>Addresses UK 206</b></p>
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1114">1114</a>.
++Related to <a href="lwg-defects.html#1114">1114</a>.
+ </p>
+
+ <p>
+ The current specification of <tt>std::is_convertible</tt> (reference is draft
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">N2798</a>)
+-is basically defined by 20.7.6 [meta.rel]/4:
++is basically defined by 20.10.6 [meta.rel] p.4:
+ </p>
+
+ <blockquote>
+@@ -57130,7 +61217,8 @@ In order to instantiate the template <tt>is_convertible&lt;From,
+ To&gt;</tt>, the following code shall be well formed:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+
+ To test() {
+@@ -57140,7 +61228,7 @@ To test() {
+
+ <p>
+ [<i>Note:</i> This requirement gives well defined results for reference
+-types, void types, array types, and function types. --<i>end note</i>]
++types, void types, array types, and function types. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -57148,7 +61236,8 @@ types, void types, array types, and function types. --<i>end note</i>]
+ The first sentence can be interpreted, that e.g. the expression
+ </p>
+
+-<blockquote><pre>std::is_convertible&lt;double, int*&gt;::value
++<blockquote><pre>
++std::is_convertible&lt;double, int*&gt;::value
+ </pre></blockquote>
+
+ <p>
+@@ -57171,7 +61260,8 @@ If the following <tt>test</tt> function is well formed code <tt>b</tt>
+ is <tt>true</tt>, else it is <tt>false</tt>.
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+
+ To test() {
+@@ -57181,7 +61271,7 @@ To test() {
+
+ <p>
+ [<i>Note:</i> This definition gives well defined results for <tt>reference</tt>
+-types, <tt>void</tt> types, array types, and function types. --<i>end note</i>]
++types, <tt>void</tt> types, array types, and function types. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -57192,7 +61282,7 @@ Post Summit:
+
+ <blockquote>
+ <p>
+-Jens: Checking that code is well-formed and then returning true/false
++Jens: Checking that code is well-formed and then returning <tt>true</tt>&#47;<tt>false</tt>
+ sounds like speculative compilation. John Spicer would really dislike
+ this. Please find another wording suggesting speculative compilation.
+ </p>
+@@ -57213,22 +61303,23 @@ John finds the following wording clearer:
+ <blockquote>
+
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Template</th><th>Condition</th><th>Comments</th>
+ </tr>
+ <tr>
+-<td><tt>template &lt;class From, class To&gt;<br>struct is_convertible;</tt></td>
++<td><tt>template &lt;class From, class To&gt;<br/>struct is_convertible;</tt></td>
+ <td><i>see below</i></td>
+ <td><tt>From</tt> and <tt>To</tt> shall be complete types, arrays of unknown bound,
+ or (possibly cv-qualified) <tt>void</tt> types.</td>
+ </tr>
+-</tbody></table>
++</table>
+
+ <p>
+ Given the following function prototype:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+ </pre></blockquote>
+
+@@ -57239,7 +61330,8 @@ any implicit conversions to the return type of the function, else
+ <tt>is_convertible&lt;From, To&gt;::value</tt> shall be <tt>false</tt>.
+ </p>
+
+-<blockquote><pre>To test() {
++<blockquote><pre>
++To test() {
+ return create&lt;From&gt;();
+ }
+ </pre></blockquote>
+@@ -57247,44 +61339,44 @@ any implicit conversions to the return type of the function, else
+ </blockquote>
+
+ </blockquote>
+-
++<p>
+ <b>Original proposed wording:</b>
+-
++</p>
+ <p>
+-In 20.7.6 [meta.rel]/4 change:
++In 20.10.6 [meta.rel]/4 change:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del>In order to instantiate the template <tt>is_convertible&lt;From, To&gt;</tt>, the
+ following code shall be well formed</del> <ins>If the following code
+ is well formed <tt>is_convertible&lt;From, To&gt;::value</tt> is <tt>true</tt>, otherwise
+ <tt>false</tt></ins>:[..]
+-</blockquote>
++</p></blockquote>
+
+ <p><b>Revision 2</b></p>
+
+ <blockquote>
+
+ <p>
+-In 20.7.6 [meta.rel] change:
++In 20.10.6 [meta.rel] change:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Template</th><th>Condition</th><th>Comments</th>
+ </tr>
++<tr><td>...</td><td>...</td><td>...</td></tr>
+ <tr>
+-</tr><tr><td>...</td><td>...</td><td>...</td></tr>
+-<tr><td><tt>template &lt;class From, class To&gt;<br>struct is_convertible;</tt></td>
++<td><tt>template &lt;class From, class To&gt;<br/>struct is_convertible;</tt></td>
+ <td>
+ <del>The code set out below shall be well formed.</del>
+ <ins><i>see below</i></ins></td>
+ <td><tt>From</tt> and <tt>To</tt> shall be complete types, arrays of unknown bound,
+ or (possibly cv-qualified) <tt>void</tt> types.</td>
+ </tr>
+-</tbody></table>
++</table>
+
+ <p>
+ -4- <del>In order to instantiate the template <tt>is_convertible&lt;From, To&gt;</tt>, the
+@@ -57292,7 +61384,8 @@ following code shall be well formed:</del>
+ <ins>Given the following function prototype:</ins>
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+ </pre></blockquote>
+
+@@ -57305,7 +61398,8 @@ any implicit conversions to the return type of the function, else
+ indirectly from <tt>false_type</tt>.</ins>
+ </p>
+
+-<blockquote><pre>To test() {
++<blockquote><pre>
++To test() {
+ return create&lt;From&gt;();
+ }
+ </pre></blockquote>
+@@ -57322,34 +61416,34 @@ void types, array types, and function types. <i>-- end note</i>]
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-In 20.7.6 [meta.rel] change:
++In 20.10.6 [meta.rel] change:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<tbody><tr>
++<tr>
+ <th>Template</th><th>Condition</th><th>Comments</th>
+ </tr>
++<tr><td>...</td><td>...</td><td>...</td></tr>
+ <tr>
+-</tr><tr><td>...</td><td>...</td><td>...</td></tr>
+-<tr><td><tt>template &lt;class From, class To&gt;<br>struct is_convertible;</tt></td>
++<td><tt>template &lt;class From, class To&gt;<br/>struct is_convertible;</tt></td>
+ <td>
+ <del>The code set out below shall be well formed.</del>
+ <ins><i>see below</i></ins></td>
+ <td><tt>From</tt> and <tt>To</tt> shall be complete types, arrays of unknown bound,
+ or (possibly cv-qualified) <tt>void</tt> types.</td>
+ </tr>
+-</tbody></table>
++</table>
+
+ <p>
+ -4- <del>In order to instantiate the template <tt>is_convertible&lt;From, To&gt;</tt>, the
+@@ -57357,7 +61451,8 @@ following code shall be well formed:</del>
+ <ins>Given the following function prototype:</ins>
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+ </pre></blockquote>
+
+@@ -57369,28 +61464,121 @@ including any implicit conversions to the return type of the
+ function.</ins>
+ </p>
+
+-<blockquote><pre>To test() {
++<blockquote><pre>
++To test() {
+ return create&lt;From&gt;();
+ }
+ </pre></blockquote>
+
+ <p>
+ [<i>Note:</i> This requirement gives well defined results for reference types,
+-void types, array types, and function types. <i>— end note</i>]
++void types, array types, and function types. &mdash; <i>end note</i>]
++</p>
++
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="976"></a>976. Class template <tt>std::stack</tt> should be movable</h3>
++<p><b>Section:</b> 23.6.5.2 [stack.defn] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The synopsis given in 23.6.5.2 [stack.defn] does not show up
++</p>
++
++<blockquote><pre>
++requires MoveConstructible&lt;Cont&gt; stack(stack&amp;&amp;);
++requires MoveAssignable&lt;Cont&gt; stack&amp; operator=(stack&amp;&amp;);
++</pre></blockquote>
++
++<p>
++although the other container adaptors do provide corresponding members.
+ </p>
+
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++We agree with the proposed resolution.
++</p>
++<p>
++Move to Tentatively Ready.
++</p>
+ </blockquote>
+
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Moved from Tentatively Ready to Open only because the wording needs to be
++tweaked for concepts removal.
++</p></blockquote>
++
++<p><i>[
++2009-08-18 Daniel updates the wording and Howard sets to Review.
++]</i></p>
++
++
++<p><i>[
++2009-08-23 Howard adds:
++]</i></p>
++
++
++<blockquote><p>
++<a href="lwg-defects.html#1194">1194</a> also adds these move members using an editorially different style.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark <del>NAD Editorial</del><ins>Resolved</ins>, addressed by issue <a href="lwg-defects.html#1194">1194</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++In the class stack synopsis of 23.6.5.2 [stack.defn] insert:
++</p>
++
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
++class stack {
++ [..]
++ explicit stack(const Container&amp;);
++ explicit stack(Container&amp;&amp; = Container());
++ <ins>stack(stack&amp;&amp; s) : c(std::move(s.c)) {}</ins>
++ <ins>stack&amp; operator=(stack&amp;&amp; s) { c = std::move(s.c); return *this; }</ins>
++ [..]
++};
++</pre></blockquote>
++
++
++
++
+
+
+
+
+ <hr>
+ <h3><a name="978"></a>978. Hashing smart pointers</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-02 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-02-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 208</b></p>
+ <p>
+@@ -57420,7 +61608,7 @@ Bill would prefer to be conservative.
+ </p>
+ <p>
+ Alisdair mentions that this issue may also be viewed as a subissue or
+-duplicate of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1025">1025</a>.
++duplicate of issue <a href="lwg-active.html#1025">1025</a>.
+ </p>
+ <p>
+ Move to Open, and recommend the issue be deferred until after the next
+@@ -57434,9 +61622,9 @@ Committee Draft is issued.
+
+
+ <blockquote>
+-<blockquote>
++<blockquote><p>
+ Howard points out that the client can always supply a custom hash function.
+-</blockquote>
++</p></blockquote>
+ <p>
+ Not entirely true. The client cannot supply the function that hashes the
+ address of the control block (the equivalent of the old <tt>operator&lt;</tt>, now
+@@ -57462,9 +61650,9 @@ This hash function makes sense in certain situations for <tt>shared_ptr</tt>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-16 Moved from Ready to Open:
+@@ -57494,9 +61682,9 @@ containers.
+ Howard writes:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Is this a request to pull 978 from Ready?
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Barry writes:
+@@ -57511,7 +61699,7 @@ Ready.
+ </blockquote>
+
+ <p><i>[
+-2010-01-31 Alisdair: related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>.
++2010-01-31 Alisdair: related to <a href="lwg-defects.html#1245">1245</a> and <a href="lwg-defects.html#1182">1182</a>.
+ ]</i></p>
+
+
+@@ -57530,7 +61718,7 @@ Ready.
+ <p><b>Proposed resolution:</b></p>
+
+ <p><i>Add the following declarations to the synopsis of <tt>&lt;memory&gt;</tt> in
+-20.9 [memory] </i></p>
++20.7 [memory] </i></p>
+
+ <blockquote>
+ <pre><ins>// [util.smartptr.hash] hash support
+@@ -57539,7 +61727,7 @@ template &lt;class T, class D&gt; struct hash&lt;unique_ptr&lt;T,D&gt;&gt;;
+ template &lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt;&gt;;</ins></pre>
+ </blockquote>
+
+-<p><i>Add a new subclause under 20.9.10 [util.smartptr] called hash support </i></p>
++<p><i>Add a new subclause under 20.8.2 [util.smartptr] called hash support </i></p>
+
+ <blockquote>
+ <h3><ins>hash support [util.smartptr.hash]</ins></h3>
+@@ -57548,7 +61736,7 @@ template &lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt;&gt;;</ins></pre>
+
+ <blockquote>
+ <p><ins>
+-Specialization meeting the requirements of class template <tt>hash</tt> (20.8.15 [unord.hash]). For an object <tt>p</tt> of type <tt>UP</tt>, where
++Specialization meeting the requirements of class template <tt>hash</tt> (20.9.13 [unord.hash]). For an object <tt>p</tt> of type <tt>UP</tt>, where
+ <tt>UP</tt> is a type <tt>unique_ptr&lt;T,D&gt;</tt>,
+ <tt>hash&lt;UP&gt;()(p)</tt> shall evaluate to the same value as
+ <tt>hash&lt;typename UP::pointer&gt;()(p.get())</tt>. The specialization
+@@ -57560,7 +61748,7 @@ Specialization meeting the requirements of class template <tt>hash</tt> (20.8.15
+
+ <blockquote>
+ <p><ins>
+-Specialization meeting the requirements of class template <tt>hash</tt> (20.8.15 [unord.hash]). For an object <tt>p</tt> of type
++Specialization meeting the requirements of class template <tt>hash</tt> (20.9.13 [unord.hash]). For an object <tt>p</tt> of type
+ <tt>shared_ptr&lt;T&gt;</tt>, <tt>hash&lt;shared_ptr&lt;T&gt;&gt;()(p)</tt>
+ shall evaluate to the same value as <tt> hash&lt;T*&gt;()(p.get())</tt>.
+ </ins></p>
+@@ -57574,11 +61762,11 @@ shall evaluate to the same value as <tt> hash&lt;T*&gt;()(p.get())</tt>.
+
+ <hr>
+ <h3><a name="981"></a>981. Unordered container requirements should add <tt>initializer_list</tt> support</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-02-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-02-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Refering to
+@@ -57586,7 +61774,7 @@ Refering to
+ all container requirements tables (including those for
+ associative containers) provide useful member function overloads
+ accepting <tt>std::initializer_list</tt> as argument, the only exception is
+-Table 87. There seems to be no reason for not providing them, because 23.7 [unord]
++Table 87. There seems to be no reason for not providing them, because 23.5 [unord]
+ is already <tt>initializer_list</tt>-aware. For the sake of
+ library interface consistency and user-expectations corresponding
+ overloads should be added to the table requirements of unordered
+@@ -57613,11 +61801,11 @@ Move to Tentatively Ready.
+ In 23.2.5 [unord.req]/9 insert:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... <tt>[q1, q2)</tt> is a valid range in <tt>a</tt>, <ins><tt>il</tt>
+ designates an object of type <tt>initializer_list&lt;value_type&gt;</tt>, </ins><tt>t</tt> is a value of type
+ <tt>X::value_type</tt>, ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ In 23.2.5 [unord.req], Table 87 insert:
+@@ -57626,11 +61814,11 @@ In 23.2.5 [unord.req], Table 87 insert:
+ <blockquote>
+ <table border="1">
+ <caption>Table 87 - Unordered associative container requirements (in addition to container)</caption>
+-<tbody><tr>
+-<th>Expression</th> <th>Return type</th> <th>Assertion/note<br>pre-/post-condition</th> <th>Complexity</th>
++<tr>
++<th>Expression</th> <th>Return type</th> <th>Assertion/note<br/>pre-/post-condition</th> <th>Complexity</th>
+ </tr>
+ <tr>
+-<td><tt>X(i, j)<br>X a(i, j)</tt></td> <td><tt>X</tt></td> <td>...</td> <td>...</td>
++<td><tt>X(i, j)<br/>X a(i, j)</tt></td> <td><tt>X</tt></td> <td>...</td> <td>...</td>
+ </tr>
+ <tr>
+ <td><ins><tt>X(il)</tt></ins></td> <td><ins><tt>X</tt></ins></td>
+@@ -57659,7 +61847,7 @@ In 23.2.5 [unord.req], Table 87 insert:
+ <td><ins>Same as <tt>a.insert(il.begin(), il.end())</tt>.</ins></td>
+ <td><ins>Same as <tt>a.insert(il.begin(), il.end())</tt>.</ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -57669,11 +61857,11 @@ In 23.2.5 [unord.req], Table 87 insert:
+
+ <hr>
+ <h3><a name="982"></a>982. Wrong complexity for initializer_list assignment in Table 85</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-02-08 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-02-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ According to
+@@ -57706,14 +61894,14 @@ In 23.2.4 [associative.reqmts], Table 85 change:
+ <blockquote>
+ <table border="1">
+ <caption>Table 85 - Associative container requirements (in addition to container)</caption>
+-<tbody><tr>
+-<th>Expression</th> <th>Return type</th> <th>Assertion/note<br>pre-/post-condition</th> <th>Complexity</th>
++<tr>
++<th>Expression</th> <th>Return type</th> <th>Assertion/note<br/>pre-/post-condition</th> <th>Complexity</th>
+ </tr>
+ <tr>
+-<td><tt>a = il</tt></td> <td><tt>X&amp;</tt></td> <td><tt>a = X(il);<br>return *this;</tt></td>
++<td><tt>a = il</tt></td> <td><tt>X&amp;</tt></td> <td><tt>a = X(il);<br/>return *this;</tt></td>
+ <td><del>constant</del><ins>Same as <tt>a = X(il)</tt>.</ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -57723,10 +61911,10 @@ In 23.2.4 [associative.reqmts], Table 85 change:
+
+ <hr>
+ <h3><a name="983"></a>983. <tt>unique_ptr</tt> reference deleters should not be moved from</h3>
+-<p><b>Section:</b> 20.9.9.2 [unique.ptr.single] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-10 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.8.1.2 [unique.ptr.single] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Dave brought to my attention that when a <tt>unique_ptr</tt> has a non-const reference
+@@ -57734,10 +61922,11 @@ type deleter, move constructing from it, even when the <tt>unique_ptr</tt> conta
+ the reference is an rvalue, could have surprising results:
+ </p>
+
+-<blockquote><pre>D d(some-state);
++<blockquote><pre>
++D d(some-state);
+ unique_ptr&lt;A, D&amp;&gt; p(new A, d);
+ unique_ptr&lt;A, D&gt; p2 = std::move(p);
+-<font color="#C80000">// has d's state changed here?</font>
++<span style="#C80000">// has d's state changed here?</span>
+ </pre></blockquote>
+
+ <p>
+@@ -57754,30 +61943,30 @@ Thanks Dave.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Seems correct, but complicated enough that we recommend moving to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-14 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We moved
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">N3073</a>
+ to the formal motions page in Pittsburgh which should obsolete this issue. I've
+ moved this issue to NAD Editorial, solved by N3073.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -57789,11 +61978,12 @@ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor], p20-21
++Change 20.8.1.2.1 [unique.ptr.single.ctor], p20-21
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -57812,7 +62002,7 @@ a reference type, then <tt>E</tt> shall be the same type as <tt>D</tt>
+ (diagnostic required). <tt>unique_ptr&lt;U, E&gt;::pointer</tt> shall be
+ implicitly convertible to <tt>pointer</tt>. [<tt>Note:</tt> These
+ requirements imply that <tt>T</tt> and <tt>U</tt> are complete types.
+-<i>-- end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+
+ <p>
+@@ -57823,7 +62013,7 @@ deleter</ins> is move constructed from <tt>u</tt>'s deleter, otherwise
+ <del>the reference</del> <ins>this deleter</ins> is copy constructed
+ from <tt>u</tt>.'s deleter. After the construction, <tt>u</tt> no longer
+ owns a pointer. [<i>Note:</i> The deleter constructor can be implemented
+-with <tt>std::forward&lt;<del>D</del><ins>E</ins>&gt;</tt>. <i>-- end
++with <tt>std::forward&lt;<del>D</del><ins>E</ins>&gt;</tt>. &mdash; <i>end
+ note</i>]
+ </p>
+
+@@ -57831,11 +62021,12 @@ note</i>]
+ </blockquote>
+
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn], p1-3
++Change 20.8.1.2.3 [unique.ptr.single.asgn], p1-3
+ </p>
+
+ <blockquote>
+-<pre>unique_ptr&amp; operator=(unique_ptr&amp;&amp; u);
++<pre>
++unique_ptr&amp; operator=(unique_ptr&amp;&amp; u);
+ </pre>
+ <blockquote>
+
+@@ -57857,17 +62048,18 @@ a<ins>n</ins> <del>move</del> assignment from <del><tt>u</tt>'s deleter to this
+ -3- <i>Postconditions:</i> This <tt>unique_ptr</tt> now owns the pointer
+ which <tt>u</tt> owned, and <tt>u</tt> no longer owns it. <del>[<i>Note:</i> If
+ <tt>D</tt> is a reference type, then the referenced lvalue deleters are
+-move assigned. <i>-- end note</i>]</del>
++move assigned. &mdash; <i>end note</i>]</del>
+ </p>
+ </blockquote>
+ </blockquote>
+
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn], p6-7
++Change 20.8.1.2.3 [unique.ptr.single.asgn], p6-7
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
++<pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u);
+ </pre>
+ <blockquote>
+
+@@ -57879,8 +62071,8 @@ Change 20.9.9.2.3 [unique.ptr.single.asgn], p6-7
+ Otherwise the deleter <tt>E</tt> is a reference type,
+ and assignment of the deleter <tt>D</tt> from an lvalue <tt>E</tt> shall not throw an exception.</ins>
+ <tt>unique_ptr&lt;U, E&gt;::pointer</tt> shall be implicitly convertible to <tt>pointer</tt>.
+-[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U&gt;</tt>
+-are complete types. <i>-- end note</i>]
++[<i>Note:</i> These requirements imply that <tt>T</tt> and <tt>U></tt>
++are complete types. &mdash; <i>end note</i>]
+ </p>
+
+ <p>
+@@ -57902,32 +62094,32 @@ deleter participates in the move assignment.</del>
+
+ <hr>
+ <h3><a name="984"></a>984. Does <tt>&lt;cinttypes&gt;</tt> have macro guards?</h3>
+-<p><b>Section:</b> 27.9.2 [c.files] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-12 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.9.2 [c.files] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.files">issues</a> in [c.files].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The C standard says about <tt>&lt;inttypes.h&gt;</tt>:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ C++ implementations should define these macros only when <tt>__STDC_FORMAT_MACROS</tt>is defined
+ before <tt>&lt;inttypes.h&gt;</tt> is included.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The C standard has a similar note about <tt>&lt;stdint.h&gt;</tt>. For <tt>&lt;cstdint&gt;</tt>
+-we adopted a "thanks but no thanks" policy and documented that fact in
+-18.4.1 [cstdint.syn]:
++we adopted a "thanks but no thanks" policy and documented that fact in 18.4.1 [cstdint.syn]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... [<i>Note:</i> The macros defined by <tt>&lt;stdint&gt;</tt> are
+ provided unconditionally. In particular, the symbols
+ <tt>__STDC_LIMIT_MACROS</tt> and <tt>__STDC_CONSTANT_MACROS</tt>
+ (mentioned in C99 footnotes 219, 220, and 222) play no role in C++.
+-<i>-- end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ I recommend we put a similar note in 27.9.2 [c.files] regarding <tt>&lt;cinttypes&gt;</tt>.
+@@ -57937,10 +62129,10 @@ I recommend we put a similar note in 27.9.2 [c.files] regarding <tt>&lt;cinttype
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -57948,26 +62140,352 @@ Move to Tentatively Ready.
+ Add to 27.9.2 [c.files]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Table 112 describes header <tt>&lt;cinttypes&gt;</tt>.
+ <ins>
+ [<i>Note:</i> The macros defined by <tt>&lt;cintypes&gt;</tt> are
+ provided unconditionally. In particular, the symbol
+ <tt>__STDC_FORMAT_MACROS</tt>
+ (mentioned in C99 footnote 182) plays no role in C++.
+-<i>-- end note</i>]
++&mdash; <i>end note</i>]
+ </ins>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="985"></a>985. Allowing throwing move</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Rani Sharoni <b>Opened:</b> 2009-02-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<b>Introduction</b>
++</p>
++
++<p>This proposal is meant to resolve potential regression of the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2800.pdf">N2800</a>
++draft, see
++next section, and to relax the requirements for containers of types with
++throwing move constructors.</p>
++
++<p>The basic problem is that some containers operations, like <tt>push_back</tt>,
++have a strong exception safety
++guarantee (i.e. no side effects upon exception) that are not achievable when
++throwing move constructors are used since there is no way to guarantee revert
++after partial move. For such operations the implementation can at most provide
++the basic guarantee (i.e. valid but unpredictable) as it does with multi
++copying operations (e.g. range insert).</p>
++
++<p>For example, <tt>vector&lt;T&gt;::push_back()</tt> (where <tt>T</tt> has a move
++constructor) might resize the <tt>vector</tt> and move the objects to the new underlying
++buffer. If move constructor throws it might
++not be possible to recover the throwing object or to move the old objects back to
++the original buffer.</p>
++
++<p>The current draft is explicit by disallowing throwing move
++for some operations (e.g. <tt>vector&lt;&gt;::reserve</tt>) and not clear about other
++operations mentioned in 23.2.1 [container.requirements.general]/10
++(e.g. single element <tt>insert</tt>): it guarantees strong exception
++safety without explicitly disallowing a throwing move constructor.
++</p>
++
++<p>
++<b>Regression</b>
++</p>
++
++<p>This section only refers to cases in which the contained object
++is by itself a standard container.</p>
++
++<p>Move constructors of standard containers are allowed to throw and therefore
++existing operations are broken, compared with C++03, due to move optimization.
++(In fact existing implementations like Dinkumware are actually throwing).</p>
++
++<p>For example, <tt>vector&lt; list&lt;int&gt; &gt;::reserve</tt> yields
++undefined behavior since <tt>list&lt;int&gt;</tt>'s move constructor is allowed to throw.
++On the other hand, the same operation has strong exception safety guarantee in
++C++03.</p>
++
++<p>There are few options to solve this regression:</p>
++
++<ol>
++<li>
++Disallow throwing move and throwing default constructor
++</li>
++
++<li>
++Disallow throwing move but disallowing usage after move
++</li>
++
++<li>
++Special casing
++</li>
++
++<li>
++Disallow throwing move and making it optional
++</li>
++
++</ol>
++
++<p>Option 1 is suggested by proposal
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2815.html">N2815</a>
++but it might not be applicable for existing implementations for which
++containers default constructors are throwing.</p>
++
++<p>Option 2 limits the usage significantly and it's error prone
++by allowing zombie objects that are nothing but destructible (e.g. no <tt>clear()</tt>
++is allowed after move). It also potentially complicates the implementation by
++introducing special state.</p>
++
++<p>Option 3 is possible, for example, using default
++construction and <tt>swap</tt> instead of move for standard containers case. The
++implementation is also free to provide special hidden operation for non
++throwing move without forcing the user the cope with the limitation of option-2
++when using the public move.</p>
++
++<p>Option 4 impact the efficiency in all use cases due to rare throwing move.</p>
++
++<p>The proposed wording will imply option 1 or 3 though option 2 is also
++achievable using more wording. I personally oppose to option 2 that has impact
++on usability.</p>
++
++<p>
++<b>Relaxation for user types</b>
++</p>
++
++<p>Disallowing throwing move constructors in general seems very restrictive
++since, for example, common implementation of move will be default construction
+++ <tt>swap</tt> so move will throw if the
++default constructor will throw. This is currently the case with the Dinkumware
++implementation of node based containers (e.g. <tt>std::list</tt>)
++though this section doesn't refer to standard types.</p>
++
++<p>For throwing move constructors it seem that the implementation should have
++no problems to provide the basic guarantee instead of the strong one. It's
++better to allow throwing move constructors with basic guarantee than to
++disallow it silently (compile and run), via undefined behavior.</p>
++
++<p>There might still be cases in which the relaxation will break existing generic
++code that assumes the strong guarantee but it's broken either way given a
++throwing move constructor since this is not a preserving optimization. </p>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++Bjarne comments (referring to his draft paper):
++"I believe that my suggestion simply solves that. Thus, we don't need a throwing move."
++</p>
++<p>
++Move to Open and recommend it be deferred until after the next
++Committee Draft is issued.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Should wait to get direction from Dave/Rani
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2983.html">N2983</a>).
++</p></blockquote>
++
++<p><i>[
++2010-03-28 Daniel updated wording to sync with N3092.
++]</i></p>
++
++
++<blockquote>
++<p>
++The suggested change of 23.3.3.4 [deque.modifiers]/2 should be removed,
++because the current wording does say more general things:
++</p>
++
++<blockquote><p>
++2 <i>Remarks:</i> If an exception is thrown other than by the copy constructor,
++move constructor, assignment operator, or move assignment operator of <tt>T</tt>
++there are no effects. If an exception is thrown by the move constructor of a
++non-CopyConstructible <tt>T</tt>, the effects are unspecified.
++</p></blockquote>
++
++<p>
++The suggested change of 23.3.6.3 [vector.capacity]/2 should be removed,
++because the current wording does say more general things:
++</p>
++
++<blockquote><p>
++2 <i>Effects:</i> A directive that informs a <tt>vector</tt> of a planned change
++in size, so that it can manage the storage allocation accordingly. After
++<tt>reserve()</tt>, <tt>capacity()</tt> is greater or equal to the argument of
++<tt>reserve</tt> if reallocation happens; and equal to the previous value of
++<tt>capacity()</tt> otherwise. Reallocation happens at this point if and only if
++the current capacity is less than the argument of <tt>reserve()</tt>. If an
++exception is thrown other than by the move constructor of a
++non-<tt>CopyConstructible</tt> type, there are no effects.
++</p></blockquote>
++
++</blockquote>
++
++<p><i>[2011-03-15: Daniel updates wording to sync with N3242 and comments]</i></p>
++
++
++<blockquote><p>
++The issue has nearly been resolved by previous changes to the working paper, in
++particular all suggested changes for <tt>deque</tt> and <tt>vector</tt> are no
++longer necessary. The still remaining parts involve the unordered associative containers.
++</p></blockquote>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>It looks like this issue has been resolved already by <tt>noexcept</tt> paper N3050</p>
++
++
++<p><b>Rationale:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html">N3050</a>
++</p>
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++23.2.1 [container.requirements.general] paragraph 10 add footnote:
++</p>
++
++<blockquote>
++<p>
++-10- Unless otherwise specified (see 23.2.4.1 [associative.reqmts.except], 23.2.5.1 [unord.req.except],
++23.3.3.4 [deque.modifiers], and 23.3.6.5 [vector.modifiers]) all container types defined in this
++Clause meet the following additional requirements:
++</p>
++<ul>
++<li>&hellip;</li>
++</ul>
++
++<p>
++<ins>[<i>Note</i>: for compatibility with C++ 2003, when "no effect" is required, standard containers should not use the
++<tt>value_type</tt>'s throwing move constructor when the contained object is by itself a standard container. &mdash; <i>end note</i>]</ins>
++</p>
++
+ </blockquote>
+
++<p>23.2.5.1 [unord.req.except] change paragraph 2+4 to say: </p>
++
++<blockquote>
++<p>
++-2- For unordered associative containers, if an exception is
++thrown by any operation other than the container's hash function from within an
++<tt>insert()</tt> function inserting a single element, the <tt>insert()</tt>
++function has no effect<ins> unless the exception is thrown by the contained
++object move constructor</ins>.
++<p/>
++[&hellip;]
++<p/>
++-4- For unordered associative containers, if an exception is
++thrown from within a <tt>rehash()</tt> function other than by the container's hash
++function or comparison function, the <tt>rehash()</tt> function has no effect
++<ins>unless the exception is thrown by the contained
++object move constructor</ins>.</p>
++
++</blockquote>
++
++<p>
++Keep 23.3.3.4 [deque.modifiers] paragraph 2 unchanged <em>[Drafting note: The originally
++proposed wording did suggest to add a last sentence as follows:</em>
++</p>
++<blockquote><p>
++<em><ins>If an exception is thrown by <tt>push_back()</tt> or <tt>emplace_back()</tt>
++function, that function has no effects unless the exception is thrown by
++the move constructor of <tt>T</tt>.</ins></em>
++</p></blockquote>
++<p> &mdash; <em> end drafting note ]</em></p>
++
++<blockquote><p>
++-2- <i>Remarks:</i> If an exception is thrown other than by
++the copy constructor, move constructor, assignment operator,
++or move assignment operator of <tt>T</tt> there are no effects.
++If an exception is thrown by the move constructor of a non-CopyInsertable
++<tt>T</tt>, the effects are unspecified.
++</p></blockquote>
++
++<p>
++Keep 23.3.6.3 [vector.capacity] paragraph 2 unchanged <em>[Drafting note: The originally
++proposed wording did suggest to change the last sentence as follows:</em>
++</p>
++<blockquote><p>
++<em>If an exception is thrown, there are no effects<ins> unless the exception is thrown by the
++contained object move constructor</ins>.</em>
++</p></blockquote>
++<p> &mdash; <em> end drafting note ]</em></p>
++
++<blockquote><p>
++-2- <i>Effects:</i> A directive that informs a <tt>vector</tt>
++of a planned change in size, so
++that it can manage the storage allocation accordingly. After <tt>reserve()</tt>,
++<tt>capacity()</tt> is greater or equal to the argument of <tt>reserve</tt>
++if reallocation happens; and equal
++to the previous value of <tt>capacity()</tt>
++otherwise. Reallocation happens at this point if and only if the current
++capacity is less than the argument of <tt>reserve()</tt>.
++If an exception is thrown other than by the move constructor of a
++non-<tt>CopyInsertable</tt> type, there are no effects.
++</p></blockquote>
++
++<p>
++Keep 23.3.6.3 [vector.capacity] paragraph 12 unchanged <em>[Drafting note: The originally
++proposed wording did suggest to change the old paragraph as follows:</em>
++</p>
++<blockquote><p>
++<em>-12- <i>Requires:</i> <del>If <tt>value_type</tt> has a move constructor,
++that constructor shall not throw any exceptions.</del>
++<ins>If an exception is thrown, there are no effects unless the exception is thrown by
++the contained object move constructor.</ins></em>
++</p></blockquote>
++<p> &mdash; <em> end drafting note ]</em></p>
++
++<blockquote><p>
++-12- <i>Requires:</i> If an exception is thrown other than by the move constructor of a non-<tt>CopyInsertable</tt>
++<tt>T</tt> there are no effects.
++</p></blockquote>
++
++<p>
++Keep 23.3.6.5 [vector.modifiers] paragraph 1 unchanged <em>[Drafting note: The originally
++proposed wording did suggest to change the old paragraph as follows:</em>
++</p>
++<blockquote><p>
++<em>-1- <del><i>Requires:</i> If <tt>value_type</tt> has a move constructor,
++that constructor shall not throw any exceptions.</del>
++<ins><i>Remarks:</i> If an exception is thrown by <tt>push_back()</tt>
++or <tt>emplace_back()</tt> function, that function has no effect unless the
++exception is thrown by the move constructor of <tt>T</tt>.</ins></em>
++</p></blockquote>
++<p> &mdash; <em> end drafting note ]</em></p>
++
++<blockquote><p>
++-1- <i>Remarks</i>: Causes reallocation if the new size is greater than the old capacity. If no reallocation happens,
++all the iterators and references before the insertion point remain valid. If an exception is thrown other
++than by the copy constructor, move constructor, assignment operator, or move assignment operator
++of <tt>T</tt> or by any <tt>InputIterator</tt> operation there are no effects. If an exception is thrown by the move
++constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</p></blockquote>
++
++
+
+
+
+
+ <hr>
+ <h3><a name="986"></a>986. Generic <tt>try_lock</tt> contradiction</h3>
+-<p><b>Section:</b> 30.4.3 [thread.lock.algorithm] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Chris Fairles <b>Opened:</b> 2009-02-14 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.4.3 [thread.lock.algorithm] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Chris Fairles <b>Opened:</b> 2009-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 30.4.3 [thread.lock.algorithm], the generic <tt>try_lock</tt> effects (p2) say that a failed
+@@ -57983,7 +62501,8 @@ will be. So what happens if multiple locks fail on <tt>try_lock</tt>?
+ Example:
+ </p>
+
+-<blockquote><pre>#include &lt;mutex&gt;
++<blockquote><pre>
++#include &lt;mutex&gt;
+
+ int main() {
+ std::mutex m0, m1, m2;
+@@ -58018,18 +62537,18 @@ Further discussion and possible resolutions in c++std-lib-23049.
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to review. Agree with proposed resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58038,25 +62557,25 @@ Move to Tentatively Ready.
+ Change 30.4.3 [thread.lock.algorithm], p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- <i>Effects:</i> Calls <tt>try_lock()</tt> for each argument in order
+ beginning with the first until all arguments have been processed or a
+ call to <tt>try_lock()</tt> fails, either by returning <tt>false</tt> or by throwing an
+ exception. If a call to <tt>try_lock()</tt> fails, <tt>unlock()</tt> shall be called for
+ all prior arguments<ins> and there shall be no further calls to <tt>try_lock()</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Delete the note from 30.4.3 [thread.lock.algorithm], p3
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -3- <i>Returns:</i> -1 if all calls to <tt>try_lock()</tt> returned <tt>true</tt>,
+ otherwise a 0-based index value that indicates
+ the argument for which <tt>try_lock()</tt> returned <tt>false</tt>. <del>[<i>Note:</i>
+ On return, either all arguments will be
+ locked or none will be locked. -- <i>end note</i>]</del>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -58064,16 +62583,17 @@ locked or none will be locked. -- <i>end note</i>]</del>
+
+ <hr>
+ <h3><a name="987"></a>987. <tt>reference_wrapper</tt> and function types</h3>
+-<p><b>Section:</b> 20.8.4 [refwrap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-18 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#refwrap">issues</a> in [refwrap].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.4 [refwrap] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-02-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap">issues</a> in [refwrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The synopsis in 20.8.4 [refwrap] says:
++The synopsis in 20.9.4 [refwrap] says:
+ </p>
+
+-<blockquote><pre>template &lt;<b>ObjectType</b> T&gt; class reference_wrapper
++<blockquote><pre>
++template &lt;<b>ObjectType</b> T&gt; class reference_wrapper
+ ...
+ </pre></blockquote>
+
+@@ -58131,7 +62651,7 @@ where <tt>F</tt> is a function type, represents a reference to a function,
+ a legitimate entity. So <tt>boost::ref</tt> was changed to allow it.
+ </p>
+ <p>
+-<a href="https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp">https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp</a>
++<a href="http://svn.boost.org/svn/boost/trunk/libs/bind/test/ref_fn_test.cpp">http://svn.boost.org/svn/boost/trunk/libs/bind/test/ref_fn_test.cpp</a>
+ </p>
+ <p>
+ Therefore, I believe an alternative proposed resolution for issue 987 could simply
+@@ -58151,7 +62671,8 @@ is code that demonstrates how easy (and useful) it is to instantiate
+ <tt>reference_wrapper</tt> with a function type:
+ </p>
+
+-<blockquote><pre>#include &lt;functional&gt;
++<blockquote><pre>
++#include &lt;functional&gt;
+
+ template &lt;class F&gt;
+ void test(F f);
+@@ -58169,7 +62690,8 @@ Output (link time error shows type of <tt>reference_wrapper</tt> instantiated
+ with function type):
+ </p>
+
+-<blockquote><pre>Undefined symbols:
++<blockquote><pre>
++Undefined symbols:
+ "void test&lt;std::reference_wrapper&lt;void ()()&gt; &gt;(std::reference_wrapper&lt;void ()()&gt;)",...
+ </pre></blockquote>
+
+@@ -58221,10 +62743,10 @@ implied reference collapsing the intended result?
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Review to Open only because the wording needs to be
+ tweaked for concepts removal.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-14 Daniel provided de-conceptified wording.
+@@ -58236,22 +62758,22 @@ tweaked for concepts removal.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.4 [refwrap]/1 as indicated:
++Change 20.9.4 [refwrap]/1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>reference_wrapper&lt;T&gt;</tt> is a <tt>CopyConstructible</tt> and
+ <tt><ins>Copy</ins>Assignable</tt> wrapper around a
+ reference to an object <ins>or function</ins> of type <tt>T</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -58262,10 +62784,10 @@ reference to an object <ins>or function</ins> of type <tt>T</tt>.
+
+ <hr>
+ <h3><a name="990"></a>990. <tt>monotonic_clock::is_monotonic</tt> must be <tt>true</tt></h3>
+-<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There is some confusion over what the value of <tt>monotonic_clock::is_monotonic</tt>
+@@ -58293,25 +62815,27 @@ Move to Tentatively Ready.
+ Change X [time.clock.monotonic], p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -1- Objects of class <tt>monotonic_clock</tt> represent clocks for which
+ values of <tt>time_point</tt> never decrease as physical time advances.
+ <tt>monotonic_clock</tt> may be a synonym for <tt>system_clock</tt>
+ <ins>if and only if <tt>system_clock::is_monotonic</tt> is
+ <tt>true</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="991"></a>991. Response to JP 50</h3>
+-<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="991"></a>991. Provide allocator for <tt>wstring_convert</tt></h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses JP-50 [CD1]</b></p>
+ <p>
+ Add custom allocator parameter to <tt>wstring_convert</tt>, since we cannot
+ allocate memory for strings from a custom allocator.
+@@ -58321,10 +62845,10 @@ allocate memory for strings from a custom allocator.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58332,7 +62856,8 @@ Move to Tentatively Ready.
+ Change 22.3.3.2.2 [conversions.string]:
+ </p>
+
+-<blockquote><pre>template&lt;class Codecvt, class Elem = wchar_t<ins>,
++<blockquote><pre>
++template&lt;class Codecvt, class Elem = wchar_t<ins>,
+ class Wide_alloc = std::allocator&lt;Elem&gt;,
+ class Byte_alloc = std::allocator&lt;char&gt; </ins>&gt; class wstring_convert {
+ public:
+@@ -58345,14 +62870,14 @@ Change 22.3.3.2.2 [conversions.string]:
+ Change 22.3.3.2.2 [conversions.string], p3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -3- The class template describes an ob ject that controls conversions
+ between wide string ob jects of class
+ <tt>std::basic_string&lt;Elem<ins>, char_traits&lt;Elem&gt;, Wide_alloc</ins>&gt;</tt>
+ and byte string objects of class
+ <tt>std::basic_string&lt;char<ins>, char_traits&lt;char&gt;, Byte_alloc</ins>&gt;</tt>
+ <del>(also known as <tt>std::string</tt>)</del>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -58360,12 +62885,13 @@ and byte string objects of class
+
+
+ <hr>
+-<h3><a name="993"></a>993. Response to UK 188</h3>
+-<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="993"></a>993. <tt>_Exit</tt> needs better specification</h3>
++<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK-188 [CD1]</b></p>
+ <p>
+ The function <tt>_Exit</tt> does not appear to be defined in this standard.
+ Should it be added to the table of functions included-by-reference to
+@@ -58381,10 +62907,10 @@ the C standard?
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58393,14 +62919,16 @@ Add to 18.5 [support.start.term] Table 20 (Header
+ <tt>&lt;cstdlib&gt;</tt> synopsis) Functions:
+ </p>
+
+-<blockquote><pre>_Exit
++<blockquote><pre>
++_Exit
+ </pre></blockquote>
+
+ <p>
+ Add before the description of <tt>abort(void)</tt>:
+ </p>
+
+-<blockquote><pre>void _Exit [[noreturn]] (int status)
++<blockquote><pre>
++void _Exit [[noreturn]] (int status)
+ </pre>
+
+ <blockquote>
+@@ -58424,24 +62952,25 @@ functions passed to <tt>atexit()</tt> (3.6.3 [basic.start.term]).
+
+
+ <hr>
+-<h3><a name="994"></a>994. Response to UK 193</h3>
+-<p><b>Section:</b> 18.6.2.3 [new.handler] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="994"></a>994. <tt>quick_exit</tt> should terminate well-defined</h3>
++<p><b>Section:</b> 18.6.2.3 [new.handler] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK-193 [CD1]</b></p>
+ <p>
+ <tt>quick_exit</tt> has been added as a new valid way to terminate a program in a
+-well defined way
++well defined way.
+ </p>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58469,12 +62998,13 @@ Change 18.6.2.3 [new.handler], p2:
+
+
+ <hr>
+-<h3><a name="997"></a>997. Response to UK 163</h3>
+-<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="997"></a>997. "<i>Effects</i>: Equivalent to" is underspecified</h3>
++<p><b>Section:</b> 17.5.1.4 [structure.specifications] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Thomas Plum <b>Opened:</b> 2009-03-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#structure.specifications">issues</a> in [structure.specifications].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses UK-163 [CD1]</b></p>
+ <p>
+ Many functions are defined as "Effects: Equivalent to a...", which seems
+ to also define the preconditions, effects, etc. But this is not made
+@@ -58509,18 +63039,18 @@ result in much less editorial re-work.
+ ]</i></p>
+
+
+-<blockquote>
+-This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#492">492</a>.
+-</blockquote>
++<blockquote><p>
++This issue is related to <a href="lwg-closed.html#492">492</a>.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58590,17 +63120,18 @@ supersedes any occurrences of that element in the <i>code-sequence</i>.
+
+ <hr>
+ <h3><a name="998"></a>998. Smart pointer referencing its owner</h3>
+-<p><b>Section:</b> 20.9.9.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pavel Minaev <b>Opened:</b> 2009-02-26 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.1.2.5 [unique.ptr.single.modifiers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pavel Minaev <b>Opened:</b> 2009-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.modifiers">issues</a> in [unique.ptr.single.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Consider the following (simplified) implementation of
+ <tt>std::auto_ptr&lt;T&gt;::reset()</tt>:
+ </p>
+
+-<blockquote><pre>void reset(T* newptr = 0) {
++<blockquote><pre>
++void reset(T* newptr = 0) {
+ if (this-&gt;ptr &amp;&amp; this-&gt;ptr != newptr) {
+ delete this-&gt;ptr;
+ }
+@@ -58612,7 +63143,8 @@ Consider the following (simplified) implementation of
+ Now consider the following code which uses the above implementation:
+ </p>
+
+-<blockquote><pre>struct foo {
++<blockquote><pre>
++struct foo {
+ std::auto_ptr&lt;foo&gt; ap;
+ foo() : ap(this) {}
+ void reset() { ap.reset(); }
+@@ -58664,10 +63196,10 @@ Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ To fix this behavior <tt>reset</tt> must be specified such that deleting the
+ pointer is the last action to be taken within <tt>reset</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Alisdair adds:
+@@ -58676,7 +63208,7 @@ Alisdair adds:
+
+ <blockquote>
+ <p>
+-The example providing the rationale for LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#998">998</a> is poor, as it relies on
++The example providing the rationale for LWG <a href="lwg-defects.html#998">998</a> is poor, as it relies on
+ broken semantics of having two object believing they are unique owners of a
+ single resource. It should not be surprising that UB results from such
+ code, and I feel no need to go out of our way to support such behaviour.
+@@ -58696,13 +63228,13 @@ Batavia (2009-05):
+ <p>
+ Howard summarizes:
+ </p>
+-<blockquote>
++<blockquote><p>
+ This issue has to do with circular ownership,
+ and affects <tt>auto_ptr</tt>, too (but we don't really care about that).
+ It is intended to spell out the order in which operations must be performed
+ so as to avoid the possibility
+ of undefined behavior in the self-referential case.
+-</blockquote>
++</p></blockquote>
+ <p>
+ Howard points to message c++std-lib-23175 for another example,
+ requested by Alisdair.
+@@ -58717,7 +63249,7 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.9.2.5 [unique.ptr.single.modifiers], p5 (<i>Effects</i> clause for <tt>reset</tt>), and p6:
++Change 20.8.1.2.5 [unique.ptr.single.modifiers], p5 (<i>Effects</i> clause for <tt>reset</tt>), and p6:
+ </p>
+
+ <blockquote>
+@@ -58743,13 +63275,13 @@ expression. <i>-- end note</i>]</ins>
+
+ <hr>
+ <h3><a name="999"></a>999. Taking the address of a function</h3>
+-<p><b>Section:</b> 20.9.8 [specialized.algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2010-10-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7.12 [specialized.algorithms] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-03-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The same fix (reference <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#987">987</a>) may be applied to <tt>addressof</tt>, which is also constrained to
++The same fix (reference <a href="lwg-defects.html#987">987</a>) may be applied to <tt>addressof</tt>, which is also constrained to
+ <tt>ObjectType</tt>. (That was why <tt>boost::ref</tt> didn't work with functions - it
+ tried to apply <tt>boost::addressof</tt> and the <tt>reinterpret_cast&lt;char&amp;&gt;</tt>
+ implementation of <tt>addressof</tt> failed.)
+@@ -58775,10 +63307,10 @@ Move to Tentatively Ready.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+ tweaked for concepts removal.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-10 Daniel updates wording to concept-free.
+@@ -58790,9 +63322,9 @@ tweaked for concepts removal.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -58804,16 +63336,16 @@ The resolution assumes that <tt>addressof</tt> is reintroduced as described in
+
+
+ <p>
+-In 20.9.8 [specialized.algorithms] change as described:
++In 20.7.12 [specialized.algorithms] change as described:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; T* addressof(T&amp; r);
++<blockquote><pre>
++template &lt;class T&gt; T* addressof(T&amp; r);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> The actual address of the object <ins>or function</ins>
+-referenced by <tt>r</tt>, even in the
+-presence of an overloaded <tt>operator&amp;</tt>.
+-</blockquote>
++referenced by <tt>r</tt>, even in the presence of an overloaded <tt>operator&amp;</tt>.
++</p></blockquote>
+ </blockquote>
+
+
+@@ -58823,11 +63355,11 @@ presence of an overloaded <tt>operator&amp;</tt>.
+
+
+ <hr>
+-<h3><a name="1004"></a>1004. Response to UK 179</h3>
+-<p><b>Section:</b> 17.6.3.8 [res.on.functions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.functions">issues</a> in [res.on.functions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1004"></a>1004. Clarify "throws an exception"</h3>
++<p><b>Section:</b> 17.6.4.8 [res.on.functions] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.functions">issues</a> in [res.on.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 179</b></p>
+@@ -58843,27 +63375,27 @@ they are caught within the function.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The phrasing "throws an exception" is commonly used elsewhere
+ to mean "throws or propagates an exception."
+ Move to Open pending a possible more general resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Replace "propagates" in the proposed resolution with the phrase "exits
+ via" and move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the 4th bullet of 17.6.3.8 [res.on.functions], p2:
++Change the 4th bullet of 17.6.4.8 [res.on.functions], p2:
+ </p>
+
+ <blockquote>
+@@ -58883,10 +63415,10 @@ allowed in the applicable <i>Required behavior:</i> paragraph.
+
+ <hr>
+ <h3><a name="1006"></a>1006. <tt>operator delete</tt> in garbage collected implementation</h3>
+-<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#new.delete">issues</a> in [new.delete].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete">issues</a> in [new.delete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 190</b></p>
+@@ -58901,29 +63433,29 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agreed.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Proposed wording is too strict for implementations that do not support
+ garbage collection. Updated wording supplied.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We recommend advancing this to Tentatively Ready
+ with the understanding that it will not be moved for adoption
+ unless and until the proposed resolution to Core issue #853 is adopted.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -58937,7 +63469,8 @@ resolution for Core #853)
+ Add paragraphs to 18.6.1.1 [new.delete.single]:
+ </p>
+
+-<blockquote><pre>void operator delete(void* ptr) throw();
++<blockquote><pre>
++void operator delete(void* ptr) throw();
+ <del>void operator delete(void* ptr, const std::nothrow_t&amp;) throw();</del>
+ </pre>
+
+@@ -58956,7 +63489,8 @@ be a safely-derived pointer.
+ <p>-10- ...</p>
+ </blockquote>
+
+-<pre>void operator delete(void* ptr, const std::nothrow_t&amp;) throw();
++<pre>
++void operator delete(void* ptr, const std::nothrow_t&amp;) throw();
+ </pre>
+
+ <blockquote>
+@@ -58975,7 +63509,8 @@ be a safely-derived pointer.
+ Add paragraphs to 18.6.1.2 [new.delete.array]:
+ </p>
+
+-<blockquote><pre>void operator delete[](void* ptr) throw();
++<blockquote><pre>
++void operator delete[](void* ptr) throw();
+ <del>void operator delete[](void* ptr, const std::nothrow_t&amp;) throw();</del>
+ </pre>
+
+@@ -58994,7 +63529,8 @@ be a safely-derived pointer.
+ <p>-9- ...</p>
+ </blockquote>
+
+-<pre>void operator delete[](void* ptr, const std::nothrow_t&amp;) throw();
++<pre>
++void operator delete[](void* ptr, const std::nothrow_t&amp;) throw();
+ </pre>
+
+ <blockquote>
+@@ -59014,7 +63550,8 @@ be a safely-derived pointer.
+ Add paragraphs to 18.6.1.3 [new.delete.placement]:
+ </p>
+
+-<blockquote><pre>void operator delete(void* ptr, void*) throw();
++<blockquote><pre>
++void operator delete(void* ptr, void*) throw();
+ </pre>
+
+ <blockquote>
+@@ -59027,7 +63564,8 @@ be a safely-derived pointer.
+ <p>-7- ...</p>
+ </blockquote>
+
+-<pre>void operator delete[](void* ptr, void*) throw();
++<pre>
++void operator delete[](void* ptr, void*) throw();
+ </pre>
+
+ <blockquote>
+@@ -59048,11 +63586,11 @@ be a safely-derived pointer.
+
+
+ <hr>
+-<h3><a name="1011"></a>1011. <tt>next/prev</tt> wrong iterator type</h3>
+-<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1011"></a>1011. <tt>next&#47;prev</tt> wrong iterator type</h3>
++<p><b>Section:</b> 24.4.4 [iterator.operations] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.operations">issues</a> in [iterator.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 271</b></p>
+@@ -59068,20 +63606,20 @@ the original iterator. However, even this may invalidate an
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 Frankfurt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+ tweaked for concepts removal.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-14 Daniel provided de-conceptified wording.
+@@ -59093,9 +63631,9 @@ tweaked for concepts removal.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -59108,7 +63646,8 @@ Moved to Ready.
+ Change header <tt>&lt;iterator&gt;</tt> synopsis 24.3 [iterator.synopsis] as indicated:
+ </p>
+
+-<blockquote><pre>// 24.4.4, iterator operations:
++<blockquote><pre>
++// 24.4.4, iterator operations:
+ ...
+ template &lt;class <del>Input</del><ins>Forward</ins>Iterator&gt;
+ <del>Input</del><ins>Forward</ins>Iterator
+@@ -59121,7 +63660,8 @@ template &lt;class <del>Input</del><ins>Forward</ins>Iterator&gt;
+ Change 24.4.4 [iterator.operations] before p.6 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class <del>Input</del><ins>Forward</ins>Iterator&gt;
++<blockquote><pre>
++template &lt;class <del>Input</del><ins>Forward</ins>Iterator>
+ <del>Input</del><ins>Forward</ins>Iterator
+ next(<del>Input</del><ins>Forward</ins>Iterator x, typename std::iterator_traits&lt;<del>Input</del><ins>Forward</ins>Iterator&gt;::difference_type n = 1);
+ </pre></blockquote>
+@@ -59135,9 +63675,9 @@ Change 24.4.4 [iterator.operations] before p.6 as indicated:
+
+ <hr>
+ <h3><a name="1012"></a>1012. <tt>reverse_iterator</tt> default ctor should value initialize</h3>
+-<p><b>Section:</b> 24.5.1.3.1 [reverse.iter.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 24.5.1.3.1 [reverse.iter.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 277</b></p>
+@@ -59157,24 +63697,24 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree with option i.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Related issue: <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>
++Related issue: <a href="lwg-closed.html#408">408</a>
+ </p>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We believe this should be revisited
+-in conjunction with issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#408">408</a>,
++in conjunction with issue <a href="lwg-closed.html#408">408</a>,
+ which nearly duplicates this issue.
+ Move to Open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 post-Frankfurt:
+@@ -59195,9 +63735,9 @@ Move to Tentatively Ready.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for this meeting.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -59206,24 +63746,26 @@ Moved to Ready for this meeting.
+ Change [reverse.iter.con]:
+ </p>
+
+-<blockquote><pre>reverse_iterator();
++<blockquote><pre>
++reverse_iterator();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> <del>Default</del> <ins>Value</ins> initializes <tt>current</tt>. Iterator
+ operations applied to the resulting iterator have defined behavior if and
+ only if the corresponding operations are defined on a <del>default constructed</del>
+ <ins>value initialized</ins>
+ iterator of type <tt>Iterator</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Change 24.5.3.3.1 [move.iter.op.const]:
+ </p>
+
+-<blockquote><pre>move_iterator();
++<blockquote><pre>
++move_iterator();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -1- <i>Effects:</i> Constructs a <tt>move_iterator</tt>, <del>default</del> <ins>value</ins>
+ initializing <tt>current</tt>.
+ <ins>Iterator
+@@ -59231,7 +63773,7 @@ operations applied to the resulting iterator have defined behavior if and
+ only if the corresponding operations are defined on a
+ value initialized
+ iterator of type <tt>Iterator</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -59240,11 +63782,11 @@ iterator of type <tt>Iterator</tt>.</ins>
+
+
+ <hr>
+-<h3><a name="1014"></a>1014. Response to UK 317 and JP 74</h3>
+-<p><b>Section:</b> 28.8.2 [re.regex.construct] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.regex.construct">issues</a> in [re.regex.construct].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1014"></a>1014. <tt>basic_regex</tt> should be created/assigned from initializer lists</h3>
++<p><b>Section:</b> 28.8.2 [re.regex.construct] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex.construct">issues</a> in [re.regex.construct].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 317 and JP 74</b></p>
+@@ -59253,29 +63795,29 @@ iterator of type <tt>Iterator</tt>.</ins>
+ UK 317:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>basic_string</tt> has both a constructor and an assignment operator that
+ accepts an initializer list, <tt>basic_regex</tt> should have the same.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ JP 74:
+ </p>
+
+-<blockquote>
+-<tt>basic_regx &amp; operator= (initializer_list&lt;T&gt;);</tt> is not defined.
+-</blockquote>
++<blockquote><p>
++<tt>basic_regex &amp; operator= (initializer_list&lt;T&gt;);</tt> is not defined.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ UK 317 asks for both assignment and constructor,
+ but the requested constructor is already present in the current Working Paper.
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -59283,7 +63825,8 @@ Move to Tentatively Ready.
+ Change 28.8 [re.regex]:
+ </p>
+
+-<blockquote><pre>template &lt;class charT,
++<blockquote><pre>
++template &lt;class charT,
+ class traits = regex_traits&lt;charT&gt; &gt;
+ class basic_regex {
+ ...
+@@ -59300,14 +63843,15 @@ Add in 28.8.2 [re.regex.construct]:
+ </p>
+
+ <blockquote>
+-<blockquote>
++<blockquote><p>
+ -20- ...
+-</blockquote>
+-<pre>basic_regex&amp; operator=(initializer_list&lt;charT&gt; il);
++</p></blockquote>
++<pre>
++basic_regex&amp; operator=(initializer_list&lt;charT&gt; il);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -21- <i>Effects:</i> returns <tt>assign(il.begin(), il.end());</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -59316,14 +63860,14 @@ Add in 28.8.2 [re.regex.construct]:
+
+
+ <hr>
+-<h3><a name="1019"></a>1019. Response to UK 205</h3>
+-<p><b>Section:</b> 20.7.3 [meta.help] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.help">issues</a> in [meta.help].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1019"></a>1019. Make <tt>integral_constant</tt> objects useable in integral-constant-expressions</h3>
++<p><b>Section:</b> 20.10.3 [meta.help] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.help">issues</a> in [meta.help].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 205</b></p>
++<p><b>Addresses UK 205 [CD1]</b></p>
+
+ <p>
+ <tt>integral_constant</tt> objects should be usable in integral-constant-expressions.
+@@ -59335,13 +63879,13 @@ constant expressions make this possible.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree that the <tt>static</tt> data member
+ ought be declared <tt>constexpr</tt>,
+ but do not see a need for the proposed <tt>operator value_type()</tt>.
+ (A use case would be helpful.)
+ Move to Open.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-23 Alisdair adds:
+@@ -59373,7 +63917,8 @@ that explicit conversion is more appropriate for 0x though.
+ Here's a use case which demonstrates the syntactic niceness which Alisdair describes:
+ </p>
+
+-<blockquote><pre>#define requires(...) class = typename std::enable_if&lt;(__VA_ARGS__)&gt;::type
++<blockquote><pre>
++#define requires(...) class = typename std::enable_if&lt;(__VA_ARGS__)&gt;::type
+
+ template &lt;class T, class U,
+ requires(!is_lvalue_reference&lt;T&gt;() ||
+@@ -59394,27 +63939,28 @@ forward(U&amp;&amp; t)
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for this meeting.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to the <tt>integral_constant</tt> struct definition in 20.7.3 [meta.help]:
++Add to the <tt>integral_constant</tt> struct definition in 20.10.3 [meta.help]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, T v&gt;
++<blockquote><pre>
++template &lt;class T, T v&gt;
+ struct integral_constant {
+ static const<ins>expr</ins> T value = v;
+ typedef T value_type;
+@@ -59428,17 +63974,18 @@ struct integral_constant {
+
+
+ <hr>
+-<h3><a name="1021"></a>1021. Response to UK 211</h3>
+-<p><b>Section:</b> 20.9.9.2.3 [unique.ptr.single.asgn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1021"></a>1021. Allow <tt>nullptr_t</tt> assignments to <tt>unique_ptr</tt></h3>
++<p><b>Section:</b> 20.8.1.2.3 [unique.ptr.single.asgn] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.asgn">issues</a> in [unique.ptr.single.asgn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 211</b></p>
++<p><b>Addresses UK 211 [CD1]</b></p>
+
+ <p>
+ The <tt>nullptr_t</tt> type was introduced to resolve the null pointer literal
+-problem. It should be used for the assignemnt operator, as with the
++problem. It should be used for the assignment operator, as with the
+ constructor and elsewhere through the library.
+ </p>
+
+@@ -59446,32 +63993,34 @@ constructor and elsewhere through the library.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis in 20.9.9.2 [unique.ptr.single]:
++Change the synopsis in 20.8.1.2 [unique.ptr.single]:
+ </p>
+
+-<blockquote><pre>unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del> <ins>nullptr_t</ins>);
++<blockquote><pre>
++unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del> <ins>nullptr_t</ins>);
+ </pre></blockquote>
+
+ <p>
+-Change 20.9.9.2.3 [unique.ptr.single.asgn]:
++Change 20.8.1.2.3 [unique.ptr.single.asgn]:
+ </p>
+
+-<blockquote><pre>unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del> <ins>nullptr_t</ins>);
++<blockquote><pre>
++unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del> <ins>nullptr_t</ins>);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del>Assigns from the literal 0 or <tt>NULL</tt>. [<i>Note:</i> The
+ <i>unspecified-pointer-type</i> is often implemented as a pointer to a
+ private data member, avoiding many of the implicit conversion pitfalls.
+-<i>-- end note</i>]</del>
+-</blockquote>
++&mdash; <i>end note</i>]</del>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -59479,13 +64028,14 @@ private data member, avoiding many of the implicit conversion pitfalls.
+
+
+ <hr>
+-<h3><a name="1030"></a>1030. Response to JP 44</h3>
+-<p><b>Section:</b> 20.9.10.5 [util.smartptr.shared.atomic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1030"></a>1030. Missing requirements for smart-pointer safety API</h3>
++<p><b>Section:</b> 20.8.2.6 [util.smartptr.shared.atomic] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.atomic">issues</a> in [util.smartptr.shared.atomic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses JP 44</b></p>
++<p><b>Addresses JP 44 [CD1]</b></p>
+
+ <p>
+ The 1st parameter <tt>p</tt> and 2nd parameter <tt>v</tt> is now
+@@ -59502,10 +64052,10 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree. All of the functions need a requirement that <tt>p</tt> (or
+ <tt>v</tt>) is a pointer to a valid object.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 post-Frankfurt:
+@@ -59550,16 +64100,16 @@ to require that such pointers not be null.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ In section "<code>shared_ptr</code> atomic access"
+-20.9.10.5 [util.smartptr.shared.atomic], add to each function the
++20.8.2.6 [util.smartptr.shared.atomic], add to each function the
+ following clause.
+ </p>
+ <blockquote><p>
+@@ -59572,10 +64122,10 @@ following clause.
+
+ <hr>
+ <h3><a name="1033"></a>1033. <tt>thread::join()</tt> effects?</h3>
+-<p><b>Section:</b> 30.3.1.5 [thread.thread.member] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.member">issues</a> in [thread.thread.member].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.3.1.5 [thread.thread.member] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.member">issues</a> in [thread.thread.member].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -59588,18 +64138,18 @@ issue or NB comment about that, but I might have missed it.
+ The postconditions clause for <tt>thread::join()</tt> is:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Postconditions:</i> If <tt>join()</tt> throws an exception, the value
+ returned by <tt>get_id()</tt> is unchanged. Otherwise, <tt>get_id() == id()</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ and the throws clause is:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> <tt>std::system_error</tt> when the postconditions cannot be achieved.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Now... how could the postconditions <em>not</em> be achieved?
+@@ -59613,10 +64163,10 @@ postconditions, but the postconditions are different in the two cases.
+ I believe the throws clause should be:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> <tt>std::system_error</tt> when the effects or postconditions
+ cannot be achieved.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ as it is in <tt>detach()</tt>, or, even better, as the postcondition is
+@@ -59624,9 +64174,9 @@ trivially satisfiable and to remove the circular dependency:
+ </p>
+
+
+-<blockquote>
++<blockquote><p>
+ <i>Throws:</i> <tt>std::system_error</tt> if the effects cannot be achieved.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Problem is that... ehm... <tt>join()</tt> has no "Effects" clause. Is that intentional?
+@@ -59644,7 +64194,7 @@ Batavia (2009-05):
+ <blockquote>
+ <p>
+ Pete believes there may be some more general language (in frontmatter)
+-that can address this and related issues such as <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#962">962</a>.
++that can address this and related issues such as <a href="lwg-defects.html#962">962</a>.
+ </p>
+ <p>
+ Move to Open.
+@@ -59667,7 +64217,8 @@ Move to Open.
+ Edit 30.3.1.5 [thread.thread.member] as indicated:
+ </p>
+
+-<blockquote><pre>void join();
++<blockquote><pre>
++void join();
+ </pre>
+ <blockquote>
+ <p>
+@@ -59681,7 +64232,7 @@ Edit 30.3.1.5 [thread.thread.member] as indicated:
+ 6 <i>Synchronization:</i> The completion of the thread represented by
+ <tt>*this</tt> happens before (1.10 [intro.multithread])
+ <tt>join()</tt> returns. [<i>Note:</i> Operations on <tt>*this</tt> are not
+-synchronized. — <i>end note</i>]
++synchronized. &mdash; <i>end note</i>]
+ </p>
+
+ <p>
+@@ -59704,15 +64255,15 @@ represented by <tt>*this</tt> has completed.</ins> <tt>get_id() == id()</tt>.
+
+
+ <hr>
+-<h3><a name="1034"></a>1034. Response to UK 222</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1034"></a>1034. Clarify generality of Container Requirement tables</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 222</b></p>
++<p><b>Addresses UK 222 [CD1]</b></p>
+
+ <p>
+ It is not clear what purpose the Requirement tables serve in the
+@@ -59747,30 +64298,30 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree in principle.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-07 post-Frankfurt:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We agree in principle, but we have a timetable. This group feels that
+ the issue should be closed as NAD unless a proposed resolution is
+ submitted prior to the March 2010 meeting.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Looked at this and still intend to close as NAD in March
+ 2010 unless there is proposed wording that we like.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-02 Nicolai M. Josuttis updates proposed wording and adds:
+@@ -59787,11 +64338,11 @@ For me, currently, this follows from
+ Sequence containers 23.2.3 [sequence.reqmts]
+ saying:
+ </p>
+-<blockquote>
++<blockquote><p>
+ The library provides five basic kinds of sequence containers: <tt>array</tt>,
+ <tt>vector</tt>, <tt>forward_list</tt>, <tt>list</tt>, and <tt>deque</tt>. while
+ later on in Table 94 "Sequence container requirements" are defined.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ IMO, you can hardly argue that this is NAD.
+@@ -59846,13 +64397,15 @@ In fact, out of all sequence container requirements <tt>array&lt;&gt;</tt> only
+ provides the following operations:
+ from sequence requirements (Table 94):
+ </p>
+-<blockquote><pre>X(il);
++<blockquote><pre>
++X(il);
+ a = il;
+ </pre></blockquote>
+ <p>
+ and from optional requirements (Table 95):
+ </p>
+-<blockquote><pre>[], at(), front(), back()
++<blockquote><pre>
++[], at(), front(), back()
+ </pre></blockquote>
+ <p>
+ This is almost nothing!
+@@ -59866,7 +64419,8 @@ a construction or assignment with an initializer list is valid
+ for all sequence containers but not valid for array:
+ </p>
+
+-<blockquote><pre>vector&lt;int&gt; v({1,2,3}); // OK
++<blockquote><pre>
++vector&lt;int&gt; v({1,2,3}); // OK
+ v = {4,5,6}; // OK
+
+ array&lt;int,3&gt; a({1,2,3}); // Error
+@@ -59927,7 +64481,7 @@ indicated: </i> </p>
+ most insertions and deletions take place at the beginning or at the end of the
+ sequence. </p>
+ </blockquote>
+-<p><i>In Class template array 23.3.1 [array] modify paragraph 3 as indicated:
++<p><i>In Class template array 23.3.2 [array] modify paragraph 3 as indicated:
+ </i> </p>
+ <blockquote>
+ <p>3 <del>Unless otherwise specified, all <tt>array</tt> operations are as
+@@ -59940,7 +64494,7 @@ indicated: </i> </p>
+ <del>in that Clause</del> <ins>in one of these tables</ins> or for operations
+ where there is additional semantic information. </p>
+ </blockquote>
+-<p><i>In array specialized algorithms 23.3.1.2 [array.special] add to the
++<p><i>In array specialized algorithms 23.3.2.3 [array.special] add to the
+ specification of <tt>swap()</tt>: </i> </p>
+ <blockquote>
+ <pre>template &lt;class T, size_t N&gt; void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y);
+@@ -59960,14 +64514,14 @@ specification of <tt>swap()</tt>: </i> </p>
+
+
+ <hr>
+-<h3><a name="1037"></a>1037. Response to UK 232</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1037"></a>1037. Unclear status of <tt>match_results</tt> as library container</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 232</b></p>
++<p><b>Addresses UK 232 [CD1]</b></p>
+
+ <p>
+ <tt>match_results</tt> may follow the requirements but is not listed a general
+@@ -59983,18 +64537,18 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree. <tt>operator[]</tt> is defined elsewhere.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60008,14 +64562,14 @@ In 23.2.3 [sequence.reqmts] Table 84, remove reference to
+
+
+ <hr>
+-<h3><a name="1038"></a>1038. Response to UK 233</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1038"></a>1038. Sequence requirement table needs to reference several new containers</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 233</b></p>
++<p><b>Addresses UK 233 [CD1]</b></p>
+
+ <p>
+ Table 84 is missing references to several new container types.
+@@ -60026,18 +64580,18 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60049,7 +64603,7 @@ containers to the following rows:
+ <blockquote>
+ <table border="1">
+ <caption>Table 84 -- Optional sequence container operations</caption>
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+@@ -60103,7 +64657,7 @@ containers to the following rows:
+ <td>...</td>
+ <td><tt>vector, deque<ins>, basic_string, array</ins></tt></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -60111,14 +64665,14 @@ containers to the following rows:
+
+
+ <hr>
+-<h3><a name="1039"></a>1039. Response to UK 234</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1039"></a>1039. Sequence container <tt>back</tt> function should also support <tt>const_iterator</tt></h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 234</b></p>
++<p><b>Addresses UK 234 [CD1]</b></p>
+
+ <p>
+ The reference to <tt>iterator</tt> in semantics for <tt>back</tt> should
+@@ -60132,18 +64686,18 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60153,8 +64707,8 @@ In 23.2.3 [sequence.reqmts] Table 84, replace iterator with auto in semantics fo
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 84 -- Optional sequence container operations</caption>
+-<tbody><tr>
++<caption>Table 84 &mdash; Optional sequence container operations</caption>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+@@ -60163,10 +64717,10 @@ In 23.2.3 [sequence.reqmts] Table 84, replace iterator with auto in semantics fo
+ <tr>
+ <td><tt>a.back()</tt></td>
+ <td><tt>reference; const_reference</tt> for constant <tt>a</tt></td>
+-<td><tt>{ <del>iterator</del> <ins>auto</ins> tmp = a.end();<br>--tmp;<br>return *tmp; }</tt></td>
++<td><tt>{ <del>iterator</del> <ins>auto</ins> tmp = a.end();<br/>--tmp;<br/>return *tmp; }</tt></td>
+ <td><tt>vector, list, deque, basic_string</tt></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -60174,15 +64728,15 @@ In 23.2.3 [sequence.reqmts] Table 84, replace iterator with auto in semantics fo
+
+
+ <hr>
+-<h3><a name="1040"></a>1040. Response to UK 238</h3>
+-<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1040"></a>1040. Clarify possible sameness of associative container's <tt>iterator</tt> and <tt>const_iterator</tt></h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 238</b></p>
++<p><b>Addresses UK 238 [CD1]</b></p>
+
+ <p>
+ Leaving it unspecified whether or not <tt>iterator</tt> and <tt>const_iterator</tt> are the
+@@ -60201,19 +64755,19 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree with issue. Agree with adding the note but not with changing the
+ normative text. We believe the note provides sufficient guidance.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60221,7 +64775,7 @@ Move to Tentatively Ready.
+ In 23.2.4 [associative.reqmts] p6, add:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -6- <tt>iterator</tt> of an associative container meets the requirements
+ of the <tt>BidirectionalIterator</tt> concept. For associative
+ containers where the value type is the same as the key type, both
+@@ -60232,24 +64786,139 @@ is unspecified whether or not <tt>iterator</tt> and
+ this case, and <tt>iterator</tt> is convertible to <tt>const_iterator</tt>. Users can avoid
+ violating the One Definition Rule by always using <tt>const_iterator</tt>
+ in their function parameter lists <i>-- end note</i>]</ins>
+-</blockquote>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1043"></a>1043. Clarify that <tt>compare_exchange</tt> is not a read-modify-write operation</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 91 [CD1]</b></p>
++
++<p>
++It is unclear whether or not a failed <tt>compare_exchange</tt> is a RMW operation
++(as used in 1.10 [intro.multithread]).
++</p>
++
++<p>
++Suggested solution:
++</p>
++
++<p>
++Make failing <tt>compare_exchange</tt> operations <b>not</b> be RMW.
++</p>
++
++<p><i>[
++Anthony Williams adds:
++]</i></p>
++
++
++<blockquote><p>
++In 29.6 [atomics.types.operations] p18 it says that "These
++operations are atomic read-modify-write operations" (final sentence).
++This is overly restrictive on the implementations of
++<tt>compare_exchange_weak</tt> and <tt>compare_exchange_strong</tt> on platforms without a
++native CAS instruction.
++</p></blockquote>
++
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote><p>
++Group agrees with the resolution as proposed by Anthony Williams in the attached note.
++</p></blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++We recommend the proposed resolution be reviewed
++by members of the Concurrency Subgroup.
++</p></blockquote>
++
++<p><i>[
++2009-07 post-Frankfurt:
++]</i></p>
++
++
++<blockquote><p>
++This is likely to be addressed by Lawrence's upcoming paper. He will
++adopt the proposed resolution.
++</p></blockquote>
++
++<p><i>[
++2009-08-17 Handled by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2925.html">N2925</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 29.6 [atomics.types.operations] p18:
++</p>
++
++<blockquote><p>
++-18- <i>Effects:</i> Atomically, compares the value pointed to by
++<tt>object</tt> or by <tt>this</tt> for equality with that in
++<tt>expected</tt>, and if true, replaces the value pointed to by
++<tt>object</tt> or by <tt>this</tt> with desired, and if false, updates
++the value in <tt>expected</tt> with the value pointed to by
++<tt>object</tt> or by <tt>this</tt>. Further, if the comparison is true,
++memory is affected according to the value of <tt>success</tt>, and if the
++comparison is false, memory is affected according to the value of
++<tt>failure</tt>. When only one <tt>memory_order</tt> argument is
++supplied, the value of <tt>success</tt> is <tt>order</tt>, and the value
++of <tt>failure</tt> is <tt>order</tt> except that a value of
++<tt>memory_order_acq_rel</tt> shall be replaced by the value
++<tt>memory_order_acquire</tt> and a value of
++<tt>memory_order_release</tt> shall be replaced by the value
++<tt>memory_order_relaxed</tt>. <ins>If the comparison is <tt>true</tt>, </ins>
++<del>T</del><ins>t</ins>hese operations are atomic
++read-modify-write operations (1.10).
++<ins>If the comparison is <tt>false</tt>, these
++operations are atomic load operations.</ins>
++</p></blockquote>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="1044"></a>1044. Response to UK 325</h3>
+-<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1044"></a>1044. Empty tag types should be <tt>constexpr</tt> literals</h3>
++<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 325</b></p>
++<p><b>Addresses UK 325 [CD1]</b></p>
+
+ <p>
+-We believe constexpr literal values should be a more natural expression
++We believe <tt>constexpr</tt> literal values should be a more natural expression
+ of empty tag types than extern objects as it should improve the
+ compiler's ability to optimize the empty object away completely.
+ </p>
+@@ -60259,19 +64928,19 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to review. The current specification is a "hack", and the proposed
+ specification is a better "hack".
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60279,7 +64948,8 @@ Move to Tentatively Ready.
+ Change the synopsis in 30.4 [thread.mutex]:
+ </p>
+
+-<blockquote><pre>struct defer_lock_t <ins>{}</ins>;
++<blockquote><pre>
++struct defer_lock_t <ins>{}</ins>;
+ struct try_to_lock_t <ins>{}</ins>;
+ struct adopt_lock_t <ins>{}</ins>;
+
+@@ -60294,17 +64964,17 @@ struct adopt_lock_t <ins>{}</ins>;
+
+
+ <hr>
+-<h3><a name="1045"></a>1045. Response to UK 326</h3>
+-<p><b>Section:</b> 30.4.2.2.1 [thread.lock.unique.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1045"></a>1045. Remove unnecessary preconditions from <tt>unique_lock</tt> constructor</h3>
++<p><b>Section:</b> 30.4.2.2.1 [thread.lock.unique.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 326</b></p>
++<p><b>Addresses UK 326 [CD1]</b></p>
+
+ <p>
+ The precondition that the mutex is not owned by this thread offers
+-introduces the risk of un-necessary undefined behaviour into the
++introduces the risk of unnecessary undefined behaviour into the
+ program. The only time it matters whether the current thread owns the
+ mutex is in the lock operation, and that will happen subsequent to
+ construction in this case. The lock operation has the identical
+@@ -60318,18 +64988,18 @@ Summit:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Agree, move to review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60337,11 +65007,553 @@ Move to Tentatively Ready.
+ Strike 30.4.2.2.1 [thread.lock.unique.cons] p7:
+ </p>
+
+-<blockquote><pre>unique_lock(mutex_type&amp; m, defer_lock_t);
++<blockquote><pre>
++unique_lock(mutex_type&amp; m, defer_lock_t);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del>-7- <i>Precondition:</i> If <tt>mutex_type</tt> is not a recursive mutex
+ the calling thread does not own the mutex.</del>
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1046"></a>1046. Provide simple facility to start asynchronous operations</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 329 [CD1]</b></p>
++
++<p>
++<tt>future</tt>, <tt>promise</tt> and <tt>packaged_task</tt> provide a
++framework for creating future values, but a simple function to tie all
++three components together is missing. Note that we only need a <em>simple</em>
++facility for C++0x. Advanced thread pools are to be left for TR2.
++</p>
++
++<p>
++Simple Proposal:
++</p>
++
++<p>
++Provide a simple function along the lines of:
++</p>
++<blockquote><pre>
++template&lt; typename F, typename ... Args &gt;
++ requires Callable&lt; F, Args... &gt;
++ future&lt; Callable::result_type &gt; async( F&amp;&amp; f, Args &amp;&amp; ... );
++</pre></blockquote>
++
++<p>
++Semantics are similar to creating a <tt>thread</tt> object with a <tt>packaged_task</tt>
++invoking <tt>f</tt> with <tt>forward&lt;Args&gt;(args...)</tt>
++but details are left unspecified to allow different scheduling and thread
++spawning implementations.
++</p>
++<p>
++It is unspecified whether a task submitted to async is run on its own thread
++or a thread previously used for another async task. If a call to <tt>async</tt>
++succeeds, it shall be safe to wait for it from any thread.
++</p>
++<p>
++The state of <tt>thread_local</tt> variables shall be preserved during <tt>async</tt> calls.
++</p>
++<p>
++No two incomplete async tasks shall see the same value of
++<tt>this_thread::get_id()</tt>.
++</p>
++<p>
++[<i>Note:</i> this effectively forces new tasks to be run on a new thread, or a
++fixed-size pool with no queue. If the
++library is unable to spawn a new thread or there are no free worker threads
++then the <tt>async</tt> call should fail. <i>--end note</i>]
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++The concurrency subgroup has revisited this issue and decided that it
++could be considered a defect according to the Kona compromise. A task
++group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a
++paper for Frankfort proposing a simple asynchronous launch facility
++returning a <tt>future</tt>. It was agreed that the callable must be run on a
++separate thread from the caller, but not necessarily a brand-new thread.
++The proposal might or might not allow for an implementation that uses
++fixed-size or unlimited thread pools.
++</p>
++<p>
++Bjarne in c++std-lib-23121: I think that what we agreed was that to
++avoid deadlock <tt>async()</tt> would almost certainly be specified to launch in
++a different thread from the thread that executed <tt>async()</tt>, but I don't
++think it was a specific design constraint.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Proposed resolution: see
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2996.htm">N2996</a>
++(Herb's and Lawrence's paper on Async). Move state to <del>NAD editorial</del><ins>Resolved</ins>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1047"></a>1047. Ensure that future's <tt>get()</tt> blocks when not ready</h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 334 [CD1]</b></p>
++
++<p>
++Behaviour of <tt>get()</tt> is undefined if calling <tt>get()</tt> while
++not <tt>is_ready()</tt>. The intent is that <tt>get()</tt> is a blocking
++call, and will wait for the future to become ready.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Agree, move to Review.
++</p>
++</blockquote>
++
++<p><i>[
++2009-04-03 Thomas J. Gritzan adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++This issue also applies to <tt>shared_future::get()</tt>.
++</p>
++
++<p>
++Suggested wording:
++</p>
++
++<p>
++Add a paragraph to 30.6.7 [futures.shared_future]:
++</p>
++
++<blockquote><pre>
++void shared_future&lt;void&gt;::get() const;
++</pre>
++<blockquote><p>
++<i>Effects:</i> If <tt>is_ready()</tt> would return <tt>false</tt>, block on the asynchronous
++result associated with <tt>*this</tt>.
++</p></blockquote>
++</blockquote>
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++It is not clear to us that this is an issue,
++because the proposed resolution's Effects clause seems to duplicate
++information already present in the Synchronization clause.
++Keep in Review status.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add a paragraph to 30.6.6 [futures.unique_future]:
++</p>
++
++<blockquote><pre>
++R&amp;&amp; unique_future::get();
++R&amp; unique_future&lt;R&amp;&gt;::get();
++void unique_future&lt;void&gt;::get();
++</pre>
++<blockquote>
++<p><i>Note:</i>...</p>
++<p>
++<ins><i>Effects:</i> If <tt>is_ready()</tt> would return <tt>false</tt>,
++block on the asynchronous result associated with <tt>*this</tt>.</ins>
++</p>
++<p>
++<i>Synchronization:</i> if <tt>*this</tt> is associated with a
++<tt>promise</tt> object, the completion of <tt>set_value()</tt> or
++<tt>set_exception()</tt> to that <tt>promise</tt> happens before (1.10)
++<tt>get()</tt> returns.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1048"></a>1048. Provide empty-state inspection for <tt>std::unique_future</tt></h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 335 [CD1]</b></p>
++
++<p>
++<tt>std::unique_future</tt> is <tt>MoveConstructible</tt>, so you can transfer the
++association with an asynchronous result from one instance to another.
++However, there is no way to determine whether or not an instance has
++been moved from, and therefore whether or not it is safe to wait for it.
++</p>
++
++<blockquote><pre>
++std::promise&lt;int&gt; p;
++std::unique_future&lt;int&gt; uf(p.get_future());
++std::unique_future&lt;int&gt; uf2(std::move(uf));
++uf.wait(); <span style="color:#C80000">// oops, uf has no result to wait for. </span>
++</pre></blockquote>
++
++<p>
++Suggest we add a <tt>waitable()</tt> function to <tt>unique_future</tt>
++(and <tt>shared_future</tt>) akin to <tt>std::thread::joinable()</tt>,
++which returns <tt>true</tt> if there is an associated result to wait for
++(whether or not it is ready).
++</p>
++
++<p>
++Then we can say:
++</p>
++
++<blockquote><pre>
++if(uf.waitable()) uf.wait();
++</pre></blockquote>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Create an issue. Requires input from Howard. Probably NAD.
++</p>
++</blockquote>
++
++<p><i>[
++Post Summit, Howard throws in his two cents:
++]</i></p>
++
++
++<blockquote>
++<p>
++Here is a copy/paste of my last prototype of <tt>unique_future</tt> which was
++several years ago. At that time I was calling <tt>unique_future</tt> <tt>future</tt>:
++</p>
++
++<blockquote><pre>
++template &lt;class R&gt;
++class future
++{
++public:
++ typedef R result_type;
++private:
++ future(const future&amp;);// = delete;
++ future&amp; operator=(const future&amp;);// = delete;
++
++ template &lt;class R1, class F1&gt; friend class prommise;
++public:
++ future();
++ ~future();
++
++ future(future&amp;&amp; f);
++ future&amp; operator=(future&amp;&amp; f);
++
++ void swap(future&amp;&amp; f);
++
++ <b>bool joinable() const;</b>
++ bool is_normal() const;
++ bool is_exceptional() const;
++ bool is_ready() const;
++
++ R get();
++
++ void join();
++ template &lt;class ElapsedTime&gt;
++ bool timed_join(const ElapsedTime&amp;);
++};
++</pre></blockquote>
++
++<p>
++<tt>shared_future</tt> had a similar interface. I intentionally reused
++the <tt>thread</tt> interface where possible to lessen the learning
++curve std::lib clients will be faced with.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1049"></a>1049. Move assignment of <tt>promise</tt> inverted</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 339 [CD1]</b></p>
++
++<p>
++Move assignment is going in the wrong direction, assigning from
++<tt>*this</tt> to the passed rvalue, and then returning a reference to
++an unusable <tt>*this</tt>.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Agree, move to Review.
++</p>
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++We recommend deferring this issue until after Detlef's paper (on futures)
++has been issued.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Strike 30.6.5 [futures.promise] p6 and change p7:
++</p>
++
++<blockquote><pre>
++promise&amp; operator=(promise&amp;&amp; rhs);
++</pre>
++<blockquote>
++<p>
++<del>-6- <i>Effects:</i> move assigns its associated state to <tt>rhs</tt>.</del>
++</p>
++<p>
++-7- <i>Postcondition:</i> <del><tt>*this</tt> has no associated
++state.</del> <ins>associated state of <tt>*this</tt> is the same as the
++associated state of <tt>rhs</tt> before the call. <tt>rhs</tt> has no
++associated state.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1050"></a>1050. Clarify postconditions for <tt>get_future()</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 340 [CD1]</b></p>
++
++<p>
++There is an implied postcondition for <tt>get_future()</tt> that the state of the
++<tt>promise</tt> is transferred into the <tt>future</tt> leaving the <tt>promise</tt> with no
++associated state. It should be spelled out.
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++
++<blockquote>
++<p>
++Agree, move to Review.
++</p>
++</blockquote>
++
++<p><i>[
++2009-04-03 Thomas J. Gritzan adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++<tt>promise::get_future()</tt> must not invalidate the state of the promise object.
++</p>
++<p>
++A promise is used like this:
++</p>
++<blockquote><pre>
++promise&lt;int&gt; p;
++unique_future&lt;int&gt; f = p.get_future();
++<span style="color:#C80000">// post 'p' to a thread that calculates a value </span>
++<span style="color:#C80000">// use 'f' to retrieve the value. </span>
++</pre></blockquote>
++<p>
++So <tt>get_future()</tt> must return an object that shares the same associated
++state with <tt>*this</tt>.
++</p>
++<p>
++But still, this function should throw an <tt>future_already_retrieved</tt> error
++when it is called twice.
++</p>
++<p>
++<tt>packaged_task::get_future()</tt> throws <tt>std::bad_function_call</tt> if its <tt>future</tt>
++was already retrieved. It should throw
++<tt>future_error(future_already_retrieved)</tt>, too.
++</p>
++<p>
++Suggested resolution:
++</p>
++<p>
++Replace p12/p13 30.6.5 [futures.promise]:
++</p>
++<blockquote>
++<p>
++-12- <i>Throws:</i> <tt>future_error</tt> if <del><tt>*this</tt> has no associated state</del>
++<ins>the <tt>future</tt> has already been retrieved</ins>.
++</p>
++<p>
++-13- <i>Error conditions:</i> <tt>future_already_retrieved</tt> if <del><tt>*this</tt>
++has no associated state</del>
++<ins>the <tt>future</tt> associated with
++the associated state has already been retrieved</ins>.
++</p>
++<p>
++<ins><i>Postcondition:</i> The returned object and <tt>*this</tt> share the associated state.</ins>
++</p>
++</blockquote>
++<p>
++Replace p14 30.6.9 [futures.task]:
++</p>
++<blockquote>
++<p>
++-14- <i>Throws:</i> <tt><del>std::bad_function_call</del> <ins>future_error</ins></tt> if the future <del>associated with
++the task</del> has already been retrieved.
++</p>
++
++<p><ins>
++<i>Error conditions:</i> <tt>future_already_retrieved</tt> if the <tt>future</tt> associated with
++the task has already been retrieved.
++</ins></p>
++<p>
++<ins><i>Postcondition:</i> The returned object and <tt>*this</tt> share the associated task.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote><p>
++Keep in Review status pending Detlef's forthcoming paper on futures.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add after p13 30.6.5 [futures.promise]:
++</p>
++
++<blockquote><pre>
++unique_future&lt;R&gt; get_future();
++</pre>
++<blockquote>
++<p>
++-13- ...
++</p>
++<p>
++<i>Postcondition:</i> <tt>*this</tt> has no associated state.
++</p>
+ </blockquote>
+ </blockquote>
+
+@@ -60352,10 +65564,10 @@ the calling thread does not own the mutex.</del>
+
+ <hr>
+ <h3><a name="1054"></a>1054. <tt>forward</tt> broken</h3>
+-<p><b>Section:</b> 20.3.3 [forward] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forward">issues</a> in [forward].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.2.4 [forward] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward">issues</a> in [forward].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -60377,9 +65589,10 @@ this issue I have not done so yet.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++
++<blockquote><p>
+ Move to Open, awaiting the promised paper.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-02 Howard adds:
+@@ -60391,7 +65604,8 @@ Move to Open, awaiting the promised paper.
+ My current preferred solution is:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ struct __base_type
+ {
+ typedef typename remove_cv&lt;typename remove_reference&lt;T&gt;::type&gt;::type type;
+@@ -60437,7 +65651,7 @@ Cast an rvalue <tt>t</tt> to an rvalue <tt>T</tt> (identity).
+ It disallows:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ Cast an rvalue <tt>t</tt> to an lvalue <tt>T</tt>.
+ </li>
+@@ -60459,7 +65673,8 @@ neither dangerous, nor compelling. I.e. I could live with or without the "b."
+ constraint. Without it, forward would look like:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class U,
++<blockquote><pre>
++template &lt;class T, class U,
+ class = typename enable_if&lt;
+ !is_lvalue_reference&lt;T&gt;::value ||
+ is_lvalue_reference&lt;T&gt;::value &amp;&amp;
+@@ -60476,7 +65691,8 @@ forward(U&amp;&amp; t)
+ Or possibly:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class U,
++<blockquote><pre>
++template &lt;class T, class U,
+ class = typename enable_if&lt;
+ !is_lvalue_reference&lt;T&gt;::value ||
+ is_lvalue_reference&lt;T&gt;::value &amp;&amp;
+@@ -60513,7 +65729,8 @@ or non-const lvalue or rvalue, restore the original "rvalue-ness" of the
+ actual argument:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ void f(T&amp;&amp; x)
+ {
+ // x is an lvalue here. If the actual argument to f was an
+@@ -60542,7 +65759,8 @@ Use a simple definition of <tt>forward</tt> that accomplishes its original
+ purpose without complications to accomodate other uses:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class U&gt;
++<blockquote><pre>
++template &lt;class T, class U&gt;
+ T&amp;&amp; forward(U&amp; x)
+ {
+ return static_cast&lt;T&amp;&amp;&gt;(x);
+@@ -60557,7 +65775,8 @@ potential mistakes as possible, by actively preventing <em>all</em> other
+ uses:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class U&gt;
++<blockquote><pre>
++template &lt;class T, class U&gt;
+ boost::enable_if_c&lt;
+ // in forward&lt;T&gt;(x), x is a parameter of the caller, thus an lvalue
+ is_lvalue_reference&lt;U&gt;::value
+@@ -60580,22 +65799,22 @@ boost::enable_if_c&lt;
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ A paper,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2951.html">N2951</a>,
+ is available which compares several implementations (including David's) with respect to several
+ use cases (including Jason's) and provides wording for one implementation.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2951.html">N2951</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -60606,14 +65825,15 @@ use cases (including Jason's) and provides wording for one implementation.
+
+
+ <hr>
+-<h3><a name="1055"></a>1055. Response to UK 98</h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1055"></a>1055. Provide a trait that returns the underlying type of an enumeration type</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+-<p><b>Addresses UK 98</b></p>
++<p><b>Addresses UK 98 [CD1]</b></p>
+
+ <p>
+ It would be useful to be able to determine the underlying
+@@ -60628,7 +65848,7 @@ programming with enumerations easier.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Pete observes (and Tom concurs)
+ that the proposed resolution seems to require compiler support
+ for its implementation,
+@@ -60641,20 +65861,20 @@ then the library might be able to do better,
+ but there is no such requirement.
+ Keep status as Open
+ and solicit input from CWG.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-23 Alisdair adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Just to confirm that the BSI originator of this comment assumed it did
+ indeed imply a compiler intrinsic. Rather than request a Core extension, it
+ seemed in keeping with that the type traits interface provides a library API
+ to unspecified compiler features - where we require several other traits
+ (e.g. <tt>has_trivial_*</tt>) to get the 'right' answer now, unlike in TR1.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2947.html">N2947</a>.
+@@ -60666,22 +65886,22 @@ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.html">N2984</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.htm">N2984</a>.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new row to the table in 20.7.7.6 [meta.trans.other]:
++Add a new row to the table in 20.10.7.6 [meta.trans.other]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+ <caption>Table 41 -- Other transformations</caption>
+-<tbody><tr>
++<tr>
+ <th>Template</th>
+ <th>Condition</th>
+ <th>Comments</th>
+@@ -60698,7 +65918,7 @@ The member typedef <tt>type</tt> shall name the underlying type
+ of the enum <tt>T</tt>.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -60706,13 +65926,13 @@ of the enum <tt>T</tt>.
+
+
+ <hr>
+-<h3><a name="1065"></a>1065. Response to UK 168</h3>
+-<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#contents">issues</a> in [contents].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1065"></a>1065. Allow inline namespaces within namespace <tt>std</tt> for implementations</h3>
++<p><b>Section:</b> 17.6.1.1 [contents] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#contents">issues</a> in [contents].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 168</b></p>
++<p><b>Addresses UK 168 [CD1]</b></p>
+ <p>
+ We should make it clear (either by note or normatively) that namespace
+ <tt>std</tt> may contain inline namespaces, and that entities specified to be
+@@ -60731,9 +65951,9 @@ namespaces nested directly or indirectly within namespace std"
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ adopt UK words (some have reservations whether it is correct)
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-09 Alisdair improves the wording.
+@@ -60761,7 +65981,7 @@ Move to Tentatively Ready.
+ Change 17.6.1.1 [contents] p2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ All library entities except macros, <tt>operator new</tt> and
+ <tt>operator delete</tt> are defined within the namespace <tt>std</tt> or
+ namespaces nested within namespace <tt>std</tt>.
+@@ -60769,19 +65989,19 @@ namespaces nested within namespace <tt>std</tt>.
+ are declared directly in that namespace, or in an inline namespace inside
+ that namespace. [<i>Footnote:</i> This gives implementers freedom to support
+ multiple configurations of the library.]</ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1066"></a>1066. Response to UK 189 and JP 27</h3>
+-<p><b>Section:</b> 18 [language.support] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1066"></a>1066. Use <tt>[[noreturn]]</tt> attribute in the library</h3>
++<p><b>Section:</b> 18 [language.support] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses UK 189 and JP 27</b></p>
++<p><b>Addresses UK 189 and JP 27 [CD1]</b></p>
+ <p>
+ The addition of the <tt>[[noreturn]]</tt> attribute to the language will be an
+ important aid for static analysis tools.
+@@ -60798,18 +66018,18 @@ The following functions should be declared in C++ with the
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Agreed.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -60819,15 +66039,18 @@ Change 18.5 [support.start.term] p3:
+
+ <blockquote>
+ <p>-2- ...</p>
+-<pre><ins>void</ins> abort <ins>[[noreturn]]</ins> (void)
++<pre>
++<ins>void</ins> abort <ins>[[noreturn]]</ins> (void)
+ </pre>
+ <p>-3- ...</p>
+ <p>-6- ...</p>
+-<pre><ins>void</ins> exit<ins> [[noreturn]] </ins>(int status)
++<pre>
++<ins>void</ins> exit<ins> [[noreturn]] </ins>(int status)
+ </pre>
+ <p>-7- ...</p>
+ <p>-11- ...</p>
+-<pre>void quick_exit<ins> [[noreturn]] </ins>(int status)
++<pre>
++void quick_exit<ins> [[noreturn]] </ins>(int status)
+ </pre>
+ <p>-12- ...</p>
+ </blockquote>
+@@ -60836,7 +66059,8 @@ Change 18.5 [support.start.term] p3:
+ Change the <tt>&lt;exception&gt;</tt> synopsis in 18.8 [support.exception]:
+ </p>
+
+-<blockquote><pre>void unexpected<ins> [[noreturn]] </ins>();
++<blockquote><pre>
++void unexpected<ins> [[noreturn]] </ins>();
+ ...
+ void terminate<ins> [[noreturn]] </ins>();
+ ...
+@@ -60846,31 +66070,35 @@ template &lt;class T&gt; void throw_with_nested<ins> [[noreturn]] </ins>(T&amp;&
+ </pre></blockquote>
+
+ <p>
+-Change D.13.3 [unexpected]:
++Change D.8.4 [unexpected]:
+ </p>
+
+-<blockquote><pre>void unexpected<ins> [[noreturn]] </ins>();
++<blockquote><pre>
++void unexpected<ins> [[noreturn]] </ins>();
+ </pre></blockquote>
+
+ <p>
+-Change 18.8.3.3 [terminate]:
++Change 18.8.3.4 [terminate]:
+ </p>
+
+-<blockquote><pre>void terminate<ins> [[noreturn]] </ins>();
++<blockquote><pre>
++void terminate<ins> [[noreturn]] </ins>();
+ </pre></blockquote>
+
+ <p>
+ Change 18.8.5 [propagation]:
+ </p>
+
+-<blockquote><pre>void rethrow_exception<ins> [[noreturn]] </ins>(exception_ptr p);
++<blockquote><pre>
++void rethrow_exception<ins> [[noreturn]] </ins>(exception_ptr p);
+ </pre></blockquote>
+
+ <p>
+ In the synopsis of 18.8.6 [except.nested] and the definition area change:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt; void throw_with_nested<ins> [[noreturn]] </ins>(T&amp;&amp; t); <del>// [[noreturn]]</del>
++<blockquote><pre>
++template &lt;class T&gt; void throw_with_nested<ins> [[noreturn]] </ins>(T&amp;&amp; t); <del>// [[noreturn]]</del>
+ </pre></blockquote>
+
+
+@@ -60879,16 +66107,18 @@ In the synopsis of 18.8.6 [except.nested] and the definition area change:
+
+ <hr>
+ <h3><a name="1070"></a>1070. Ambiguous move overloads in function</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The synopsis in 20.8.14.2 [func.wrap.func] says:
++The synopsis in 20.9.12.2 [func.wrap.func] says:
+ </p>
+
+-<blockquote><pre>template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
++<blockquote><pre>
++template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
+ class function&lt;R(ArgTypes...)&gt;
+ {
+ ...
+@@ -60928,9 +66158,9 @@ In the proposed wording I've gotten lazy and just used the pass-by-value signatu
+ ]</i></p>
+
+
+-<blockquote>
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1024">1024</a> modifies the second removed constructor.
+-</blockquote>
++<blockquote><p>
++<a href="lwg-closed.html#1024">1024</a> modifies the second removed constructor.
++</p></blockquote>
+
+ <p><i>[
+ Batavia (2009-05):
+@@ -60949,11 +66179,12 @@ Move to Tentatively Ready.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopsis of 20.8.14.2 [func.wrap.func], and remove the associated definitions in
+-20.8.14.2.1 [func.wrap.func.con]:
++Change the synopsis of 20.9.12.2 [func.wrap.func], and remove the associated definitions in
++20.9.12.2.1 [func.wrap.func.con]:
+ </p>
+
+-<blockquote><pre>template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
++<blockquote><pre>
++template&lt;Returnable R, CopyConstructible... ArgTypes&gt;
+ class function&lt;R(ArgTypes...)&gt;
+ {
+ ...
+@@ -60987,18 +66218,19 @@ class function&lt;R(ArgTypes...)&gt;
+
+
+ <hr>
+-<h3><a name="1071"></a>1071. is_bind_expression should derive from integral_constant&lt;bool&gt;</h3>
+-<p><b>Section:</b> 20.8.10.1.1 [func.bind.isbind] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.bind.isbind">issues</a> in [func.bind.isbind].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1071"></a>1071. <tt>is_bind_expression</tt> should derive from <tt>integral_constant&lt;bool&gt;</tt></h3>
++<p><b>Section:</b> 20.9.10.1 [func.bind.isbind] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.isbind">issues</a> in [func.bind.isbind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-Class template is_bind_expression 20.8.10.1.1 [func.bind.isbind]:
++Class template is_bind_expression 20.9.10.1 [func.bind.isbind]:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template&lt;class T&gt; struct is_bind_expression {
+ static const bool value = see below;
+ };
+@@ -61013,9 +66245,9 @@ other similar trait types.
+ Daniel adds:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We need the same thing for the trait <tt>is_placeholder</tt> as well.
+-</blockquote>
++</p></blockquote>
+ <p><i>[
+ 2009-03-22 Daniel provided wording.
+ ]</i></p>
+@@ -61067,10 +66299,10 @@ alone.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready. We are comfortable with requiring user specializations
+ to derive from <tt>integral_constant</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -61078,9 +66310,10 @@ to derive from <tt>integral_constant</tt>.
+ <ol>
+ <li>
+ <p>
+-In 20.8.10.1.1 [func.bind.isbind] change as indicated:
++In 20.9.10.1 [func.bind.isbind] change as indicated:
+ </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template&lt;class T&gt; struct is_bind_expression <ins>: integral_constant&lt;bool, <i>see below</i>&gt; { };</ins><del>{
+ static const bool value = <i>see below</i>;
+ };</del>
+@@ -61089,25 +66322,27 @@ In 20.8.10.1.1 [func.bind.isbind] change as indicated:
+ </li>
+ <li>
+ <p>
+-In 20.8.10.1.1 [func.bind.isbind]/2 change as indicated:
++In 20.9.10.1 [func.bind.isbind]/2 change as indicated:
+ </p>
+-<blockquote><pre><del>static const bool value;</del>
++<blockquote><pre>
++<del>static const bool value;</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -2- <del><tt>true</tt> if <tt>T</tt> is a type returned from <tt>bind</tt>, <tt>false</tt> otherwise.</del>
+ <ins>If <tt>T</tt> is a type returned from <tt>bind</tt>, <tt>is_bind_expression&lt;T&gt;</tt> shall
+ be publicly derived from
+ <tt>integral_constant&lt;bool, true&gt;</tt>, otherwise it shall be
+ publicly derived from
+ <tt>integral_constant&lt;bool, false&gt;</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ <li>
+ <p>
+-In [func.bind.isplace] change as indicated:
++In 20.9.10.2 [func.bind.isplace] change as indicated:
+ </p>
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template&lt;class T&gt; struct is_placeholder <ins>: integral_constant&lt;int, <i>see below</i>&gt; { };</ins><del>{
+ static const int value = <i>see below</i>;
+ };</del>
+@@ -61116,18 +66351,19 @@ In [func.bind.isplace] change as indicated:
+ </li>
+ <li>
+ <p>
+-In [func.bind.isplace]/2 change as indicated:
++In 20.9.10.2 [func.bind.isplace]/2 change as indicated:
+ </p>
+-<blockquote><pre><del>static const int value;</del>
++<blockquote><pre>
++<del>static const int value;</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -2- <del>value is <tt>J</tt> if <tt>T</tt> is the type of <tt>std::placeholders::_J</tt>, 0 otherwise.</del>
+ <ins>If <tt>T</tt> is the type of <tt>std::placeholders::_J</tt>, <tt>is_placeholder&lt;T&gt;</tt>
+ shall be publicly
+ derived from <tt>integral_constant&lt;int, J&gt;</tt> otherwise it shall
+ be publicly derived
+ from <tt>integral_constant&lt;int, 0&gt;</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ </ol>
+@@ -61138,10 +66374,10 @@ be publicly derived
+
+ <hr>
+ <h3><a name="1073"></a>1073. Declaration of <tt>allocator_arg</tt> should be <tt>constexpr</tt></h3>
+-<p><b>Section:</b> 20.9 [memory] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#memory">issues</a> in [memory].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7 [memory] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#memory">issues</a> in [memory].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -61153,17 +66389,18 @@ initialization.
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution. Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9 [memory] p2:
++Change 20.7 [memory] p2:
+ </p>
+
+-<blockquote><pre>// 20.8.1, allocator argument tag
++<blockquote><pre>
++// 20.8.1, allocator argument tag
+ struct allocator_arg_t { };
+ const<ins>expr</ins> allocator_arg_t allocator_arg = allocator_arg_t();
+ </pre></blockquote>
+@@ -61174,22 +66411,23 @@ const<ins>expr</ins> allocator_arg_t allocator_arg = allocator_arg_t();
+
+
+ <hr>
+-<h3><a name="1075"></a>1075. Response to US 65, US 74.1</h3>
+-<p><b>Section:</b> 20 [utilities], 23 [containers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alan Talbot <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utilities">issues</a> in [utilities].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1075"></a>1075. Scoped allocators are too complex</h3>
++<p><b>Section:</b> 20 [utilities], 23 [containers] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alan Talbot <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utilities">issues</a> in [utilities].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US 65 and US 74.1</b></p>
++<p><b>Addresses US 65 and US 74.1 [CD1]</b></p>
+
+ <p>US 65:</p>
+
+-<blockquote>
++<blockquote><p>
+ Scoped allocators and allocator propagation traits add a small amount of
+ utility at the cost of a great deal of machinery. The machinery is user
+ visible, and it extends to library components that don't have any
+ obvious connection to allocators, including basic concepts and simple
+ components like <tt>pair</tt> and <tt>tuple</tt>.
++</p>
+
+ <p>Suggested resolution:</p>
+
+@@ -61201,9 +66439,9 @@ components that don't explicitly allocate memory (e.g. pair), and adjust
+ container interfaces to reflect this simplification.
+ </p>
+ <p>
+-Components that I propose eliminating include HasAllocatorType,
+-is_scoped_allocator, allocator_propagation_map, scoped_allocator_adaptor,
+-and ConstructibleAsElement.
++Components that I propose eliminating include <tt>HasAllocatorType</tt>,
++<tt>is_scoped_allocator</tt>, <tt>allocator_propagation_map</tt>, <tt>scoped_allocator_adaptor</tt>,
++and <tt>ConstructibleAsElement</tt>.
+ </p>
+ </blockquote>
+
+@@ -61231,7 +66469,7 @@ Some evidence of the complexity introduced by scoped allocators:
+ </p>
+ <blockquote>
+ <p>
+-20.3.5 [pairs], 20.4 [tuple]: Large increase in the
++20.3 [pairs], 20.4 [tuple]: Large increase in the
+ number of pair and tuple constructors.
+ </p>
+ <p>
+@@ -61250,7 +66488,7 @@ includes at least the following changes:
+ Remove X [allocator.element.concepts]
+ </p>
+ <p>
+-Remove 20.10 [allocator.adaptor]
++Remove 20.13 [allocator.adaptor]
+ </p>
+ <p>
+ Remove [construct.element]
+@@ -61285,8 +66523,9 @@ bullet) but we do want to allow explicit constructors in emplace, as the
+ following example shows:
+ </p>
+
+-<blockquote><pre>vector&lt;shared_ptr&lt;int&gt;&gt; v;
+-v.emplace_back(new int); <font color="#C80000">// should be allowed</font>
++<blockquote><pre>
++vector&lt;shared_ptr&lt;int&gt;&gt; v;
++v.emplace_back(new int); <span style="color:#C80000">// should be allowed</span>
+ </pre></blockquote>
+
+ <p>
+@@ -61294,7 +66533,8 @@ If the issue is accepted and scoped allocators are removed, I suggest to
+ add a new pair of concepts to [concept.construct], namely:
+ </p>
+
+-<blockquote><pre>auto concept HasExplicitConstructor&lt;typename T, typename... Args&gt; {
++<blockquote><pre>
++auto concept HasExplicitConstructor&lt;typename T, typename... Args&gt; {
+ explicit T::T(Args...);
+ }
+
+@@ -61313,7 +66553,8 @@ For coherence and consistency with the similar concepts
+ <tt>Constructible</tt> to:
+ </p>
+
+-<blockquote><pre>auto concept Constructible&lt;typename T, typename... Args&gt;
++<blockquote><pre>
++auto concept Constructible&lt;typename T, typename... Args&gt;
+ : HasConstructor&lt;T, Args...&gt;, ExplicitConstructible&lt;T, Args...&gt;
+ { }
+ </pre></blockquote>
+@@ -61329,10 +66570,11 @@ On the other hand, if the issue is not accepted, the scoped allocator
+ adaptors should be fixed because the following code:
+ </p>
+
+-<blockquote><pre>template &lt;typename T&gt; using scoped_allocator = scoped_allocator_adaptor&lt;allocator&lt;T&gt;&gt;;
++<blockquote><pre>
++template &lt;typename T&gt; using scoped_allocator = scoped_allocator_adaptor&lt;allocator&lt;T&gt;&gt;;
+
+ vector&lt;shared_ptr&lt;int&gt;, scoped_allocator&lt;shared_ptr&lt;int&gt;&gt;&gt; v;
+-v.emplace_back(new int); <font color="#C80000">// ops! doesn't compile</font>
++v.emplace_back(new int); <span style="color:#C80000">// ops! doesn't compile</span>
+ </pre></blockquote>
+
+ <p>
+@@ -61360,7 +66602,7 @@ requires a disposition that addresses the concerns.
+ <p>
+ The notes in the NB comment list (US 65 &amp; US 74.1) say that:
+ </p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ this issue has not introduced any new arguments not previously discussed,
+ </li>
+@@ -61375,7 +66617,7 @@ the issue is resolved by
+ <p>
+ My opinion is:
+ </p>
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ there are new arguments in both comments regarding concepts (which were
+ not present in the library when the scoped allocator proposal was voted
+@@ -61410,10 +66652,10 @@ rather than later so there is more time to deal with it.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -61421,7 +66663,9 @@ rather than later so there is more time to deal with it.
+
+
+ <p><b>Rationale:</b></p>
++<p>
+ Scoped allocators have been revised significantly.
++</p>
+
+
+
+@@ -61429,10 +66673,10 @@ Scoped allocators have been revised significantly.
+
+ <hr>
+ <h3><a name="1079"></a>1079. UK-265: <code>RandomAccessIterator</code>'s <code>operator-</code> has nonsensical effects clause</h3>
+-<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 24.2.7 [random.access.iterators] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2009-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#random.access.iterators">issues</a> in [random.access.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 265</b></p>
+
+@@ -61458,7 +66702,8 @@ For random access iterators, the definitions of <tt>(b-a)</tt> and
+ From table Table 104 -- Random access iterator requirements:
+ </p>
+
+-<blockquote><pre>b - a :==&gt; (a &lt; b) ? distance(a,b) : -distance(b,a)
++<blockquote><pre>
++b - a :==&gt; (a &lt; b) ? distance(a,b) : -distance(b,a)
+
+ a &lt; b :==&gt; b - a &gt; 0
+ </pre></blockquote>
+@@ -61469,9 +66714,9 @@ a &lt; b :==&gt; b - a &gt; 0
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-13 Alisdair opens.
+@@ -61480,7 +66725,7 @@ Moved to Ready.
+
+ <blockquote>
+ <p>
+-Looking again at LWG #1079, the wording in the issue no longer exists, and
++Looking again at LWG <a href="lwg-defects.html#1079">1079</a>, the wording in the issue no longer exists, and
+ appears to be entirely an artefact of the concepts wording.
+ </p>
+
+@@ -61510,15 +66755,18 @@ The previous wording is preserved here:
+
+ <p>Modify 24.2.7 [random.access.iterators]p7-9 as follows:</p>
+
+-<blockquote><pre>difference_type operator-(const X&amp; a, const X&amp; b);
++<blockquote><pre>
++difference_type operator-(const X&amp; a, const X&amp; b);
+ </pre>
+-<ol start="7">
+- <li><i>Precondition</i>: there exists a value <code>n</code> of
+- <code>difference_type</code> such that <code>a == b + n</code>.</li>
+- <li><del><i>Effects</i>: <code>b == a + (b - a)</code></del></li>
+- <li><i>Returns</i>: <del><code>(a &lt; b) ? distance(a,b) :
+- -distance(b,a)</code></del><ins><code>n</code></ins></li>
+-</ol>
++<blockquote><p>
++ -7- <i>Precondition</i>: there exists a value <code>n</code> of
++ <code>difference_type</code> such that <code>a == b + n</code>.
++ <p/>
++ -8- <del><i>Effects</i>: <code>b == a + (b - a)</code></del>
++ <p/>
++ -9- <i>Returns</i>: <del><code>(a &lt; b) ? distance(a,b) :
++ -distance(b,a)</code></del><ins><code>n</code></ins>
++</p></blockquote>
+ </blockquote>
+
+ </blockquote>
+@@ -61529,9 +66777,9 @@ The previous wording is preserved here:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -61542,14 +66790,14 @@ Modify Table 105 in 24.2.7 [random.access.iterators]:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 105 — Random access iterator requirements (in addition to
++<caption>Table 105 &mdash; Random access iterator requirements (in addition to
+ bidirectional iterator)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
+ </tr>
+
+ <tr>
+@@ -61561,21 +66809,121 @@ bidirectional iterator)</caption>
+ n == b</tt>. <tt>b == a + (b - a)</tt>.</td>
+ </tr>
+
+-</tbody></table>
++</table>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1088"></a>1088. <tt>std::promise</tt> should provide non-member <tt>swap</tt> overload</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses UK 342 [CD1]</b></p>
++
++<p>
++<tt>std::promise</tt> is missing a non-member overload of <tt>swap</tt>. This is
++inconsistent with other types that provide a <tt>swap</tt> member function.
++</p>
++
++<p>
++Add a non-member overload <tt>void swap(promise&amp;&amp; x,promise&amp;&amp; y){ x.swap(y); }</tt>
++</p>
++
++<p><i>[
++Summit:
++]</i></p>
++
++<blockquote><p>
++Create an issue. Move to review, attention: Howard. Detlef will also look into it.
++</p></blockquote>
++
++<p><i>[
++Post Summit Daniel provided wording.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++In 30.6.5 [futures.promise], before p.1, immediately after class template
++promise add:
++</p>
++<blockquote><pre>
++<ins>
++template &lt;class R&gt;
++void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
++</ins>
++</pre></blockquote>
++</li>
++<li>
++<p>
++Change 30.6.5 [futures.promise]/10 as indicated (to fix a circular definition):
++</p>
++<blockquote>
++<p>
++-10- <i>Effects:</i> <del>swap(*this, other)</del><ins>Swaps the associated state
++of <tt>*this</tt> and <tt>other</tt></ins>
++</p>
++<p>
++<ins><i>Throws:</i> Nothing.</ins>
++</p>
++</blockquote>
++</li>
++<li>
++<p>
++After the last paragraph in 30.6.5 [futures.promise] add the following
++prototype description:
++</p>
++<blockquote><pre>
++<ins>
++template &lt;class R&gt;
++void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
++</ins></pre>
++<blockquote>
++<p>
++<ins><i>Effects:</i> <tt>x.swap(y)</tt></ins>
++</p>
++<p>
++<ins><i>Throws:</i> Nothing.</ins>
++</p>
++</blockquote>
+ </blockquote>
++</li>
++
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="1089"></a>1089. Response to JP 76</h3>
+-<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread">issues</a> in [thread].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1089"></a>1089. Unify "Throws: Nothing." specifications</h3>
++<p><b>Section:</b> 30 [thread] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread">issues</a> in [thread].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP 76</b></p>
++<p><b>Addresses JP 76 [CD1]</b></p>
+
+ <p>
+ A description for "Throws: Nothing." are not unified.
+@@ -61611,9 +66959,9 @@ Add "Throws: Nothing." to the following.
+ Summit:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Pass on to editor.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Post Summit: Editor declares this non-editorial.
+@@ -61649,9 +66997,9 @@ It can call a function which never returns, such as <tt>std::exit</tt> or
+ It can throw an exception.
+ </li>
+ </ol>
+-
++<p>
+ The above list can be abbreviated with:
+-
++</p>
+ <ol>
+ <li><b>R</b>eturns.</li>
+ <li><b>E</b>nds program.</li>
+@@ -61679,7 +67027,8 @@ function. It may return, it may end the program, or it may throw. When we
+ specify a function with an empty throw spec:
+ </p>
+
+-<blockquote><pre>void f() throw();
++<blockquote><pre>
++void f() throw();
+ </pre></blockquote>
+
+ <p>
+@@ -61713,7 +67062,8 @@ allow these functions to throw:
+ Add a paragraph under 30.4.2.1 [thread.lock.guard] p4:
+ </p>
+
+-<blockquote><pre>explicit lock_guard(mutex_type&amp; m);
++<blockquote><pre>
++explicit lock_guard(mutex_type&amp; m);
+ </pre>
+
+ <p><ins>
+@@ -61725,7 +67075,8 @@ Add a paragraph under 30.4.2.1 [thread.lock.guard] p4:
+ Add a paragraph under 30.4.2.2.1 [thread.lock.unique.cons] p6:
+ </p>
+
+-<blockquote><pre>explicit unique_lock(mutex_type&amp; m);
++<blockquote><pre>
++explicit unique_lock(mutex_type&amp; m);
+ </pre>
+
+ <p><ins>
+@@ -61737,7 +67088,8 @@ Add a paragraph under 30.4.2.2.1 [thread.lock.unique.cons] p6:
+ Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
+ </p>
+
+-<blockquote><pre>template &lt;class Lock, class Rep, class Period&gt;
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period&gt;
+ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+ </pre>
+
+@@ -61746,7 +67098,8 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
+ </ins></p>
+ </blockquote>
+
+-<blockquote><pre>template &lt;class Lock, class Duration, class Predicate&gt;
++<blockquote><pre>
++template &lt;class Lock, class Duration, class Predicate&gt;
+ bool wait_until(Lock&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; rel_time, Predicate pred);
+ </pre>
+
+@@ -61755,7 +67108,8 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
+ </ins></p>
+ </blockquote>
+
+-<blockquote><pre>template &lt;class Lock, class Rep, class Period, class Predicate&gt;
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period, class Predicate&gt;
+ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
+ </pre>
+
+@@ -61773,9 +67127,9 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Defer pending further developments with exception restriction annotations.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-11 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+@@ -61787,22 +67141,22 @@ Defer pending further developments with exception restriction annotations.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ A "<i>Throws:</i> Nothing" specification is not the place to say that a function
+ is not allowed to call <tt>exit()</tt>. While I agree with the thrust of the
+ proposed resolution, "doesn't throw exceptions" is a subset of "always returns
+ normally". If it's important to say that most library functions don't call
+ <tt>exit()</tt>, say so.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready except for the added paragraph to 17.5.1.4 [structure.specifications].
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -61813,7 +67167,8 @@ Move to Ready except for the added paragraph to 17.5.1.4 [structure.specificatio
+ Add a paragraph under 30.3.1.6 [thread.thread.static] p1:
+ </p>
+
+-<blockquote><pre>unsigned hardware_concurrency();
++<blockquote><pre>
++unsigned hardware_concurrency();
+ </pre>
+
+ <p>
+@@ -61835,10 +67190,11 @@ Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8:
+ </p>
+ <dl>
+ <dt><i>[EINVAL]</i></dt>
+-<dd><i>The value <tt>cond</tt> does not refer to an initialized condition variable. — end informational]</i></dd>
++<dd><i>The value <tt>cond</tt> does not refer to an initialized condition variable. &mdash; end informational]</i></dd>
+ </dl>
+
+-<pre>void notify_one();
++<pre>
++void notify_one();
+ </pre>
+
+ <p>
+@@ -61850,7 +67206,8 @@ Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8:
+ </ins></p>
+ </blockquote>
+
+-<blockquote><pre>void notify_all();
++<blockquote><pre>
++void notify_all();
+ </pre>
+
+ <p>
+@@ -61868,7 +67225,8 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:
+ </p>
+
+ <blockquote>
+-<pre>void notify_one();
++<pre>
++void notify_one();
+ </pre>
+
+ <p>
+@@ -61880,7 +67238,8 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:
+ </ins></p>
+ </blockquote>
+
+-<blockquote><pre>void notify_all();
++<blockquote><pre>
++void notify_all();
+ </pre>
+
+ <p>
+@@ -61899,13 +67258,271 @@ Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:
+
+
+ <hr>
+-<h3><a name="1094"></a>1094. Response to JP 65 and JP 66</h3>
+-<p><b>Section:</b> 27.5.4.3 [iostate.flags] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1090"></a>1090. Missing description of <tt>packaged_task</tt> member <tt>swap</tt>, missing non-member <tt>swap</tt></h3>
++<p><b>Section:</b> 30.6.9 [futures.task] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task">issues</a> in [futures.task].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses JP 65 and JP 66</b></p>
++<p>
++Class template <tt>packaged_task</tt> in 30.6.9 [futures.task] shows a member <tt>swap</tt>
++declaration, but misses to document it's effects (No prototype provided). Further on this class
++misses to provide a non-member swap.
++</p>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++Alisdair notes that paragraph 2 of the proposed resolution has already been
++applied in the current Working Draft.
++</p>
++<p>
++We note a pending <tt>future</tt>-related paper by Detlef;
++we would like to wait for this paper before proceeding.
++</p>
++<p>
++Move to Open.
++</p>
++</blockquote>
++
++<p><i>[
++2009-05-24 Daniel removed part 2 of the proposed resolution.
++]</i></p>
++
++
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Move to Tentatively Ready, removing bullet 3 from the proposed
++resolution but keeping the other two bullets.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++In 30.6.9 [futures.task], immediately after the definition of class
++template packaged_task add:
++</p>
++<blockquote><pre>
++<ins>
++template&lt;class R, class... Argtypes&gt;
++void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp;, packaged_task&lt;R(ArgTypes...)&gt;&amp;);
++</ins>
++</pre></blockquote>
++</li>
++<li>
++<p>
++At the end of 30.6.9 [futures.task] (after p. 20), add the following
++prototype description:
++</p>
++
++<blockquote><pre>
++<ins>
++template&lt;class R, class... Argtypes&gt;
++void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp; x, packaged_task&lt;R(ArgTypes...)&gt;&amp; y);
++</ins></pre>
++<blockquote>
++<p><ins>
++<i>Effects:</i> <tt>x.swap(y)</tt>
++</ins></p>
++<p><ins>
++<i>Throws:</i> Nothing.
++</ins></p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1093"></a>1093. Multiple definitions for <tt>random_shuffle</tt> algorithm</h3>
++<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-03-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++There are a couple of issues with the declaration of the <tt>random_shuffle</tt>
++algorithm accepting a random number engine.
++</p>
++
++<ol style="list-style-type:lower-roman">
++<li>
++The Iterators must be shuffle iterators, yet this requirement is missing.
++</li>
++<li>
++The <tt>RandomNumberEngine</tt> concept is now provided by the random number
++library
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2836.pdf">n2836</a>)
++and the placeholder should be removed.
++</li>
++</ol>
++
++<p><i>[
++2009-05-02 Daniel adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++this issue completes adding necessary requirement to the
++third new <tt>random_shuffle</tt> overload. The current suggestion is:
++</p>
++
++<blockquote><pre>
++template&lt;RandomAccessIterator Iter, UniformRandomNumberGenerator Rand&gt;
++requires ShuffleIterator&lt;Iter&gt;
++void random_shuffle(Iter first, Iter last, Rand&amp;&amp; g);
++</pre></blockquote>
++
++<p>
++IMO this is still insufficient and I suggest to add the requirement
++</p>
++<blockquote><pre>
++Convertible&lt;Rand::result_type, Iter::difference_type&gt;
++</pre></blockquote>
++<p>
++to the list (as the two other overloads already have).
++</p>
++
++<p>
++Rationale:
++</p>
++
++<blockquote>
++<p>
++Its true that this third overload is somewhat different from the remaining
++two. Nevertheless we know from <tt>UniformRandomNumberGenerator</tt>, that
++it's <tt>result_type</tt> is an integral type and that it satisfies
++<tt>UnsignedIntegralLike&lt;result_type&gt;</tt>.
++</p>
++<p>
++To realize it's designated task, the algorithm has to invoke the
++<tt>Callable</tt> aspect of <tt>g</tt> and needs to perform some algebra involving
++it's <tt>min()/max()</tt> limits to compute another index value that
++at this point is converted into <tt>Iter::difference_type</tt>. This is so,
++because 24.2.7 [random.access.iterators] uses this type as argument
++of it's algebraic operators. Alternatively consider the equivalent
++iterator algorithms in 24.4.4 [iterator.operations] with the same result.
++</p>
++<p>
++This argument leads us to the conclusion that we also need
++<tt>Convertible&lt;Rand::result_type, Iter::difference_type&gt;</tt> here.
++</p>
++</blockquote>
++
++</blockquote>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++Alisdair notes that point (ii) has already been addressed.
++</p>
++<p>
++We agree with the proposed resolution to point (i)
++with Daniel's added requirement.
++</p>
++<p>
++Move to Review.
++</p>
++</blockquote>
++
++<p><i>[
++2009-06-05 Daniel updated proposed wording as recommended in Batavia.
++]</i></p>
++
++
++<p><i>[
++2009-07-28 Alisdair adds:
++]</i></p>
++
++
++<blockquote><p>
++Revert to Open, with a note there is consensus on direction but the
++wording needs updating to reflect removal of concepts.
++</p></blockquote>
++
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Leave Open, Walter to work on it.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>, addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3056.pdf">N3056</a>.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3056.pdf">N3056</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]:
++</p>
++
++<blockquote><pre>
++<del>concept UniformRandomNumberGenerator&lt;typename Rand&gt; { }</del>
++template&lt;RandomAccessIterator Iter, UniformRandomNumberGenerator Rand&gt;
++ <ins>requires ShuffleIterator&lt;Iter&gt; &amp;&amp;
++ Convertible&lt;Rand::result_type, Iter::difference_type&gt;</ins>
++ void random_shuffle(Iter first, Iter last, Rand&amp;&amp; g);
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1094"></a>1094. Replace "<em>unspecified-bool-type</em>" by "<tt>explicit operator bool() const</tt>" in I/O library</h3>
++<p><b>Section:</b> 27.5.5.4 [iostate.flags] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2009-03-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostate.flags">issues</a> in [iostate.flags].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses JP 65 and JP 66 [CD1]</b></p>
+
+ <p>
+ Switch from "unspecified-bool-type" to "explicit operator bool() const".
+@@ -61919,35 +67536,37 @@ Replace <tt>operator unspecified-bool-type() const;</tt>" with <tt>explicit oper
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ We agree with the proposed resolution.
+ Move to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the synopis in 27.5.4 [ios]:
++Change the synopis in 27.5.5 [ios]:
+ </p>
+
+-<blockquote><pre><ins>explicit</ins> operator <del><i>unspecified-bool-type</i></del> <ins>bool</ins>() const;
++<blockquote><pre>
++<ins>explicit</ins> operator <del><i>unspecified-bool-type</i></del> <ins>bool</ins>() const;
+ </pre></blockquote>
+
+ <p>
+-Change 27.5.4.3 [iostate.flags]:
++Change 27.5.5.4 [iostate.flags]:
+ </p>
+
+-<blockquote><pre><ins>explicit</ins> operator <del><i>unspecified-bool-type</i></del> <ins>bool</ins>() const;
++<blockquote><pre>
++<ins>explicit</ins> operator <del><i>unspecified-bool-type</i></del> <ins>bool</ins>() const;
+ </pre>
+
+ <blockquote>
+@@ -61975,27 +67594,28 @@ choice for this type is pointer-to-member. <i>-- end note</i>]</del>
+
+ <hr>
+ <h3><a name="1095"></a>1095. <i>Shared objects and the library</i> wording unclear</h3>
+-<p><b>Section:</b> 17.6.3.10 [res.on.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-03-27 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.4.10 [res.on.objects] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-03-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.objects">issues</a> in [res.on.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2775.htm">N2775</a>,
+ <i>Small library thread-safety revisions</i>, among other changes, removed a note from
+-17.6.3.10 [res.on.objects] that read:
++17.6.4.10 [res.on.objects] that read:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> This prohibition against concurrent non-const access means that
+ modifying an object of a standard library type shared between threads
+ without using a locking mechanism may result in a data race. <i>--end note</i>.]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ That resulted in wording which is technically correct but can only be
+-understood by reading the lengthy and complex 17.6.4.9 [res.on.data.races]
++understood by reading the lengthy and complex 17.6.5.9 [res.on.data.races]
+ Data race avoidance. This has the effect of making
+-17.6.3.10 [res.on.objects] unclear, and has already resulted in a query
++17.6.4.10 [res.on.objects] unclear, and has already resulted in a query
+ to the LWG reflector. See c++std-lib-23194.
+ </p>
+
+@@ -62022,15 +67642,15 @@ move to Review status.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Note: Change to read: "Modifying...", Delete 'thus', move to Ready
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 17.6.3.10 [res.on.objects] as indicated:
++Change 17.6.4.10 [res.on.objects] as indicated:
+ </p>
+
+ <blockquote>
+@@ -62053,10 +67673,10 @@ locking mechanism. <i>--end note</i>]
+
+ <hr>
+ <h3><a name="1097"></a>1097. #define __STDCPP_THREADS</h3>
+-<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.types">issues</a> in [support.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE 18</b></p>
+
+@@ -62109,9 +67729,9 @@ Move to Review.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-25 Pete moved to Open:
+@@ -62124,10 +67744,10 @@ The proposed resolution adds a feature-test macro named
+ <tt>__STDCPP_THREADS</tt>, described after the following new text:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The standard library defines the following macros; no explicit prior inclusion
+ of any header file is necessary.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The correct term here is "header", not "header file". But that's minor. The real
+@@ -62159,10 +67779,10 @@ mention of a decision to change this.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Most macros we have begin and end with with double underbars, this one
+ only begins with double underbars.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Ganesh's wording adopted and moved to Ready for Pittsburgh.
+@@ -62177,7 +67797,7 @@ only begins with double underbars.
+ Change 17.6.1.3 [compliance]/3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 The supplied version of the header <tt>&lt;cstdlib&gt;</tt> shall
+ declare at least the functions <tt>abort()</tt>, <tt>atexit()</tt>, and
+ <tt>exit()</tt> (18.5). <ins>The supplied version of the header
+@@ -62185,7 +67805,7 @@ declare at least the functions <tt>abort()</tt>, <tt>atexit()</tt>, and
+ hosted implementation or including it shall have no effect.</ins> The
+ other headers listed in this table shall meet the same requirements as
+ for a hosted implementation.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Add the following line to table 15:
+@@ -62193,9 +67813,9 @@ Add the following line to table 15:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 15 — C++ headers for freestanding implementations</caption>
++<caption>Table 15 &mdash; C++ headers for freestanding implementations</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Subclause</th>
+ <th>Header(s)</th>
+ </tr>
+@@ -62209,7 +67829,7 @@ Add the following line to table 15:
+ <td><ins><tt>&lt;thread&gt;</tt></ins></td>
+ </tr>
+
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+@@ -62217,7 +67837,8 @@ Add the following line to table 15:
+ Add to the <tt>&lt;thread&gt;</tt> synopsis in 30.3 [thread.threads]/1 the line:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+
+ <ins>#define __STDCPP_THREADS __cplusplus</ins>
+
+@@ -62234,16 +67855,16 @@ Add to the <tt>&lt;thread&gt;</tt> synopsis in 30.3 [thread.threads]/1 the line:
+
+
+ <hr>
+-<h3><a name="1098"></a>1098. definition of get_pointer_safety()</h3>
+-<p><b>Section:</b> 20.9.11 [util.dynamic.safety] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1098"></a>1098. definition of <tt>get_pointer_safety()</tt></h3>
++<p><b>Section:</b> 20.7.4 [util.dynamic.safety] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE 18</b></p>
+
+ <p>
+- In 20.9.11 [util.dynamic.safety], <tt>get_pointer_safety()</tt> purports
++ In 20.7.4 [util.dynamic.safety], <tt>get_pointer_safety()</tt> purports
+ to define behavior for
+ non-safely derived pointers (3.7.4.3 [basic.stc.dynamic.safety]). However,
+ the cited core-language section in paragraph 4 specifies undefined behavior
+@@ -62282,15 +67903,15 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The core issue is 853 and is in Ready status.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.9.11 [util.dynamic.safety] p16, replace the description of
++In 20.7.4 [util.dynamic.safety] p16, replace the description of
+ <tt>get_pointer_safety()</tt> with:
+ </p>
+
+@@ -62343,10 +67964,10 @@ Footnote) <tt>pointer_safety::preferred</tt> might be returned to indicate to th
+
+ <hr>
+ <h3><a name="1100"></a>1100. <tt>auto_ptr</tt> to <tt>unique_ptr</tt> conversion</h3>
+-<p><b>Section:</b> 20.9.9.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.8.1.2.1 [unique.ptr.single.ctor] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.ctor">issues</a> in [unique.ptr.single.ctor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Message c++std-lib-23182 led to a discussion in which several people
+@@ -62383,43 +68004,43 @@ Move to Tentatively Ready.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved from Tentatively Ready to Open only because the wording needs to be
+ tweaked for concepts removal.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-08-01 Howard deconceptifies wording:
+ ]</i></p>
+
+
+-<blockquote>
+-I also moved the change from D.12 [depr.auto.ptr]
+-to 20.9.9.2 [unique.ptr.single] per the Editor's request
++<blockquote><p>
++I also moved the change from X [depr.auto.ptr]
++to 20.8.1.2 [unique.ptr.single] per the Editor's request
+ in Batavia (as long as I was making changes anyway). Set back
+ to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-14 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We moved
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">N3073</a>
+ to the formal motions page in Pittsburgh which should obsolete this issue. I've
+ moved this issue to NAD Editorial, solved by N3073.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -62431,10 +68052,11 @@ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 20.9.9.2 [unique.ptr.single]:
++Add to 20.8.1.2 [unique.ptr.single]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class D&gt;
++<blockquote><pre>
++template &lt;class T, class D&gt;
+ class unique_ptr
+ {
+ public:
+@@ -62446,10 +68068,11 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Add to 20.9.9.2.1 [unique.ptr.single.ctor]:
++Add to 20.8.1.2.1 [unique.ptr.single.ctor]:
+ </p>
+
+-<blockquote><pre>template &lt;class U&gt;
++<blockquote><pre>
++template &lt;class U&gt;
+ unique_ptr(auto_ptr&lt;U&gt;&amp; u);
+ template &lt;class U&gt;
+ unique_ptr(auto_ptr&lt;U&gt;&amp;&amp; u);
+@@ -62484,15 +68107,16 @@ constructors shall not participate in overload resolution.
+
+ <hr>
+ <h3><a name="1103"></a>1103. <tt>system_error</tt> constructor postcondition overly strict</h3>
+-<p><b>Section:</b> 19.5.6.2 [syserr.syserr.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 19.5.6.2 [syserr.syserr.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 19.5.6.2 [syserr.syserr.members] says:
+ </p>
+
+-<blockquote><pre>system_error(error_code ec, const string&amp; what_arg);
++<blockquote><pre>
++system_error(error_code ec, const string&amp; what_arg);
+ </pre>
+ <blockquote>
+ <p>
+@@ -62508,10 +68132,11 @@ constructors shall not participate in overload resolution.
+ However the intent is for:
+ </p>
+
+-<blockquote><pre>std::system_error se(std::errc::not_a_directory, "In FooBar");
++<blockquote><pre>
++std::system_error se(std::errc::not_a_directory, "In FooBar");
+ ...
+-se.what(); <font color="#C80000">// returns something along the lines of:</font>
+- <font color="#C80000">// "In FooBar: Not a directory"</font>
++se.what(); <span style="color:#C80000">// returns something along the lines of:</span>
++ <span style="color:#C80000">// "In FooBar: Not a directory"</span>
+ </pre></blockquote>
+
+ <p>
+@@ -62582,51 +68207,57 @@ In 19.5.6.2 [syserr.syserr.members], change the following constructor postcondit
+ </p>
+
+ <blockquote>
+-<pre>system_error(error_code ec, const string&amp; what_arg);
++<pre>
++system_error(error_code ec, const string&amp; what_arg);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -2- <i>Postconditions:</i> <tt>code() == ec</tt>
+ and <tt><del>strcmp(runtime_error::what(), what_arg.c_str()) == 0</del>
+ <ins>string(what()).find(what_arg) != string::npos</ins></tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>system_error(error_code ec, const char* what_arg);
++<pre>
++system_error(error_code ec, const char* what_arg);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Postconditions:</i> <tt>code() == ec</tt>
+ and <tt><del>strcmp(runtime_error::what(), what_arg) == 0</del>
+ <ins>string(what()).find(what_arg) != string::npos</ins></tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>system_error(error_code ec);
++<pre>
++system_error(error_code ec);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -6- <i>Postconditions:</i> <tt>code() == ec</tt>
+ <del>and <tt>strcmp(runtime_error::what(), ""</tt></del>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>system_error(int ev, const error_category&amp; ecat, const string&amp; what_arg);
++<pre>
++system_error(int ev, const error_category&amp; ecat, const string&amp; what_arg);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -8- <i>Postconditions:</i> <tt>code() == error_code(ev, ecat)</tt>
+ and <tt><del>strcmp(runtime_error::what(), what_arg.c_str()) == 0</del>
+ <ins>string(what()).find(what_arg) != string::npos</ins></tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>system_error(int ev, const error_category&amp; ecat, const char* what_arg);
++<pre>
++system_error(int ev, const error_category&amp; ecat, const char* what_arg);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -10- <i>Postconditions:</i> <tt>code() == error_code(ev, ecat)</tt>
+ and <tt><del>strcmp(runtime_error::what(), what_arg) == 0</del>
+ <ins>string(what()).find(what_arg) != string::npos</ins></tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>system_error(int ev, const error_category&amp; ecat);
++<pre>
++system_error(int ev, const error_category&amp; ecat);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -12- <i>Postconditions:</i> <tt>code() == error_code(ev, ecat)</tt>
+ <del>and <tt>strcmp(runtime_error::what(), "") == 0</tt></del>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -62635,7 +68266,8 @@ In 19.5.6.2 [syserr.syserr.members], change the description of <tt>what()</tt>:
+ </p>
+
+ <blockquote>
+-<pre>const char *what() const throw();
++<pre>
++const char *what() const throw();
+ </pre>
+ <blockquote>
+ <p>
+@@ -62662,16 +68294,17 @@ if (msg.empty()) {
+ return msg.c_str();
+ </del></pre></blockquote>
+ <p>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+
+ <p>
+-In 27.5.2.1.1 [ios::failure], change the synopsis:
++In 27.5.3.1.1 [ios::failure], change the synopsis:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ class ios_base::failure : public system_error {
+ public:
+ explicit failure(const string&amp; msg, const error_code&amp; ec = io_errc::stream);
+@@ -62682,12 +68315,13 @@ In 27.5.2.1.1 [ios::failure], change the synopsis:
+ </pre></blockquote>
+
+ <p>
+-In 27.5.2.1.1 [ios::failure], change the description of the constructors:
++In 27.5.3.1.1 [ios::failure], change the description of the constructors:
+ </p>
+
+ <blockquote>
+
+-<pre>explicit failure(const string&amp; msg, , const error_code&amp; ec = io_errc::stream);
++<pre>
++explicit failure(const string&amp; msg, , const error_code&amp; ec = io_errc::stream);
+ </pre>
+ <blockquote>
+ <p>
+@@ -62699,7 +68333,8 @@ In 27.5.2.1.1 [ios::failure], change the description of the constructors:
+ </p>
+ </blockquote>
+
+-<pre>explicit failure(const char* msg, const error_code&amp; ec = io_errc::stream);
++<pre>
++explicit failure(const char* msg, const error_code&amp; ec = io_errc::stream);
+ </pre>
+ <blockquote>
+ <p>
+@@ -62714,16 +68349,17 @@ In 27.5.2.1.1 [ios::failure], change the description of the constructors:
+ </blockquote>
+
+ <p>
+-In 27.5.2.1.1 [ios::failure], remove <tt>what</tt> (the base class definition
++In 27.5.3.1.1 [ios::failure], remove <tt>what</tt> (the base class definition
+ need not be repeated here).
+ </p>
+
+ <blockquote>
+-<pre><del>const char* what() const;</del>
++<pre>
++<del>const char* what() const;</del>
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <del>-7- <i>Returns:</i> The message <tt>msg</tt> with which the exception was created.</del>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -62734,10 +68370,10 @@ need not be repeated here).
+
+ <hr>
+ <h3><a name="1104"></a>1104. <tt>basic_ios::move</tt> should accept lvalues</h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ With the rvalue reference changes in
+@@ -62745,7 +68381,8 @@ With the rvalue reference changes in
+ <tt>basic_ios::move</tt> no longer has the most convenient signature:
+ </p>
+
+-<blockquote><pre>void move(basic_ios&amp;&amp; rhs);
++<blockquote><pre>
++void move(basic_ios&amp;&amp; rhs);
+ </pre></blockquote>
+
+ <p>
+@@ -62779,28 +68416,29 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Added overload, moved to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a signature to the existing prototype in the synopsis of 27.5.4 [ios]
+-and in 27.5.4.2 [basic.ios.members]:
++Add a signature to the existing prototype in the synopsis of 27.5.5 [ios]
++and in 27.5.5.3 [basic.ios.members]:
+ </p>
+
+-<blockquote><pre><ins>void move(basic_ios&amp; rhs);</ins>
++<blockquote><pre>
++<ins>void move(basic_ios&amp; rhs);</ins>
+ void move(basic_ios&amp;&amp; rhs);
+ </pre></blockquote>
+
+@@ -62809,19 +68447,110 @@ void move(basic_ios&amp;&amp; rhs);
+
+
+ <hr>
++<h3><a name="1106"></a>1106. Multiple exceptions from connected <tt>shared_future::get()</tt>?</h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Thomas J. Gritzan <b>Opened:</b> 2009-04-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++It is not clear, if multiple threads are waiting in a
++<tt>shared_future::get()</tt> call, if each will rethrow the stored exception.
++</p>
++<p>
++Paragraph 9 reads:
++</p>
++<blockquote><p>
++<i>Throws:</i> the stored exception, if an exception was stored and not
++retrieved before.
++</p></blockquote>
++<p>
++The "not retrieved before" suggests that only one exception is thrown,
++but one exception for each call to <tt>get()</tt> is needed, and multiple calls
++to <tt>get()</tt> even on the same <tt>shared_future</tt> object seem to be allowed.
++</p>
++<p>
++I suggest removing "and not retrieved before" from the Throws paragraph.
++I recommend adding a note that explains that multiple calls on <tt>get()</tt> are
++allowed, and each call would result in an exception if an exception was
++stored.
++</p>
++
++<p><i>[
++Batavia (2009-05):
++]</i></p>
++
++<blockquote>
++<p>
++We note there is a pending paper by Detlef
++on such <tt>future</tt>-related issues;
++we would like to wait for his paper before proceeding.
++</p>
++<p>
++Alisdair suggests we may want language to clarify that this
++<tt>get()</tt> function can be called from several threads
++with no need for explicit locking.
++</p>
++<p>
++Move to Open.
++</p>
++</blockquote>
++
++<p><i>[
++2010-01-23 Moved to Tentatively NAD Editorial after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Resolved by paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 30.6.7 [futures.shared_future]:
++</p>
++
++<blockquote><pre>
++const R&amp; shared_future::get() const;
++R&amp; shared_future&lt;R&amp;&gt;::get() const;
++void shared_future&lt;void&gt;::get() const;
++</pre>
++<blockquote>
++<p>...</p>
++<p>
++-9- <i>Throws:</i> the stored exception, if an exception was stored<del> and not retrieved before</del>.
++<ins>
++[<i>Note:</i> Multiple calls on <tt>get()</tt> are allowed, and each call would result in an exception
++if an exception was stored. &mdash; <i>end note</i>]
++</ins>
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1108"></a>1108. thread.req.exception overly constrains implementations</h3>
+-<p><b>Section:</b> 30.2.2 [thread.req.exception] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Christopher Kohlhoff <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.2.2 [thread.req.exception] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Christopher Kohlhoff <b>Opened:</b> 2009-04-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current formulation of 30.2.2 [thread.req.exception]/2 reads:
+ </p>
+-<blockquote>
+-The error_category of the <tt>error_code</tt> reported by such an
++<blockquote><p>
++The <tt>error_category</tt> of the <tt>error_code</tt> reported by such an
+ exception's <tt>code()</tt> member function is as specified in the error
+ condition Clause.
+-</blockquote>
++</p></blockquote>
+ <p>
+ This constraint on the code's associated <tt>error_categor</tt> means an
+ implementation must perform a mapping from the system-generated
+@@ -62844,8 +68573,8 @@ The original error produced by the operating system is lost.
+ The latter was one of Peter Dimov's main objections (in a private
+ email discussion) to the original <tt>error_code</tt>-only design, and led to
+ the creation of <tt>error_condition</tt> in the first place. Specifically,
+-<tt>error_code</tt> and <tt>error_condition</tt> are intended to perform the following
+-roles:
++<tt>error_code</tt> and <tt>error_condition</tt> are intended to perform
++the following roles:
+ </p>
+ <ul>
+ <li>
+@@ -62866,35 +68595,34 @@ need to match the right error condition when returning an error code
+ from a library function.)
+ </p>
+ <p>
+-It is important that this <tt>error_code/error_condition</tt> usage is done
+-correctly for the thread library since it is likely to set the
+-pattern for future TR libraries that interact with the operating
+-system.
++It is important that this <tt>error_code&#47;error_condition</tt> usage is done
++correctly for the thread library since it is likely to set the pattern for future
++TR libraries that interact with the operating system.
+ </p>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open, and recommend the issue be deferred until after the next
+ Committee Draft is issued.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 post-Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 30.2.2 [thread.req.exception]/2:
++Change 30.2.2 [thread.req.exception] p.2:
+ </p>
+
+ <blockquote>
+@@ -62915,7 +68643,7 @@ ec == errc::resource_unavailable_try_again // holds true
+ </ins></pre></blockquote>
+
+ <p><ins>
+-— <i>end example</i>]
++&mdash; <i>end example</i>]
+ </ins></p>
+
+ </blockquote>
+@@ -62927,17 +68655,18 @@ ec == errc::resource_unavailable_try_again // holds true
+
+ <hr>
+ <h3><a name="1110"></a>1110. Is <tt>for_each</tt> overconstrained?</h3>
+-<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-29 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25.2.4 [alg.foreach] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-04-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.foreach">issues</a> in [alg.foreach].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Quoting working paper for reference (25.2.4 [alg.foreach]):
+ </p>
+
+ <blockquote>
+-<pre>template&lt;InputIterator Iter, Callable&lt;auto, Iter::reference&gt; Function&gt;
++<pre>
++template&lt;InputIterator Iter, Callable&lt;auto, Iter::reference&gt; Function&gt;
+ requires CopyConstructible&lt;Function&gt;
+ Function for_each(Iter first, Iter last, Function f);
+ </pre>
+@@ -62996,10 +68725,10 @@ Committee Draft is issued.
+ <p>
+ The note in 25.1 [algorithms.general]/9 already says the right thing:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Unless otherwise specified, algorithms that take function objects
+ as arguments are permitted to copy those function objects freely.
+-</blockquote>
++</p></blockquote>
+ <p>
+ So we only need to ensure that the wording for <tt>for_each</tt> is sufficiently
+ clear, which is the intend of the following rewording.
+@@ -63029,9 +68758,9 @@ Add a new Requires clause just after the prototype declaration (25.2.4 [alg.fore
+ Change 25.2.4 [alg.foreach]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <ins>std::move(</ins>f<ins>)</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ul>
+ </blockquote>
+@@ -63041,10 +68770,10 @@ Change 25.2.4 [alg.foreach]/2 as indicated:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready, using Daniel's wording without the portion
+ saying "CopyConstructible is not required".
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-27 Daniel adds:
+@@ -63056,19 +68785,19 @@ saying "CopyConstructible is not required".
+ I see that during the Santa Cruz meeting the originally proposed addition
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ , <tt>CopyConstructible</tt> is not required.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ was removed. I don't think that this removal was a good idea. The combination
+-of 25.1 [algorithms.general]/9
++of 25.1 [algorithms.general] p.9
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Unless otherwise specified, algorithms that take function objects
+ as arguments are permitted to copy those function objects freely.[..]
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ with the fact that <tt>CopyConstructible</tt> is a refinement <tt>MoveConstructible</tt>
+@@ -63076,12 +68805,12 @@ makes it necessary that such an explicit statement is given. Even the
+ existence of the usage of <tt>std::move</tt> in the <i>Returns</i> clause doesn't
+ help much, because this would still be well-formed for a <tt>CopyConstructible</tt>
+ without move constructor. Let me add that the originally proposed
+-addition reflects current practice in the standard, e.g. 25.3.9 [alg.unique]/5
++addition reflects current practice in the standard, e.g. 25.3.9 [alg.unique] p.5
+ usages a similar terminology.
+ </p>
+
+ <p>
+-For similar wording need in case for auto_ptr see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#973">973</a>.
++For similar wording need in case for auto_ptr see <a href="lwg-closed.html#973">973</a>.
+ </p>
+
+ <p><i>[
+@@ -63121,9 +68850,9 @@ Add a new Requires clause just after the prototype declaration (25.2.4 [alg.fore
+ Change 25.2.4 [alg.foreach]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <ins>std::move(</ins>f<ins>)</ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ul>
+
+@@ -63136,13 +68865,14 @@ Change 25.2.4 [alg.foreach]/2 as indicated:
+
+ <hr>
+ <h3><a name="1113"></a>1113. <tt>bitset::to_string</tt> could be simplified</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a> our resolution is changing the signature by adding two
++In <a href="lwg-defects.html#853">853</a> our resolution is changing the signature by adding two
+ defaulting arguments to 3 calls. In principle, this means that ABI breakage
+ is not an issue, while API is preserved.
+ </p>
+@@ -63150,38 +68880,39 @@ is not an issue, while API is preserved.
+ With that observation, it would be very nice to use the new ability to
+ supply default template parameters to function templates to collapse all 3
+ signatures into 1. In that spirit, this issue offers an alternative resolution
+-than that of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a>.
++than that of <a href="lwg-defects.html#853">853</a>.
+ </p>
+
+ <p><i>[
+ Batavia (2009-05):
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Move to Open,
+-and look at the issue again after <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#853">853</a> has been accepted.
++and look at the issue again after <a href="lwg-defects.html#853">853</a> has been accepted.
+ We further recommend this be deferred until after the next Committee Draft.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 post-Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+
+-<ol type="A">
++<ol style="list-style-type:upper-alpha">
+ <li>
+ <p>
+-In 20.5 [template.bitset]/1 (class bitset) ammend:
++In 20.6 [template.bitset]/1 (class bitset) ammend:
+ </p>
+-<blockquote><pre>template &lt;class charT <ins>= char</ins>,
++<blockquote><pre>
++template &lt;class charT <ins>= char</ins>,
+ class traits <ins>= char_traits&lt;charT&gt;</ins>,
+ class Allocator <ins>= allocator&lt;charT&gt;</ins>&gt;
+ basic_string&lt;charT, traits, Allocator&gt;
+@@ -63195,9 +68926,10 @@ basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt; to_str
+ </li>
+ <li>
+ <p>
+-In 20.5.2 [bitset.members] prior to p35 ammend:
++In 20.6.2 [bitset.members] prior to p35 ammend:
+ </p>
+-<blockquote><pre>template &lt;class charT <ins>= char</ins>,
++<blockquote><pre>
++template &lt;class charT <ins>= char</ins>,
+ class traits <ins>= char_traits&lt;charT&gt;</ins>,
+ class Allocator <ins>= allocator&lt;charT&gt;</ins>&gt;
+ basic_string&lt;charT, traits, Allocator&gt;
+@@ -63205,7 +68937,7 @@ In 20.5.2 [bitset.members] prior to p35 ammend:
+ </pre></blockquote>
+ </li>
+ <li>
+-Strike 20.5.2 [bitset.members] paragraphs 37 -&gt; 39 (including signature
++Strike 20.6.2 [bitset.members] paragraphs 37 -> 39 (including signature
+ above 37)
+ </li>
+ </ol>
+@@ -63217,37 +68949,38 @@ above 37)
+
+ <hr>
+ <h3><a name="1114"></a>1114. Type traits underspecified</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-05-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-05-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#975">975</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1023">1023</a>.
++Related to <a href="lwg-defects.html#975">975</a> and <a href="lwg-closed.html#1023">1023</a>.
+ </p>
+
+ <p>
+-The current wording in 20.7.1 [meta.rqmts] is still unclear concerning
++The current wording in 20.10.1 [meta.rqmts] is still unclear concerning
+ it's requirements on the type traits classes regarding ambiguities.
+ Specifically it's unclear
+ </p>
+
+ <ul>
+ <li>
+-if a predicate trait (20.7.4 [meta.unary], 20.7.6 [meta.rel]) could derive from both
+-<tt>true_type</tt>/<tt>false_type</tt>.
++if a predicate trait (20.10.4 [meta.unary], 20.10.6 [meta.rel]) could derive from both
++<tt>true_type</tt>&#47;<tt>false_type</tt>.
+ </li>
+ <li>
+-if any of the type traits (20.7.1 [meta.rqmts], 20.7.4 [meta.unary], 20.7.6 [meta.rel]) could ambiguously derive
++if any of the type traits (20.10.1 [meta.rqmts], 20.10.4 [meta.unary], 20.10.6 [meta.rel]) could ambiguously derive
+ from the same specified result type.
+ </li>
+ <li>
+-if any of the type traits (20.7.1 [meta.rqmts], 20.7.4 [meta.unary], 20.7.6 [meta.rel]) could derive from other
++if any of the type traits (20.10.1 [meta.rqmts], 20.10.4 [meta.unary], 20.10.6 [meta.rel]) could derive from other
+ <tt>integral_constant</tt> types making the contained names ambiguous
+ </li>
+ <li>
+-if any of the type traits (20.7.1 [meta.rqmts], 20.7.4 [meta.unary], 20.7.6 [meta.rel]) could have other base
++if any of the type traits (20.10.1 [meta.rqmts], 20.10.4 [meta.unary], 20.10.6 [meta.rel]) could have other base
+ classes that contain members hiding the name of the result type members
+ or make the contained member names ambiguous.
+ </li>
+@@ -63273,16 +69006,16 @@ Move to Open.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p><i>[
+ The usage of the notion of a <i>BaseCharacteristic</i> below might be
+-useful in other places - e.g. to define the base class relation in 20.8.4 [refwrap], 20.8.13 [func.memfn], or 20.8.14.2 [func.wrap.func]. In this case it's definition should probably
++useful in other places - e.g. to define the base class relation in 20.9.4 [refwrap], 20.9.11 [func.memfn], or 20.9.12.2 [func.wrap.func]. In this case it's definition should probably
+ be moved to Clause 17
+ ]</i></p>
+
+@@ -63290,9 +69023,9 @@ be moved to Clause 17
+ <ol>
+ <li>
+ <p>
+-Change 20.7.1 [meta.rqmts]/1 as indicated:
++Change 20.10.1 [meta.rqmts] p.1 as indicated:
+ </p>
+-<blockquote>
++<blockquote><p>
+ [..] It shall be <tt>DefaultConstructible</tt>, <tt>CopyConstructible</tt>, and publicly
+ <ins>and unambiguously</ins> derived, directly or indirectly, from
+ <ins>its <i>BaseCharacteristic</i>, which is</ins> a specialization of the
+@@ -63301,13 +69034,13 @@ template <tt>integral_constant</tt> (20.6.3), with the arguments to the template
+ property being described. <ins>The member names of the
+ <i>BaseCharacteristic</i> shall be unhidden and unambiguously
+ available in the <i>UnaryTypeTrait</i>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+-Change 20.7.1 [meta.rqmts]/2 as indicated:
++Change 20.10.1 [meta.rqmts] p.2 as indicated:
+ </p>
+-<blockquote>
++<blockquote><p>
+ [..] It shall be <tt>DefaultConstructible</tt>, <tt>CopyConstructible</tt>, and publicly
+ <ins>and unambiguously</ins> derived, directly or indirectly, from
+ <del>an instance</del> <ins>its <i>BaseCharacteristic</i>, which is a
+@@ -63316,32 +69049,32 @@ the arguments to the template <tt>integral_constant</tt> determined by the
+ requirements for the particular relationship being described. <ins>The
+ member names of the <i>BaseCharacteristic</i> shall be unhidden
+ and unambiguously available in the <i>BinaryTypeTrait</i>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+-Change 20.7.4 [meta.unary]/2 as indicated:
++Change 20.10.4 [meta.unary] p.2 as indicated:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Each of these templates shall be a <i>UnaryTypeTrait</i> (20.6.1),
+ <del>publicly derived directly or indirectly from <tt>true_type</tt> if the
+ corresponding condition is true, otherwise from <tt>false_type</tt></del>
+ <ins>where its <i>BaseCharacteristic</i> shall be <tt>true_type</tt> if the
+ corresponding condition is true, otherwise <tt>false_type</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>
+ <p>
+-Change 20.7.6 [meta.rel]/2 as indicated:
++Change 20.10.6 [meta.rel] p.2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Each of these templates shall be a <i>BinaryTypeTrait</i> (20.6.1),
+ <del>publicly derived directly or indirectly from <tt>true_type</tt> if the
+ corresponding condition is true, otherwise from <tt>false_type</tt></del>
+ <ins>where its <i>BaseCharacteristic</i> shall be <tt>true_type</tt> if the
+ corresponding condition is true, otherwise <tt>false_type</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -63352,10 +69085,10 @@ corresponding condition is true, otherwise <tt>false_type</tt></ins>.
+
+ <hr>
+ <h3><a name="1116"></a>1116. Literal constructors for tuple</h3>
+-<p><b>Section:</b> 20.4.2 [tuple.tuple] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.tuple">issues</a> in [tuple.tuple].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.4.2 [tuple.tuple] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.tuple">issues</a> in [tuple.tuple].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It is not currently possible to construct <tt>tuple</tt> literal values,
+@@ -63380,10 +69113,10 @@ clear of that class while other constructor-related issues settle.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.html">N2994</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -63397,7 +69130,8 @@ follows
+ Add the following concept:
+ </p>
+
+-<blockquote><pre>auto concept AllLiteral&lt; typename ... Types &gt; {
++<blockquote><pre>
++auto concept AllLiteral&lt; typename ... Types &gt; {
+ requires LiteralType&lt;Types&gt;...;
+ }
+ </pre></blockquote>
+@@ -63406,7 +69140,8 @@ Add the following concept:
+ ammend the constructor
+ </p>
+
+-<blockquote><pre><ins>template &lt;class... UTypes&gt;
++<blockquote><pre>
++<ins>template &lt;class... UTypes&gt;
+ requires AllLiteral&lt;Types...&gt;
+ &amp;&amp; Constructible&lt;Types, UTypes&gt;...
+ explicit tuple(UTypes...);</ins>
+@@ -63421,7 +69156,8 @@ template &lt;class... UTypes&gt;
+ ammend the constructor
+ </p>
+
+-<blockquote><pre><ins>template &lt;class... UTypes&gt;
++<blockquote><pre>
++<ins>template &lt;class... UTypes&gt;
+ requires AllLiteral&lt;Types...&gt;
+ &amp;&amp; Constructible&lt;Types, UTypes&gt;...
+ tuple(tuple&lt;UTypes...&gt;);</ins>
+@@ -63443,11 +69179,12 @@ Update the same signatures in 20.4.2.1 [tuple.cnstr], paras 3 and 5.
+
+
+ <hr>
+-<h3><a name="1117"></a>1117. tuple copy constructor</h3>
+-<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1117"></a>1117. <tt>tuple</tt> copy constructor</h3>
++<p><b>Section:</b> 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.cnstr">active issues</a> in [tuple.cnstr].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.cnstr">issues</a> in [tuple.cnstr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The copy constructor for the <tt>tuple</tt> template is constrained. This seems an
+@@ -63455,7 +69192,7 @@ unusual strategy, as the copy constructor will be implicitly deleted if the
+ constraints are not met. This is exactly the same effect as requesting an
+ <tt>=default;</tt> constructor. The advantage of the latter is that it retains
+ triviality, and provides support for <tt>tuple</tt>s as literal types if issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1116">1116</a> is also accepted.
++<a href="lwg-defects.html#1116">1116</a> is also accepted.
+ </p>
+ <p>
+ Actually, it might be worth checking with core if a constrained copy
+@@ -63469,19 +69206,19 @@ the template in this case.
+ ]</i></p>
+
+
+-<blockquote>
+-This would solve one half of the suggested changes in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#801">801</a>.
+-</blockquote>
++<blockquote><p>
++This would solve one half of the suggested changes in <a href="lwg-defects.html#801">801</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -63489,7 +69226,8 @@ This would solve one half of the suggested changes in <a href="http://www.open-s
+ Change 20.4.2 [tuple.tuple] and 20.4.2.1 [tuple.cnstr] p4:
+ </p>
+
+-<blockquote><pre><del>requires CopyConstructible&lt;Types&gt;...</del> tuple(const tuple&amp;)<ins> = default</ins>;
++<blockquote><pre>
++<del>requires CopyConstructible&lt;Types&gt;...</del> tuple(const tuple&amp;)<ins> = default</ins>;
+ </pre></blockquote>
+
+
+@@ -63497,11 +69235,11 @@ Change 20.4.2 [tuple.tuple] and 20.4.2.1 [tuple.cnstr] p4:
+
+
+ <hr>
+-<h3><a name="1118"></a>1118. tuple query APIs do not support cv-qualification</h3>
+-<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1118"></a>1118. <tt>tuple</tt> query APIs do not support cv-qualification</h3>
++<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The APIs <tt>tuple_size</tt> and <tt>tuple_element</tt> do not support
+@@ -63510,7 +69248,7 @@ cv-qualified <tt>tuple</tt>s, <tt>pair</tt>s or <tt>array</tt>s.
+ <p>
+ The most generic solution would be to supply partial specializations once
+ for each cv-type in the <tt>tuple</tt> header. However, requiring this header for
+-cv-qualified <tt>pair</tt>s/<tt>array</tt>s seems unhelpful. The BSI editorial
++cv-qualified <tt>pair</tt>s&#47;<tt>array</tt>s seems unhelpful. The BSI editorial
+ suggestion (UK-198/US-69,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2533.html">N2533</a>)
+ to merge <tt>tuple</tt> into <tt>&lt;utility&gt;</tt> would help with <tt>pair</tt>,
+@@ -63529,7 +69267,8 @@ the dependency be fulfilled in a Remark.
+ All <tt>tuple_size</tt> templates with a base class need to derive publicly, e.g.
+ </p>
+
+-<blockquote><pre>template &lt;IdentityOf T&gt; class tuple_size&lt; const T &gt; :
++<blockquote><pre>
++template &lt;IdentityOf T&gt; class tuple_size&lt; const T &gt; :
+ <ins>public</ins> tuple_size&lt;T&gt; {};
+ </pre></blockquote>
+
+@@ -63539,10 +69278,10 @@ The same applies to the tuple_element class hierarchies.
+ <p>
+ What is actually meant with the comment
+ </p>
+-<blockquote>
++<blockquote><p>
+ this solution relies on 'metafunction forwarding' to inherit the
+ nested typename type
+-</blockquote>
++</p></blockquote>
+ <p>
+ ?
+ </p>
+@@ -63581,10 +69320,10 @@ though.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Open, Alisdair to provide wording. Once wording is
+ provided, Howard will move to Review.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-28 Daniel deconceptified wording.
+@@ -63597,7 +69336,7 @@ Post-Rapperswil - Daniel provides wording:
+
+
+ <p>
+-The below given P/R reflects the discussion from the Rapperswil meeting that the wording should not constrain
++The below given P&#47;R reflects the discussion from the Rapperswil meeting that the wording should not constrain
+ implementation freedom to realize the actual issue target. Thus the original code form was replaced by
+ normative words.
+ </p>
+@@ -63612,9 +69351,9 @@ unqualified type uses. The following wording follows the second approach.
+ The wording refers to N3126.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -63626,8 +69365,9 @@ Adopted at 2010-11 Batavia
+ <p><b>Proposed resolution:</b></p>
+
+ <ol>
+-<li>Change 20.4.1 [tuple.general]/2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
+-<blockquote><pre>// 20.4.2.5, tuple helper classes:
++<li>Change 20.4.1 [tuple.general] p.2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
++<blockquote><pre>
++// 20.4.2.5, tuple helper classes:
+ template &lt;class T&gt; class tuple_size; // undefined
+ <ins>template &lt;class T&gt; class tuple_size&lt;const T&gt;;</ins>
+ <ins>template &lt;class T&gt; class tuple_size&lt;volatile T&gt;;</ins>
+@@ -63644,22 +69384,24 @@ template &lt;size_t I, class... Types&gt; class tuple_element&lt;I, tuple&lt;Typ
+ </pre></blockquote>
+ </li>
+ <li>Add the end of subclause 20.4.2.5 [tuple.helper] insert the following two paragraphs:
+-<blockquote><pre><ins>template &lt;class T&gt; class tuple_size&lt;const T&gt;;</ins>
++<blockquote><pre>
++<ins>template &lt;class T&gt; class tuple_size&lt;const T&gt;;</ins>
+ <ins>template &lt;class T&gt; class tuple_size&lt;volatile T&gt;;</ins>
+ <ins>template &lt;class T&gt; class tuple_size&lt;const volatile T&gt;;</ins>
+-</pre><blockquote>
++</pre><blockquote><p>
+ <ins>Let <em>TS</em> denote <tt>tuple_size&lt;T&gt;</tt> of the <em>cv</em>-unqualified type <tt>T</tt>.
+ Then each of the three templates shall meet the UnaryTypeTrait requirements (20.7.1) with a BaseCharacteristic of
+ <tt>integral_constant&lt;remove_cv&lt;decltype(<em>TS</em>::value)&gt;::type, <em>TS</em>::value&gt;</tt>.</ins>
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+
+-<blockquote><pre><ins>template &lt;size_t I, class T&gt; class tuple_element&lt;I, const T&gt;;</ins>
++<blockquote><pre>
++<ins>template &lt;size_t I, class T&gt; class tuple_element&lt;I, const T&gt;;</ins>
+ <ins>template &lt;size_t I, class T&gt; class tuple_element&lt;I, volatile T&gt;;</ins>
+ <ins>template &lt;size_t I, class T&gt; class tuple_element&lt;I, const volatile T&gt;;</ins>
+-</pre><blockquote>
++</pre><blockquote><p>
+ <ins>Let <em>TE</em> denote <tt>tuple_element&lt;I, T&gt;</tt> of the <em>cv</em>-unqualified type <tt>T</tt>. Then each of the
+ three templates shall meet the TransformationTrait requirements (20.7.1) with a member typedef <tt>type</tt> that shall name the
+-same type as the following type:</ins>
++same type as the following type:</ins></p>
+ <ul>
+ <li><ins>for the first specialization, the type <tt>add_const&lt;<em>TE</em>::type&gt;::type</tt>,</ins></li>
+ <li><ins>for the second specialization, the type <tt>add_volatile&lt;<em>TE</em>::type&gt;::type</tt>, and</ins></li>
+@@ -63675,11 +69417,11 @@ same type as the following type:</ins>
+
+
+ <hr>
+-<h3><a name="1122"></a>1122. Ratio values should be constexpr</h3>
+-<p><b>Section:</b> 20.6.1 [ratio.ratio] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-25 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1122"></a>1122. Ratio values should be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 20.11.3 [ratio.ratio] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The values <tt>num</tt> and <tt>den</tt> in the <tt>ratio</tt> template
+@@ -63691,18 +69433,19 @@ should be declared <tt>constexpr</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-20.6.1 [ratio.ratio]
++20.11.3 [ratio.ratio]
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;intmax_t N, intmax_t D = 1&gt;
+ class ratio {
+ public:
+@@ -63718,11 +69461,11 @@ should be declared <tt>constexpr</tt>.
+
+
+ <hr>
+-<h3><a name="1123"></a>1123. no requirement that standard streams be flushed</h3>
+-<p><b>Section:</b> 27.5.2.1.6 [ios::Init] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> James Kanze <b>Opened:</b> 2009-05-14 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ios::Init">issues</a> in [ios::Init].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1123"></a>1123. No requirement that standard streams be flushed</h3>
++<p><b>Section:</b> 27.5.3.1.6 [ios::Init] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2009-05-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios::Init">issues</a> in [ios::Init].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ As currently formulated, the standard doesn't require that there
+@@ -63735,30 +69478,30 @@ be constructed before <tt>main</tt>, and before the dynamic
+ initialization of any non-local objects defined after the
+ inclusion of <tt>&lt;iostream&gt;</tt> in the same translation unit. The only
+ requirement that I can find concerning flushing, however, is in
+-27.5.2.1.6 [ios::Init], where the destructor of the last
++27.5.3.1.6 [ios::Init], where the destructor of the last
+ <tt>std::ios_base::Init</tt> object flushes. But there is, as far as I
+ can see, no guarantee that such an object ever exists.
+ </p>
+ <p>
+ Also, the wording in [iostreams.objects] says that:
+ </p>
+-<blockquote>
++<blockquote><p>
+ The objects
+ are constructed and the associations are established at some
+ time prior to or during the first time an object of class
+ <tt>ios_base::Init</tt> is constructed, and in any case before the body
+ of main begins execution.
+-</blockquote>
++</p></blockquote>
+ <p>
+-In 27.5.2.1.6 [ios::Init], however, as an
++In 27.5.3.1.6 [ios::Init], however, as an
+ effect of the constructor, it says that
+ </p>
+-<blockquote>
++<blockquote><p>
+ If <tt>init_cnt</tt> is zero,
+ the function stores the value one in <tt>init_cnt</tt>, then constructs
+ and initializes the objects <tt>cin</tt>, <tt>cout</tt>, <tt>cerr</tt>, <tt>clog</tt>
+ <tt>wcin</tt>, <tt>wcout</tt>, <tt>wcerr</tt>, and <tt>wclog</tt>"
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ which seems to forbid earlier
+@@ -63773,12 +69516,14 @@ int init_cnt</tt>" in <tt>ios_base::Init</tt> can be dropped.)
+ Of course, a determined programmer can still inhibit the
+ flush with things like:
+ </p>
+-<blockquote><pre>new std::ios_base::Init ; // never deleted
++<blockquote><pre>
++new std::ios_base::Init ; // never deleted
+ </pre></blockquote>
+ <p>
+ or (in a function):
+ </p>
+-<blockquote><pre>std::ios_base::Init ensureConstruction ;
++<blockquote><pre>
++std::ios_base::Init ensureConstruction ;
+ // ...
+ exit( EXIT_SUCCESS ) ;
+ </pre></blockquote>
+@@ -63793,10 +69538,10 @@ would be in order.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready. Some editorial changes are expected (in addition to the
+ proposed wording) to remove <tt>init_cnt</tt> from <tt>Init</tt>.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -63805,7 +69550,7 @@ proposed wording) to remove <tt>init_cnt</tt> from <tt>Init</tt>.
+ Change 27.4 [iostream.objects]/2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ -2- The objects are constructed and the associations are established at
+ some time prior to or during the first time an object of class
+ <tt>ios_base::Init</tt> is constructed, and in any case before the body
+@@ -63821,16 +69566,17 @@ unit shall be as if <tt>&lt;iostream&gt;</tt> defined an instance of
+ <tt>ios_base::Init</tt> with static lifetime. Similarly, the entire
+ program shall behave as if there were at least one instance of
+ <tt>ios_base::Init</tt> with static lifetime.</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-Change 27.5.2.1.6 [ios::Init]/3:
++Change 27.5.3.1.6 [ios::Init]/3:
+ </p>
+
+ <blockquote>
+-<pre>Init();
++<pre>
++Init();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -3- <i>Effects:</i> Constructs an object of class <tt>Init</tt>.
+ <del>If <tt>init_cnt</tt> is zero, the function stores the value one in
+ <tt>init_cnt</tt>, then constructs and initializes the objects
+@@ -63842,17 +69588,18 @@ Change 27.5.2.1.6 [ios::Init]/3:
+ <tt>cerr</tt>, <tt>clog</tt>, <tt>wcin</tt>, <tt>wcout</tt>,
+ <tt>wcerr</tt> and <tt>wclog</tt> if they have not already been
+ constructed and initialized.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 27.5.2.1.6 [ios::Init]/4:
++Change 27.5.3.1.6 [ios::Init]/4:
+ </p>
+
+ <blockquote>
+-<pre>~Init();
++<pre>
++~Init();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Effects:</i> Destroys an object of class <tt>Init</tt>.
+ <del>The function subtracts one from the value stored in <tt>init_cnt</tt> and,
+ if the resulting stored value is one,</del>
+@@ -63861,7 +69608,7 @@ existance,</ins>
+ calls <tt>cout.flush()</tt>,
+ <tt>cerr.flush()</tt>, <tt>clog.flush()</tt>, <tt>wcout.flush()</tt>,
+ <tt>wcerr.flush()</tt>, <tt>wclog.flush()</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -63871,10 +69618,10 @@ calls <tt>cout.flush()</tt>,
+
+ <hr>
+ <h3><a name="1126"></a>1126. <tt>istreambuff_iterator::equal</tt> needs a const &amp; parameter</h3>
+-<p><b>Section:</b> 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istreambuf.iterator::equal">issues</a> in [istreambuf.iterator::equal].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 24.6.3.5 [istreambuf.iterator::equal] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istreambuf.iterator::equal">issues</a> in [istreambuf.iterator::equal].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>equal</tt> member function of <tt>istreambuf_iterator</tt> is
+@@ -63887,7 +69634,7 @@ const.
+ </p>
+
+ <p><i>[
+-The proposed wording is consistent with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#110">110</a> with status TC1.
++The proposed wording is consistent with <a href="lwg-defects.html#110">110</a> with status TC1.
+ ]</i></p>
+
+
+@@ -63896,20 +69643,207 @@ The proposed wording is consistent with <a href="http://www.open-std.org/jtc1/sc
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Set to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Ammend in both:<br/>
++24.6.3 [istreambuf.iterator]<br/>
++24.6.3.5 [istreambuf.iterator::equal]<br/>
++</p>
++
++<blockquote><pre>
++bool equal(<ins>const </ins>istreambuf_iterator&amp; b) const;
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1129"></a>1129. <tt>istream(buf)_iterator</tt> should support literal sentinel value</h3>
++<p><b>Section:</b> 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator.cons">issues</a> in [istream.iterator.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>istream_iterator</tt> and <tt>istreambuf_iterator</tt> should support literal sentinel
++values. The default constructor is frequently used to terminate ranges, and
++could easily be a literal value for <tt>istreambuf_iterator</tt>, and
++<tt>istream_iterator</tt> when iterating value types. A little more work using a
++suitably sized/aligned char-array for storage (or an updated component like
++<tt>boost::optional</tt> proposed for TR2) would allow <tt>istream_iterator</tt> to support
++<tt>constexpr</tt> default constructor in all cases, although we might leave this
++tweak as a QoI issue. Note that requiring <tt>constexpr</tt> be supported also
++allows us to place no-throw guarantees on this constructor too.
++</p>
++
++<p><i>[
++2009-06-02 Daniel adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++I agree with the usefulness of the issue suggestion, but we need
++to ensure that <tt>istream_iterator</tt> <em>can</em> satisfy be literal if needed.
++Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares
++a copy constructor and a destructor and explains their semantic in
++24.6.1.1 [istream.iterator.cons]/3+4.
++</p>
++<p>
++The prototype semantic specification is ok (although it seems
++somewhat redundant to me, because the semantic doesn't say
++anything interesting in both cases), but for support of trivial class
++types we also need a trivial copy constructor and destructor as of
++9 [class]/6. The current non-informative specification of these
++two special members suggests to remove their explicit declaration
++in the class and add explicit wording that says that if <tt>T</tt> is
++trivial a default constructed iterator is also literal, alternatively it
++would be possible to mark both as defaulted and add explicit
++(memberwise) wording that guarantees that they are trivial.
++</p>
++<p>
++Btw.: I'm quite sure that the <tt>istreambuf_iterator</tt> additions to
++ensure triviality are not sufficient as suggested, because the
++library does not yet give general guarantees that a defaulted
++special member declaration makes this member also trivial.
++Note that e.g. the atomic types do give a general statement!
++</p>
++<p>
++Finally there is a wording issue: There does not exist something
++like a "literal constructor". The core language uses the term
++"constexpr constructor" for this.
++</p>
++<p>
++Suggestion:
++</p>
++<ol>
++<li>
++<p>
++Change 24.6.1 [istream.iterator]/3 as indicated:
++</p>
++<blockquote><pre>
++<ins>constexpr</ins> istream_iterator();
++istream_iterator(istream_type&amp; s);
++istream_iterator(const istream_iterator<del>&lt;T,charT,traits,Distance&gt;</del>&amp; x)<ins> = default</ins>;
++~istream_iterator()<ins> = default</ins>;
++</pre></blockquote>
++</li>
++<li>
++<p>
++Change 24.6.1.1 [istream.iterator.cons]/1 as indicated:
++</p>
++<blockquote><pre>
++<ins>constexpr</ins> istream_iterator();
++</pre>
++<blockquote><p>
++-1- <i>Effects:</i> Constructs the end-of-stream iterator. <ins>If <tt>T</tt> is a literal type,
++then this constructor shall be a constexpr constructor.</ins>
++</p></blockquote>
++</blockquote>
++</li>
++<li>
++<p>
++Change 24.6.1.1 [istream.iterator.cons]/3 as indicated:
++</p>
++<blockquote><pre>
++istream_iterator(const istream_iterator<del>&lt;T,charT,traits,Distance&gt;</del>&amp; x)<ins> = default</ins>;
++</pre>
++<blockquote><p>
++-3- <i>Effects:</i> Constructs a copy of <tt>x</tt>. <ins>If <tt>T</tt> is a literal type, then
++this constructor shall be a trivial copy constructor.</ins>
++</p></blockquote>
++</blockquote>
++</li>
++<li>
++<p>
++Change 24.6.1.1 [istream.iterator.cons]/4 as indicated:
++</p>
++
++<blockquote><pre>
++~istream_iterator()<ins> = default</ins>;
++</pre>
++<blockquote><p>
++-4- <i>Effects:</i> The iterator is destroyed. <ins>If <tt>T</tt> is a literal type, then
++this destructor shall be a trivial
++destructor.</ins>
++</p></blockquote>
+ </blockquote>
++</li>
++<li>
++<p>
++Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated:
++</p>
++
++<blockquote><pre>
++<ins>constexpr</ins> istreambuf_iterator() throw();
++<ins>istreambuf_iterator(const istreambuf_iterator&amp;) throw() = default;</ins>
++<ins>~istreambuf_iterator() throw() = default;</ins>
++</pre></blockquote>
++</li>
++<li>
++<p>
++Change 24.6.3 [istreambuf.iterator]/1 as indicated:
++</p>
++<blockquote><p>
++[..] The default constructor <tt>istreambuf_iterator()</tt> and the constructor
++<tt>istreambuf_iterator(0)</tt> both construct an end of stream iterator object
++suitable for use as an end-of-range. <ins>All specializations of
++<tt>istreambuf_iterator</tt> shall have a trivial copy constructor, a constexpr
++default constructor and a trivial destructor.</ins>
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">N2994</a>.
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Ammend in both:<br>
+-24.6.3 [istreambuf.iterator]<br>
+-24.6.3.5 [istreambuf.iterator::equal]<br>
++24.6.1 [istream.iterator] para 3
+ </p>
+
+-<blockquote><pre>bool equal(<ins>const </ins>istreambuf_iterator&amp; b) const;
++<blockquote><pre>
++<ins>constexpr</ins> istream_iterator();
++</pre></blockquote>
++
++<p>
++24.6.1.1 [istream.iterator.cons]
++</p>
++
++<blockquote><pre>
++<ins>constexpr</ins> istream_iterator();
++</pre>
++<blockquote><p>
++-1- <i>Effects:</i> Constructs the end-of-stream iterator.
++<ins>If <tt>T</tt> is a literal type, then this constructor shall
++be a literal constructor.</ins>
++</p></blockquote>
++</blockquote>
++
++<p>
++24.6.3 [istreambuf.iterator]
++</p>
++
++<blockquote><pre>
++<ins>constexpr</ins> istreambuf_iterator() throw();
+ </pre></blockquote>
+
+
+@@ -63919,11 +69853,10 @@ Ammend in both:<br>
+
+ <hr>
+ <h3><a name="1130"></a>1130. <tt>copy_exception</tt> name misleading</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-05-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-05-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The naming of <tt>std::copy_exception</tt> misleads almost everyone
+@@ -63931,7 +69864,8 @@ The naming of <tt>std::copy_exception</tt> misleads almost everyone
+ <tt>exception_ptr</tt>:
+ </p>
+
+-<blockquote><pre>exception_ptr p1 = current_exception();
++<blockquote><pre>
++exception_ptr p1 = current_exception();
+ exception_ptr p2 = copy_exception( p1 );
+ </pre></blockquote>
+
+@@ -63952,16 +69886,17 @@ Therefore, I propose <tt>copy_exception</tt> to be renamed to
+ <tt>create_exception</tt>:
+ </p>
+
+-<blockquote><pre>template&lt;class E&gt; exception_ptr create_exception(E e);
++<blockquote><pre>
++template&lt;class E&gt; exception_ptr create_exception(E e);
+ </pre></blockquote>
+
+ <p>
+ with the following explanatory paragraph after it:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Creates an <tt>exception_ptr</tt> that refers to a copy of <tt>e</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-05-13 Daniel adds:
+@@ -63972,7 +69907,8 @@ Creates an <tt>exception_ptr</tt> that refers to a copy of <tt>e</tt>.
+ <p>
+ What about
+ </p>
+-<blockquote><pre>make_exception_ptr
++<blockquote><pre>
++make_exception_ptr
+ </pre></blockquote>
+ <p>
+ in similarity to <tt>make_pair</tt> and <tt>make_tuple</tt>, <tt>make_error_code</tt> and
+@@ -63980,7 +69916,8 @@ in similarity to <tt>make_pair</tt> and <tt>make_tuple</tt>, <tt>make_error_code
+ <tt>current_exception</tt> is preferred:
+ </p>
+
+-<blockquote><pre>make_exception
++<blockquote><pre>
++make_exception
+ </pre></blockquote>
+ <p>
+ We have not a single <tt>create_*</tt> function in the library, it was always
+@@ -63993,9 +69930,9 @@ We have not a single <tt>create_*</tt> function in the library, it was always
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <tt>make_exception_ptr</tt> works for me.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-06-02 Thomas J. Gritzan adds:
+@@ -64010,7 +69947,8 @@ To avoid surprises and unwanted recursion, how about making a call to
+ <p>
+ It might work like this:
+ </p>
+-<blockquote><pre>template&lt;class E&gt;
++<blockquote><pre>
++template&lt;class E&gt;
+ exception_ptr make_exception_ptr(E e);
+ template&lt;&gt;
+ exception_ptr make_exception_ptr&lt;exception_ptr&gt;(exception_ptr e) = delete;
+@@ -64022,24 +69960,24 @@ exception_ptr make_exception_ptr&lt;exception_ptr&gt;(exception_ptr e) = delete;
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Review for the time being. The subgroup thinks this is a good
+ idea, but doesn't want to break compatibility unnecessarily if someone
+ is already shipping this. Let's talk to Benjamin and PJP tomorrow to
+ make sure neither objects.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-16 Jonathan Wakely adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ GCC 4.4 shipped with <tt>copy_exception</tt> but we could certainly keep that
+ symbol in the library (but not the headers) so it can still be found
+ by any apps foolishly relying on the experimental C++0x mode being ABI
+ stable.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-16 Peter adopts wording supplied by Daniel.
+@@ -64060,7 +69998,8 @@ Change 18.8 [support.exception]/1, header <tt>&lt;exception&gt;</tt>
+ synopsis as indicated:
+ </p>
+
+-<blockquote><pre>exception_ptr current_exception();
++<blockquote><pre>
++exception_ptr current_exception();
+ void rethrow_exception [[noreturn]] (exception_ptr p);
+ template&lt;class E&gt; exception_ptr <del>copy_exception</del><ins>make_exception_ptr</ins>(E e);
+ </pre></blockquote>
+@@ -64072,7 +70011,8 @@ Change 18.8.5 [propagation]:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class E&gt; exception_ptr <del>copy_exception</del><ins>make_exception_ptr</ins>(E e);
++<pre>
++template&lt;class E&gt; exception_ptr <del>copy_exception</del><ins>make_exception_ptr</ins>(E e);
+ </pre>
+
+ <blockquote>
+@@ -64081,7 +70021,8 @@ Change 18.8.5 [propagation]:
+ to a copy of <tt>e</tt>,</ins> as if
+ </p>
+
+-<blockquote><pre>try {
++<blockquote><pre>
++try {
+ throw e;
+ } catch(...) {
+ return current_exception();
+@@ -64099,12 +70040,12 @@ to a copy of <tt>e</tt>,</ins> as if
+ Change 30.6.5 [futures.promise]/7 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> if the associated state of <tt>*this</tt> is not ready, stores an exception
+ object of type <tt>future_error</tt> with an error code of <tt>broken_promise</tt> as if by
+ <tt>this-&gt;set_exception(<del>copy_exception</del><ins>make_exception_ptr</ins>(
+ future_error(future_errc::broken_promise))</tt>. Destroys ...
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -64115,17 +70056,18 @@ future_error(future_errc::broken_promise))</tt>. Destroys ...
+
+ <hr>
+ <h3><a name="1131"></a>1131. C++0x does not need <tt>alignment_of</tt></h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2009-06-01 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Niels Dekker <b>Opened:</b> 2009-06-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>alignment_of</tt> template is no longer necessary, now that the
+ core language will provide <tt>alignof</tt>. Scott Meyers raised this
+ issue at comp.std.c++,
+ <a href="http://groups.google.com/group/comp.std.c++/browse_thread/thread/9b020306e803f08a">C++0x: alignof vs. alignment_of</a>,
+-May 21, 2009. In a reply, Daniel Krügler pointed out that
++May 21, 2009. In a reply, Daniel Kr&uuml;gler pointed out that
+ <tt>alignof</tt> was added to the working paper <i>after</i>
+ <tt>alignment_of</tt>. So it appears that <tt>alignment_of</tt> is only
+ part of the current Working Draft
+@@ -64161,43 +70103,45 @@ Suggested Resolution:
+ <blockquote>
+ <p>
+ Change the first row of Table 44 ("Type property queries"), from Type properties
+-20.7.4.3 [meta.unary.prop]:
++20.10.4.3 [meta.unary.prop]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 44 — Type property queries</caption>
+-<tbody><tr>
++<caption>Table 44 &mdash; Type property queries</caption>
++<tr>
+ <td>
+ <tt>template &lt;class T&gt; struct alignment_of;</tt>
+ </td>
+ <td>
+-<tt>alignof(T)</tt>.<br>
++<tt>alignof(T)</tt>.<br/>
+ <i>Precondition:</i> <del><tt>T</tt> shall be a complete type, a reference type,
+ or an array of unknown bound, but shall not be a function type or (possibly
+ cv-qualified) <tt>void</tt>.</del> <ins><tt>alignof(T)</tt> shall be defined</ins>
+ </td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+ Change text in Table 51 ("Other transformations"), from Other transformations
+-20.7.7.6 [meta.trans.other], as follows:
++20.10.7.6 [meta.trans.other], as follows:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 51 — Other transformations</caption>
+-<tbody><tr><td>...<tt>aligned_storage;</tt></td>
++<caption>Table 51 &mdash; Other transformations</caption>
++<tr>
++<td>&hellip;<tt>aligned_storage;</tt></td>
+ <td>
+ <tt>Len</tt> shall not be zero. <tt>Align</tt> shall be equal to
+ <tt><del>alignment_of&lt;T&gt;::value</del> <ins>alignof(T)</ins></tt> for some
+ type <tt>T</tt> or to <i>default-alignment</i>.
+ </td>
+-<td>...</td>
+-</tr></tbody></table>
++<td>&hellip;</td>
++</tr>
++</table>
+ </blockquote>
+ </blockquote>
+ </blockquote>
+@@ -64214,44 +70158,47 @@ Original proposed wording saved here:
+ </p>
+ <blockquote>
+ <p>
+-Remove from Header &lt;type_traits&gt; synopsis 20.7.2 [meta.type.synop]:
++Remove from Header &lt;type_traits&gt; synopsis 20.10.2 [meta.type.synop]:
+ </p>
+-<blockquote><pre><del>template &lt;class T&gt; struct alignment_of;</del>
++<blockquote><pre>
++<del>template &lt;class T&gt; struct alignment_of;</del>
+ </pre></blockquote>
+
+ <p>
+ Remove the first row of Table 44 ("Type property queries"), from
+-Type properties 20.7.4.3 [meta.unary.prop]:
++Type properties 20.10.4.3 [meta.unary.prop]:
+ </p>
+ <blockquote>
+ <table border="1">
+-<caption>Table 44 — Type property queries</caption>
+-<tbody><tr>
++<caption>Table 44 &mdash; Type property queries</caption>
++<tr>
+ <td><del><tt>template &lt;class T&gt; struct alignment_of;</tt></del></td>
+-<td><del><tt>alignof(T)</tt>.</del><br>
++<td><del><tt>alignof(T)</tt>.</del><br/>
+ <del><i>Precondition:</i> <tt>T</tt> shall be a complete type, a reference
+ type, or an array of unknown bound, but shall not be a function type or
+ (possibly cv-qualified) <tt>void</tt>.</del>
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+ Change text in Table 51 ("Other transformations"), from Other
+-transformations 20.7.7.6 [meta.trans.other], as follows:
++transformations 20.10.7.6 [meta.trans.other], as follows:
+ </p>
+ <blockquote>
+ <table border="1">
+-<caption>Table 51 — Other transformations</caption>
+-<tbody><tr><td>...<tt>aligned_storage;</tt></td>
++<caption>Table 51 &mdash; Other transformations</caption>
++<tr>
++<td>&hellip;<tt>aligned_storage;</tt></td>
+ <td>
+ <tt>Len</tt> shall not be zero. Align shall be equal to
+ <tt><del>alignment_of&lt;T&gt;::value</del> <ins>alignof(T)</ins></tt> for some
+ type <tt>T</tt> or to <i>default-alignment</i>.
+ </td>
+-<td>...</td>
+-</tr></tbody></table>
++<td>&hellip;</td>
++</tr>
++</table>
+ </blockquote>
+ </blockquote>
+ </blockquote>
+@@ -64267,18 +70214,18 @@ type <tt>T</tt> or to <i>default-alignment</i>.
+
+ <p>
+ Change the first row of Table 43 ("Type property queries"), from Type properties
+-20.7.4.3 [meta.unary.prop]:
++20.10.4.3 [meta.unary.prop]:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 43 — Type property queries</caption>
+-<tbody><tr>
++<caption>Table 43 &mdash; Type property queries</caption>
++<tr>
+ <td>
+ <tt>template &lt;class T&gt; struct alignment_of;</tt>
+ </td>
+ <td>
+-<tt>alignof(T)</tt>.<br>
++<tt>alignof(T)</tt>.<br/>
+ <i>Precondition:</i> <del><tt>T</tt> shall be a complete type, a reference type,
+ or an array of unknown bound, but shall not be a function type or (possibly
+ cv-qualified) <tt>void</tt>.</del> <ins><tt>alignof(T)</tt> is a valid
+@@ -64286,25 +70233,27 @@ expression (5.3.6 [expr.alignof])</ins>
+ </td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+ Change text in Table 51 ("Other transformations"), from Other transformations
+-20.7.7.6 [meta.trans.other], as follows:
++20.10.7.6 [meta.trans.other], as follows:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 51 — Other transformations</caption>
+-<tbody><tr><td>...<tt>aligned_storage;</tt></td>
++<caption>Table 51 &mdash; Other transformations</caption>
++<tr>
++<td>&hellip;<tt>aligned_storage;</tt></td>
+ <td>
+ <tt>Len</tt> shall not be zero. <tt>Align</tt> shall be equal to
+ <tt><del>alignment_of&lt;T&gt;::value</del> <ins>alignof(T)</ins></tt> for some
+ type <tt>T</tt> or to <i>default-alignment</i>.
+ </td>
+-<td>...</td>
+-</tr></tbody></table>
++<td>&hellip;</td>
++</tr>
++</table>
+ </blockquote>
+
+
+@@ -64314,17 +70263,17 @@ type <tt>T</tt> or to <i>default-alignment</i>.
+
+ <hr>
+ <h3><a name="1133"></a>1133. Does N2844 break current specification of list::splice?</h3>
+-<p><b>Section:</b> 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops], 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-05-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ IIUC,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html">N2844</a>
+ means that lvalues will no longer bind to rvalue references.
+ Therefore, the current specification of <tt>list::splice</tt> (list
+-operations 23.3.4.4 [list.ops]) will be a breaking change of behaviour for existing
++operations 23.3.5.5 [list.ops]) will be a breaking change of behaviour for existing
+ programs. That is because we changed the signature to swallow via an rvalue
+ reference rather than the lvalue reference used in 03.
+ </p>
+@@ -64337,7 +70286,8 @@ breaking programs so here it might be viewed as a positive feature.
+ <p>
+ The problem signatures:
+ </p>
+-<blockquote><pre>void splice_after(const_iterator position, forward_list&lt;T,Alloc&gt;&amp;&amp; x);
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&lt;T,Alloc&gt;&amp;&amp; x);
+ void splice_after(const_iterator position, forward_list&lt;T,Alloc&gt;&amp;&amp; x,
+ const_iterator i);
+ void splice_after(const_iterator position, forward_list&lt;T,Alloc&gt;&amp;&amp; x,
+@@ -64350,7 +70300,9 @@ void splice(const_iterator position, list&lt;T,Alloc&gt;&amp;&amp; x,
+ const_iterator first, const_iterator last);
+ </pre></blockquote>
+
++<p>
+ <b>Possible resolutions:</b>
++</p>
+
+ <p>
+ Option A. Add an additional (non-const) lvalue-reference
+@@ -64405,14 +70357,15 @@ Wording updated.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 23.3.4 [list]
++In 23.3.5 [list]
+ </p>
+
+ <p>
+ Add lvalue overloads before rvalue ones:
+ </p>
+
+-<blockquote><pre><ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x);</ins>
++<blockquote><pre>
++<ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x);</ins>
+ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
+ <ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x, const_iterator i);</ins>
+ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
+@@ -64428,13 +70381,14 @@ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, C
+ </pre></blockquote>
+
+ <p>
+-In 23.3.4.4 [list.ops], similarly add lvalue overload before each rvalue one:
++In 23.3.5.5 [list.ops], similarly add lvalue overload before each rvalue one:
+ </p>
+ <p>
+ (After paragraph 2)
+ </p>
+
+-<blockquote><pre><ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x);</ins>
++<blockquote><pre>
++<ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x);</ins>
+ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
+ </pre></blockquote>
+
+@@ -64442,7 +70396,8 @@ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
+ (After paragraph 6)
+ </p>
+
+-<blockquote><pre><ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x, const_iterator i);</ins>
++<blockquote><pre>
++<ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x, const_iterator i);</ins>
+ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, <ins>const_</ins>iterator i);
+ </pre></blockquote>
+
+@@ -64450,17 +70405,19 @@ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x, <ins>c
+ (After paragraph 10)
+ </p>
+
+-<blockquote><pre><ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x,
++<blockquote><pre>
++<ins>void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x,
+ const_iterator first, const_iterator last);</ins>
+ void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x,
+ <ins>const_</ins>iterator first, <ins>const_</ins>iterator last);
+ </pre></blockquote>
+
+ <p>
+-In 23.3.4.4 [list.ops], after paragraph 21
++In 23.3.5.5 [list.ops], after paragraph 21
+ </p>
+
+-<blockquote><pre><ins>void merge(list&lt;T,Allocator&gt;&amp; x);
++<blockquote><pre>
++<ins>void merge(list&lt;T,Allocator&gt;&amp; x);
+ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);</ins>
+ void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
+ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);
+@@ -64472,10 +70429,11 @@ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, C
+
+
+ <hr>
+-<h3><a name="1134"></a>1134. Redundant specification of stdint.h, fenv.h, tgmath.h, and maybe complex.h</h3>
+-<p><b>Section:</b> X [stdinth], X [fenv], 26.8 [c.math], X [cmplxh] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2009-05-26 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1134"></a>1134. Redundant specification of <tt>&lt;stdint.h&gt;</tt>, <tt>&lt;fenv.h&gt;</tt>, <tt>&lt;tgmath.h&gt;</tt>,
++ and maybe <tt>&lt;complex.h&gt;</tt></h3>
++<p><b>Section:</b> X [stdinth], X [fenv], 26.8 [c.math], X [cmplxh] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Robert Klarer <b>Opened:</b> 2009-05-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This is probably editorial.
+@@ -64503,20 +70461,20 @@ X [cmplxh] (regarding <tt>&lt;complex.h&gt;</tt>, though the note in this subcla
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ While searching for <tt>stdint</tt> in the CD, I found that <tt>&lt;stdint.h&gt;</tt> is also
+-mentioned in 3.9.1 [basic.fundamental] /5. It guess it should refer to
++mentioned in 3.9.1 [basic.fundamental] p.5. I guess it should refer to
+ <tt>&lt;cstdint&gt;</tt> instead.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Real issue. Maybe just editorial, maybe not. Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -64531,10 +70489,10 @@ Remove the section X [fenv].
+ Remove 26.8 [c.math], p3:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del>-3- The header <tt>&lt;tgmath.h&gt;</tt> effectively includes the headers <tt>&lt;complex.h&gt;</tt>
+ and <tt>&lt;math.h&gt;</tt>.</del>
+-</blockquote>
++</p></blockquote>
+ <p>
+ Remove the section X [cmplxh].
+ </p>
+@@ -64545,20 +70503,20 @@ Remove the section X [cmplxh].
+
+ <hr>
+ <h3><a name="1135"></a>1135. <tt>exception_ptr</tt> should support contextual conversion to <tt>bool</tt></h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-06-06 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-06-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ As of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>
+-18.8.5 [propagation]/5, the implementation-defined type
++18.8.5 [propagation] p.5, the implementation-defined type
+ <tt>exception_ptr</tt> does provide the following ways to check whether
+ it is a null value:
+ </p>
+-<blockquote><pre>void f(std::exception_ptr p) {
++<blockquote><pre>
++void f(std::exception_ptr p) {
+ p == nullptr;
+ p == 0;
+ p == exception_ptr();
+@@ -64570,7 +70528,8 @@ and I suggest to require support for evaluation in a boolean
+ context like so:
+ </p>
+
+-<blockquote><pre>void g(std::exception_ptr p) {
++<blockquote><pre>
++void g(std::exception_ptr p) {
+ if (p) {}
+ !p;
+ }
+@@ -64581,23 +70540,23 @@ context like so:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready. Note to editor: considering putting in a cross-reference
+ to 4 [conv], paragraph 3, which defines the phrase
+ "contextually converted to <tt>bool</tt>".
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-14 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We moved
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">N3073</a>
+ to the formal motions page in Pittsburgh which should obsolete this issue. I've
+ moved this issue to NAD Editorial, solved by N3073.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -64612,14 +70571,14 @@ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073
+ In section 18.8.5 [propagation] insert a new paragraph between p.5 and p.6:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>
+ An object <tt>e</tt> of type <tt>exception_ptr</tt> can be contextually converted to <tt>bool</tt>.
+ The effect shall be as if <tt>e != exception_ptr()</tt> had been evaluated in place
+ of <tt>e</tt>. There shall be no implicit conversion to arithmetic type, to
+ enumeration type or to pointer type.
+ </ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -64627,10 +70586,11 @@ enumeration type or to pointer type.
+
+ <hr>
+ <h3><a name="1136"></a>1136. Incomplete specification of <tt>nested_exception::rethrow_nested()</tt></h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2007-06-06 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2007-06-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It was recently mentioned in a newsgroup article
+@@ -64640,17 +70600,19 @@ class <tt>nested_exception</tt> is incomplete, specifically it remains unclear
+ what happens, if member <tt>nested_ptr()</tt> returns a null value. In
+ 18.8.6 [except.nested] we find only the following paragraph related to that:
+ </p>
+-<blockquote><pre>void rethrow_nested() const; // [[noreturn]]
++<blockquote><pre>
++void rethrow_nested() const; // [[noreturn]]
+ </pre>
+-<blockquote>
++<blockquote><p>
+ -4- <i>Throws:</i> the stored exception captured by this <tt>nested_exception</tt> object.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ <p>
+ This is a problem, because it is possible to create an object of
+ <tt>nested_exception</tt> with exactly such a state, e.g.
+ </p>
+-<blockquote><pre>#include &lt;exception&gt;
++<blockquote><pre>
++#include &lt;exception&gt;
+ #include &lt;iostream&gt;
+
+ int main() try {
+@@ -64675,15 +70637,15 @@ exception is being handled.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change around 18.8.6 [except.nested]/4 as indicated:
++Change around 18.8.6 [except.nested] p.4 as indicated:
+ </p>
+ <blockquote>
+ <p>
+@@ -64702,10 +70664,10 @@ shall be called.</ins>
+
+ <hr>
+ <h3><a name="1137"></a>1137. Return type of <tt>conj</tt> and <tt>proj</tt></h3>
+-<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Marc Steinbach <b>Opened:</b> 2009-06-11 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Marc Steinbach <b>Opened:</b> 2009-06-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In clause 1, the Working Draft
+@@ -64713,7 +70675,8 @@ In clause 1, the Working Draft
+ specifies overloads of the
+ functions
+ </p>
+-<blockquote><pre>arg, conj, imag, norm, proj, real
++<blockquote><pre>
++arg, conj, imag, norm, proj, real
+ </pre></blockquote>
+ <p>
+ for non-complex arithmetic types (<tt>float</tt>, <tt>double</tt>,
+@@ -64723,10 +70686,10 @@ The only requirement (clause 2) specifies effective type promotion of arguments.
+ <p>
+ I strongly suggest to add the following requirement on the return types:
+ </p>
+-<blockquote>
++<blockquote><p>
+ All the specified overloads must return real (i.e., non-complex) values,
+ specifically, the nested <tt>value_type</tt> of effectively promoted arguments.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ (This has no effect on <tt>arg</tt>, <tt>imag</tt>, <tt>norm</tt>, <tt>real</tt>:
+@@ -64742,7 +70705,8 @@ mathematical property in the same way as <tt>exp()</tt>, <tt>sin()</tt>, etc.
+ A typical use of <tt>conj()</tt>, e.g., is the generic scalar product of n-vectors:
+ </p>
+
+-<blockquote><pre>template&lt;typename T&gt;
++<blockquote><pre>
++template&lt;typename T&gt;
+ inline T
+ scalar_product(size_t n, T const* x, T const* y) {
+ T result = 0;
+@@ -64786,22 +70750,22 @@ of <tt>conj()</tt> and <tt>proj()</tt> not only useless but actually troublesome
+ Insert a new paragraph after 26.4.9 [cmplx.over]/2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>
+ All of the specified overloads shall have a return type which is the nested <tt>value_type</tt> of
+ the effectively cast arguments.
+ </ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1138"></a>1138. unusual return value for operator+</h3>
+-<p><b>Section:</b> 21.4.8.1 [string::op+] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-06-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1138"></a>1138. Unusual return value for <tt>operator+</tt></h3>
++<p><b>Section:</b> 21.4.8.1 [string::op+] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-06-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Many of the <tt>basic_string operator+</tt> overloads return an rvalue-reference. Is
+@@ -64813,14 +70777,16 @@ un-necessary copies of a cheaply movable type, but it opens risk to dangling
+ references in code like:
+ </p>
+
+-<blockquote><pre>auto &amp;&amp; s = string{"x"} + string{y};
++<blockquote><pre>
++auto &amp;&amp; s = string{"x"} + string{y};
+ </pre></blockquote>
+
+ <p>
+ and I'm not sure about:
+ </p>
+
+-<blockquote><pre>auto s = string{"x"} + string{y};
++<blockquote><pre>
++auto s = string{"x"} + string{y};
+ </pre></blockquote>
+
+ <p><i>[
+@@ -64833,9 +70799,9 @@ and I'm not sure about:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+@@ -64849,7 +70815,8 @@ signatures:
+ 21.3 [string.classes] p2 Header Synopsis
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
+@@ -64888,61 +70855,68 @@ template&lt;class charT, class traits, class Allocator&gt;
+ 21.4.8.1 [string::op+]
+ </p>
+
+-<blockquote><pre>template&lt;class charT, class traits, class Allocator&gt;
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
+ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>lhs.append(rhs)<ins>)</ins></tt>
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
+ basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>rhs.insert(0, lhs)<ins>)</ins></tt>
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
+ basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>lhs.append(rhs)<ins>)</ins></tt> [<i>Note:</i> Or equivalently
+-<tt><ins>std::move(</ins>rhs.insert(0, lhs)<ins>)</ins></tt> — <i>end note</i>]
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++<tt><ins>std::move(</ins>rhs.insert(0, lhs)<ins>)</ins></tt> &mdash; <i>end note</i>]
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(const charT* lhs,
+ basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>rhs.insert(0, lhs)<ins>)</ins></tt>.
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(charT lhs, basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>rhs.insert(0, 1, lhs)<ins>)</ins></tt>.
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
+ const charT* rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>lhs.append(rhs)<ins>)</ins></tt>.
+-</blockquote>
+-<pre>template&lt;class charT, class traits, class Allocator&gt;
++</p></blockquote>
++<pre>
++template&lt;class charT, class traits, class Allocator&gt;
+ basic_string&lt;charT,traits,Allocator&gt;<del>&amp;&amp;</del>
+ operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs, charT rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt><ins>std::move(</ins>lhs.append(1, rhs)<ins>)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ </blockquote>
+@@ -64953,11 +70927,47 @@ template&lt;class charT, class traits, class Allocator&gt;
+
+
+ <hr>
++<h3><a name="1143"></a>1143. Atomic operations library not concept enabled</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 87, UK 311</b></p>
++
++<p>
++The atomics chapter is not concept enabled.
++</p>
++
++<p>
++Needs to also consider issues <a href="lwg-defects.html#923">923</a> and <a href="lwg-defects.html#924">924</a>.
++</p>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1144"></a>1144. "thread safe" is undefined</h3>
+-<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.5 [support.start.term] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.start.term">issues</a> in [support.start.term].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 187</b></p>
+@@ -65020,18 +71030,18 @@ will succeed.
+ the <code>at_quick_exit()</code> functions
+ shall not introduce a data race (17.6.4.7).
+ <del>exitnote</del>
+-<ins>—<i>end note</i>]</ins>
++<ins>&mdash;<i>end note</i>]</ins>
+ <ins>
+ [<i>Note:</i>
+ The order of registration may be indeterminate
+ if <code>at_quick_exit</code> was called from more than one thread.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </ins>
+ [<i>Note:</i> The <code>at_quick_exit</code> registrations
+ are distinct from the <code>atexit</code> registrations,
+ and applications may need to call both registration functions
+ with the same argument.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </p></blockquote>
+
+ <p>
+@@ -65060,14 +71070,14 @@ because the function does not provide a handler for a thrown exception,
+ [<i>Note:</i>
+ Functions registered by one thread may be called by any thread,
+ and hence should not rely on the identity of thread-storage-duration objects.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </ins>
+ After calling registered functions,
+ <code>quick_exit</code> shall call <code>_Exit(status)</code>.
+ [<i>Note:</i>
+ The standard file buffers are not flushed.
+ See: ISO C 7.20.4.4.
+-—<i>end note</i>]
++&mdash;<i>end note</i>]
+ </p></blockquote>
+
+
+@@ -65075,12 +71085,432 @@ See: ISO C 7.20.4.4.
+
+
+ <hr>
++<h3><a name="1145"></a>1145. Inappropriate headers for atomics</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 312</b></p>
++
++<p>
++The contents of the <tt>&lt;stdatomic.h&gt;</tt> header are not listed anywhere,
++and <tt>&lt;cstdatomic&gt;</tt> is listed as a C99 header in chapter 17.
++If we intend to use these for compatibility with a future C standard,
++we should not use them now.
++</p>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Remove <tt>&lt;cstdatomic&gt;</tt> from the C99 headers in table 14.
++Add a new header <tt>&lt;atomic&gt;</tt> to the headers in table 13.
++Update chapter 29 to remove reference to <tt>&lt;stdatomic.h&gt;</tt>
++and replace the use of <tt>&lt;cstdatomic&gt;</tt> with <tt>&lt;atomic&gt;</tt>.
++</p>
++<p><i>[
++If and when WG14 adds atomic operations to C
++we can add corresponding headers to table 14 with a TR.
++]</i></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="1146"></a>1146. "lockfree" does not say enough</h3>
++<p><b>Section:</b> 29.4 [atomics.lockfree] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.lockfree">issues</a> in [atomics.lockfree].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 88</b></p>
++
++<p>
++The "lockfree" facilities do not tell the programmer enough.
++</p>
++
++<p>
++There are 2 problems here.
++First, at least on x86,
++it's less important to me whether some integral types are lock free
++than what is the largest type I can pass to atomic and have it be lock-free.
++For example, if <tt>long long</tt>s are not lock-free,
++<tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> is probably 1,
++but I'd still be interested in knowing whether longs are always lock-free.
++Or if long longs at any address are lock-free,
++I'd expect <tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> to be 2,
++but I may actually care whether I have access to
++the <code>cmpxchg16b</code> instruction.
++None of the support here helps with that question.
++(There are really 2 related questions here:
++what alignment requirements are there for lock-free access;
++and what processor is the program actually running on,
++as opposed to what it was compiled for?)
++</p>
++
++<p>
++Second, having <tt>atomic_is_lock_free</tt> only apply to individual objects
++is pretty useless
++(except, as Lawrence Crowl points out,
++for throwing an exception when an object is unexpectedly not lock-free).
++I'm likely to want to use its result to decide what algorithm to use,
++and that algorithm is probably going to allocate new memory
++containing atomic objects and then try to act on them.
++If I can't predict the lock-freedom of the new object
++by checking the lock-freedom of an existing object,
++I may discover after starting the algorithm that I can't continue.
++</p>
++
++<p><i>[
++2009-06-16 Jeffrey Yasskin adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++To solve the first problem, I think 2 macros would help:
++<tt>MAX_POSSIBLE_LOCK_FREE_SIZE</tt> and <tt>MAX_GUARANTEED_LOCK_FREE_SIZE</tt>,
++which expand to the maximum value of <tt>sizeof(T)</tt> for which atomic may
++(or will, respectively) use lock-free operations.
++Lawrence points out that this
++"relies heavily on implementations
++using word-size compare-swap on sub-word-size types,
++which in turn requires address modulation."
++He expects that to be the end state anyway, so it doesn't bother him much.
++</p>
++
++<p>
++To solve the second,
++I think one could specify that equally aligned objects of the same type
++will return the same value from <tt>atomic_is_lock_free()</tt>.
++I don't know how to specify "equal alignment".
++Lawrence suggests an additional function, <tt>atomic_is_always_lock_free()</tt>.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10-22 Benjamin Kosnik:
++]</i></p>
++
++
++<blockquote>
++<p>
++In the evolution discussion of N2925, "More Collected Issues with
++Atomics," there is an action item with respect to
++LWG <a href="lwg-defects.html#1146">1146</a>, US 88
++</p>
++
++<p>
++This is stated in the paper as:
++</p>
++<p>
++Relatedly, Mike Sperts will create an issue to propose adding a traits
++mechanism to check the compile-time properties through a template
++mechanism rather than macros
++</p>
++
++<p>
++Here is my attempt to do this. I don't believe that a separate trait is
++necessary for this, and that instead <tt>atomic_integral::is_lock_free</tt> can
++be re-purposed with minimal work as follows.
++</p>
++
++<p><i>[
++Howard: Put Benjamin's wording in the proposed wording section.
++]</i></p>
++
++
++</blockquote>
++
++<p><i>[
++2009-10-22 Alberto Ganesh Barbati:
++]</i></p>
++
++
++<blockquote>
++<p>
++Just a thought... wouldn't it be better to use a scoped enum instead of
++plain integers? For example:
++</p>
++
++<blockquote><pre>
++enum class is_lock_free
++{
++ never = 0, sometimes = 1, always = 2;
++};
++</pre></blockquote>
++
++<p>
++if compatibility with C is deemed important, we could use an unscoped
++enum with suitably chosen names. It would still be more descriptive
++than 0, 1 and 2.
++</p>
++
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Header <tt>&lt;cstdatomic&gt;</tt> synopsis [atomics.synopsis]
++</p>
++
++<p>
++Edit as follows:
++</p>
++
++<blockquote><pre>
++namespace std {
++...
++// 29.4, lock-free property
++<del>#define ATOMIC_INTEGRAL_LOCK_FREE unspecified</del>
++<ins>#define ATOMIC_CHAR_LOCK_FREE unspecified
++#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
++#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
++#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
++#define ATOMIC_SHORT_LOCK_FREE unspecified
++#define ATOMIC_INT_LOCK_FREE unspecified
++#define ATOMIC_LONG_LOCK_FREE unspecified
++#define ATOMIC_LLONG_LOCK_FREE unspecified</ins>
++#define ATOMIC_ADDRESS_LOCK_FREE unspecified
++</pre></blockquote>
++
++<p>
++Lock-free Property 29.4 [atomics.lockfree]
++</p>
++
++<p>
++Edit the synopsis as follows.
++</p>
++
++<blockquote><pre>
++namespace std {
++ <del>#define ATOMIC_INTEGRAL_LOCK_FREE unspecified</del>
++ <ins>#define ATOMIC_CHAR_LOCK_FREE unspecified
++ #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
++ #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
++ #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
++ #define ATOMIC_SHORT_LOCK_FREE unspecified
++ #define ATOMIC_INT_LOCK_FREE unspecified
++ #define ATOMIC_LONG_LOCK_FREE unspecified
++ #define ATOMIC_LLONG_LOCK_FREE unspecified</ins>
++ #define ATOMIC_ADDRESS_LOCK_FREE unspecified
++}
++</pre></blockquote>
++
++<p>
++Edit paragraph 1 as follows.
++</p>
++
++<blockquote><p>
++The <ins>ATOMIC_...._LOCK_FREE</ins> macros <del>ATOMIC_INTEGRAL_LOCK_FREE and ATOMIC_ADDRESS_LOCK_FREE</del> indicate the general lock-free
++property of <del>integral and address atomic</del> <ins>the corresponding atomic integral</ins> types<ins>, with the
++signed and unsigned variants grouped together</ins>.
++<del>The properties also apply to the corresponding specializations of the atomic template.</del>
++A value of 0
++indicates that the types are never lock-free. A value of 1
++indicates that the types are sometimes lock-free. A value of 2
++indicates that the types are always lock-free.
++</p></blockquote>
++
++<p>
++Operations on Atomic Types 29.6 [atomics.types.operations]
++</p>
++
++<p>
++Edit as follows.
++</p>
++
++<blockquote><pre>
++<del>void</del> <ins>static constexpr bool</ins> A::is_lock_free() const volatile;
++</pre>
++<blockquote><p>
++<i>Returns:</i> True if the <del>object's</del> <ins>types's</ins> operations are lock-free, false
++otherwise.
++<ins>
++[<i>Note:</i> In the same way that <tt>&lt;limits&gt;</tt>
++<tt>std::numeric_limits&lt;short&gt;::max()</tt> is related to <tt>&lt;limits.h&gt;</tt>
++<tt>__LONG_LONG_MAX__</tt>, <tt>&lt;atomic&gt; std::atomic_short::is_lock_free</tt> is related to
++<tt>&lt;stdatomic.h&gt;</tt> and <tt>ATOMIC_SHORT_LOCK_FREE</tt> &mdash; <i>end note</i>]
++</ins>
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1147"></a>1147. Non-volatile atomic functions</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 90</b></p>
++
++<p>
++The C++0X draft declares all of the functions dealing with atomics
++(section 29.6 [atomics.types.operations]) to take volatile
++arguments. Yet it also says (29.4-3),
++</p>
++
++<blockquote>
++<p>
++[ Note: Many operations are volatile-qualified.
++The "volatile as device register" semantics have not changed in the standard.
++This qualification means that volatility is preserved
++when applying these operations to volatile objects.
++It does not mean that operations on non-volatile objects become volatile.
++Thus, volatile qualified operations on non-volatile objects
++may be merged under some conditions. &mdash; end note ]
++</p>
++</blockquote>
++
++<p>
++I was thinking about how to implement this in gcc,
++and I believe that we'll want to overload most of the functions
++on volatile and non-volatile.
++Here's why:
++</p>
++
++<p>
++To let the compiler take advantage of the permission
++to merge non-volatile atomic operations and reorder atomics in certain,
++we'll need to tell the compiler backend
++about exactly which atomic operation was used.
++So I expect most of the functions of the form <tt>atomic_&lt;op&gt;_explicit()</tt>
++(e.g. <tt>atomic_load_explicit</tt>, <tt>atomic_exchange_explicit</tt>,
++<tt>atomic_fetch_add_explicit</tt>, etc.)
++to become compiler builtins.
++A builtin can tell whether its argument was volatile or not,
++so those functions don't really need extra explicit overloads.
++However, I don't expect that we'll want to add builtins
++for every function in chapter 29,
++since most can be implemented in terms of the <tt>_explicit</tt> free functions:
++</p>
++
++<pre><code>class atomic_int {
++ __atomic_int_storage value;
++ public:
++ int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
++ // &amp;value has type "volatile __atomic_int_storage*".
++ atomic_fetch_add_explicit(&amp;value, increment, order);
++ }
++ ...
++};
++</code></pre>
++
++<p>
++But now this <em>always</em> calls
++the volatile builtin version of <tt>atomic_fetch_add_explicit()</tt>,
++even if the <tt>atomic_int</tt> wasn't declared volatile.
++To preserve volatility and the compiler's permission to optimize,
++I'd need to write:
++</p>
++
++<pre><code>class atomic_int {
++ __atomic_int_storage value;
++ public:
++ int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
++ atomic_fetch_add_explicit(&amp;value, increment, order);
++ }
++ int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
++ atomic_fetch_add_explicit(&amp;value, increment, order);
++ }
++ ...
++};
++</code></pre>
++
++<p>
++But this is visibly different from the declarations in the standard
++because it's now overloaded.
++(Consider passing <tt>&amp;atomic_int::fetch_add</tt> as a template parameter.)
++</p>
++
++<p>
++The implementation may already have permission to add overloads
++to the member functions:
++</p>
++
++<blockquote>
++<p>
++17.6.5.5 [member.functions] An implementation may declare additional non-virtual
++member function signatures within a class:<br/>
++...
++</p>
++<ul>
++<li>by adding a member function signature for a member function name.</li>
++</ul>
++</blockquote>
++
++<p>
++but I don't see an equivalent permission to add overloads to the free functions.
++</p>
++
++<p><i>[
++2009-06-16 Lawrence adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++I recommend allowing non-volatile overloads.
++</p>
++</blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2992.htm">N2992</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1151"></a>1151. Behavior of the library in the presence of threads is incompletely specified</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US 63</b></p>
+
+@@ -65106,11 +71536,11 @@ See: ISO C 7.20.4.4.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to "Open". Hans and the rest of the concurrency working group will
+ study this. We can't make progress without a thorough review and a
+ paper.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Moved to NAD Editorial. Rationale added below.
+@@ -65133,21 +71563,21 @@ Solved by
+
+
+ <hr>
+-<h3><a name="1152"></a>1152. expressions parsed differently than intended</h3>
+-<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2009-06-27 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1152"></a>1152. Expressions parsed differently than intended</h3>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Seungbeom Kim <b>Opened:</b> 2009-06-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Table 73 -- Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals],
++In Table 73 &mdash; Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals],
+ in
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>,
+ we have the following entries:
+ </p>
+ <table border="1">
+-<caption>Table 73 — Floating-point conversions</caption>
+-<tbody><tr>
++<caption>Table 73 &mdash; Floating-point conversions</caption>
++<tr>
+ <th>State</th> <th><tt>stdio</tt> equivalent</th>
+ </tr>
+ <tr>
+@@ -65159,19 +71589,21 @@ we have the following entries:
+ <td><tt>floatfield == ios_base::fixed | ios_base::scientific</tt></td>
+ <td align="center"><tt>%A</tt></td>
+ </tr>
+-</tbody></table>
++</table>
+
+ <p>
+ These expressions are supposed to mean:
+ </p>
+
+-<blockquote><pre>floatfield == (ios_base::fixed | ios_base::scientific) &amp;&amp; !uppercase
++<blockquote><pre>
++floatfield == (ios_base::fixed | ios_base::scientific) &amp;&amp; !uppercase
+ floatfield == (ios_base::fixed | ios_base::scientific)
+ </pre></blockquote>
+ <p>
+ but technically parsed as:
+ </p>
+-<blockquote><pre>((floatfield == ios_base::fixed) | ios_base::scientific) &amp;&amp; (!uppercase)
++<blockquote><pre>
++((floatfield == ios_base::fixed) | ios_base::scientific) &amp;&amp; (!uppercase)
+ ((floatfield == ios_base::fixed) | ios_base::scientific)
+ </pre></blockquote>
+ <p>
+@@ -65183,20 +71615,20 @@ and should be corrected with additional parentheses, as shown above.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change Table 83 — Floating-point conversions in 22.4.2.2.2 [facet.num.put.virtuals]:
++Change Table 83 &mdash; Floating-point conversions in 22.4.2.2.2 [facet.num.put.virtuals]:
+ </p>
+
+ <table border="1">
+-<caption>Table 83 — Floating-point conversions</caption>
+-<tbody><tr>
++<caption>Table 83 &mdash; Floating-point conversions</caption>
++<tr>
+ <th>State</th> <th><tt>stdio</tt> equivalent</th>
+ </tr>
+ <tr>
+@@ -65208,7 +71640,7 @@ Change Table 83
+ <td><tt>floatfield == <ins>(</ins>ios_base::fixed | ios_base::scientific<ins>)</ins></tt></td>
+ <td align="center"><tt>%A</tt></td>
+ </tr>
+-</tbody></table>
++</table>
+
+
+
+@@ -65216,9 +71648,10 @@ Change Table 83
+
+ <hr>
+ <h3><a name="1157"></a>1157. Local types can now instantiate templates</h3>
+-<p><b>Section:</b> 17.6.3.2.1 [namespace.std] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.4.2.1 [namespace.std] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#namespace.std">issues</a> in [namespace.std].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 175</b></p>
+@@ -65243,15 +71676,15 @@ Change Table 83
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-17.6.3.2.1 [namespace.std]
++17.6.4.2.1 [namespace.std]
+ </p>
+ <p>
+ Strike "of external linkage" in p1 and p2:
+@@ -65301,10 +71734,10 @@ library requirements for the original template.
+
+ <hr>
+ <h3><a name="1158"></a>1158. Encouragement to use monotonic clock</h3>
+-<p><b>Section:</b> 30.2.4 [thread.req.timing] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.req.timing">issues</a> in [thread.req.timing].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.2.4 [thread.req.timing] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.req.timing">issues</a> in [thread.req.timing].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 322, US 96</b></p>
+@@ -65319,8 +71752,8 @@ library requirements for the original template.
+
+ <p><b>Notes</b></p>
+ <p>Create an issue, together with UK 96. Note that the specification as is
+- already allows a non-monotonic clock due to the word “should” rather than
+- “shall”. If this wording is kept, a footnote should be added to make the
++ already allows a non-monotonic clock due to the word &#8220;should&#8221; rather than
++ &#8220;shall&#8221;. If this wording is kept, a footnote should be added to make the
+ meaning clear.</p>
+
+ <p><i>[ 2009-06-29 Beman provided a proposed resolution. ] </i></p>
+@@ -65330,22 +71763,22 @@ library requirements for the original template.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Set to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-02-24 Pete moved to Open:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ LWG 1158's proposed resolution replaces the ISO-specified normative term
+ "should" with "are encouraged but not required to", which presumably means the
+ same thing, but has no ISO normative status. The WD used the latter formulation
+ in quite a few non-normative places, but only three normative ones. I've changed
+ all the normative uses to "should".
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-06 Beman updates wording.
+@@ -65368,7 +71801,7 @@ The member functions whose names end in <tt>_for</tt> take an argument that
+ specifies a relative time. Implementations should use a monotonic clock to
+ measure time for these functions. <ins>[<i>Note:</i> Implementations are not
+ required to use a monotonic clock because such a clock may be unavailable.
+-— <i>end note</i>]</ins>
++&mdash; <i>end note</i>]</ins>
+ </p>
+
+
+@@ -65378,11 +71811,11 @@ required to use a monotonic clock because such a clock may be unavailable.
+
+ <hr>
+ <h3><a name="1159"></a>1159. Unclear spec for <tt>resource_deadlock_would_occur</tt></h3>
+-<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a></p>
++<p><b>Section:</b> 30.4.2.2.2 [thread.lock.unique.locking] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.lock.unique.locking">issues</a> in [thread.lock.unique.locking].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1219">1219</a></p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 327, UK 328</b></p>
+@@ -65428,7 +71861,7 @@ required to use a monotonic clock because such a clock may be unavailable.
+ is the correct one.</p>
+
+ <p><i>[
+-2009-11-11 Alisdair notes that this issue is very closely related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1219">1219</a>,
++2009-11-11 Alisdair notes that this issue is very closely related to <a href="lwg-closed.html#1219">1219</a>,
+ if not a dup.
+ ]</i></p>
+
+@@ -65443,9 +71876,9 @@ if not a dup.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Wording updated and moved to Ready for Pittsburgh.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -65558,10 +71991,359 @@ Remove 30.4.2.2.2 [thread.lock.unique.locking] p19 (Error condition clause).
+
+
+ <hr>
++<h3><a name="1160"></a>1160. <tt>future_error</tt> public constructor is 'exposition only'</h3>
++<p><b>Section:</b> 30.6.3 [futures.future_error] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 331</b></p>
++
++<p><b>Description</b></p>
++ <p>Not clear what
++ it means for a public constructor to be 'exposition only'.
++ If the intent is purely to support the library calling this
++ constructor then it can be made private and accessed
++ through friendship. Otherwise it should be documented for
++ public consumption.</p>
++<p><b>Suggestion</b></p>
++ <p>Declare the constructor as private with a
++ note about intended friendship, or remove the
++ exposition-only comment and document the semantics.</p>
++<p><b>Notes</b></p>
++<p>Create an issue. Assigned to Detlef. Suggested resolution probably makes
++ sense.</p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Pending a paper from Anthony Williams &#47; Detlef Vollmann.
++</p></blockquote>
++
++<p><i>[
++2009-10-14 Pending paper:
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1161"></a>1161. Unnecessary <tt>unique_future</tt> limitations</h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 336</b></p>
++
++<p><b>Description</b></p>
++
++ <p>It is possible
++ to transfer ownership of the asynchronous result from one
++ unique_future instance to another via the move-constructor.
++ However, it is not possible to transfer it back, and nor is
++ it possible to create a default-constructed unique_future
++ instance to use as a later move target. This unduly limits
++ the use of <tt>unique_future</tt> in code. Also, the lack of a
++ move-assignment operator restricts the use of <tt>unique_future</tt>
++ in containers such as <tt>std::vector</tt> - <tt>vector::insert</tt> requires
++ move-assignable for example.</p>
++<p><b>Suggestion</b></p>
++ <p>Add a default constructor with the
++ semantics that it creates a <tt>unique_future</tt> with no
++ associated asynchronous result. Add a move-assignment
++ operator which transfers ownership.</p>
++<p><b>Notes</b></p>
++<p>Create an issue. Detlef will look into it.</p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Pending a paper from Anthony Williams &#47; Detlef Vollmann.
++</p></blockquote>
++
++<p><i>[
++2009-10-14 Pending paper:
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1162"></a>1162. <tt>shared_future</tt> should support an efficient move constructor</h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 337</b></p>
++
++<p><b>Description</b></p>
++ <p><tt>shared_future</tt>
++ should support an efficient move constructor that can avoid
++ unnecessary manipulation of a reference count, much like
++ <tt>shared_ptr</tt></p>
++<p><b>Suggestion</b></p>
++ <p>Add a move constructor</p>
++<p><b>Notes</b></p>
++<p>Create an issue. Detlef will look into it.</p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Pending a paper from Anthony Williams &#47; Detlef Vollmann.
++</p></blockquote>
++
++<p><i>[
++2009-10-14 Pending paper:
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1163"></a>1163. <tt>shared_future</tt> is inconsistent with <tt>shared_ptr</tt></h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 338</b></p>
++
++<p><b>Description</b></p>
++
++ <p><tt>shared_future</tt> is currently
++ <tt>CopyConstructible</tt>, but not <tt>CopyAssignable</tt>. This is
++ inconsistent with <tt>shared_ptr</tt>, and will surprise users.
++ Users will then write work-arounds to provide this
++ behaviour. We should provide it simply and efficiently as
++ part of shared_future. Note that since the shared_future
++ member functions for accessing the state are all declared
++ const, the original usage of an immutable shared_future
++ value that can be freely copied by multiple threads can be
++ retained by declaring such an instance as "<tt>const
++ shared_future</tt>".</p>
++<p><b>Suggestion</b></p>
++ <p>Remove "=delete"
++ from the copy-assignment operator of shared_future. Add a
++ move-constructor <tt>shared_future(shared_future&amp;&amp;
++ rhs)</tt>, and a move-assignment operator <tt>shared_future&amp;
++ operator=(shared_future&amp;&amp; rhs)</tt>. The postcondition
++ for the copy-assignment operator is that <tt>*this</tt> has the same
++ associated state as <tt>rhs</tt>. The postcondition for the
++ move-constructor and move assignment is that <tt>*this</tt> has the
++ same associated as <tt>rhs</tt> had before the
++ constructor&#47;assignment call and that <tt>rhs</tt> has no associated
++ state.</p>
++<p><b>Notes</b></p>
++<p>Create an issue. Detlef will look into it.</p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Pending a paper from Anthony Williams &#47; Detlef Vollmann.
++</p></blockquote>
++
++<p><i>[
++2009-10-14 Pending paper:
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2967.html">N2967</a>.
++]</i></p>
++
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Adressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1165"></a>1165. Unneeded <tt>promise</tt> move constructor</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses UK 343</b></p>
++
++<p><b>Description</b></p>
++ <p>The move constructor of a <tt>std::promise</tt>
++ object does not need to allocate any memory, so the
++ move-construct-with-allocator overload of the constructor
++ is superfluous.</p>
++<p><b>Suggestion</b></p>
++ <p>Remove the constructor with the signature <tt>template &lt;class
++ Allocator&gt; promise(allocator_arg_t, const Allocator&amp;
++ a, promise&amp; rhs);</tt></p>
++<p><b>Notes</b></p>
++<p>Create an issue. Detlef will look into it. Will solicit feedback from Pablo.
++ Note that &quot;rhs&quot; argument should also be an rvalue reference in any case.</p>
++
++<p><i>[
++2009-07 Frankfurt
++]</i></p>
++
++
++<blockquote><p>
++Pending a paper from Anthony Williams &#47; Detlef Vollmann.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Adressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">N2997</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1166"></a>1166. Allocator-specific move&#47;copy break model of move-constructor and
++ move-assignment</h3>
++<p><b>Section:</b> X [allocator.propagation], X [allocator.propagation.map], 23 [containers] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> LWG <b>Opened:</b> 2009-06-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 77</b></p>
++
++<p><b>Description</b></p>
++ <p>Allocator-specific move and copy behavior for containers
++ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a>) complicates a little-used and already-complicated
++ portion of the standard library (allocators), and breaks
++ the conceptual model of move-constructor and
++ move-assignment operations on standard containers being
++ efficient operations. The extensions for allocator-specific
++ move and copy behavior should be removed from the working
++ paper.</p>
++ <p>With the introduction of rvalue references, we are teaching
++ programmers that moving from a standard container (e.g., a
++ <tt>vector&lt;string&gt;</tt>) is an efficient, constant-time
++ operation. The introduction of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a> removed that
++ guarantee; depending on the behavior of four different
++ traits (20.8.4), the complexity of copy and move operations
++ can be constant or linear time. This level of customization
++ greatly increases the complexity of standard containers,
++ and benefits only a tiny fraction of the C++ community.</p>
++<p><b>Suggestion</b></p>
++
++ <p>Remove 20.8.4.</p>
++
++ <p>Remove 20.8.5.</p>
++
++ <p>Remove all references to the facilities in
++ 20.8.4 and 20.8.5 from clause 23.</p>
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1170"></a>1170. String <i>char-like types</i> no longer PODs</h3>
+-<p><b>Section:</b> 21.1 [strings.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-06-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 21.1 [strings.general] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-06-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses UK 218</b></p>
+@@ -65574,21 +72356,21 @@ language and its library.</p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2349.pdf">N2349</a>,
+ Constant Expressions in the Standard Library Revision 2, changed the
+-requirement in 21/1 from "POD type" to "literal type". That change had the
++requirement in 21/1 from &quot;POD type&quot; to &quot;literal type&quot;. That change had the
+ effect of removing the trivially copyable and standard-layout requirements from
+ <tt>basic_string</tt> elements.</p>
+ <p>This means that <tt>basic_string</tt> elements no longer are guaranteed to be
+ memcpy'able, and are no longer guaranteed to be standard-layout types:</p>
+ <blockquote>
+- <p>3.9/p2 and 3.9/p3 both make it clear that a "trivially copyable type" is
++ <p>3.9/p2 and 3.9/p3 both make it clear that a &quot;trivially copyable type&quot; is
+ required for memcpy to be guaranteed to work.</p>
+ <p>Literal types (3.9p12) may have a non-trivial copy assignment operator, and
+ that violates the trivially copyable requirements given in 9/p 6, bullet item
+ 2. </p>
+ <p>Literal types (3.9p12) have no standard-layout requirement, either.</p>
+ </blockquote>
+-<p>This situation probably arose because the wording for "Constant Expressions
+-in the Standard Library" was in process at the same time the C++ POD
++<p>This situation probably arose because the wording for &quot;Constant Expressions
++in the Standard Library&quot; was in process at the same time the C++ POD
+ deconstruction wording was in process. </p>
+ <p>Since trivially copyable types meet the C++0x requirements for literal types,
+ and thus work with constant expressions, it seems an easy fix to revert the
+@@ -65599,9 +72381,9 @@ and thus work with constant expressions, it seems an easy fix to revert the
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ When looking for any resolution for this issue, consider the definition of
+-"character container type" in 17.3.5 [defns.character.container]. This
++"character container type" in 17.3 [defns.character.container]. This
+ does require the character type to be a POD, and this term is used in a
+ number of places through clause 21 and 28. This suggests the PODness
+ constraint remains, but is much more subtle than before. Meanwhile, I
+@@ -65610,7 +72392,7 @@ the assumption that trivially copyable types with
+ non-trivial-but-constexpr constructors should serve as well. I don't
+ believe the current wording offers the right guarantees for either of
+ the above designs.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-04 Howard modifies proposed wording to disallow array types as
+@@ -65643,13 +72425,13 @@ types are called <i>char-like objects</i> or simply
+
+ <hr>
+ <h3><a name="1171"></a>1171. duration types should be literal</h3>
+-<p><b>Section:</b> 20.11.3 [time.duration] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-06 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration">issues</a> in [time.duration].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.5 [time.duration] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration">issues</a> in [time.duration].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The <tt>duration</tt> types in 20.11.3 [time.duration] are exactly the sort of type
++The <tt>duration</tt> types in 20.12.5 [time.duration] are exactly the sort of type
+ that should be "literal types" in the new standard. Likewise,
+ arithmetic operations on <tt>duration</tt>s should be declared <tt>constexpr</tt>.
+ </p>
+@@ -65659,12 +72441,12 @@ arithmetic operations on <tt>duration</tt>s should be declared <tt>constexpr</tt
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ An alternative (and possibly preferable solution for potentially
+-heap-allocating big_int representation types) would be to ask the core
++heap-allocating <tt>big_int</tt> representation types) would be to ask the core
+ language to allow references to <tt>const</tt> literal types as feasible
+ arguments for <tt>constexpr</tt> functions.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-30 Alisdair adds:
+@@ -65678,7 +72460,7 @@ I suggest this issue moves from New to Open.
+
+ <p>
+ Half of this issue was dealt with in paper
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.html">n2994</a>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2994.htm">n2994</a>
+ on constexpr constructors.
+ </p>
+
+@@ -65701,11 +72483,12 @@ The other half (duration arithmetic) is on hold pending Core support for
+ ]</i></p>
+
+
+-<blockquote>
+-This issue was the motivation for Core adding the facility for <tt>constexpr</tt> functions to take parameters by <tt>const &amp;</tt>.
++<blockquote><p>
++This issue was the motivation for Core adding the facility for <tt>constexpr</tt>
++functions to take parameters by <tt>const &amp;</tt>.
+
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia.
+@@ -65719,8 +72502,8 @@ Adopted at 2010-11 Batavia.
+ Add <tt>constexpr</tt> to declaration of following functions and constructors:
+ </p>
+ <p>
+-Modify p1 20.11 [time], and the prototype definitions in 20.11.3.5 [time.duration.nonmember], 20.11.3.6 [time.duration.comparisons],
+-and 20.11.3.7 [time.duration.cast]:
++Modify p1 20.12 [time], and the prototype definitions in 20.12.5.5 [time.duration.nonmember], 20.12.5.6 [time.duration.comparisons],
++and 20.12.5.7 [time.duration.cast]:
+ </p>
+
+ <blockquote>
+@@ -65728,7 +72511,8 @@ and 20.11.3.7 [time.duration.cast]:
+ <b>Header <tt>&lt;chrono&gt;</tt> synopsis</b>
+ </p>
+
+-<pre><i>// duration arithmetic</i>
++<pre>
++<i>// duration arithmetic</i>
+ template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
+ typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
+ <ins>constexpr</ins> operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
+@@ -65770,12 +72554,13 @@ template &lt;class ToDuration, class Rep, class Period&gt;
+ </blockquote>
+
+ <p>
+-Change 20.11.3 [time.duration]:
++Change 20.12.5 [time.duration]:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
++<pre>
++template &lt;class Rep, class Period = ratio&lt;1&gt;&gt;
+ class duration {
+ ...
+ public:
+@@ -65787,8 +72572,9 @@ public:
+ </pre>
+ </blockquote>
+ <p><i>[
+-Note - this edit already seems assumed by definition of the duration static members <tt>zero/min/max</tt>.
+-They cannot meaningfully be <tt>constexpr</tt> without this change.
++Note - this edit already seems assumed by definition of the duration static members
++<tt>zero&#47;min&#47;max</tt>. They cannot meaningfully be <tt>constexpr</tt> without
++this change.
+ ]</i></p>
+
+
+@@ -65797,53 +72583,139 @@ They cannot meaningfully be <tt>constexpr</tt> without this change.
+
+
+ <hr>
+-<h3><a name="1174"></a>1174. type property predicates</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Jason Merrill <b>Opened:</b> 2009-07-16 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1172"></a>1172. <tt>select_on_container_(copy|move)_construction</tt> over-constrained</h3>
++<p><b>Section:</b> X [allocator.concepts.members] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-07-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-I've been implementing compiler support for <tt>is_standard_layout</tt>, and
+-noticed a few nits about 20.7.4.3 [meta.unary.prop]:
++I believe the two functions
++<tt>select_on_container_(copy|move)_construction()</tt> are over-constrained. For
++example, the return value of the "copy" version is (see
++X [allocator.concepts.members]/21):
++</p>
++<blockquote><p>
++<i>Returns:</i> <tt>x</tt> if the allocator should propagate from the existing
++container to the new container on copy construction, otherwise <tt>X()</tt>.
++</p></blockquote>
++<p>
++Consider the case where a user decides to provide an explicit concept
++map for Allocator to adapt some legacy allocator class, as he wishes to
++provide customizations that the <tt>LegacyAllocator</tt> concept map template
++does not provide. Now, although it's true that the legacy class is
++required to have a default constructor, the user might have reasons to
++prefer a different constructor to implement
++<tt>select_on_container_copy_construction()</tt>. However, the current wording
++requires the use of the default constructor.
++</p>
++<p>
++Moreover, it's not said explicitly that <tt>x</tt> is supposed to be the
++allocator of the existing container. A clarification would do no harm.
+ </p>
+-
+-<ol>
+-<li>
+-There's no trait for "trivially copyable type", which is now the
+-property that lets you do bitwise copying of a type, and therefore seems
+-useful to be able to query. <tt>has_trivial_assign</tt> &amp;&amp;
+-<tt>has_trivial_copy_constructor</tt> &amp;&amp; <tt>has_trivial_destructor</tt>
+-is similar, but
+-not identical, specifically with respect to const types.
+-</li>
+-<li>
+-<tt>has_trivial_copy_constructor</tt> and <tt>has_trivial_assign</tt> lack the "or an
+-array of such a class type" language that most other traits in that
+-section, including <tt>has_nothrow_copy_constructor</tt> and <tt>has_nothrow_assign</tt>,
+-have; this seems like an oversight.
+-</li>
+-</ol>
+
+ <p><i>[
+-See the thread starting with c++std-lib-24420 for further discussion.
++2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<p><i>[
+-Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2947.html">N2947</a>.
+-]</i></p>
++<blockquote><p>
++<del>NAD Editorial</del><ins>Resolved</ins>. Addressed by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2982.pdf">N2982</a>.
++</p></blockquote>
+
+
+-<p><i>[
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Replace X [allocator.concepts.members]/21 with:
++</p>
++
++<blockquote><pre>
++X select_on_container_copy_construction(const X&amp; x);
++</pre>
++<p>
++-21- <i>Returns:</i> <del><tt>x</tt> if the allocator should propagate from the existing
++container to the new container on copy construction, otherwise <tt>X()</tt>.</del>
++<ins>an allocator object to be used by the new container on copy
++construction. [<i>Note:</i> <tt>x</tt> is the allocator of the existing container that
++is being copied. The most obvious choices for the return value are <tt>x</tt>, if
++the allocator should propagate from the existing container, and <tt>X()</tt>.
++<i>&mdash; end note</i>]</ins>
++</p>
++</blockquote>
++
++<p>
++Replace X [allocator.concepts.members]/25 with:
++</p>
++
++<blockquote><pre>
++X select_on_container_move_construction(X&amp;&amp; x);
++</pre>
++<p>
++-25- <i>Returns:</i> <del><tt>move(x)</tt> if the allocator should propagate from the existing
++container to the new container on move construction, otherwise <tt>X()</tt>.</del>
++<ins>an allocator object to be used by the new container on move
++construction. [<i>Note:</i> <tt>x</tt> is the allocator of the existing container that
++is being moved. The most obvious choices for the return value are <tt>move(x)</tt>, if
++the allocator should propagate from the existing container, and <tt>X()</tt>.
++<i>&mdash; end note</i>]</ins>
++</p>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1174"></a>1174. Type property predicates</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jason Merrill <b>Opened:</b> 2009-07-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I've been implementing compiler support for <tt>is_standard_layout</tt>, and
++noticed a few nits about 20.10.4.3 [meta.unary.prop]:
++</p>
++
++<ol>
++<li>
++There's no trait for "trivially copyable type", which is now the
++property that lets you do bitwise copying of a type, and therefore seems
++useful to be able to query. <tt>has_trivial_assign</tt> &amp;&amp;
++<tt>has_trivial_copy_constructor</tt> &amp;&amp; <tt>has_trivial_destructor</tt>
++is similar, but
++not identical, specifically with respect to const types.
++</li>
++<li>
++<tt>has_trivial_copy_constructor</tt> and <tt>has_trivial_assign</tt> lack the "or an
++array of such a class type" language that most other traits in that
++section, including <tt>has_nothrow_copy_constructor</tt> and <tt>has_nothrow_assign</tt>,
++have; this seems like an oversight.
++</li>
++</ol>
++
++<p><i>[
++See the thread starting with c++std-lib-24420 for further discussion.
++]</i></p>
++
++
++<p><i>[
++Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2947.html">N2947</a>.
++]</i></p>
++
++
++<p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ <del>NAD Editorial</del><ins>Resolved</ins>. Solved by
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.html">N2984</a>.
+-</blockquote>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.htm">N2984</a>.
++</p></blockquote>
+
+
+
+@@ -65857,10 +72729,10 @@ Addressed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2
+
+ <hr>
+ <h3><a name="1177"></a>1177. Improve "diagnostic required" wording</h3>
+-<p><b>Section:</b> 20.11.3 [time.duration] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration">issues</a> in [time.duration].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.12.5 [time.duration] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration">issues</a> in [time.duration].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ "diagnostic required" has been used (by me) for code words meaning "use
+@@ -65874,9 +72746,9 @@ the overload set, and moving this wording to a <i>Remarks</i> paragraph.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-19 Pete opens:
+@@ -65889,35 +72761,35 @@ Oh, and speaking of 1177, most of the changes result in rather convoluted prose.
+ Instead of saying
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ A shall be B, else C
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ it should be
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ C if A is not B
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ That is:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>Rep2</tt> shall be implicitly convertible to <tt>CR(Rep1, Rep2)</tt>, else
+ this signature shall not participate in overload resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ should be
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ This signature shall not participate in overload resolution if <tt>Rep2</tt> is
+ not implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ That is clearer, and eliminates the false requirement that <tt>Rep2</tt> "shall
+@@ -65931,10 +72803,10 @@ be" convertible.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I've updated the wording to match Pete's suggestion and included bullet 16
+-from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195">1195</a>.
+-</blockquote>
++from <a href="lwg-defects.html#1195">1195</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-19 Jens adds:
+@@ -65946,10 +72818,10 @@ from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1195"
+ Further wording suggestion using "unless":
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ This signature shall not participate in overload resolution unless <tt>Rep2</tt>
+ is implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -65957,9 +72829,9 @@ is implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I've updated the wording to match Jens' suggestion.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-22 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+@@ -65970,19 +72842,20 @@ I've updated the wording to match Jens' suggestion.
+
+ <p><b>Proposed resolution:</b></p>
+ <p><i>[
+-This proposed resolution addresses <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#947">947</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#974">974</a>.
++This proposed resolution addresses <a href="lwg-defects.html#947">947</a> and <a href="lwg-defects.html#974">974</a>.
+ ]</i></p>
+
+
+ <ol>
+ <li>
+ <p>
+-Change 20.11.3.1 [time.duration.cons] (and reorder the <i>Remarks</i>
++Change 20.12.5.1 [time.duration.cons] (and reorder the <i>Remarks</i>
+ paragraphs per 17.5.1.4 [structure.specifications]):
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Rep2&gt;
++<pre>
++template &lt;class Rep2&gt;
+ explicit duration(const Rep2&amp; r);
+ </pre>
+ <blockquote>
+@@ -66004,12 +72877,13 @@ participate in overload resolution unless</ins> <tt>Rep2</tt> <del>shall be</del
+ <p>
+ <del>Diagnostic required</del> [<i>Example:</i>
+ </p>
+-<blockquote><pre>duration&lt;int, milli&gt; d(3); // OK
++<blockquote><pre>
++duration&lt;int, milli&gt; d(3); // OK
+ duration&lt;int, milli&gt; d(3.5); // error
+ </pre></blockquote>
+
+ <p>
+-— <i>end example</i>]
++&mdash; <i>end example</i>]
+ </p>
+
+ <p>
+@@ -66022,7 +72896,8 @@ duration&lt;int, milli&gt; d(3.5); // error
+
+ </blockquote>
+
+-<pre>template &lt;class Rep2, class Period2&gt;
++<pre>
++template &lt;class Rep2, class Period2&gt;
+ duration(const duration&lt;Rep2, Period2&gt;&amp; d);
+ </pre>
+ <blockquote>
+@@ -66034,17 +72909,18 @@ participate in overload resolution unless</ins>
+ period&gt;::type::den</tt> <del>shall be</del> <ins>is</ins> 1. <del>Diagnostic
+ required.</del> [<i>Note:</i> This requirement prevents implicit truncation
+ error when converting between integral-based duration types. Such a construction
+-could easily lead to confusion about the value of the duration. — <i>end
++could easily lead to confusion about the value of the duration. &mdash; <i>end
+ note</i>] [<i>Example:</i>
+ </p>
+
+-<blockquote><pre>duration&lt;int, milli&gt; ms(3);
++<blockquote><pre>
++duration&lt;int, milli&gt; ms(3);
+ duration&lt;int, micro&gt; us = ms; // OK
+ duration&lt;int, milli&gt; ms2 = us; // error
+ </pre></blockquote>
+
+ <p>
+-— <i>end example</i>]
++&mdash; <i>end example</i>]
+ </p>
+
+ <p>
+@@ -66061,80 +72937,85 @@ duration&lt;int, milli&gt; ms2 = us; // error
+
+ <li>
+ <p>
+-Change the following paragraphs in 20.11.3.5 [time.duration.nonmember]:
++Change the following paragraphs in 20.12.5.5 [time.duration.nonmember]:
+ </p>
+
+ <blockquote>
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This operator shall not
+ participate in overload resolution unless</ins> <tt>Rep2</tt> <del>shall
+ be</del> <ins>is</ins> implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.
+ <del>Diagnostic required.</del>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This operator shall not
+ participate in overload resolution unless</ins> <tt>Rep1</tt> <del>shall
+ be</del> <ins>is</ins> implicitly convertible to <tt>CR(Rep1, Rep2)</tt>.
+ <del>Diagnostic required.</del>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This operator shall not
+ participate in overload resolution unless</ins> <tt>Rep2</tt> <del>shall
+ be</del> <ins>is</ins> implicitly convertible to <tt>CR(Rep1, Rep2)</tt> and
+ <tt>Rep2</tt> <del>shall not be</del> <ins>is not</ins> an instantiation of
+ <tt>duration</tt>. <del>Diagnostic required.</del>
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This operator shall not
+ participate in overload resolution unless</ins> <tt>Rep2</tt> <del>shall
+ be</del> <ins>is</ins> implicitly convertible to <tt>CR(Rep1, Rep2)</tt> and
+ <tt>Rep2</tt> <del>shall not be</del> <ins>is not</ins> an instantiation of
+ <tt>duration</tt>. <del>Diagnostic required.</del>
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change the following paragraphs in 20.11.3.7 [time.duration.cast]:
++Change the following paragraphs in 20.12.5.7 [time.duration.cast]:
+ </p>
+
+-<blockquote><pre>template &lt;class ToDuration, class Rep, class Period&gt;
++<blockquote><pre>
++template &lt;class ToDuration, class Rep, class Period&gt;
+ ToDuration duration_cast(const duration&lt;Rep, Period&gt;&amp; d);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This function shall not
+ participate in overload resolution unless</ins> <tt>ToDuration</tt> <del>shall
+ be</del> <ins>is</ins> an instantiation of <tt>duration</tt>. <del>Diagnostic
+ required.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.11.4.1 [time.point.cons]/3 as indicated:
++Change 20.12.6.1 [time.point.cons]/3 as indicated:
+ </p>
+
+ <blockquote>
+@@ -66154,19 +73035,20 @@ resolution unless <tt>Duration2</tt> is implicitly convertible to
+
+ <li>
+ <p>
+-Change the following paragraphs in 20.11.4.7 [time.point.cast]:
++Change the following paragraphs in 20.12.6.7 [time.point.cast]:
+ </p>
+
+-<blockquote><pre>template &lt;class ToDuration, class Clock, class Duration&gt;
++<blockquote><pre>
++template &lt;class ToDuration, class Clock, class Duration&gt;
+ time_point&lt;Clock, ToDuration&gt; time_point_cast(const time_point&lt;Clock, Duration&gt;&amp; t);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i><del>Requires</del> <ins>Remarks</ins>:</i> <ins>This function shall not
+ participate in overload resolution unless</ins> <tt>ToDuration</tt> <del>shall
+ be</del> <ins>is</ins> an instantiation of <tt>duration</tt>. <del>Diagnostic
+ required.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+ </ol>
+@@ -66178,17 +73060,17 @@ required.</del>
+
+ <hr>
+ <h3><a name="1178"></a>1178. Header dependencies</h3>
+-<p><b>Section:</b> 17.6.4.2 [res.on.headers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.5.2 [res.on.headers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-07-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-See Frankfurt notes of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1001">1001</a>.
++See Frankfurt notes of <a href="lwg-closed.html#1001">1001</a>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:</i></p>
++<p><i>Change 17.6.5.2 [res.on.headers], Headers, paragraph 1, as indicated:</i></p>
+
+ <blockquote>
+
+@@ -66211,10 +73093,10 @@ the synopses of those other headers.</ins>
+
+
+ <hr>
+-<h3><a name="1180"></a>1180. Missing string_type member typedef in class <tt>sub_match</tt></h3>
+-<p><b>Section:</b> 28.9.1 [re.submatch.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-07-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1180"></a>1180. Missing <tt>string_type</tt> member typedef in class <tt>sub_match</tt></h3>
++<p><b>Section:</b> 28.9.1 [re.submatch.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-07-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The definition of class template <tt>sub_match</tt> is strongly dependent
+@@ -66239,7 +73121,8 @@ In the class template <tt>sub_match</tt> synopsis 28.9 [re.submatch]/1
+ change as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class BidirectionalIterator&gt;
++<blockquote><pre>
++template &lt;class BidirectionalIterator&gt;
+ class sub_match : public std::pair&lt;BidirectionalIterator, BidirectionalIterator&gt; {
+ public:
+ typedef typename iterator_traits&lt;BidirectionalIterator&gt;::value_type value_type;
+@@ -66264,14 +73147,15 @@ public:
+ In 28.9.1 [re.submatch.members]/2 change as indicated:
+ </p>
+
+-<blockquote><pre>operator <del>basic_string&lt;value_type&gt;</del><ins>string_type</ins>() const;
++<blockquote><pre>
++operator <del>basic_string&lt;value_type&gt;</del><ins>string_type</ins>() const;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>matched ? <del>basic_string&lt;value_type&gt;</del>
+ <ins>string_type</ins>(first, second) : <del>basic_string&lt;value_type&gt;</del>
+ <ins>string_type</ins>()</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -66280,14 +73164,15 @@ In 28.9.1 [re.submatch.members]/2 change as indicated:
+ In 28.9.1 [re.submatch.members]/3 change as indicated:
+ </p>
+
+-<blockquote><pre><del>basic_string&lt;value_type&gt;</del><ins>string_type</ins> str() const;
++<blockquote><pre>
++<del>basic_string&lt;value_type&gt;</del><ins>string_type</ins> str() const;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>matched ? <del>basic_string&lt;value_type&gt;</del>
+ <ins>string_type</ins>(first, second) : <del>basic_string&lt;value_type&gt;</del>
+ <ins>string_type</ins>()</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -66296,7 +73181,8 @@ In 28.9.1 [re.submatch.members]/3 change as indicated:
+ In 28.9.1 [re.submatch.members]/5 change as indicated:
+ </p>
+
+-<blockquote><pre>int compare(const <del>basic_string&lt;value_type&gt;</del><ins>string_type</ins>&amp; s) const;
++<blockquote><pre>
++int compare(const <del>basic_string&lt;value_type&gt;</del><ins>string_type</ins>&amp; s) const;
+ </pre></blockquote>
+ </li>
+ </ol>
+@@ -66308,10 +73194,10 @@ In 28.9.1 [re.submatch.members]/5 change as indicated:
+
+ <hr>
+ <h3><a name="1181"></a>1181. Invalid <tt>sub_match</tt> comparison operators</h3>
+-<p><b>Section:</b> 28.9.2 [re.submatch.op] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-07-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.submatch.op">issues</a> in [re.submatch.op].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.9.2 [re.submatch.op] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-07-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.submatch.op">issues</a> in [re.submatch.op].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Several heterogeneous comparison operators of class template
+@@ -66319,15 +73205,16 @@ Several heterogeneous comparison operators of class template
+ in general. E.g. 28.9.2 [re.submatch.op]/7:
+ </p>
+
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator==(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>lhs == rhs.str()</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -66345,14 +73232,16 @@ traits class), the second one would define the semantics of the
+ comparison using the traits class
+ </p>
+
+-<blockquote><pre>std::char_traits&lt;iterator_traits&lt;BiIter&gt;::value_type&gt;
++<blockquote><pre>
++std::char_traits&lt;iterator_traits&lt;BiIter&gt;::value_type&gt;
+ </pre></blockquote>
+
+ <p>
+ which is essentially identical to
+ </p>
+
+-<blockquote><pre>std::char_traits&lt;sub_match&lt;BiIter&gt;::value_type&gt;
++<blockquote><pre>
++std::char_traits&lt;sub_match&lt;BiIter&gt;::value_type&gt;
+ </pre></blockquote>
+
+ <p>
+@@ -66381,9 +73270,9 @@ where defined by referring to <tt>sub_match</tt>'s compare function, all remaini
+ definitions in terms of these two.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -66399,315 +73288,351 @@ Adopted at 2010-11 Batavia
+
+ <ol>
+ <li>Change 28.9.2 [re.submatch.op]/7 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator==(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 7 <em>Returns</em>: <tt><del>lhs == rhs.str()</del><ins>rhs.compare(lhs.c_str()) == 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/8 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator!=(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 8 <em>Returns</em>: <tt><del>lhs != rhs.str()</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/9 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&lt;(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 9 <em>Returns</em>: <tt><del>lhs &lt; rhs.str()</del><ins>rhs.compare(lhs.c_str()) &gt; 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/10 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&gt;(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 10 <em>Returns</em>: <tt><del>lhs &gt; rhs.str()</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/11 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&gt;=(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 11 <em>Returns</em>: <tt><del>lhs &gt;= rhs.str()</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/12 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&lt;=(
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 12 <em>Returns</em>: <tt><del>lhs &lt;= rhs.str()</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/13 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 13 <em>Returns</em>: <tt><del>lhs.str() == rhs</del><ins>lhs.compare(rhs.c_str()) == 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/14 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 14 <em>Returns</em>: <tt><del>lhs.str() != rhs</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/15 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 15 <em>Returns</em>: <tt><del>lhs.str() &lt; rhs</del><ins>lhs.compare(rhs.c_str()) &lt; 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/16 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
+- bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator>(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 16 <em>Returns</em>: <tt><del>lhs.str() &gt; rhs</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/17 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 17 <em>Returns</em>: <tt><del>lhs.str() &gt;= rhs</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/18 as indicated:
+-<blockquote><pre>template &lt;class BiIter, class ST, class SA&gt;
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
+ bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ const basic_string&lt;
+ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 18 <em>Returns</em>: <tt><del>lhs.str() &lt;= rhs</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/19 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator==(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 19 <em>Returns</em>: <tt><del>lhs == rhs.str()</del><ins>rhs.compare(lhs) == 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/20 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator!=(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 20 <em>Returns</em>: <tt><del>lhs != rhs.str()</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/21 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 21 <em>Returns</em>: <tt><del>lhs &lt; rhs.str()</del><ins>rhs.compare(lhs) &gt; 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/22 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 22 <em>Returns</em>: <tt><del>lhs &gt; rhs.str()</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/23 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;=(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 23 <em>Returns</em>: <tt><del>lhs &gt;= rhs.str()</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/24 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;=(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 24 <em>Returns</em>: <tt><del>lhs &lt;= rhs.str()</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/25 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 25 <em>Returns</em>: <tt><del>lhs.str() == rhs</del><ins>lhs.compare(rhs) == 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/26 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 26 <em>Returns</em>: <tt><del>lhs.str() != rhs</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/27 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 27 <em>Returns</em>: <tt><del>lhs.str() &lt; rhs</del><ins>lhs.compare(rhs) &lt; 0</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/28 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 28 <em>Returns</em>: <tt><del>lhs.str() &gt; rhs</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/29 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 29 <em>Returns</em>: <tt><del>lhs.str() &gt;= rhs</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/30 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
+-</pre>
++</pre><p>
+ 30 <em>Returns</em>: <tt><del>lhs.str() &lt;= rhs</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/31 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator==(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
+-<del>31 <em>Returns</em>: <tt>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) == rhs.str()</tt>.</del><br>
++</pre><p>
++<del>31 <em>Returns</em>: <tt>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) == rhs.str()</tt>.</del><br/>
+ <ins>31 <em>Returns</em>: <tt>rhs.compare(typename sub_match&lt;BiIter&gt;::string_type(1, lhs)) == 0</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/32 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator!=(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 32 <em>Returns</em>: <tt><del>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) !=
+ rhs.str()</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/33 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
+-<del>33 <em>Returns</em>: <tt>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) &lt; rhs.str()</tt>.</del><br>
++</pre><p>
++<del>33 <em>Returns</em>: <tt>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type>(1, lhs) &lt; rhs.str()</tt>.</del><br/>
+ <ins>33 <em>Returns</em>: <tt>rhs.compare(typename sub_match&lt;BiIter&gt;::string_type(1, lhs)) &gt; 0</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/34 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 34 <em>Returns</em>: <tt><del>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) &gt; rhs.str()</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/35 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;=(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
+-35 <em>Returns</em>: <tt><del>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) &gt;= rhs.str()</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</pre><p>
++35 <em>Returns</em>: <tt><del>basic_string&lt;typename iterator_traits&lt;BiIter>::value_type>(1, lhs) &gt;= rhs.str()</del><ins>!(lhs &lt; rhs)</ins></tt>.
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/36 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;=(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
+ const sub_match&lt;BiIter&gt;&amp; rhs);
+-</pre>
++</pre><p>
+ 36 <em>Returns</em>: <tt><del>basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, lhs) &lt;= rhs.str()</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/37 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
+-<del>37 <em>Returns</em>: <tt>lhs.str() == basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</tt>.</del><br>
++</pre><p>
++<del>37 <em>Returns</em>: <tt>lhs.str() == basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</tt>.</del><br/>
+ <ins>37 <em>Returns</em>: <tt>lhs.compare(typename sub_match&lt;BiIter&gt;::string_type(1, rhs)) == 0</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/38 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator!=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
++</pre><p>
+ 38 <em>Returns</em>: <tt><del>lhs.str() != basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</del><ins>!(lhs == rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/39 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
+-<del>39 <em>Returns</em>: <tt>lhs.str() &lt; basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</tt>.</del><br>
++</pre><p>
++<del>39 <em>Returns</em>: <tt>lhs.str() &lt; basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</tt>.</del><br/>
+ <ins>39 <em>Returns</em>: <tt>lhs.compare(typename sub_match&lt;BiIter&gt;::string_type(1, rhs)) &lt; 0</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/40 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
++</pre><p>
+ 40 <em>Returns</em>: <tt><del>lhs.str() &gt; basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</del><ins>rhs &lt; lhs</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/41 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&gt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
++</pre><p>
+ 41 <em>Returns</em>: <tt><del>lhs.str() &gt;= basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</del><ins>!(lhs &lt; rhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ <li>Change 28.9.2 [re.submatch.op]/42 as indicated:
+-<blockquote><pre>template &lt;class BiIter&gt;
++<blockquote><pre>
++template &lt;class BiIter&gt;
+ bool operator&lt;=(const sub_match&lt;BiIter&gt;&amp; lhs,
+ typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
+-</pre>
++</pre><p>
+ 42 <em>Returns</em>: <tt><del>lhs.str() &lt;= basic_string&lt;typename iterator_traits&lt;BiIter&gt;::value_type&gt;(1, rhs)</del><ins>!(rhs &lt; lhs)</ins></tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -66718,10 +73643,11 @@ rhs.str()</del><ins>!(lhs == rhs)</ins></tt>.
+
+ <hr>
+ <h3><a name="1182"></a>1182. Unfortunate hash dependencies</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-28 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 324</b></p>
+
+@@ -66739,7 +73665,7 @@ template in order to access the necessary bits.
+ <p>
+ Note that the proposed resolution purely involves moving the
+ declarations of a few specializations, it specifically does not make any
+-changes to 20.8.15 [unord.hash].
++changes to 20.9.13 [unord.hash].
+ </p>
+
+ <p><i>[
+@@ -66747,8 +73673,6 @@ changes to 20.8.15 [unord.hash].
+ ]</i></p>
+
+
+-<blockquote>
+-</blockquote>
+ <p>
+ I suggest to add to the current existing
+ proposed resolution the following items.
+@@ -66761,7 +73685,8 @@ Add to the very first strike-list of the currently suggested resolution
+ the following lines:
+ </p>
+
+-<blockquote><pre><del>template &lt;&gt; struct hash&lt;std::error_code&gt;;</del>
++<blockquote><pre>
++<del>template &lt;&gt; struct hash&lt;std::error_code&gt;;</del>
+ <del>template &lt;&gt; struct hash&lt;std::thread::id&gt;;</del>
+ </pre></blockquote>
+ </li>
+@@ -66772,7 +73697,8 @@ Add the following declarations to 19.5 [syserr], header
+ <tt>&lt;system_error&gt;</tt> synopsis after // 19.5.4:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ // 19.5.x hash support
+ template &lt;class T&gt; struct hash;
+ template &lt;&gt; struct hash&lt;error_code&gt;;
+@@ -66794,13 +73720,13 @@ Add a new clause 19.5.X (probably after 19.5.4):
+ template &lt;&gt; struct hash&lt;error_code&gt;;
+ </ins></pre>
+
+-<blockquote><ins>
+-An explicit specialization of the class template hash (20.8.15 [unord.hash])
++<blockquote><p><ins>
++An explicit specialization of the class template hash (20.9.13 [unord.hash])
+ shall be provided
+ for the type <tt>error_code</tt> suitable for using this type as key in
+ unordered associative
+-containers (23.7 [unord]).
+-</ins></blockquote>
++containers (23.5 [unord]).
++</ins></p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -66811,7 +73737,8 @@ declaration of
+ the comparison operators:
+ </p>
+
+-<blockquote><pre><ins>
++<blockquote><pre>
++<ins>
+ template &lt;class T&gt; struct hash;
+ template &lt;&gt; struct hash&lt;thread::id&gt;;
+ </ins></pre></blockquote>
+@@ -66827,30 +73754,30 @@ Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]:
+ template &lt;&gt; struct hash&lt;thread::id&gt;;
+ </ins></pre>
+
+-<blockquote><ins>
+-An explicit specialization of the class template hash (20.8.15 [unord.hash])
++<blockquote><p><ins>
++An explicit specialization of the class template hash (20.9.13 [unord.hash])
+ shall be provided
+ for the type <tt>thread::id</tt> suitable for using this type as key in
+ unordered associative
+-containers (23.7 [unord]).
+-</ins></blockquote>
++containers (23.5 [unord]).
++</ins></p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a> independently suggests moving the specialization
++Issue <a href="lwg-defects.html#889">889</a> independently suggests moving the specialization
+ <tt>std::hash&lt;std::thread::id&gt;</tt> to header <tt>&lt;thread&gt;</tt>.
+ </li>
+ </ul>
+
+ <p><i>[
+ 2009-11-13 Alisdair adopts Daniel's suggestion and the extended note from
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">889</a>.
++<a href="lwg-defects.html#889">889</a>.
+ ]</i></p>
+
+
+ <p><i>[
+-2010-01-31 Alisdair: related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1245">1245</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a>.
++2010-01-31 Alisdair: related to <a href="lwg-defects.html#1245">1245</a> and <a href="lwg-defects.html#978">978</a>.
+ ]</i></p>
+
+
+@@ -66868,9 +73795,9 @@ Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#889">
+
+ <p><b>Proposed resolution:</b></p>
+ <p><i>Strike the following specializations declared in the <tt>&lt;functional&gt;</tt>
+-synopsis p2 20.8 [function.objects] </i> </p>
+-<blockquote>
+- <pre><del>template &lt;&gt; struct hash&lt;std::string&gt;;</del>
++synopsis p2 20.9 [function.objects] </i> </p>
++<blockquote><pre>
++<del>template &lt;&gt; struct hash&lt;std::string&gt;;</del>
+ <del>template &lt;&gt; struct hash&lt;std::u16string&gt;;</del>
+ <del>template &lt;&gt; struct hash&lt;std::u32string&gt;;</del>
+ <del>template &lt;&gt; struct hash&lt;std::wstring&gt;;</del>
+@@ -66880,9 +73807,9 @@ synopsis p2 20.8 [function.objects] </i> </p>
+ <del>template &lt;class Allocator&gt; struct hash&lt;std::vector&lt;bool, Allocator&gt; &gt;;</del>
+ <del>template &lt;std::size_t N&gt; struct hash&lt;std::bitset&lt;N&gt; &gt;;</del></pre>
+ </blockquote>
+-<p><i>Add the following at the end of 20.8.15 [unord.hash]:</i></p>
+-<blockquote>
+- <pre><ins>template &lt;&gt; struct hash&lt;bool&gt;;
++<p><i>Add the following at the end of 20.9.13 [unord.hash]:</i></p>
++<blockquote><pre>
++<ins>template &lt;&gt; struct hash&lt;bool&gt;;
+ template &lt;&gt; struct hash&lt;char&gt;;
+ template &lt;&gt; struct hash&lt;signed char&gt;;
+ template &lt;&gt; struct hash&lt;unsigned char&gt;;
+@@ -66902,7 +73829,7 @@ template &lt;&gt; struct hash&lt;double&gt;;
+ template &lt;&gt; struct hash&lt;long double&gt;;
+ template&lt;class T&gt; struct hash&lt;T*&gt;;</ins></pre>
+ <p><ins>
+- Specializations meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ Specializations meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+ <p><i>Add the following declarations to 19.5 [syserr], header <tt>&lt;system_error&gt;</tt>
+ synopsis after // 19.5.4: </i> </p>
+@@ -66915,13 +73842,13 @@ template &lt;&gt; struct hash&lt;error_code&gt;;</ins></pre>
+ <blockquote>
+ <p><ins>19.5.X Hash support [syserr.hash] </ins></p>
+ <pre><ins>template &lt;&gt; struct hash&lt;error_code&gt;;</ins></pre>
+- <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+ <p><i>Add the following declarations to the synopsis of <tt>&lt;string&gt;</tt> in 21.3 [string.classes]
+ </i>
+ </p>
+-<blockquote>
+- <pre><ins>// [basic.string.hash] hash support
++<blockquote><pre>
++<ins>// [basic.string.hash] hash support
+ template &lt;class T&gt; struct hash;
+ template &lt;&gt; struct hash&lt;string&gt;;
+ template &lt;&gt; struct hash&lt;u16string&gt;;
+@@ -66930,26 +73857,26 @@ template &lt;&gt; struct hash&lt;wstring&gt;;</ins></pre>
+ </blockquote>
+ <p><i>Add a new clause 21.4.X </i> </p>
+ <blockquote>
+- <p><ins>21.4.X Hash support [basic.string.hash]&gt;</ins></p>
++ <p><ins>21.4.X Hash support [basic.string.hash]></ins></p>
+ <pre><ins>template &lt;&gt; struct hash&lt;string&gt;;
+ template &lt;&gt; struct hash&lt;u16string&gt;;
+ template &lt;&gt; struct hash&lt;u32string&gt;;
+ template &lt;&gt; struct hash&lt;wstring&gt;;</ins></pre>
+- <p><ins>Specializations meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ <p><ins>Specializations meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+ <p><i>Add the following declarations to the synopsis of <tt>&lt;vector&gt;</tt> in
+ 23.3 [sequences]</i> </p>
+-<blockquote>
+- <pre><ins>// 21.4.x hash support
++<blockquote><pre>
++<ins>// 21.4.x hash support
+ template &lt;class T&gt; struct hash;
+ template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt;&gt;;</ins></pre>
+ </blockquote>
+-<p><i>Add a new paragraph to the end of 23.4.2 [vector.bool] </i> </p>
++<p><i>Add a new paragraph to the end of 23.3.7 [vector.bool] </i> </p>
+ <blockquote>
+ <pre><ins>template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt;&gt;;</ins></pre>
+- <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+-<p><i>Add the following declarations to the synopsis of <tt>&lt;bitset&gt;</tt> in 20.5 [template.bitset] </i> </p>
++<p><i>Add the following declarations to the synopsis of <tt>&lt;bitset&gt;</tt> in 20.6 [template.bitset] </i> </p>
+ <blockquote>
+ <pre><ins>// [bitset.hash] hash support
+ template &lt;class T&gt; struct hash;
+@@ -66959,7 +73886,7 @@ template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;</ins></pre>
+ <blockquote>
+ <p><ins>20.3.7.X bitset hash support [bitset.hash]</ins></p>
+ <pre><ins>template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;</ins></pre>
+- <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+ <p><i>Add the following declarations to 30.3.1.1 [thread.thread.id] synopsis just after the
+ declaration of the comparison operators: </i> </p>
+@@ -66970,10 +73897,10 @@ template &lt;&gt; struct hash&lt;thread::id&gt;;</ins></pre>
+ <p><i>Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]: </i> </p>
+ <blockquote>
+ <pre><ins>template &lt;&gt; struct hash&lt;thread::id&gt;;</ins></pre>
+- <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.8.15 [unord.hash].</ins></p>
++ <p><ins>Specialization meeting the requirements of class template <tt>hash</tt> 20.9.13 [unord.hash].</ins></p>
+ </blockquote>
+
+-<p><i>Change Header &lt;typeindex&gt; synopsis 20.13.1 [type.index.synopsis] as
++<p><i>Change Header &lt;typeindex&gt; synopsis 20.14.1 [type.index.synopsis] as
+ indicated:</i></p>
+ <blockquote>
+ <pre>namespace std {
+@@ -67013,22 +73940,22 @@ class type_index;
+
+ <hr>
+ <h3><a name="1183"></a>1183. <tt>basic_ios::set_rdbuf</tt> may break class invariants</h3>
+-<p><b>Section:</b> 27.5.4.2 [basic.ios.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-07-28 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.5.5.3 [basic.ios.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.members">issues</a> in [basic.ios.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The protected member function <tt>set_rdbuf</tt> had been added during the
+ process of adding move and swap semantics to IO classes. A relevant
+ property of this function is described by it's effects in
+-27.5.4.2 [basic.ios.members]/19:
++27.5.5.3 [basic.ios.members]/19:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Associates the <tt>basic_streambuf</tt> object pointed to by sb with
+ this stream without calling <tt>clear()</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This means that implementors of or those who derive from existing IO classes
+@@ -67038,14 +73965,16 @@ implementations which rely on the fact that setting a stream buffer via the
+ currently only ways, i.e. either by calling
+ </p>
+
+-<blockquote><pre>void init(basic_streambuf&lt;charT,traits&gt;* sb);
++<blockquote><pre>
++void init(basic_streambuf&lt;charT,traits&gt;* sb);
+ </pre></blockquote>
+
+ <p>
+ or by calling
+ </p>
+
+-<blockquote><pre>basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);
++<blockquote><pre>
++basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);
+ </pre></blockquote>
+
+ <p>
+@@ -67063,11 +73992,11 @@ set a non-0 value.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Open. Martin volunteers to provide new wording, where
+ <tt>set_rdbuf()</tt> sets the <tt>badbit</tt> but does not cause an
+ exception to be thrown like a call to <tt>clear()</tt> would.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-20 Martin provides wording:
+@@ -67075,10 +74004,11 @@ exception to be thrown like a call to <tt>clear()</tt> would.
+
+
+ <p>
+-Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated:
++Change 27.5.5.3 [basic.ios.members] around p. 19 as indicated:
+ </p>
+
+-<blockquote><pre>void set_rdbuf(basic_streambuf&lt;charT, traits&gt;* sb);
++<blockquote><pre>
++void set_rdbuf(basic_streambuf&lt;charT, traits&gt;* sb);
+ </pre>
+
+ <blockquote>
+@@ -67108,14 +74038,14 @@ catch(ios_base::failure) {
+ </blockquote>
+ </blockquote>
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ We need to be able to call <tt>set_rdbuf()</tt> on stream objects
+ for which (<tt>rdbuf() == 0</tt>) holds without causing <tt>ios_base::failure</tt> to
+ be thrown. We also don't want <tt>badbit</tt> to be set as a result of
+ setting <tt>rdbuf()</tt> to 0 if it wasn't set before the call. This changed
+ Effects clause maintains the current behavior (as of N2914) without
+ requiring that <tt>sb</tt> be non-null.
+-
++</p>
+
+ <p><i>[
+ Post-Rapperswil
+@@ -67127,9 +74057,9 @@ Several reviewers and the submitter believe that the best solution would be to a
+ buffer shall not be a null pointer value.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording provided by Daniel after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -67141,11 +74071,12 @@ Adopted at 2010-11 Batavia
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+ <li>Add a new pre-condition just before 27.5.4.2 [basic.ios.members]/23 as indicated:
+-<blockquote><pre>void set_rdbuf(basic_streambuf&lt;charT, traits&gt;* sb);
++<blockquote><pre>
++void set_rdbuf(basic_streambuf&lt;charT, traits&gt;* sb);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <ins>?? <em>Requires</em>: <tt>sb != nullptr</tt>.</ins>
+-<p>
++<p/>
+ 23 <em>Effects</em>: Associates the <tt>basic_streambuf</tt> object pointed to by <tt>sb</tt> with this stream without calling <tt>clear()</tt>.
+ </p>
+ <p>
+@@ -67159,19 +74090,92 @@ Adopted at 2010-11 Batavia
+ </ol>
+
+
+-<p><b>Rationale:</b></p>
++<p><b>Rationale:</b></p><p>
+ We believe that setting a <tt>nullptr</tt> stream buffer can be prevented.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1185"></a>1185. Iterator categories and output iterators</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-07-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++(wording relative to
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
++pending new working paper)
++</p>
++
++<p>
++According to p3 24.2 [iterator.requirements], Forward iterators,
++Bidirectional iterators and Random Access iterators all satisfy the
++requirements for an Output iterator:
++</p>
++
++<blockquote><p>
++XXX iterators satisfy all the requirements of the input and output iterators
++and can be used whenever either kind is specified ...
++</p></blockquote>
++
++<p>
++Meanwhile, p4 goes on to contradict this:
++</p>
++
++<blockquote><p>
++Besides its category, a forward, bidirectional, or random access
++iterator can also be mutable or constant...
++</p></blockquote>
++
++<blockquote><p>
++... Constant iterators do not satisfy the requirements for output iterators
++</p></blockquote>
++
++<p>
++The latter seems to be the overriding concern, as the iterator tag
++hierarchy does not define <tt>forward_iterator_tag</tt> as multiply derived from
++both <tt>input_iterator_tag</tt> and <tt>output_iterator_tag</tt>.
++</p>
++
++<p>
++The work on concepts for iterators showed us that output iterator really
++is fundamentally a second dimension to the iterator categories, rather
++than part of the linear input -&gt; forward -&gt; bidirectional -&gt;
++random-access sequence. It would be good to clear up these words to
++reflect that, and separately list output iterator requirements in the
++requires clauses for the appropriate algorithms and operations.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1187"></a>1187. std::decay</h3>
+-<p><b>Section:</b> 20.7.7.6 [meta.trans.other] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jason Merrill <b>Opened:</b> 2009-08-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1187"></a>1187. <tt>std::decay</tt></h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jason Merrill <b>Opened:</b> 2009-08-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I notice that <tt>std::decay</tt> is specified to strip the cv-quals from
+@@ -67184,12 +74188,12 @@ class type, since class rvalues can have cv-qualified type (3.10 [basic.lval]/9)
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ See the thread starting with c++std-lib-24568 for further discussion. And
+ here is a convenience link to the
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2069.html">original proposal</a>.
+-Also see the closely related issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#705">705</a>.
+-</blockquote>
++Also see the closely related issue <a href="lwg-defects.html#705">705</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010 Pittsburgh: Moved to Ready.
+@@ -67201,16 +74205,16 @@ Also see the closely related issue <a href="http://www.open-std.org/jtc1/sc22/wg
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Add a note to <tt>decay</tt> in 20.7.7.6 [meta.trans.other]:
++Add a note to <tt>decay</tt> in 20.10.7.6 [meta.trans.other]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> This behavior is similar to the lvalue-to-rvalue (4.1),
+ array-to-pointer (4.2), and function-to-pointer (4.3) conversions
+ applied when an lvalue expression is used as an rvalue, but also strips
+ cv-qualifiers from class types in order to more closely model by-value
+-argument passing. — <i>end note</i>]
+-</blockquote>
++argument passing. &mdash; <i>end note</i>]
++</p></blockquote>
+
+
+
+@@ -67221,11 +74225,11 @@ argument passing.
+
+ <hr>
+ <h3><a name="1189"></a>1189. Awkward interface for changing the number of buckets in an unordered associative container</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req], 23.7 [unord] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-08-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Consider a typical use case: I create an <tt>unordered_map</tt> and then start
+@@ -67240,7 +74244,7 @@ Unfortunately, the existing interface makes this awkward. The user
+ naturally sees the problem in terms of the number of elements, but the
+ interface presents it as buckets. If <tt>m</tt> is the map and <tt>n</tt> is the expected
+ number of elements, this operation is written <tt>m.rehash(n /
+-m.max_load_factor())</tt> — not very novice friendly.
++m.max_load_factor())</tt> &mdash; not very novice friendly.
+ </p>
+
+ <p><i>[
+@@ -67248,14 +74252,14 @@ m.max_load_factor())</tt>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I recommend to replace "<tt>resize</tt>" by a different name like
+ "<tt>reserve</tt>", because that would better match the intended
+ use-case. Rational: Any existing resize function has the on-success
+ post-condition that the provided size is equal to <tt>size()</tt>, which
+ is not satisfied for the proposal. Reserve seems to fit the purpose of
+ the actual renaming suggestion.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-28 Ganesh summarizes alternative resolutions and expresses a
+@@ -67274,10 +74278,10 @@ rehash and replace it with:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 87 — Unordered associative container requirements
++<caption>Table 87 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+@@ -67293,11 +74297,11 @@ Post: <tt>a.bucket_count &gt; <ins>max(</ins>a.size()<ins>, n)</ins>
+ Average case linear in <tt>a.size()</tt>, worst case quadratic.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Make the corresponding change in the class synopses in 23.7.1 [unord.map], 23.7.2 [unord.multimap], 23.7.3 [unord.set], and 23.7.4 [unord.multiset].
++Make the corresponding change in the class synopses in 23.5.4 [unord.map], 23.5.5 [unord.multimap], 23.5.6 [unord.set], and 23.5.7 [unord.multiset].
+ </p>
+ </li>
+ <li>
+@@ -67308,10 +74312,10 @@ In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 87 — Unordered associative container requirements
++<caption>Table 87 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+@@ -67341,18 +74345,19 @@ Same as <tt>a.rehash(ceil(n / a.max_load_factor()))</tt>
+ Average case linear in <tt>a.size()</tt>, worst case quadratic.
+ </ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-In 23.7.1 [unord.map]/3 in the definition of class template <tt>unordered_map</tt>, in
+-23.7.2 [unord.multimap]/3 in the definition of class template <tt>unordered_multimap</tt>, in
+-23.7.3 [unord.set]/3 in the definition of class template <tt>unordered_set</tt> and in
+-23.7.4 [unord.multiset]/3 in the definition of class template <tt>unordered_multiset</tt>, add the
++In 23.5.4 [unord.map]/3 in the definition of class template <tt>unordered_map</tt>, in
++23.5.5 [unord.multimap]/3 in the definition of class template <tt>unordered_multimap</tt>, in
++23.5.6 [unord.set]/3 in the definition of class template <tt>unordered_set</tt> and in
++23.5.7 [unord.multiset]/3 in the definition of class template <tt>unordered_multiset</tt>, add the
+ following line after member function <tt>rehash()</tt>:
+ </p>
+
+-<blockquote><pre>void reserve(size_type n);
++<blockquote><pre>
++void reserve(size_type n);
+ </pre></blockquote>
+
+ </li>
+@@ -67384,10 +74389,10 @@ rehash and replace it with:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 87 — Unordered associative container requirements
++<caption>Table 87 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+@@ -67403,11 +74408,11 @@ Post: <tt>a.bucket_count &gt; <ins>max(</ins>a.size()<ins>, n)</ins>
+ Average case linear in <tt>a.size()</tt>, worst case quadratic.
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Make the corresponding change in the class synopses in 23.7.1 [unord.map], 23.7.2 [unord.multimap], 23.7.3 [unord.set], and 23.7.4 [unord.multiset].
++Make the corresponding change in the class synopses in 23.5.4 [unord.map], 23.5.5 [unord.multimap], 23.5.6 [unord.set], and 23.5.7 [unord.multiset].
+ </p>
+
+ </blockquote>
+@@ -67421,10 +74426,10 @@ In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 87 — Unordered associative container requirements
++<caption>Table 87 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th><th>Return type</th><th>Assertion/note pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+@@ -67454,18 +74459,19 @@ Same as <tt>a.rehash(ceil(n / a.max_load_factor()))</tt>
+ Average case linear in <tt>a.size()</tt>, worst case quadratic.
+ </ins></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-In 23.7.1 [unord.map]/3 in the definition of class template <tt>unordered_map</tt>, in
+-23.7.2 [unord.multimap]/3 in the definition of class template <tt>unordered_multimap</tt>, in
+-23.7.3 [unord.set]/3 in the definition of class template <tt>unordered_set</tt> and in
+-23.7.4 [unord.multiset]/3 in the definition of class template <tt>unordered_multiset</tt>, add the
++In 23.5.4 [unord.map]/3 in the definition of class template <tt>unordered_map</tt>, in
++23.5.5 [unord.multimap]/3 in the definition of class template <tt>unordered_multimap</tt>, in
++23.5.6 [unord.set]/3 in the definition of class template <tt>unordered_set</tt> and in
++23.5.7 [unord.multiset]/3 in the definition of class template <tt>unordered_multiset</tt>, add the
+ following line after member function <tt>rehash()</tt>:
+ </p>
+
+-<blockquote><pre>void reserve(size_type n);
++<blockquote><pre>
++void reserve(size_type n);
+ </pre></blockquote>
+
+
+@@ -67474,9 +74480,10 @@ following line after member function <tt>rehash()</tt>:
+
+ <hr>
+ <h3><a name="1191"></a>1191. <tt>tuple get</tt> API should respect rvalues</h3>
+-<p><b>Section:</b> 20.4.2.6 [tuple.elem] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.4.2.6 [tuple.elem] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.elem">issues</a> in [tuple.elem].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>tuple get</tt> API should respect rvalues. This would allow for moving a
+@@ -67511,11 +74518,13 @@ feedback given, and it has not (yet) been rejected as NAD.
+ ]</i></p>
+
+
+-<blockquote>
+-Note that wording has been provided, and this issue becomes more important now that we have added a function to support forwarding argument lists as <tt>tuple</tt>s.
++<blockquote><p>
++Note that wording has been provided, and this issue becomes more important
++now that we have added a function to support forwarding argument lists as
++<tt>tuple</tt>s.
+
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -67553,14 +74562,14 @@ typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;&amp; get(tupl
+ [<i>Note:</i> If a <tt>T</tt> in <tt>Types</tt> is some reference type <tt>X&amp;</tt>,
+ the return type is <tt>X&amp;</tt>, not <tt>X&amp;&amp;</tt>.
+ However, if the element type is non-reference type <tt>T</tt>,
+-the return type is <tt>T&amp;&amp;</tt>. — <i>end note</i>]
++the return type is <tt>T&amp;&amp;</tt>. &mdash; <i>end note</i>]
+ </ins></p>
+
+ </blockquote>
+ </blockquote>
+
+ <p>
+-Add the following signature to p1 20.3 [utility]
++Add the following signature to p1 20.2 [utility]
+ </p>
+
+ <blockquote><pre><ins>
+@@ -67569,7 +74578,7 @@ typename tuple_element&lt;I, pair&lt;T1,T2&gt; &gt;::type&amp;&amp; get(pair&lt;
+ </ins></pre></blockquote>
+
+ <p>
+-And to p5 20.3.5.4 [pair.astuple]
++And to p5 20.3.4 [pair.astuple]
+ </p>
+
+ <blockquote><pre><ins>
+@@ -67601,16 +74610,17 @@ T&amp;&amp; get(array&lt;T,N&gt; &amp;&amp;);
+ </ins></pre></blockquote>
+
+ <p>
+-And after p8 23.3.1.8 [array.tuple]
++And after p8 23.3.2.9 [array.tuple]
+ </p>
+
+-<blockquote><pre><ins>template &lt;size_t I, class T, size_t N&gt;
++<blockquote><pre>
++<ins>template &lt;size_t I, class T, size_t N&gt;
+ T&amp;&amp; get(array&lt;T,N&gt; &amp;&amp; a);
+ </ins></pre>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Effects:</i> Equivalent to <tt>return std::move(get&lt;I&gt;(a));</tt>
+-</ins></blockquote>
++</ins></p></blockquote>
+ </blockquote>
+
+
+@@ -67619,10 +74629,10 @@ T&amp;&amp; get(array&lt;T,N&gt; &amp;&amp; a);
+
+
+ <hr>
+-<h3><a name="1192"></a>1192. <tt>basic_string</tt> missing definitions for <tt>cbegin</tt> / <tt>cend</tt> / <tt>crbegin</tt> / <tt>crend</tt></h3>
+-<p><b>Section:</b> 21.4.3 [string.iterators] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-08-14 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1192"></a>1192. <tt>basic_string</tt> missing definitions for <tt>cbegin</tt> &#47; <tt>cend</tt> &#47; <tt>crbegin</tt> &#47; <tt>crend</tt></h3>
++<p><b>Section:</b> 21.4.3 [string.iterators] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-08-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Unlike the containers in clause 23, <tt>basic_string</tt> has definitions for
+@@ -67635,10 +74645,10 @@ Unlike the containers in clause 23, <tt>basic_string</tt> has definitions for
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively NAD after 5 positive votes on c++std-lib. Added
+ rationale.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10-28 Alisdair disagrees:
+@@ -67654,16 +74664,16 @@ I'm going to have to speak up as the dissenting voice.
+ I agree the issue could be handled editorially, and that would be my
+ preference if Pete feels this is appropriate. Failing that, I really
+ think this issue should be accepted and moved to ready. The other
+-begin/end functions all have a semantic definition for this template,
++begin&#47;end functions all have a semantic definition for this template,
+ and it is confusing if a small few are missing.
+ </p>
+
+ <p>
+ I agree that an alternative would be to strike <em>all</em> the definitions for
+-<tt>begin/end/rbegin/rend</tt> and defer completely to the requirements tables in
++<tt>begin&#47;end&#47;rbegin&#47;rend</tt> and defer completely to the requirements tables in
+ clause 23. I think that might be confusing without a forward reference
+-though, as those tables are defined in a *later* clause than the
+-basic_string template itself. If someone wants to pursue this I would
++though, as those tables are defined in a <em>later</em> clause than the
++<tt>basic_string</tt> template itself. If someone wants to pursue this I would
+ support it, but recommend it as a separate issue.
+ </p>
+
+@@ -67679,10 +74689,10 @@ preference for NAD Editorial if Pete is happy to make these changes.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib. Removed
+ rationale to mark it NAD. :-)
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -67691,28 +74701,32 @@ rationale to mark it NAD. :-)
+ Add to 21.4.3 [string.iterators]
+ </p>
+
+-<blockquote><pre>iterator begin();
++<blockquote><pre>
++iterator begin();
+ const_iterator begin() const;
+ <ins>const_iterator cbegin() const;</ins>
+ </pre>
+
+ <p>...</p>
+
+-<pre>iterator end();
++<pre>
++iterator end();
+ const_iterator end() const;
+ <ins>const_iterator cend() const;</ins>
+ </pre>
+
+ <p>...</p>
+
+-<pre>reverse_iterator rbegin();
++<pre>
++reverse_iterator rbegin();
+ const_reverse_iterator rbegin() const;
+ <ins>const_reverse_iterator crbegin() const;</ins>
+ </pre>
+
+ <p>...</p>
+
+-<pre>reverse_iterator rend();
++<pre>
++reverse_iterator rend();
+ const_reverse_iterator rend() const;
+ <ins>const_reverse_iterator crend() const;</ins>
+ </pre>
+@@ -67724,19 +74738,18 @@ const_reverse_iterator rend() const;
+
+
+ <hr>
+-<h3><a name="1193"></a>1193. <tt>default_delete</tt> cannot be instantiated with incomplete types</h3>
+-<p><b>Section:</b> 20.9.9.1 [unique.ptr.dltr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1193"></a>1193. <tt>default_delete</tt> cannot be instantiated with incomplete types</h3>
++<p><b>Section:</b> 20.8.1.1 [unique.ptr.dltr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-According to the general rules of 17.6.3.8 [res.on.functions]/2 b 5 the effects
++According to the general rules of 17.6.4.8 [res.on.functions] p 2 b 5 the effects
+ are undefined, if an incomplete type is used to instantiate a library template. But neither in
+-20.9.9.1 [unique.ptr.dltr] nor
++20.8.1.1 [unique.ptr.dltr] nor
+ in any other place of the standard such explicit allowance is given.
+ Since this template is intended to be instantiated with incomplete
+-types, this must
+-be fixed.
++types, this must be fixed.
+ </p>
+
+ <p><i>[
+@@ -67751,23 +74764,23 @@ be fixed.
+
+ <blockquote>
+ <p>
+-LWG 1193 tries to support unique_ptr for incomplete types. I believe the
++LWG 1193 tries to support <tt>unique_ptr</tt> for incomplete types. I believe the
+ proposed wording goes too far:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The template parameter <tt>T</tt> of <tt>default_delete</tt> may be an
+ incomplete type.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Do we really want to support <tt>cv-void</tt>? Suggested ammendment:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The template parameter <tt>T</tt> of <tt>default_delete</tt> may be an
+ incomplete type <ins>other than <tt>cv-void</tt></ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ We might also consider saying something about arrays of incomplete types.
+@@ -67801,8 +74814,8 @@ too.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add two new paragraphs directly to 20.9.9.1 [unique.ptr.dltr] (before
+-20.9.9.1.2 [unique.ptr.dltr.dflt]) with the following
++Add two new paragraphs directly to 20.8.1.1 [unique.ptr.dltr] (before
++20.8.1.1.2 [unique.ptr.dltr.dflt]) with the following
+ content:
+ </p>
+
+@@ -67823,23 +74836,25 @@ The template parameter <tt>T</tt> of <tt>default_delete</tt> may be an incomplet
+
+ <hr>
+ <h3><a name="1194"></a>1194. Unintended <tt>queue</tt> constructor</h3>
+-<p><b>Section:</b> 23.5 [container.adaptors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-08-20 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-08-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-23.5.1.1 [queue.defn] has the following <tt>queue</tt> constructor:
++23.6.3.1 [queue.defn] has the following <tt>queue</tt> constructor:
+ </p>
+
+-<blockquote><pre>template &lt;class Alloc&gt; explicit queue(const Alloc&amp;);
++<blockquote><pre>
++template &lt;class Alloc&gt; explicit queue(const Alloc&amp;);
+ </pre></blockquote>
+
+ <p>
+ This will be implemented like so:
+ </p>
+
+-<blockquote><pre>template &lt;class Alloc&gt; explicit queue(const Alloc&amp; a) : c(a) {}
++<blockquote><pre>
++template &lt;class Alloc&gt; explicit queue(const Alloc&amp; a) : c(a) {}
+ </pre></blockquote>
+
+ <p>
+@@ -67847,7 +74862,8 @@ The issue is that <tt>Alloc</tt> can be anything that a container will construct
+ from, for example an <tt>int</tt>. Is this intended to compile?
+ </p>
+
+-<blockquote><pre>queue&lt;int&gt; q(5);
++<blockquote><pre>
++queue&lt;int&gt; q(5);
+ </pre></blockquote>
+
+ <p>
+@@ -67873,9 +74889,9 @@ Daniel, Howard and Pablo collaborated on the proposed wording.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -67884,8 +74900,8 @@ Move to Ready.
+ <p><i>[
+ This resolution includes a semi-editorial clean up, giving definitions to members
+ which in some cases weren't defined since C++98.
+-This resolution also offers editorially different wording for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#976">976</a>,
+-and it also provides wording for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1196">1196</a>.
++This resolution also offers editorially different wording for <a href="lwg-defects.html#976">976</a>,
++and it also provides wording for <a href="lwg-defects.html#1196">1196</a>.
+ ]</i></p>
+
+
+@@ -67893,7 +74909,7 @@ and it also provides wording for <a href="http://www.open-std.org/jtc1/sc22/wg21
+ Change container.adaptors, p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The container adaptors each take a <tt>Container</tt> template parameter, and
+ each constructor takes a <tt>Container</tt> reference argument. This container is
+ copied into the <tt>Container</tt> member of each adaptor. If the container takes
+@@ -67903,14 +74919,15 @@ used for the container argument. <del>[<i>Note:</i> it is not necessary for an
+ implementation to distinguish between the one-argument constructor that
+ takes a <tt>Container</tt> and the one- argument constructor that takes an
+ allocator_type. Both forms use their argument to construct an instance
+-of the container. — <i>end note</i>]</del>
+-</blockquote>
++of the container. &mdash; <i>end note</i>]</del>
++</p></blockquote>
+
+ <p>
+ Change queue.defn, p1:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class queue {
+ public:
+ typedef typename Container::value_type value_type;
+@@ -67937,13 +74954,14 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Add a new section after 23.5.1.1 [queue.defn], [queue.cons]:
++Add a new section after 23.6.3.1 [queue.defn], [queue.cons]:
+ </p>
+
+ <blockquote>
+ <p><b><tt>queue</tt> constructors [queue.cons]</b></p>
+
+-<pre>explicit queue(const Container&amp; cont);
++<pre>
++explicit queue(const Container&amp; cont);
+ </pre>
+
+ <blockquote>
+@@ -67954,7 +74972,8 @@ Add a new section after 23.5.1.1 [queue.defn], [queue.cons]:
+
+ </blockquote>
+
+-<pre>explicit queue(Container&amp;&amp; cont = Container());
++<pre>
++explicit queue(Container&amp;&amp; cont = Container());
+ </pre>
+
+ <blockquote>
+@@ -67965,7 +74984,8 @@ Add a new section after 23.5.1.1 [queue.defn], [queue.cons]:
+
+ </blockquote>
+
+-<pre>queue(queue&amp;&amp; q)
++<pre>
++queue(queue&amp;&amp; q)
+ </pre>
+
+ <blockquote>
+@@ -67982,7 +75002,8 @@ if <tt>uses_allocator&lt;container_type, Alloc&gt;::value</tt> is <tt>false</tt>
+ then the constructor shall not participate in overload resolution.
+ </p>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ explicit queue(const Alloc&amp; a);
+ </pre>
+
+@@ -67994,7 +75015,8 @@ then the constructor shall not participate in overload resolution.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ queue(const container_type&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68007,7 +75029,8 @@ argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ queue(container_type&amp;&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68020,7 +75043,8 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ queue(queue&amp;&amp; q, const Alloc&amp; a);
+ </pre>
+
+@@ -68033,7 +75057,8 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>queue&amp; operator=(queue&amp;&amp; q);
++<pre>
++queue&amp; operator=(queue&amp;&amp; q);
+ </pre>
+
+ <blockquote>
+@@ -68053,12 +75078,13 @@ first argument and <tt>a</tt> as the second argument.
+ </blockquote>
+
+ <p>
+-Add to 23.5.2.1 [priqueue.cons]:
++Add to 23.6.4.1 [priqueue.cons]:
+ </p>
+
+ <blockquote>
+
+-<pre>priority_queue(priority_queue&amp;&amp; q);
++<pre>
++priority_queue(priority_queue&amp;&amp; q);
+ </pre>
+
+ <blockquote>
+@@ -68076,7 +75102,8 @@ if <tt>uses_allocator&lt;container_type, Alloc&gt;::value</tt> is <tt>false</tt>
+ then the constructor shall not participate in overload resolution.
+ </p>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ explicit priority_queue(const Alloc&amp; a);
+ </pre>
+
+@@ -68088,7 +75115,8 @@ then the constructor shall not participate in overload resolution.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ priority_queue(const Compare&amp; compare, const Alloc&amp; a);
+ </pre>
+
+@@ -68101,7 +75129,8 @@ with <tt>compare</tt>.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ priority_queue(const Compare&amp; compare, const Container&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68115,7 +75144,8 @@ and initializes <tt>comp</tt> with <tt>compare</tt>.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ priority_queue(const Compare&amp; compare, Container&amp;&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68129,7 +75159,8 @@ and initializes <tt>comp</tt> with <tt>compare</tt>.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ priority_queue(priority_queue&amp;&amp; q, const Alloc&amp; a);
+ </pre>
+
+@@ -68143,7 +75174,8 @@ and initializes <tt>comp</tt> with <tt>std::move(q.comp)</tt>.
+
+ </blockquote>
+
+-<pre>priority_queue&amp; operator=(priority_queue&amp;&amp; q);
++<pre>
++priority_queue&amp; operator=(priority_queue&amp;&amp; q);
+ </pre>
+
+ <blockquote>
+@@ -68165,10 +75197,11 @@ assigns <tt>comp</tt> with <tt>std::move(q.comp)</tt>.
+
+
+ <p>
+-Change 23.5.3.1 [stack.defn]:
++Change 23.6.5.2 [stack.defn]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class stack {
+ public:
+ typedef typename Container::value_type value_type;
+@@ -68195,13 +75228,14 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Add a new section after 23.5.3.1 [stack.defn], [stack.cons]:
++Add a new section after 23.6.5.2 [stack.defn], [stack.cons]:
+ </p>
+
+ <blockquote>
+ <p><b><tt>stack</tt> constructors [stack.cons]</b></p>
+
+-<pre>stack(stack&amp;&amp; s);
++<pre>
++stack(stack&amp;&amp; s);
+ </pre>
+
+ <blockquote>
+@@ -68218,7 +75252,8 @@ if <tt>uses_allocator&lt;container_type, Alloc&gt;::value</tt> is <tt>false</tt>
+ then the constructor shall not participate in overload resolution.
+ </p>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ explicit stack(const Alloc&amp; a);
+ </pre>
+
+@@ -68230,7 +75265,8 @@ then the constructor shall not participate in overload resolution.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ stack(const container_type&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68243,7 +75279,8 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ stack(container_type&amp;&amp; cont, const Alloc&amp; a);
+ </pre>
+
+@@ -68256,7 +75293,8 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ stack(stack&amp;&amp; s, const Alloc&amp; a);
+ </pre>
+
+@@ -68269,7 +75307,8 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<pre>stack&amp; operator=(stack&amp;&amp; s);
++<pre>
++stack&amp; operator=(stack&amp;&amp; s);
+ </pre>
+
+ <blockquote>
+@@ -68293,50 +75332,50 @@ first argument and <tt>a</tt> as the second argument.
+
+ <hr>
+ <h3><a name="1195"></a>1195. "Diagnostic required" wording is insufficient to prevent UB</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Several parts of the library use the notion of "Diagnostic required"
+ to indicate that
+ in the corresponding situation an error diagnostic should occur, e.g.
+-20.9.9.1.2 [unique.ptr.dltr.dflt]/2
++20.8.1.1.2 [unique.ptr.dltr.dflt]/2
+ </p>
+-<blockquote><pre>void operator()(T *ptr) const;
++<blockquote><pre>
++void operator()(T *ptr) const;
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> calls <tt>delete</tt> on <tt>ptr</tt>. A diagnostic is required if <tt>T</tt> is an
+ incomplete type.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ The problem with this approach is that such a requirement is
+-insufficient to prevent
+-undefined behavior, if this situation occurs. According to 1.3.6 [defns.diagnostic]
++insufficient to prevent undefined behavior, if this situation occurs.
++According to 1.3 [defns.diagnostic]
+ a <i>diagnostic message</i> is defined as
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ a message belonging to an implementation-defined subset of the
+ implementation's output messages.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ which doesn't indicate any relation to an ill-formed program. In fact,
+-"compiler warnings"
+-are a typical expression of such diagnostics. This means that above
+-wording can be interpreted
+-by compiler writers that they satisfy the requirements of the standard
+-if they just produce
+-such a "warning", if the compiler happens to compile code like this:
++"compiler warnings" are a typical expression of such diagnostics. This means
++that above wording can be interpreted by compiler writers that they satisfy
++the requirements of the standard if they just produce such a "warning", if
++the compiler happens to compile code like this:
+ </p>
+
+-<blockquote><pre>#include &lt;memory&gt;
++<blockquote><pre>
++#include &lt;memory&gt;
+
+ struct Ukn; // defined somewhere else
+ Ukn* create_ukn(); // defined somewhere else
+@@ -68373,10 +75412,11 @@ Move to NAD.
+ </p>
+ <p>
+ It's not clear that there's any important difference between
+-"ill-formed" and "diagnostic required". From 1.4 [intro.compliance], 1.3.9 [defns.ill.formed], and 1.3.26 [defns.well.formed] it appears that an ill-formed program is one
+-that is not correctly constructed according to the syntax rules and
+-diagnosable semantic rules, which means that... "a conforming
+-implementation shall issue at least one diagnostic message." The
++"ill-formed" and "diagnostic required". From 1.4 [intro.compliance],
++1.3 [defns.ill.formed], and 1.3 [defns.well.formed]
++it appears that an ill-formed program is one that is not correctly constructed
++according to the syntax rules and diagnosable semantic rules, which means
++that... "a conforming implementation shall issue at least one diagnostic message." The
+ author's intent seems to be that we should be requiring a fatal error
+ instead of a mere warning, but the standard just doesn't have language
+ to express that distinction. The strongest thing we can ever require is
+@@ -68393,10 +75433,10 @@ that the WP already says, but such a rewording is editorial.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Considered again. Group disagrees that the change is technical, but likes
+ it editorially. Moved to NAD Editorial.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-19: Moved from NAD Editorial to Open. Please see the thread starting
+@@ -68423,18 +75463,18 @@ any violation would make the program ill-formed. As an example, the currently
+ existing phrase 20.4.2.5 [tuple.helper]/1
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <tt>I &lt; sizeof...(Types)</tt>. The program is ill-formed if
+ <tt>I</tt> is out of bounds.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ could then be written as
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Static constraints:</i> <tt>I &lt; sizeof...(Types)</tt>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -68454,20 +75494,20 @@ could then be written as
+ <ol>
+ <li>
+ <p>
+-Change 20.6 [ratio]/2 as indicated:
++Change 20.11 [ratio]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Throughout this subclause, <ins>if</ins> the template argument types <tt>R1</tt>
+ and <tt>R2</tt> <del>shall be</del> <ins>are not</ins> specializations of the
+ <tt>ratio</tt> template<ins>, the program is ill-formed</ins>. <del>Diagnostic
+ required.</del>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.6.1 [ratio.ratio]/1 as indicated:
++Change 20.11.3 [ratio.ratio]/1 as indicated:
+ </p>
+
+ <p>
+@@ -68482,33 +75522,33 @@ ill-formed</ins>. <del>Diagnostic required.</del> [..]
+
+ <li>
+ <p>
+-Change 20.6.2 [ratio.arithmetic]/1 as indicated:
++Change 20.11.4 [ratio.arithmetic]/1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Implementations may use other algorithms to compute these values. If overflow
+ occurs, <ins>the program is ill-formed</ins> <del>a diagnostic shall be
+ issued</del>.
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-Change 20.6.3 [ratio.comparison]/2 as indicated:
++Change 20.11.5 [ratio.comparison]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [...] Implementations may use other algorithms to compute this relationship to
+ avoid overflow. If overflow occurs, <ins>the program is ill-formed</ins> <del>a
+ diagnostic is required</del>.
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.1.2 [unique.ptr.dltr.dflt]/2 as indicated:
++Change 20.8.1.1.2 [unique.ptr.dltr.dflt]/2 as indicated:
+ </p>
+
+ <blockquote>
+@@ -68527,10 +75567,11 @@ ill-formed.</ins>
+
+ <li>
+ <p>
+-Change 20.9.9.1.3 [unique.ptr.dltr.dflt1]/1 as indicated:
++Change 20.8.1.1.3 [unique.ptr.dltr.dflt1]/1 as indicated:
+ </p>
+
+-<blockquote><pre>void operator()(T* ptr) const;
++<blockquote><pre>
++void operator()(T* ptr) const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -68549,17 +75590,17 @@ ill-formed.</ins>
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor] as indicated: <i>[Note: This
+-editorially improves the currently suggested wording of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a> by
++Change 20.8.1.2.1 [unique.ptr.single.ctor] as indicated: <i>[Note: This
++editorially improves the currently suggested wording of <a href="lwg-defects.html#932">932</a> by
+ replacing</i>
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>"shall be ill-formed" by "is ill-formed"]</i>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ <i>[If
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3025.html">N3025</a>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3025.html">N3025</a>
+ is accepted this bullet is applied identically in that paper as well.]</i>
+ </p>
+
+@@ -68583,21 +75624,22 @@ ill-formed.
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/8 as indicated: <i>[Note: This
+-editorially improves the currently suggested wording of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#932">932</a> by
++Change 20.8.1.2.1 [unique.ptr.single.ctor]/8 as indicated: <i>[Note: This
++editorially improves the currently suggested wording of <a href="lwg-defects.html#932">932</a> by
+ replacing</i>
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>"shall be ill-formed" by "is ill-formed"]</i>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ <i>[If
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3025.html">N3025</a>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3025.html">N3025</a>
+ is accepted this bullet is applied identically in that paper as well.]</i>
+ </p>
+
+-<blockquote><pre>unique_ptr(pointer p);
++<blockquote><pre>
++unique_ptr(pointer p);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -68613,27 +75655,27 @@ ill-formed.
+
+ <li>
+ <p>
+-Change 20.9.9.2.1 [unique.ptr.single.ctor]/13 as indicated:
++Change 20.8.1.2.1 [unique.ptr.single.ctor]/13 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [..] If <tt>d</tt> is an rvalue, it will bind to the second constructor of this
+ pair <ins>and the program is ill-formed</ins>. <del>That constructor shall emit
+ a diagnostic.</del> [<i>Note:</i> The diagnostic could be implemented using a
+ <tt>static_assert</tt> which assures that <tt>D</tt> is not a reference type.
+-— <i>end note</i>] Else <tt>d</tt> is an lvalue and will bind to the first
++&mdash; <i>end note</i>] Else <tt>d</tt> is an lvalue and will bind to the first
+ constructor of this pair. [..]
+-</blockquote>
++</p></blockquote>
+
+ </li>
+
+ <li>
+-20.9.9.2.1 [unique.ptr.single.ctor]/20: Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#950">950</a>.
++20.8.1.2.1 [unique.ptr.single.ctor]/20: Solved by <a href="lwg-defects.html#950">950</a>.
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9.3 [unique.ptr.runtime]/1 as indicated:
++Change 20.8.1.3 [unique.ptr.runtime]/1 as indicated:
+ </p>
+
+ <blockquote>
+@@ -68654,7 +75696,7 @@ required)</del> <ins>produce an ill-formed program</ins>.
+
+ <li>
+ <p>
+-Change 20.11.3 [time.duration]/2-4 as indicated:
++Change 20.12.5 [time.duration]/2-4 as indicated:
+ </p>
+
+ <blockquote>
+@@ -68687,34 +75729,34 @@ positive, <del>diagnostic required</del> <ins>the program is ill-formed</ins>.
+ </li>
+
+ <li>
+-20.11.3.1 [time.duration.cons]/1+4: Apply <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>
++20.12.5.1 [time.duration.cons]/1+4: Apply <a href="lwg-defects.html#1177">1177</a>
+ </li>
+
+ <li>
+-20.11.3.5 [time.duration.nonmember]/4+6+8+11: Apply <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>
++20.12.5.5 [time.duration.nonmember]/4+6+8+11: Apply <a href="lwg-defects.html#1177">1177</a>
+ </li>
+
+ <li>
+-20.11.3.7 [time.duration.cast]/1: Apply <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>
++20.12.5.7 [time.duration.cast]/1: Apply <a href="lwg-defects.html#1177">1177</a>
+ </li>
+
+ <li>
+ <p>
+-Change 20.11.4 [time.point]/2 as indicated:
++Change 20.12.6 [time.point]/2 as indicated:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <ins>If</ins> <tt>Duration</tt> <del>shall be</del> <ins>is not</ins> an
+ instance of <tt>duration</tt><ins>, the program is ill-formed</ins>.
+ <del>Diagnostic required.</del>
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+-20.11.4.1 [time.point.cons]/3: Apply <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>
++20.12.6.1 [time.point.cons]/3: Apply <a href="lwg-defects.html#1177">1177</a>
+ </li>
+
+ <li>
+-20.11.4.7 [time.point.cast]/1: Apply <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1177">1177</a>
++20.12.6.7 [time.point.cast]/1: Apply <a href="lwg-defects.html#1177">1177</a>
+ </li>
+
+ </ol>
+@@ -68725,12 +75767,52 @@ instance of <tt>duration</tt><ins>, the program is ill-formed</ins>.
+
+
+ <hr>
++<h3><a name="1196"></a>1196. move semantics undefined for priority_queue</h3>
++<p><b>Section:</b> 23.6.4.1 [priqueue.cons] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-08-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The class template <tt>priority_queue</tt> declares signatures for a move
++constructor and move assignment operator in its class definition.
++However, it does not provide a definition (unlike <tt>std::queue</tt>, and
++proposed resolution for <tt>std::stack</tt>.) Nor does it provide a text clause
++specifying their behaviour.
++</p>
++
++<p><i>[
++2009-08-23 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++<a href="lwg-defects.html#1194">1194</a> provides wording that solves this issue.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Mark <del>NAD Editorial</del><ins>Resolved</ins>, solved by issue <a href="lwg-defects.html#1194">1194</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1197"></a>1197. Can unordered containers have <tt>bucket_count() == 0</tt>?</h3>
+-<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-08-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.req">issues</a> in [unord.req].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-08-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Table 97 "Unordered associative container requirements" in
+@@ -68739,10 +75821,10 @@ Table 97 "Unordered associative container requirements" in
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 97 — Unordered associative container requirements
++<caption>Table 97 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Assertion/note pre-/post-condition</th>
+@@ -68761,7 +75843,7 @@ b.bucket_count())</tt>.</td>
+ <td>Constant</td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -68828,7 +75910,8 @@ and consistent, it has exactly the same role as a past-the-end
+ iterator value. A typical use-case is:
+ </p>
+
+-<blockquote><pre>size_type pos = m.bucket(key);
++<blockquote><pre>
++size_type pos = m.bucket(key);
+ if (pos != m.bucket_count()) {
+ ...
+ } else {
+@@ -68836,7 +75919,7 @@ if (pos != m.bucket_count()) {
+ }
+ </pre></blockquote>
+
+-<p>— end Rationale]</p>
++<p>&mdash; end Rationale]</p>
+
+ <p>
+ - Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column "Assertion/..."):
+@@ -68844,10 +75927,10 @@ if (pos != m.bucket_count()) {
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 97 — Unordered associative container requirements
++<caption>Table 97 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Assertion/note pre-/post-condition</th>
+@@ -68866,7 +75949,7 @@ b.bucket_count())</tt><ins>, otherwise 0</ins>.</td>
+ <td>Constant</td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ </blockquote>
+@@ -68890,10 +75973,10 @@ Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 97 — Unordered associative container requirements
++<caption>Table 97 &mdash; Unordered associative container requirements
+ (in addition to container)</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Assertion/note pre-/post-condition</th>
+@@ -68910,7 +75993,7 @@ b.bucket_count())</tt>.</td>
+ <td>Constant</td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+
+@@ -68920,27 +76003,29 @@ b.bucket_count())</tt>.</td>
+
+ <hr>
+ <h3><a name="1198"></a>1198. Container adaptor swap: member or non-member?</h3>
+-<p><b>Section:</b> 23.5 [container.adaptors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-08-26 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-08-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Under 23.5 [container.adaptors] of
++Under 23.6 [container.adaptors] of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>
+ the member function of <tt>swap</tt> of <tt>queue</tt> and <tt>stack</tt> call:
+ </p>
+
+-<blockquote><pre>swap(c, q.c);
++<blockquote><pre>
++swap(c, q.c);
+ </pre></blockquote>
+
+ <p>
+-But under 23.5 [container.adaptors] of
++But under 23.6 [container.adaptors] of
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2723.pdf">N2723</a>
+ these members are specified to call:
+ </p>
+
+-<blockquote><pre>c.swap(q.c);
++<blockquote><pre>
++c.swap(q.c);
+ </pre></blockquote>
+
+ <p>
+@@ -68965,12 +76050,12 @@ should use the container's namespace scope <tt>swap</tt>.
+ ]</i></p>
+
+
+-<blockquote>
+-The outcome of this issue should be considered with the outcome of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a> both in style and in content (e.g. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#774">774</a> bullet 9
++<blockquote><p>
++The outcome of this issue should be considered with the outcome of <a href="lwg-defects.html#774">774</a> both in style and in content (e.g. <a href="lwg-defects.html#774">774</a> bullet 9
+ suggests to define the semantic of <tt>void
+ priority_queue::swap(priority_queue&amp;)</tt> in terms of the member
+ <tt>swap</tt> of the container).
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-28 Daniel update to diff against N3092.
+@@ -68983,11 +76068,11 @@ priority_queue::swap(priority_queue&amp;)</tt> in terms of the member
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Preference to move the wording into normative text, rather than inline function definitions in the class synopsis.
+
+ Move to Tenatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -68999,10 +76084,11 @@ Adopted at 2010-11 Batavia
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Change 23.5.1.1 [queue.defn]:
++Change 23.6.3.1 [queue.defn]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class queue {
+ ...
+ void swap(queue&amp; q) { <ins>using std::swap;</ins>
+@@ -69012,10 +76098,11 @@ class queue {
+ </pre></blockquote>
+
+ <p>
+-Change 23.5.2 [priority.queue]:
++Change 23.6.4 [priority.queue]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = vector&lt;T&gt;,
++<blockquote><pre>
++template &lt;class T, class Container = vector&lt;T&gt;,
+ class Compare = less&lt;typename Container::value_type&gt; &gt;
+ class priority_queue {
+ ...
+@@ -69027,10 +76114,11 @@ class priority_queue {
+ </pre></blockquote>
+
+ <p>
+-Change 23.5.3.1 [stack.defn]:
++Change 23.6.5.2 [stack.defn]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class stack {
+ ...
+ void swap(stack&amp; s) { <ins>using std::swap;</ins>
+@@ -69046,16 +76134,17 @@ class stack {
+
+ <hr>
+ <h3><a name="1199"></a>1199. Missing extended copy constructor in container adaptors</h3>
+-<p><b>Section:</b> 23.5 [container.adaptors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-08-26 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-08-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>queue</tt> has a constructor:
+ </p>
+
+-<blockquote><pre>template &lt;class Alloc&gt;
++<blockquote><pre>
++template &lt;class Alloc&gt;
+ queue(queue&amp;&amp;, const Alloc&amp;);
+ </pre></blockquote>
+
+@@ -69063,7 +76152,8 @@ class stack {
+ but it is missing a corresponding constructor:
+ </p>
+
+-<blockquote><pre>template &lt;class Alloc&gt;
++<blockquote><pre>
++template &lt;class Alloc&gt;
+ queue(const queue&amp;, const Alloc&amp;);
+ </pre></blockquote>
+
+@@ -69083,13 +76173,14 @@ user of a container adaptor can always specify the allocator for his adaptor.
+ <p><b>Proposed resolution:</b></p>
+ <p><i>[
+ This resolution has been harmonized with the proposed resolution to issue
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>
++<a href="lwg-defects.html#1194">1194</a>
+ ]</i></p>
+
+
+-<p>Change 23.5.1.1 [queue.defn], p1:</p>
++<p>Change 23.6.3.1 [queue.defn], p1:</p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class queue {
+ public:
+ typedef typename Container::value_type value_type;
+@@ -69118,13 +76209,14 @@ public:
+ </pre></blockquote>
+
+ <p>
+-To the new section 23.5.1.2 [queue.cons], introduced
+-in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, add:
++To the new section 23.6.3.2 [queue.cons], introduced
++in <a href="lwg-defects.html#1194">1194</a>, add:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ queue(const queue&amp; q, const Alloc&amp; a);
+ </pre>
+
+@@ -69135,10 +76227,11 @@ first argument and <tt>a</tt> as the second argument.
+
+ </blockquote>
+
+-<p>Change 23.5.2 [priority.queue] as follows (I've an included an editorial change to
++<p>Change 23.6.4 [priority.queue] as follows (I've an included an editorial change to
+ move the poorly-placed move-assignment operator):</p>
+
+-<blockquote><pre>template &lt;class T, class Container = vector&lt;T&gt;,
++<blockquote><pre>
++template &lt;class T, class Container = vector&lt;T&gt;,
+ class Compare = less&lt;typename Container::value_type&gt; &gt;
+ class priority_queue {
+ public:
+@@ -69177,12 +76270,13 @@ public:
+ </pre></blockquote>
+
+ <p>
+-Add to 23.5.2.1 [priqueue.cons]:
++Add to 23.6.4.1 [priqueue.cons]:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ priority_queue(const priority_queue&amp; q, const Alloc&amp; a);
+ </pre>
+
+@@ -69195,10 +76289,11 @@ and initializes <tt>comp</tt> with <tt>q.comp</tt>.
+ </blockquote>
+
+ <p>
+-Change 23.5.3.1 [stack.defn]:
++Change 23.6.5.2 [stack.defn]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class Container = deque&lt;T&gt; &gt;
++<blockquote><pre>
++template &lt;class T, class Container = deque&lt;T&gt; &gt;
+ class stack {
+ public:
+ typedef typename Container::value_type value_type;
+@@ -69227,13 +76322,14 @@ public:
+ </pre></blockquote>
+
+ <p>
+-To the new section 23.5.3.2 [stack.cons], introduced
+-in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a>, add:
++To the new section 23.6.5.3 [stack.cons], introduced
++in <a href="lwg-defects.html#1194">1194</a>, add:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class Alloc&gt;
++<pre>
++template &lt;class Alloc&gt;
+ stack(const stack&amp; s, const Alloc&amp; a);
+ </pre>
+
+@@ -69250,10 +76346,10 @@ first argument and <tt>a</tt> as the second argument.
+
+ <hr>
+ <h3><a name="1204"></a>1204. Global permission to move</h3>
+-<p><b>Section:</b> 17.6.3.9 [res.on.arguments] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.arguments">issues</a> in [res.on.arguments].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.4.9 [res.on.arguments] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.arguments">issues</a> in [res.on.arguments].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ When a library function binds an rvalue reference parameter to an argument, the
+@@ -69263,12 +76359,13 @@ able to modify that argument without concern that such modifications will corrup
+ the logic of the calling code. For example:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class A&gt;
++<blockquote><pre>
++template &lt;class T, class A&gt;
+ void
+ vector&lt;T, A&gt;::push_back(value_type&amp;&amp; v)
+ {
+- <font color="#C80000">// This function should move from v, potentially modifying</font>
+- <font color="#C80000">// the object v is bound to.</font>
++ <span style="color:#C80000">// This function should move from v, potentially modifying</span>
++ <span style="color:#C80000">// the object v is bound to.</span>
+ }
+ </pre></blockquote>
+
+@@ -69285,13 +76382,13 @@ the logic of his program after this statement. I.e. the client is making a stat
+ that <tt>push_back</tt> may treat <tt>x</tt> as a temporary.
+ </p>
+
+-<blockquote><em>
++<blockquote><p><em>
+ The above statement is the very foundation upon which move semantics is based.
+-</em></blockquote>
++</em></p></blockquote>
+
+ <p>
+ The standard is currently lacking a global statement to this effect. I propose
+-the following addition to 17.6.3.9 [res.on.arguments]:
++the following addition to 17.6.4.9 [res.on.arguments]:
+ </p>
+
+ <blockquote>
+@@ -69324,7 +76421,7 @@ a library function (e.g. <tt>move(x)</tt>), then the program is effectively
+ asking the library to treat that lvalue as a temporary. The library is at
+ liberty to optimize away aliasing checks which might be needed if the argument
+ were an lvalue.
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </ins></li>
+ </ul>
+
+@@ -69332,14 +76429,14 @@ were an lvalue.
+
+ <p>
+ Such a global statement will eliminate the need for piecemeal statements such as
+-23.2.1 [container.requirements.general]/13:
++23.2.1 [container.requirements.general]&#47;13:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ An object bound to an rvalue reference parameter of a member function of
+ a container shall not be an element of that container; no diagnostic
+ required.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Additionally this clarifies that move assignment operators need not perform the
+@@ -69352,25 +76449,25 @@ copy assignment operators.
+ ]</i></p>
+
+
+-<blockquote>
+-Note: This resolution supports the change of 27.9.1.3 [filebuf.assign]/1,
+-proposed by LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#900">900</a>.
+-</blockquote>
++<blockquote><p>
++Note: This resolution supports the change of 27.9.1.3 [filebuf.assign]&#47;1,
++proposed by LWG <a href="lwg-defects.html#900">900</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2009 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a bullet to 17.6.3.9 [res.on.arguments]:
++Add a bullet to 17.6.4.9 [res.on.arguments]:
+ </p>
+
+ <blockquote>
+@@ -69403,20 +76500,20 @@ a library function (e.g. <tt>move(x)</tt>), then the program is effectively
+ asking the library to treat that lvalue as a temporary. The library is at
+ liberty to optimize away aliasing checks which might be needed if the argument
+ were an lvalue.
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </ins></li>
+ </ul>
+ </blockquote>
+
+ <p>
+-Delete 23.2.1 [container.requirements.general]/13:
++Delete 23.2.1 [container.requirements.general]&#47;13:
+ </p>
+
+-<blockquote><del>
++<blockquote><p><del>
+ An object bound to an rvalue reference parameter of a member function of
+ a container shall not be an element of that container; no diagnostic
+ required.
+-</del></blockquote>
++</del></p></blockquote>
+
+
+
+@@ -69425,10 +76522,11 @@ required.
+
+ <hr>
+ <h3><a name="1205"></a>1205. Some algorithms could more clearly document their handling of empty ranges</h3>
+-<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#algorithms">issues</a> in [algorithms].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25 [algorithms] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#algorithms">active issues</a> in [algorithms].</p>
++<p><b>View all other</b> <a href="lwg-index.html#algorithms">issues</a> in [algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There are a number of algorithms whose result might depend on the
+@@ -69441,10 +76539,10 @@ rather than require some subtle intuition of the supplied wording.
+ 25.2.1 [alg.all_of]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>true</tt> if <tt>pred(*i)</tt> is <tt>true</tt> for every
+ iterator <tt>i</tt> in the range <tt>[first,last)</tt>, ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ What does this mean if the range is empty?
+@@ -69459,19 +76557,19 @@ non-normative note to clarify:
+ Add to p1 25.2.1 [alg.all_of]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.2.3 [alg.none_of]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>true</tt> if <tt>pred(*i)</tt> is <tt>false</tt> for every
+ iterator <tt>i</tt> in the range <tt>[first,last)</tt>, ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ What does this mean if the range empty?
+@@ -69486,10 +76584,10 @@ non-normative note to clarify:
+ Add to p1 25.2.3 [alg.none_of]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.2.2 [alg.any_of]
+@@ -69505,10 +76603,10 @@ for <tt>all_of</tt>/<tt>none_of</tt> algorithms.
+ Add to p1 25.2.2 [alg.any_of]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>false</tt> if <tt>[first,last)</tt> is empty.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.2.6 [alg.find.end]
+@@ -69533,10 +76631,10 @@ My proposed wording is a note to clarify the current semantic:
+ Add to p2 25.2.6 [alg.find.end]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is
+-empty. — <i>end note</i>]
+-</blockquote>
++empty. &mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ I would prefer a normative wording treating empty ranges specially, but
+@@ -69550,9 +76648,9 @@ Alternative wording: (NOT a note)
+ <p>
+ Add to p2 25.2.6 [alg.find.end]:
+ </p>
+-<blockquote>
++<blockquote><p>
+ Returns <tt>first1</tt> if <tt>[first2,last2)</tt> is empty.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ 25.2.7 [alg.find.first.of]
+@@ -69566,10 +76664,10 @@ note to confirm the reader's understanding might still help.
+ <p>
+ Add to p2 25.2.7 [alg.find.first.of]
+ </p>
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is
+-empty. — <i>end note</i>]
+-</blockquote>
++empty. &mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.2.13 [alg.search]
+@@ -69594,10 +76692,10 @@ My proposed wording is a note to clarify the current semantic:
+ Add to p2 25.2.13 [alg.search]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is
+-empty. — <i>end note</i>]
+-</blockquote>
++empty. &mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ Again, I would prefer a normative wording treating empty ranges
+@@ -69612,9 +76710,9 @@ Alternative wording: (NOT a note)
+ Add to p2 25.2.13 [alg.search]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Returns <tt>first1</tt> if <tt>[first2,last2)</tt> is empty.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ 25.3.13 [alg.partitions]
+@@ -69632,20 +76730,20 @@ Proposed wording:
+ Add to p1 25.3.13 [alg.partitions]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.4.5.1 [includes]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>true</tt> if every element in the range
+ <tt>[first2,last2)</tt> is contained in the range
+ <tt>[first1,last1)</tt>. ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ I really don't know what this means if <tt>[first2,last2)</tt> is empty.
+@@ -69657,10 +76755,10 @@ my proposed wording is to clarify exactly that:
+ Add to p1 25.4.5.1 [includes]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> Returns <tt>true</tt> if <tt>[first2,last2)</tt> is empty.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p>
+ 25.4.6.2 [pop.heap]
+@@ -69679,10 +76777,10 @@ Proposed wording:
+ Revise p2 25.4.6.2 [pop.heap]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The range <tt>[first,last)</tt> shall be a valid
+ <ins>non-empty</ins> heap.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ [Editorial] Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
+@@ -69701,9 +76799,9 @@ range in the same way that <tt>min_element</tt> and <tt>max_element</tt> do.
+ Add to p31 25.4.7 [alg.min.max]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Returns <tt>make_pair(first, first)</tt> if <tt>first == last</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ 25.4.8 [alg.lex.comparison]
+@@ -69719,10 +76817,10 @@ rest of these issue resolutions:
+ Add to p1 25.4.8 [alg.lex.comparison]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ [<i>Note:</i> An empty sequence is lexicographically less than any other
+-non-empty sequence, but not to another empty sequence. — <i>end note</i>]
+-</blockquote>
++non-empty sequence, but not to another empty sequence. &mdash; <i>end note</i>]
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-11 Howard changes Notes to Remarks and changed <tt>search</tt> to
+@@ -69740,101 +76838,102 @@ return <tt>first1</tt> instead of <tt>last1</tt>.
+ <p>
+ Add to 25.2.1 [alg.all_of]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.2.2 [alg.any_of]:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>false</tt> if <tt>[first,last)</tt> is empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.2.3 [alg.none_of]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.2.6 [alg.find.end]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is
+ empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.2.7 [alg.find.first.of]
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is
+ empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.2.13 [alg.search]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>first1</tt> if <tt>[first2,last2)</tt> is
+ empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.3.13 [alg.partitions]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>true</tt> if <tt>[first,last)</tt> is empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Add to 25.4.5.1 [includes]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> Returns <tt>true</tt> if <tt>[first2,last2)</tt> is empty.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Revise p2 25.4.6.2 [pop.heap]
+ </p>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> The range <tt>[first,last)</tt> shall be a valid
+ <ins>non-empty</ins> heap.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ [Editorial]
+ </p>
+-<blockquote>
++<blockquote><p>
+ Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Add to p35 25.4.7 [alg.min.max]:
+ </p>
+-<blockquote><pre>template&lt;class ForwardIterator, class Compare&gt;
++<blockquote><pre>
++template&lt;class ForwardIterator, class Compare&gt;
+ pair&lt;ForwardIterator, ForwardIterator&gt;
+ minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <tt>make_pair(m, M)</tt>, where <tt>m</tt> is the first iterator in
+ <tt>[first,last)</tt> such that no iterator in the range refers to a smaller
+ element, and where <tt>M</tt> is the last iterator in <tt>[first,last)</tt> such that no
+ iterator in the range refers to a larger element.
+ <ins>Returns <tt>make_pair(first, first)</tt> if <tt>first == last</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Add to 25.4.8 [alg.lex.comparison]:
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Remarks:</i> An empty sequence is lexicographically less than any other
+ non-empty sequence, but not less than another empty sequence.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+
+
+@@ -69843,16 +76942,17 @@ non-empty sequence, but not less than another empty sequence.
+
+ <hr>
+ <h3><a name="1206"></a>1206. Incorrect requires for <tt>move_backward</tt> and <tt>copy_backward</tt></h3>
+-<p><b>Section:</b> 25.3.2 [alg.move] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25.3.2 [alg.move] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 25.3.2 [alg.move], p6 says:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
++<pre>
++template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
+ BidirectionalIterator2
+ move_backward(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+@@ -69907,7 +77007,8 @@ Change 25.3.2 [alg.move], p6:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
++<pre>
++template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
+ BidirectionalIterator2
+ move_backward(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+@@ -69927,7 +77028,8 @@ Change 25.3.1 [alg.copy], p13:
+ </p>
+
+ <blockquote>
+-<pre>template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
++<pre>
++template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
+ BidirectionalIterator2
+ copy_backward(BidirectionalIterator1 first,
+ BidirectionalIterator1 last,
+@@ -69947,11 +77049,11 @@ Change 25.3.1 [alg.copy], p13:
+
+
+ <hr>
+-<h3><a name="1207"></a>1207. Underspecified std::list operations?</h3>
+-<p><b>Section:</b> 23.3.4.4 [list.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Loïc Joly <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#list.ops">issues</a> in [list.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1207"></a>1207. Underspecified <tt>std::list</tt> operations?</h3>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Lo&iuml;c Joly <b>Opened:</b> 2009-09-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ It looks to me like some operations of <tt>std::list</tt>
+@@ -69994,23 +77096,25 @@ Suggested resolution:
+ </p>
+
+ <p>
+-In 23.3.4.4 [list.ops] change paragraph 19
++In 23.3.5.5 [list.ops] change paragraph 19
+ </p>
+
+-<blockquote><pre> void unique();
++<blockquote><pre>
++ void unique();
+ template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate binary_pred);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> <del>Eliminates</del> <ins>Erases</ins> all but the first
+ element from every consecutive group ...
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Add to the end of paragraph 23
+ </p>
+
+-<blockquote><pre>void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
++<blockquote><pre>
++void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
+ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);
+ </pre>
+ <blockquote>
+@@ -70028,7 +77132,7 @@ iterators into <tt>*this</tt>, not into <tt>x</tt>.</ins>
+ </blockquote>
+
+ <p><i>[
+-2009-12-12 Loïc adds wording.
++2009-12-12 Lo&iuml;c adds wording.
+ ]</i></p>
+
+
+@@ -70074,11 +77178,11 @@ concerns.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The wording looks good.
+
+ Move to Tentatively Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -70093,49 +77197,52 @@ Adopted at 2010-11 Batavia
+
+ <li>
+ <p>
+-Change 23.3.3.5 [forwardlist.ops]/12 as indicated:
++Change 23.3.4.6 [forwardlist.ops]/12 as indicated:
+ </p>
+
+-<blockquote><pre>void remove(const T&amp; value);
++<blockquote><pre>
++void remove(const T&amp; value);
+ template &lt;class Predicate&gt; void remove_if(Predicate pred);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 12 <i>Effects:</i> Erases all the elements in the list referred by a list
+ iterator <tt>i</tt> for which the following conditions hold: <tt>*i == value
+ (for remove()), pred(*i)</tt> is true (<tt>for remove_if()</tt>). This operation
+ shall be stable: the relative order of the elements that are not removed is the
+ same as their relative order in the original list. <ins>Invalidates only the
+ iterators and references to the erased elements.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.3.5 [forwardlist.ops]/15 as indicated:
++Change 23.3.4.6 [forwardlist.ops]/15 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate pred);
++<blockquote><pre>
++template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate pred);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 15 <i>Effects:</i>: <del>Eliminates</del><ins>Erases</ins> all but the first
+ element from every consecutive group of equal elements referred to by the
+ iterator <tt>i</tt> in the range <tt>[first + 1,last)</tt> for which <tt>*i ==
+ *(i-1)</tt> (for the version with no arguments) or <tt>pred(*i, *(i - 1))</tt>
+ (for the version with a predicate argument) holds. <ins>Invalidates only the
+ iterators and references to the erased elements.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.3.5 [forwardlist.ops]/19 as indicated:
++Change 23.3.4.6 [forwardlist.ops]/19 as indicated:
+ </p>
+
+-<blockquote><pre>void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++<blockquote><pre>
++void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
+ template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp)
+ </pre>
+
+@@ -70161,10 +77268,11 @@ elements, but they now behave as iterators into <tt>*this</tt>, not into
+
+ <li>
+ <p>
+-Change 23.3.3.5 [forwardlist.ops]/22 as indicated:
++Change 23.3.4.6 [forwardlist.ops]/22 as indicated:
+ </p>
+
+-<blockquote><pre>void sort();
++<blockquote><pre>
++void sort();
+ template &lt;class Compare&gt; void sort(Compare comp);
+ </pre>
+
+@@ -70186,45 +77294,48 @@ validity of iterators and references.</ins>
+
+ <li>
+ <p>
+-Change 23.3.3.5 [forwardlist.ops]/24 as indicated:
++Change 23.3.4.6 [forwardlist.ops]/24 as indicated:
+ </p>
+
+-<blockquote><pre>void reverse();
++<blockquote><pre>
++void reverse();
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 24 <i>Effects:</i>: Reverses the order of the elements in the list. <ins>Does
+ not affect the validity of iterators and references.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.4.4 [list.ops], p15:
++Change 23.3.5.5 [list.ops], p15:
+ </p>
+
+-<blockquote><pre> void remove(const T&amp; value);
++<blockquote><pre>
++ void remove(const T&amp; value);
+ template &lt;class Predicate&gt; void remove_if(Predicate pred);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Erases all the elements in the list referred by a list iterator
+ <tt>i</tt> for which the following conditions hold: <tt>*i == value, pred(*i) !=
+ false</tt>. <ins>Invalidates only the iterators and references to the erased
+ elements.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.4.4 [list.ops], p19:
++Change 23.3.5.5 [list.ops], p19:
+ </p>
+
+-<blockquote><pre> void unique();
++<blockquote><pre>
++ void unique();
+ template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate binary_pred);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> <del>Eliminates</del> <ins>Erases</ins> all but the first
+ element from every consecutive group of equal elements referred to by the
+ iterator <tt>i</tt> in the range <tt>[first + 1,last)</tt> for which <tt>*i ==
+@@ -70232,19 +77343,20 @@ iterator <tt>i</tt> in the range <tt>[first + 1,last)</tt> for which <tt>*i ==
+ <tt>pred(*i, *(i - 1))</tt> (for the version of <tt>unique</tt> with a predicate
+ argument) holds. <ins>Invalidates only the iterators and references to the
+ erased elements.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.4.4 [list.ops], p23:
++Change 23.3.5.5 [list.ops], p23:
+ </p>
+
+-<blockquote><pre>void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
++<blockquote><pre>
++void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
+ template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> If <tt>(&amp;x == this)</tt> does nothing; otherwise, merges the
+ two sorted ranges <tt>[begin(), end())</tt> and <tt>[x.begin(), x.end())</tt>.
+ The result is a range in which the elements will be sorted in non-decreasing
+@@ -70255,37 +77367,39 @@ iterator <tt>i</tt>, in the range other than the first, the condition
+ those same elements but as members of <tt>*this</tt>. Iterators referring to the
+ moved elements will continue to refer to their elements, but they now behave as
+ iterators into <tt>*this</tt>, not into <tt>x</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.4.4 [list.ops], p26:
++Change 23.3.5.5 [list.ops], p26:
+ </p>
+
+-<blockquote><pre>void reverse();
++<blockquote><pre>
++void reverse();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Reverses the order of the elements in the list.
+ <ins>Does not affect the validity of iterators and references.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 23.3.4.4 [list.ops], p30:
++Change 23.3.5.5 [list.ops], p30:
+ </p>
+
+-<blockquote><pre> void sort();
++<blockquote><pre>
++ void sort();
+ template &lt;class Compare&gt; void sort(Compare comp);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Sorts the list according to the <tt>operator&lt;</tt> or a
+ <tt>Compare</tt> function object.
+ <ins>Does not affect the validity of iterators and references.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -70297,22 +77411,23 @@ template &lt;class Compare&gt; void sort(Compare comp);
+
+
+ <hr>
+-<h3><a name="1208"></a>1208. valarray initializer_list constructor has incorrect effects</h3>
+-<p><b>Section:</b> 26.6.2.1 [valarray.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1208"></a>1208. <tt>valarray initializer_list</tt> constructor has incorrect effects</h3>
++<p><b>Section:</b> 26.6.2.2 [valarray.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-09-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.cons">issues</a> in [valarray.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-26.6.2.1 [valarray.cons] says:
++26.6.2.2 [valarray.cons] says:
+ </p>
+
+ <blockquote>
+-<pre>valarray(initializer_list&lt;T&gt; il);
++<pre>
++valarray(initializer_list&lt;T&gt; il);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Same as <tt>valarray(il.begin(), il.end())</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -70324,22 +77439,23 @@ But there is no <tt>valarray</tt> constructor taking two <tt>const T*</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 26.6.2.1 [valarray.cons]:
++Change 26.6.2.2 [valarray.cons]:
+ </p>
+
+ <blockquote>
+-<pre>valarray(initializer_list&lt;T&gt; il);
++<pre>
++valarray(initializer_list&lt;T&gt; il);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Same as <tt>valarray(il.begin(), il.<del>end</del><ins>size</ins>())</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -70347,10 +77463,12 @@ Change 26.6.2.1 [valarray.cons]:
+
+
+ <hr>
+-<h3><a name="1209"></a>1209. match_results should be moveable</h3>
+-<p><b>Section:</b> 28.10.1 [re.results.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-09-15 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1209"></a>1209. <tt>match_results</tt> should be moveable</h3>
++<p><b>Section:</b> 28.10.1 [re.results.const] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-09-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.results.const">active issues</a> in [re.results.const].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.const">issues</a> in [re.results.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In Working Draft
+@@ -70362,7 +77480,7 @@ should be moveable.
+
+ <p>
+ As far as I can tell, this isn't tracked by an active issue yet; Library
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723">723</a> doesn't talk about <tt>match_results</tt>.
++Issue <a href="lwg-defects.html#723">723</a> doesn't talk about <tt>match_results</tt>.
+ </p>
+
+ <p><i>[
+@@ -70383,7 +77501,8 @@ Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#723"
+ Add the following member declarations to 28.10 [re.results]/3:
+ </p>
+
+-<blockquote><pre>// 28.10.1, construct/copy/destroy:
++<blockquote><pre>
++// 28.10.1, construct/copy/destroy:
+ explicit match_results(const Allocator&amp; a = Allocator());
+ match_results(const match_results&amp; m);
+ <ins>match_results(match_results&amp;&amp; m);</ins>
+@@ -70402,15 +77521,17 @@ using the table numbering of
+ </p>
+
+ <blockquote>
+-<pre>match_results(const match_results&amp; m);
++<pre>
++match_results(const match_results&amp; m);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 4 <i>Effects:</i> Constructs an object of class <tt>match_results</tt>, as a
+ copy of <tt>m</tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre><ins>match_results(match_results&amp;&amp; m);</ins>
++<pre>
++<ins>match_results(match_results&amp;&amp; m);</ins>
+ </pre>
+
+ <blockquote>
+@@ -70427,15 +77548,17 @@ state.</ins>
+ </p>
+ </blockquote>
+
+-<pre>match_results&amp; operator=(const match_results&amp; m);
++<pre>
++match_results&amp; operator=(const match_results&amp; m);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 7 <i>Effects:</i> Assigns <tt>m</tt> to <tt>*this</tt>. The postconditions of this function are
+ indicated in Table 131.
+-</blockquote>
++</p></blockquote>
+
+-<pre><ins>match_results&amp; operator=(match_results&amp;&amp; m);</ins>
++<pre>
++<ins>match_results&amp; operator=(match_results&amp;&amp; m);</ins>
+ </pre>
+
+ <blockquote>
+@@ -70459,14 +77582,585 @@ a valid but unspecified state.</ins>
+
+
+ <hr>
++<h3><a name="1210"></a>1210. Iterator reachability should not require a container</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++p6 Iterator requirements 24.2 [iterator.requirements]
++</p>
++
++<blockquote><p>
++An iterator <tt>j</tt> is called reachable from an iterator <tt>i</tt> if and only if
++there is a finite sequence of applications of the expression <tt>++i</tt> that
++makes <tt>i == j</tt>. If <tt>j</tt> is reachable from <tt>i</tt>, they refer to the same
++container.
++</p></blockquote>
++
++<p>
++A good example would be stream iterators, which do not refer to a
++container. Typically, the end iterator from a range of stream iterators
++will compare equal for many such ranges. I suggest striking the second
++sentence.
++</p>
++
++<p>
++An alternative wording might be:
++</p>
++
++<blockquote><p>
++If <tt>j</tt> is reachable from <tt>i</tt>, and both <tt>i</tt> and
++<tt>j</tt> are dereferencable iterators, then they refer to the same
++range.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 24.2 [iterator.requirements], p6:
++</p>
++
++<blockquote><p>
++An iterator <tt>j</tt> is called <i>reachable</i> from an iterator
++<tt>i</tt> if and only if there is a finite sequence of applications of
++the expression <tt>++i</tt> that makes <tt>i == j</tt>. <del>If
++<tt>j</tt> is reachable from <tt>i</tt>, they refer to the same
++container.</del>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1211"></a>1211. Move iterators should be restricted as input iterators</h3>
++<p><b>Section:</b> 24.5.3.1 [move.iterator] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#move.iterator">issues</a> in [move.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I contend that while we can support both bidirectional and random access
++traversal, the category of a move iterator should never be better than
++<tt>input_iterator_tag</tt>.
++</p>
++
++<p>
++The contentious point is that you cannot truly have a multipass property
++when values are moved from a range. This is contentious if you view a
++moved-from object as still holding a valid value within the range.
++</p>
++
++<p>
++The second reason comes from the Forward Iterator requirements table:
++</p>
++
++<blockquote>
++<p>
++Forward iterators 24.2.5 [forward.iterators]
++</p>
++
++<p>
++Table 102 &mdash; Forward iterator requirements
++</p>
++
++<blockquote><p>
++For expression <tt>*a</tt> the return type is:
++"<tt>T&amp;</tt> if <tt>X</tt> is mutable, otherwise <tt>const T&amp;</tt>"
++</p></blockquote>
++</blockquote>
++
++<p>
++There is a similar constraint on <tt>a-&gt;m</tt>.
++</p>
++
++<p>
++There is no support for rvalue references, nor do I believe their should
++be. Again, opinions may vary but either this table or the definition of
++<tt>move_iterator</tt> need updating.
++</p>
++
++<p>
++Note: this requirement probably need updating anyway if we wish to
++support proxy iterators but I am waiting to see a new working paper
++before filing that issue.
++</p>
++
++<p><i>[
++2009-10 post-Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++Move to Open. Howard to put his rationale mentioned above into the issue
++as a note.
++</p></blockquote>
++
++<p><i>[
++2009-10-26 Howard adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++<tt>vector::insert(pos, iter, iter)</tt> is significantly more effcient when
++<tt>iter</tt> is a random access iterator, as compared to when it is an
++input iterator.
++</p>
++
++<p>
++When <tt>iter</tt> is an input iterator, the best algorithm
++is to append the inserted range to the end of the <tt>vector</tt> using
++<tt>push_back</tt>. This may involve several reallocations before the input
++range is exhausted. After the append, then one can use <tt>std::rotate</tt>
++to place the inserted range into the correct position in the vector.
++</p>
++
++<p>
++But when <tt>iter</tt> is a random access iterator, the best algorithm
++is to first compute the size of the range to be inserted (<tt>last - first</tt>),
++do a buffer reallocation if necessary, scoot existing elements in the <tt>vector</tt>
++down to make the "hole", and then insert the new elements directly to their correct
++place.
++</p>
++
++<blockquote><p><b>
++The insert-with-random-access-iterators algorithm is considerably more efficient
++than the insert-with-input-iterators algorithm
++</b></p></blockquote>
++
++<p>
++Now consider:
++</p>
++
++<blockquote><pre>
++vector&lt;A&gt; v;
++<span style="color:#C80000">// ... build up a large vector of A ...</span>
++vector&lt;A&gt; temp;
++<span style="color:#C80000">// ... build up a large temporary vector of A to later be inserted ...</span>
++typedef move_iterator&lt;vector&lt;A&gt;::iterator&gt; MI;
++<span style="color:#C80000">// Now insert the temporary elements:</span>
++v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));
++</pre></blockquote>
++
++<p>
++A major motivation for using <tt>move_iterator</tt> in the above example is the
++expectation that <tt>A</tt> is cheap to move but expensive to copy. I.e. the
++customer is looking for <em>high performance</em>. If we allow <tt>vector::insert</tt>
++to subtract two <tt>MI</tt>'s to get the distance between them, the customer enjoys
++substantially better performance, compared to if we say that <tt>vector::insert</tt>
++can not subtract two <tt>MI</tt>'s.
++</p>
++
++<p>
++I can find no rationale for not giving this performance boost to our customers.
++Therefore I am strongly against restricting <tt>move_iterator</tt> to the
++<tt>input_iterator_tag</tt> category.
++</p>
++
++<p>
++I believe that the requirement that forward
++iterators have a dereference that returns an lvalue reference to cause unacceptable
++pessimization. For example <tt>vector&lt;bool&gt;::iterator</tt> also does not return
++a <tt>bool&amp;</tt> on dereference. Yet I am not aware of a single vendor that
++is willing to ship <tt>vector&lt;bool&gt;::iterator</tt> as an input iterator.
++Everyone classifies it as a random access iterator. Not only does this not
++cause any problems, it prevents significant performance problems.
++</p>
++
++</blockquote>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Class template move_iterator 24.5.3.1 [move.iterator]
++</p>
++
++<blockquote><pre>
++namespace std {
++template &lt;class Iterator&gt;
++class move_iterator {
++public:
++ ...
++ typedef <del>typename iterator_traits&lt;Iterator&gt;::iterator_category</del> <ins>input_iterator_tag</ins> iterator_category;
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1212"></a>1212. result of post-increment/decrement operator</h3>
++<p><b>Section:</b> 24.2 [iterator.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-09-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.requirements">issues</a> in [iterator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Forward iterator and bidirectional iterator place different requirements on the result of post-increment/decrement operator.
++The same form should be used in each case.
++</p>
++
++<p>
++Merging row from:
++</p>
++
++<blockquote><pre>
++Table 102 -- Forward iterator requirements
++Table 103 -- Bidirectional iterator requirements
++
++ r++ : convertible to const X&amp;
++ r-- : convertible to const X&amp;
++
++ *r++ : T&amp; if X is mutable, otherwise const T&amp;
++ *r-- : convertible to T
++</pre></blockquote>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="1214"></a>1214. Insufficient/inconsistent key immutability requirements for associative containers</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Scott Meyers' mentions on a recent posting on <a
++href="http://groups.google.de/group/comp.std.c++/msg/6f9160fc428bcbea">c.s.c++</a>
++some arguments that point to an incomplete resolution
++of <a href="lwg-defects.html#103">103</a> and to an inconsistency of requirements on keys in ordered and
++unordered associative
++containers:
++</p>
++
++<blockquote>
++<p>
++1) <a href="lwg-defects.html#103">103</a> introduced the term immutable without defining it in a unique manner in
++23.2.4 [associative.reqmts]/5:
++</p>
++
++<blockquote><p>
++[..] Keys in an associative container are immutable.
++</p></blockquote>
++
++<p>
++According to conventional dictionaries immutable is an unconditional way of
++saying that something cannot be changed. So without any further explicit
++allowance a user <em>always</em> runs into undefined behavior if (s)he attempts
++to modify such a key. IMO this was not the intend of the committee to resolve
++<a href="lwg-defects.html#103">103</a> in that way because the comments suggest an interpretation that
++should give any user the freedom to modify the key in an <em>explicit</em> way
++<em>provided</em> it would not affect the sort order in that container.
++</p>
++
++<p>
++2) Another observation was that surprisingly no similar 'safety guards'
++exists against unintentional key changes for the unordered associative
++containers, specifically there is no such requirement as in
++23.2.4 [associative.reqmts]/6 that "both <tt>iterator</tt> and <tt>const_iterator</tt> are constant
++iterators". But the need for such protection against unintentional
++changes as well as the constraints in which manner any explicit
++changes may be performed are both missing and necessary, because
++such changes could potentially change the <em>equivalence</em> of keys that
++is measured by the <tt>hasher</tt> and <tt>key_equal</tt>.
++</p>
++
++<p>
++I suggest to fix the unconditional wording involved with "immutable keys"
++by at least adding a hint for the reader that users <em>may</em> perform such
++changes in an explicit manner <em>and</em> to perform similar wording changes
++as <a href="lwg-defects.html#103">103</a> did for the ordered associative containers also for the unordered
++containers.
++</p>
++</blockquote>
++
++<p><i>[
++2010-03-27 Daniel provides wording.
++]</i></p>
++
++
++<blockquote><p>
++This update attempts to provide normative wording that harmonizes the key and
++function object constraints of associative and unordered containers.
++</p></blockquote>
++
++<p><i>[
++2010 Batavia:
++]</i></p>
++
++
++<p>
++We're uncomfortable with the first agenda item, and we can live with the second agenda
++item being applied before or after Madrid.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Further discussion persuades us this issue is Ready (and so moved).
++We may need a further issue clarifying the notion of key <i>value</i>
++vs. key <i>object</i>, as object identity appears to be important
++to this wording.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Change 23.2.4 [associative.reqmts]/2 as indicated: <i>[This ensures that
++associative containers make better clear what this "arbitrary" type is, as the
++unordered containers do in 23.2.5 [unord.req]/3]</i>
++</p>
++
++<blockquote><p>
++2 Each associative container is parameterized on <tt>Key</tt> and an ordering
++relation <tt>Compare</tt> that induces a strict weak ordering (25.4) on elements
++of <tt>Key</tt>. In addition, <tt>map</tt> and <tt>multimap</tt> associate an
++arbitrary <ins><em>mapped type</em></ins><del>type</del> <tt>T</tt> with the
++<tt>Key</tt>. The object of type <tt>Compare</tt> is called the <em>comparison
++object</em> of a container.
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Change 23.2.4 [associative.reqmts]/5 as indicated: <i>[This removes the
++too strong requirement that keys must not be changed at all and brings this line
++in sync with 23.2.5 [unord.req]/7. We take care about the real
++constraints by the remaining suggested changes. The rationale provided by LWG
++<a href="lwg-defects.html#103">103</a> didn't really argue why that addition is necessary, and I
++believe the remaining additions make it clear that any user changes have strong
++restrictions]</i>:
++</p>
++
++<blockquote><p>
++5 For <tt>set</tt> and <tt>multiset</tt> the value type is the same as the key
++type. For <tt>map</tt> and <tt>multimap</tt> it is equal to <tt>pair&lt;const
++Key, T&gt;</tt>. <del>Keys in an associative container are immutable.</del>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++Change 23.2.5 [unord.req]/3+4 as indicated: <i>[The current sentence of
++p.4 has doesn't say something really new and this whole subclause misses to
++define the concepts of the container-specific hasher <i>object</i> and predicate
++<i>object</i>. We introduce the term <em>key equality predicate</em> which is
++already used in the requirements table. This change does not really correct part
++of this issue, but is recommended to better clarify the nomenclature and the
++difference between the function objects and the function object <em>types</em>,
++which is important, because both can potentially be stateful.]</i>
++</p>
++
++<blockquote>
++<p>
++3 Each unordered associative container is parameterized by <tt>Key</tt>, by a
++function object type <tt>Hash</tt> that meets the <tt>Hash</tt> requirements
++(20.2.4) and acts as a hash function for argument values of type <tt>Key</tt>,
++and by a binary predicate <tt>Pred</tt> that induces an equivalence relation on
++values of type <tt>Key</tt>. Additionally, <tt>unordered_map</tt> and
++<tt>unordered_multimap</tt> associate an arbitrary <em>mapped type</em>
++<tt>T</tt> with the <tt>Key</tt>.
++</p>
++
++<p>
++4 <ins>The container's object of type <tt>Hash</tt> - denoted by
++<tt>hash</tt> - is called the <em>hash function</em> of the container.
++The container's object of type <tt>Pred</tt> - denoted by
++<tt>pred</tt> - is called the <em>key equality predicate</em> of the
++container.</ins><del>A hash function is a function object that takes a single
++argument of type <tt>Key</tt> and returns a value of type
++<tt>std::size_t</tt></del>.
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Change 23.2.5 [unord.req]/5 as indicated: <i>[This adds a similar
++safe-guard as the last sentence of 23.2.4 [associative.reqmts]/3]</i>
++</p>
++
++<blockquote><p>
++5 Two values <tt>k1</tt> and <tt>k2</tt> of type <tt>Key</tt> are considered
++equivalent if the container's <ins>key equality
++predicate</ins><del><tt>key_equal</tt> function object</del> returns
++<tt>true</tt> when passed those values. If <tt>k1</tt> and <tt>k2</tt> are
++equivalent, the <ins>container's</ins> hash function shall return the same value
++for both. [<i>Note:</i> thus, when an unordered associative container is
++instantiated with a non-default <tt>Pred</tt> parameter it usually needs a
++non-default <tt>Hash</tt> parameter as well. &mdash; <i>end note</i>] <ins>For
++any two keys <tt>k1</tt> and <tt>k2</tt> in the same container, calling
++<tt>pred(k1, k2)</tt> shall always return the same value. For any key <tt>k</tt>
++in a container, calling <tt>hash(k)</tt> shall always return the same
++value.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>
++After 23.2.5 [unord.req]/7 add the following new paragraph: <i>[This
++ensures the same level of compile-time protection that we already require for
++associative containers. It is necessary for similar reasons, because any change
++in the stored key which would change it's equality relation to others or would
++change it's hash value such that it would no longer fall in the same bucket,
++would break the container invariants]</i>
++</p>
++
++<blockquote>
++<p>
++7 For <tt>unordered_set</tt> and <tt>unordered_multiset</tt> the value type is
++the same as the key type. For <tt>unordered_map</tt> and
++<tt>unordered_multimap</tt> it is <tt>std::pair&lt;const Key, T&gt;</tt>.
++</p>
++<p>
++<ins>For unordered containers where the value type is the same as the key type,
++both <tt>iterator</tt> and <tt>const_iterator</tt> are constant iterators. It is
++unspecified whether or not <tt>iterator</tt> and <tt>const_iterator</tt> are the
++same type. [<i>Note:</i> <tt>iterator</tt> and <tt>const_iterator</tt> have
++identical semantics in this case, and <tt>iterator</tt> is convertible to
++<tt>const_iterator</tt>. Users can avoid violating the One Definition Rule by
++always using <tt>const_iterator</tt> in their function parameter lists. &mdash;
++<i>end note</i>]</ins>
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="1215"></a>1215. <tt>list::merge</tt> with unequal allocators</h3>
++<p><b>Section:</b> 23.3.5.5 [list.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In Bellevue (I think), we passed
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2525.pdf">N2525</a>,
++which, among other things, specifies that the behavior of
++<tt>list::splice</tt> is undefined if the allocators of the two lists
++being spliced do not compare equal. The same rationale should apply to
++<tt>list::merge</tt>. The intent of <tt>list::merge</tt> (AFAIK) is to
++move nodes from one sorted <tt>list</tt> into another sorted
++<tt>list</tt> without copying the elements. This is possible only if the
++allocators compare equal.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Relative to the August 2009 WP,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">N2857</a>,
++change 23.3.5.5 [list.ops],
++paragraphs 22-25 as follows:
++</p>
++
++<blockquote>
++<pre>
++void merge(list&amp;&amp; x);
++template &lt;class Compare&gt; void merge(list&amp;&amp; x, Compare comp);
++</pre>
++<blockquote>
++<p>
++<i>Requires</i>: both the list and the argument list shall be sorted
++according to operator&lt; or comp.
++</p>
++<p>
++<i>Effects</i>: If <tt>(&amp;x == this)</tt> does nothing; otherwise, merges the
++two sorted ranges <tt>[begin(), end())</tt> and <tt>[x.begin(),
++x.end())</tt>. The result is a range in which the elements will be
++sorted in non-decreasing order according to the ordering defined by
++<tt>comp</tt>; that is, for every iterator <tt>i</tt>, in the range other than the
++<tt>first</tt>, the condition <tt>comp(*i, *(i - 1)<ins>)</ins></tt> will be
++<tt>false</tt>.
++</p>
++<p>
++<i>Remarks</i>: Stable. If <tt>(&amp;x != this)</tt> the range <tt>[x.begin(), x.end())</tt> is
++empty after the merge. <ins>No elements are copied by this operation.
++The behavior is undefined if <tt>this-&gt;get_allocator() !=
++x.get_allocator()</tt>.</ins>
++</p>
++<p>
++<i>Complexity</i>: At most <tt>size() + x.size() - 1</tt> applications of <tt>comp</tt>
++if <tt>(&amp;x != this)</tt>; otherwise, no applications of <tt>comp</tt> are performed. If an
++exception is thrown other than by a comparison there are no effects.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++<hr>
+ <h3><a name="1216"></a>1216. LWG 1066 Incomplete?</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-09-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2009-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1066">1066</a> adds <tt>[[noreturn]]</tt> to a bunch of things.
++LWG <a href="lwg-defects.html#1066">1066</a> adds <tt>[[noreturn]]</tt> to a bunch of things.
+ It doesn't add it to <tt>rethrow_nested()</tt>, which seems like an obvious
+ candidate. I've made the changes indicated in the issue, and haven't
+ changed <tt>rethrow_nested()</tt>.
+@@ -70477,9 +78171,9 @@ changed <tt>rethrow_nested()</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Move to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -70494,10 +78188,11 @@ Add <tt>[[noreturn]]</tt> to <tt>rethrow_nested()</tt> in 18.8.6 [except.nested]
+
+ <hr>
+ <h3><a name="1218"></a>1218. mutex destructor synchronization</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ If an object <tt>*o</tt> contains a mutex <tt>mu</tt> and a
+@@ -70505,7 +78200,8 @@ correctly-maintained reference count <tt>c</tt>, is the following code
+ safe?
+ </p>
+
+-<blockquote><pre>o-&gt;mu.lock();
++<blockquote><pre>
++o-&gt;mu.lock();
+ bool del = (--(o-&gt;c) == 0);
+ o-&gt;mu.unlock();
+ if (del) { delete o; }
+@@ -70544,7 +78240,7 @@ observe that it is no longer in use, unlock and destroy it, before thread
+ required to handle such scenarios correctly, as long as thread <tt>A</tt>
+ doesn't access the mutex after the unlock call returns. These cases typically
+ occur when a reference-counted object contains a mutex that is used to protect
+-the reference count. — <i>end note</i>]
++the reference count. &mdash; <i>end note</i>]
+ </ins></p>
+ </blockquote>
+ </li>
+@@ -70556,11 +78252,11 @@ the reference count.
+
+
+ <hr>
+-<h3><a name="1220"></a>1220. What does condition_variable wait on?</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1220"></a>1220. What does <tt>condition_variable</tt> wait on?</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ "Class <tt>condition_variable</tt> provides a condition variable that can only
+@@ -70573,9 +78269,9 @@ wait on an object of type <tt>unique_lock</tt>" should say "...object of type
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -70584,7 +78280,7 @@ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+ Change 30.5 [thread.condition], p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Condition variables provide synchronization primitives used to block a
+ thread until notified by some other thread that some condition is met or
+ until a system time is reached. Class <tt>condition_variable</tt>
+@@ -70593,34 +78289,35 @@ provides a condition variable that can only wait on an object of type
+ efficiency on some platforms. Class <tt>condition_variable_any</tt>
+ provides a general condition variable that can wait on objects of
+ user-supplied lock types.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1221"></a>1221. condition_variable wording</h3>
+-<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1221"></a>1221. <tt>condition_variable</tt> wording</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.5.1 [thread.condition.condvar] says:
+ </p>
+
+ <blockquote>
+-<pre>~condition_variable();
++<pre>
++~condition_variable();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Precondition:</i> There shall be no thread blocked on <tt>*this</tt>.
+ [<i>Note:</i> That is, all threads shall have been notified; they may
+ subsequently block on the lock specified in the wait. Beware that
+ destroying a <tt>condition_variable</tt> object while the corresponding
+ predicate is <tt>false</tt> is likely to lead to undefined behavior.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -70647,7 +78344,7 @@ Modify 30.5.1 [thread.condition.condvar]p4 as follows:
+
+ <blockquote>
+ <pre>~condition_variable();</pre>
+-<blockquote>
++<blockquote><p>
+ 4 <i>Precondition:</i> There shall be no thread blocked on <tt>*this</tt>.
+ [<i>Note:</i> That is, all threads shall have been notified; they may
+ subsequently block on the lock specified in the wait. <del>Beware that
+@@ -70656,9 +78353,9 @@ predicate is false is likely to lead to undefined behavior.</del> <ins>The user
+ must take care to ensure that no threads wait on <tt>*this</tt> once the
+ destructor has been started, especially when the waiting threads are calling the
+ wait functions in a loop or using the overloads of <tt>wait</tt>,
+-<tt>wait_for</tt> or <tt>wait_until</tt> that take a predicate.</ins> —
++<tt>wait_for</tt> or <tt>wait_until</tt> that take a predicate.</ins> &mdash;
+ <i>end note</i>]
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -70667,17 +78364,18 @@ wait functions in a loop or using the overloads of <tt>wait</tt>,
+
+ <hr>
+ <h3><a name="1222"></a>1222. condition_variable incorrect effects for exception safety</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2009-09-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.5.1 [thread.condition.condvar] says:
+ </p>
+
+ <blockquote>
+-<pre>void wait(unique_lock&lt;mutex&gt;&amp; lock);
++<pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -70711,7 +78409,8 @@ Change 30.5.1 [thread.condition.condvar] p10:
+ </p>
+
+ <blockquote>
+-<pre>void wait(unique_lock&lt;mutex&gt;&amp; lock);
++<pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -70739,14 +78438,378 @@ p8 and p13.
+
+
+ <hr>
++<h3><a name="1225"></a>1225. C++0x <tt>result_of</tt> issue </h3>
++<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Sebastian Gesemann <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.ret">issues</a> in [func.ret].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I think the text about <tt>std::result_of</tt> could be a little more precise.
++Quoting from
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>...
++</p>
++
++<blockquote>
++<p>
++X [func.ret] Function object return types
++</p>
++
++<pre>
++template&lt;class&gt; class result_of;
++
++template&lt;class Fn, class... ArgTypes&gt;
++class result_of&lt;Fn(ArgTypes...)&gt; {
++public:
++ typedef <i>see below</i> type;
++};
++</pre>
++
++<p>
++Given an rvalue <tt>fn</tt> of type <tt>Fn</tt> and values <tt>t1, t2,
++..., tN</tt> of types <tt>T1, T2, ... TN</tt> in <tt>ArgTypes</tt>
++respectivly, the <tt>type</tt> member is the result type of the
++expression <tt>fn(t1,t2,...,tN)</tt>. the values <tt>ti</tt> are lvalues
++when the corresponding type <tt>Ti</tt> is an lvalue-reference type, and
++rvalues otherwise.
++</p>
++</blockquote>
++
++<p>
++This text doesn't seem to consider lvalue reference types for <tt>Fn</tt>.
++Also, it's not clear whether this class template can be used for
++"SFINAE" like <tt>std::enable_if</tt>. Example:
++</p>
++
++<blockquote><pre>
++template&lt;typename Fn, typename... Args&gt;
++typename std::result_of&lt;Fn(Args...)&gt;::type
++apply(Fn &amp;&amp; fn, Args &amp;&amp; ...args)
++{
++ // Fn may be an lvalue reference, too
++ return std::forward&lt;Fn&gt;(fn)(std::forward&lt;Args&gt;(args)...);
++}
++</pre></blockquote>
++
++<p>
++Either <tt>std::result_of&lt;...&gt;</tt> can be instantiated and simply may not have
++a typedef "<tt>type</tt>" (--&gt;SFINAE) or instantiating the class template for
++some type combinations will be a "hard" compile-time error.
++</p>
++
++<p><i>[
++2010-02-14 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++This issue should be considered resolved by <a href="lwg-defects.html#1255">1255</a> and <a href="lwg-defects.html#1270">1270</a>. The wish to change <tt>result_of</tt> into a compiler-support
++trait was beyond the actual intention of the submitter Sebastian.
++</p></blockquote>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>, rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="lwg-defects.html#1270">1270</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><i>[
++These changes will require compiler support
++]</i></p>
++
++
++<p>
++Change X [func.ret]:
++</p>
++
++<blockquote><pre>
++template&lt;class&gt; class result_of; // <i>undefined</i>
++
++template&lt;class Fn, class... ArgTypes&gt;
++class result_of&lt;Fn(ArgTypes...)&gt; {
++public:
++ <del>typedef</del> <i>see below</i> <del>type;</del>
++};
++</pre>
++
++<p><del>
++Given an rvalue <tt>fn</tt> of type <tt>Fn</tt> and values <tt>t1, t2,
++..., tN</tt> of types <tt>T1, T2, ... TN</tt> in <tt>ArgTypes</tt>
++respectivly, the <tt>type</tt> member is the result type of the
++expression <tt>fn(t1,t2,...,tN)</tt>. the values <tt>ti</tt> are lvalues
++when the corresponding type <tt>Ti</tt> is an lvalue-reference type, and
++rvalues otherwise.
++</del></p>
++
++<p>
++<ins>The class template <tt>result_of</tt> shall meet the requirements of a
++<i>TransformationTrait</i>: Given the types <tt>Fn</tt>, <tt>T1</tt>, <tt>T2</tt>, ..., <tt>TN</tt> every
++template specialization <tt>result_of&lt;Fn(T1,T2,...,TN)&gt;</tt> shall define the
++member typedef type equivalent to <tt>decltype(<i>RE</i>)</tt> if and only if
++the expression <tt><i>RE</i></tt>
++</ins></p>
++
++<blockquote><pre><ins>
++value&lt;Fn&gt;() ( value&lt;T1&gt;(), value&lt;T2&gt;(), ... value&lt;TN&gt;() )
++</ins></pre></blockquote>
++
++<p><ins>
++would be well-formed. Otherwise, there shall be no member typedef
++<tt>type</tt> defined.
++</ins></p>
++
++</blockquote>
++
++<p><i>[
++The <tt>value&lt;&gt;</tt> helper function is a utility Daniel Kr&uuml;gler
++proposed in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html">N2958</a>.
++]</i></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="1226"></a>1226. Incomplete changes of #890</h3>
++<p><b>Section:</b> 30.6.2 [futures.errors] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Defect issue <a href="lwg-defects.html#890">890</a> overlooked to adapt the <tt>future_category</tt> from
++30.6.1 [futures.overview] and 30.6.2 [futures.errors]:
++</p>
++
++<blockquote><pre>
++extern const error_category* const future_category;
++</pre></blockquote>
++
++<p>
++which should be similarly transformed into function form.
++</p>
++
++<p><i>[
++2009-10-27 Howard:
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++2009-11-11 Daniel adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++I just observe that the proposed resolution of this issue
++is incomplete and needs to reworded. The problem is that the
++corresponding declarations
++</p>
++
++<blockquote><pre>
++constexpr error_code make_error_code(future_errc e);
++constexpr error_condition make_error_condition(future_errc e);
++</pre></blockquote>
++
++<p>
++as constexpr functions are incompatible to the requirements of constexpr
++functions given their specified implementation. Note that the incompatibility
++is <em>not</em> a result of the modifications proposed by the issue resolution,
++but already existed within the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
++state where we have
++</p>
++
++<blockquote><pre>
++extern const error_category* const future_category;
++</pre></blockquote>
++
++<p>
++combined with
++</p>
++
++<blockquote><pre>
++constexpr error_code make_error_code(future_errc e);
++</pre>
++<blockquote><p>
++3 <i>Returns:</i> <tt>error_code(static_cast&lt;int&gt;(e), *future_category)</tt>.
++</p></blockquote>
++
++<pre>
++constexpr error_code make_error_condition(future_errc e);
++</pre>
++<blockquote><p>
++4 <i>Returns:</i> <tt>error_condition(static_cast&lt;int&gt;(e), *future_category)</tt>.
++</p></blockquote>
++</blockquote>
++
++<p>
++Neither is any of the constructors of <tt>error_code</tt> and <tt>error_condition</tt>
++constexpr, nor does the expression <tt>*future_category</tt> satisfy the
++requirements for a constant expression (5.20 [expr.const]/2 bullet 6 in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>).
++</p>
++
++<p>
++The simple solution is just to remove the constexpr qualifiers for both
++functions, which makes sense, because none of the remaining <tt>make_error_*</tt>
++overloads in the library is constexpr. One might consider to realize that
++those <tt>make_*</tt> functions could satisfy the constexpr requirements, but this
++looks not like an easy task to me, because it would need to rely on a not
++yet existing language feature. If such a change is wanted, a new issue
++should be opened after the language extension approval (if at all) [1].
++</p>
++
++<p>
++If no-one complaints I would like to ask Howard to add the following
++modifications to this issue, alternatively a new issue could be opened but I
++don't know what the best solution is that would cause as little overhead
++as possible.
++</p>
++<p>
++What-ever the route is, the following is my proposed resolution for this issue
++interaction part of the story:
++</p>
++
++<blockquote>
++<p>
++In 30.6.1 [futures.overview]/1, Header <tt>&lt;future&gt;</tt> synopsis <em>and</em>
++in 30.6.2 [futures.errors]/3+4
++change as indicated:
++</p>
++
++<blockquote><pre>
++<del>constexpr</del> error_code make_error_code(future_errc e);
++<del>constexpr</del> error_condition make_error_condition(future_errc e);
++</pre></blockquote>
++</blockquote>
++
++<p>
++[1] Let me add that we have a related NAD issue here: <a href="lwg-closed.html#832">832</a>
++so the chances for realization are little IMO.
++</p>
++
++<p><i>[
++Howard: I've updated the proposed wording as Daniel suggests and set to Review.
++]</i></p>
++
++</blockquote>
++
++<p><i>[
++2009-11-13 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Change in 30.6.1 [futures.overview], header <tt>&lt;future&gt;</tt> synopsis:
++</p>
++
++<blockquote><pre>
++<del>extern</del> const error_category<ins>&amp;</ins><del>* const</del> future_category<ins>()</ins>;
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++In 30.6.1 [futures.overview]/1, Header <tt>&lt;future&gt;</tt> synopsis
++change as indicated:
++</p>
++
++<blockquote><pre>
++<del>constexpr</del> error_code make_error_code(future_errc e);
++<del>constexpr</del> error_condition make_error_condition(future_errc e);
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Change in 30.6.2 [futures.errors]:
++</p>
++
++<blockquote><pre>
++<del>extern</del> const error_category<ins>&amp;</ins><del>* const</del> future_category<ins>()</ins>;
++</pre>
++
++<blockquote>
++<p>
++<del>1- <tt>future_category</tt> shall point to a statically initialized object
++of a type derived from class <tt>error_category</tt>.</del>
++</p>
++<p>
++<ins>1- <i>Returns:</i> A reference to an object of a type
++derived from class <tt>error_category</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<del>constexpr</del> error_code make_error_code(future_errc e);
++</pre>
++
++<blockquote><p>
++3 <i>Returns:</i> <tt>error_code(static_cast&lt;int&gt;(e),
++<del>*</del>future_category<ins>()</ins>)</tt>.
++</p></blockquote>
++
++<pre>
++<del>constexpr</del> error_<del>code</del><ins>condition</ins> make_error_condition(future_errc e);
++</pre>
++
++<blockquote><p>
++4 <i>Returns:</i> <tt>error_condition(static_cast&lt;int&gt;(e),
++<del>*</del>future_category<ins>()</ins>)</tt>.
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
+ <h3><a name="1227"></a>1227. <tt>&lt;bitset&gt;</tt> synopsis overspecified</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The resolutions to some library defect reports, like <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1178">1178</a>
++The resolutions to some library defect reports, like <a href="lwg-defects.html#1178">1178</a>
+ requires that <tt>#includes</tt> in each synopsis should be taken
+ literally. This means that the <tt>&lt;bitset&gt;</tt> header now
+ <em>must</em> include <tt>&lt;stdexcept&gt;</tt>, even though none of the
+@@ -70769,18 +78832,19 @@ I propose that <tt>&lt;stdexcept&gt;</tt> is removed from the
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.5 [template.bitset]:
++Change 20.6 [template.bitset]:
+ </p>
+
+-<blockquote><pre>#include &lt;cstddef&gt; // for size_t
++<blockquote><pre>
++#include &lt;cstddef&gt; // for size_t
+ #include &lt;string&gt;
+ <del>#include &lt;stdexcept&gt; // for invalid_argument,</del>
+ <del>// out_of_range, overflow_error</del>
+@@ -70794,23 +78858,209 @@ namespace std {
+
+
+ <hr>
++<h3><a name="1229"></a>1229. <tt>error_code operator=</tt> typo</h3>
++<p><b>Section:</b> 19.5.2.3 [syserr.errcode.modifiers] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2009-10-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>
++19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers] say:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
++ typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value&gt;::type&amp;
++ operator=(ErrorCodeEnum e);
++</pre></blockquote>
++
++<p>
++They should say:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
++ typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value, error_code&gt;::type&amp;
++ operator=(ErrorCodeEnum e);
++</pre></blockquote>
++
++<p>
++Or (I prefer this form):
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
++ typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value, error_code&amp;&gt;::type
++ operator=(ErrorCodeEnum e);
++</pre></blockquote>
++
++<p>
++This is because <tt>enable_if</tt> is declared as (20.10.7.6 [meta.trans.other]):
++</p>
++
++<blockquote><pre>
++template &lt;bool B, class T = void&gt; struct enable_if;
++</pre></blockquote>
++
++<p>
++So, the current wording makes <tt>operator=</tt> return
++<tt>void&amp;</tt>, which is not good.
++</p>
++
++<p>
++19.5.2.3 [syserr.errcode.modifiers]/4 says
++</p>
++
++<blockquote><p>
++<i>Returns:</i> <tt>*this</tt>.
++</p></blockquote>
++<p>
++which is correct.
++</p>
++
++<p>
++Additionally,
++</p>
++
++<p>
++19.5.3.1 [syserr.errcondition.overview]/1 says:
++</p>
++
++<blockquote><pre>
++template&lt;typename ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;, error_code&gt;::type &amp;
++ operator=( ErrorConditionEnum e );
++</pre></blockquote>
++
++<p>
++Which contains several problems (<tt>typename</tt> versus <tt>class</tt>
++inconsistency, lack of <tt>::value</tt>, <tt>error_code</tt> instead of
++<tt>error_condition</tt>), while 19.5.3.3 [syserr.errcondition.modifiers] says:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value&gt;::type&amp;
++ operator=(ErrorConditionEnum e);
++</pre></blockquote>
++
++<p>
++Which returns <tt>void&amp;</tt>. They should both say:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value,
++ error_condition&gt;::type&amp;
++ operator=(ErrorConditionEnum e);
++</pre></blockquote>
++
++<p>
++Or (again, I prefer this form):
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value,
++ error_condition&amp;&gt;::type
++ operator=(ErrorConditionEnum e);
++</pre></blockquote>
++
++<p>
++Additionally, 19.5.3.3 [syserr.errcondition.modifiers] lacks a
++"<i>Returns:</i> <tt>*this</tt>." paragraph, which is presumably
++necessary.
++</p>
++
++<p><i>[
++2009-10-18 Beman adds:
++]</i></p>
++
++
++<blockquote><p>
++The proposed resolution for issue <a href="lwg-defects.html#1237">1237</a> makes this issue
++moot, so it should become NAD.
++</p></blockquote>
++
++<p><i>[
++2009-10 Santa Cruz:
++]</i></p>
++
++
++<blockquote><p>
++<del>NAD</del><ins>Resolved</ins>, solved by <a href="lwg-defects.html#1237">1237</a>.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Change 19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers]:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
++ typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value<ins>,
++ error_code&amp;</ins>&gt;::type<del>&amp;</del>
++ operator=(ErrorCodeEnum e);
++</pre></blockquote>
++
++<p>
++Change 19.5.3.1 [syserr.errcondition.overview]:
++</p>
++
++<blockquote><pre>
++template&lt;<del>typename</del> <ins>class</ins> ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;<ins>::value</ins>,
++ error_co<ins>ndition</ins><del>de</del><ins>&amp;</ins>&gt;::type<del> &amp;</del>
++ operator=( ErrorConditionEnum e );
++</pre></blockquote>
++
++<p>
++Change 19.5.3.3 [syserr.errcondition.modifiers]:
++</p>
++
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
++ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value<ins>,
++ error_condition&amp;</ins>&gt;::type<del>&amp;</del>
++ operator=(ErrorConditionEnum e);
++</pre>
++<blockquote>
++<p>
++<i>Postcondition:</i> <tt>*this == make_error_condition(e)</tt>.
++</p>
++<p><ins>
++<i>Returns:</i> <tt>*this</tt>.
++</ins></p>
++<p>
++<i>Throws:</i> Nothing.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1231"></a>1231. <tt>weak_ptr</tt> comparisons incompletely resolved</h3>
+-<p><b>Section:</b> 20.9.10.3.5 [util.smartptr.weak.obs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.3.5 [util.smartptr.weak.obs] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.weak.obs">issues</a> in [util.smartptr.weak.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2637.pdf">n2637</a>
+-paper suggested several updates of the ordering semantics of
+-<tt>shared_ptr</tt>
++paper suggested several updates of the ordering semantics of <tt>shared_ptr</tt>
+ and <tt>weak_ptr</tt>, among those the explicit comparison operators of <tt>weak_ptr</tt> were
+-removed/deleted, instead a corresponding functor <tt>owner_less</tt> was added.
+-The problem
+-is that
++removed&#47;deleted, instead a corresponding functor <tt>owner_less</tt> was added.
++The problem is that
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2637.pdf">n2637</a>
+-did not clearly enough specify, how the previous wording
+-parts describing
++did not clearly enough specify, how the previous wording parts describing
+ the comparison semantics of <tt>weak_ptr</tt> should be removed.
+ </p>
+
+@@ -70819,9 +79069,9 @@ the comparison semantics of <tt>weak_ptr</tt> should be removed.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -70829,27 +79079,27 @@ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+ <ol>
+ <li>
+ <p>
+-Change 20.9.10.3 [util.smartptr.weak]/2 as described, the intention is to fix
+-the now no longer valid
+-requirement that <tt>weak_ptr</tt> is <tt>LessComparable</tt> [Note the deleted comma]:
++Change 20.8.2.3 [util.smartptr.weak]/2 as described, the intention is to fix
++the now no longer valid requirement that <tt>weak_ptr</tt> is <tt>LessComparable</tt>
++[Note the deleted comma]:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Specializations of <tt>weak_ptr</tt> shall be <tt>CopyConstructible</tt><del>,</del>
+-<ins>and</ins> <tt>CopyAssignable</tt>,
+-<del>and <tt>LessThanComparable</tt>,</del> allowing their use in standard containers.
+-</blockquote>
++<ins>and</ins> <tt>CopyAssignable</tt>, <del>and <tt>LessThanComparable</tt>,</del>
++allowing their use in standard containers.
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-In 20.9.10.3.5 [util.smartptr.weak.obs] remove the paragraphs 9-11 including prototype:
++In 20.8.2.3.5 [util.smartptr.weak.obs] remove the paragraphs 9-11 including prototype:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <del>template&lt;class T, class U&gt; bool operator&lt;(const weak_ptr&lt;T&gt;&amp; a, const weak_ptr&lt;U&gt;&amp; b);</del>
+
+-<p>
++<p/>
+ <del><i>Returns:</i> an unspecified value such that</del>
+ </p>
+ <ul>
+@@ -70869,7 +79119,7 @@ equivalent if and only if they share ownership or are both empty.</del>
+
+ <p>
+ <del>[<i>Note:</i> Allows <tt>weak_ptr</tt> objects to be used as keys in associative
+-containers. — <i>end note</i>]</del>
++containers. &mdash; <i>end note</i>]</del>
+ </p>
+ </blockquote>
+ </li>
+@@ -70880,19 +79130,19 @@ containers.
+
+
+ <hr>
+-<h3><a name="1234"></a>1234. "Do the right thing" and NULL</h3>
+-<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-10-09 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1234"></a>1234. "Do the right thing" and <tt>NULL</tt></h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2009-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-On g++ 4.2.4 (x86_64-linux-gnu), the following file gives a compile
+-error:
++On g++ 4.2.4 (x86_64-linux-gnu), the following file gives a compile error:
+ </p>
+
+-<blockquote><pre>#include &lt;vector&gt;
+-void foo() { std::vector&lt;int*&gt; v(500l, NULL); }
++<blockquote><pre>
++#include &lt;vector&gt;
++void foo() { std::vector&lt;int*&gt; v(500L, NULL); }
+ </pre></blockquote>
+
+ <p>
+@@ -70900,15 +79150,15 @@ Is this supposed to work?
+ </p>
+
+ <p>
+-The issue: if <tt>NULL</tt> happens to be defined as <tt>0l</tt>, this is an invocation of
++The issue: if <tt>NULL</tt> happens to be defined as <tt>0L</tt>, this is an invocation of
+ the constructor with two arguments of the same integral type.
+ 23.2.3 [sequence.reqmts]/14
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3035.pdf">N3035</a>)
+-says that this will behave as if the the
+-overloaded constructor
++says that this will behave as if the overloaded constructor
+ </p>
+
+-<blockquote><pre>X(size_type, const value_type&amp; = value_type(),
++<blockquote><pre>
++X(size_type, const value_type&amp; = value_type(),
+ const allocator_type&amp; = allocator_type())
+ </pre></blockquote>
+
+@@ -70950,13 +79200,13 @@ Adapts the numbering used in the discussion to the recent working paper
+ <li>
+ Proposes a resolution that requires implementations to use sfinae-like means to
+ possibly filter away the too generic template c'tor. In fact this resolution is
+-equivalent to that used for the <tt>pair-NULL</tt> problem (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>),
++equivalent to that used for the <tt>pair-NULL</tt> problem (<a href="lwg-defects.html#811">811</a>),
+ the only difference is, that issue 1234 was already a C++03 problem.
+ </li>
+ </ul>
+
+ <p>
+-This issue can be considered as a refinement of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#438">438</a>.
++This issue can be considered as a refinement of <a href="lwg-defects.html#438">438</a>.
+ </p>
+
+ </blockquote>
+@@ -70972,9 +79222,9 @@ WP has a defect that should be fixed here as well: The functions signatures <tt>
+ incorrectly referring to <tt>iterator</tt> instead of <tt>const_iterator</tt>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording after 7 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -71001,17 +79251,16 @@ Change 23.2.3 [sequence.reqmts]/14+15 as indicated:
+ If the constructor
+ </p>
+
+-<blockquote><pre>template &lt;class InputIterator&gt;
++<blockquote><pre>
++template &lt;class InputIterator&gt;
+ X(InputIterator first, InputIterator last,
+ const allocator_type&amp; alloc = allocator_type())
+-
+ </pre></blockquote>
+
+ <p>
+ is called with a type <tt>InputIterator</tt> that does not qualify as an input
+ iterator, then the constructor <ins>shall not participate in overload
+-resolution.</ins><del>will
+-behave as if the overloaded constructor:</del>
++resolution.</ins><del>will behave as if the overloaded constructor:</del>
+ </p>
+
+ <blockquote><pre><del>
+@@ -71020,9 +79269,8 @@ X(size_type, const value_type&amp; = value_type(),
+ </del></pre></blockquote>
+
+ <p>
+-<del>were called instead, with the arguments
+-<tt>static_cast&lt;size_type&gt;(first)</tt>, <tt>last</tt> and <tt>alloc</tt>,
+-respectively</del>.
++<del>were called instead, with the arguments <tt>static_cast&lt;size_type&gt;(first)</tt>,
++<tt>last</tt> and <tt>alloc</tt>, respectively</del>.
+ </p>
+ </li>
+
+@@ -71032,7 +79280,8 @@ respectively</del>.
+ If the member functions of the forms:
+ </p>
+
+-<blockquote><pre>template &lt;class InputIterator&gt; <i>// such as insert()</i>
++<blockquote><pre>
++template &lt;class InputIterator&gt; <i>// such as insert()</i>
+ rt fx1(<ins>const_</ins>iterator p, InputIterator first, InputIterator last);
+
+ template &lt;class InputIterator&gt; <i>// such as append(), assign()</i>
+@@ -71048,7 +79297,8 @@ iterator, then these functions <ins>shall not participate in overload
+ resolution.</ins><del>will behave as if the overloaded member functions:</del>
+ </p>
+
+-<blockquote><pre><del>rt fx1(iterator, size_type, const value_type&amp;);</del>
++<blockquote><pre>
++<del>rt fx1(iterator, size_type, const value_type&amp;);</del>
+
+ <del>rt fx2(size_type, const value_type&amp;);</del>
+
+@@ -71075,11 +79325,11 @@ not implicitly convertible to <tt>X::value_type</tt>.
+
+
+ <hr>
+-<h3><a name="1237"></a>1237. Constrained error_code/error_condition members</h3>
+-<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-14 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#syserr">issues</a> in [syserr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1237"></a>1237. Constrained <tt>error_code</tt>&#47;<tt>error_condition members</tt></h3>
++<p><b>Section:</b> 19.5 [syserr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr">issues</a> in [syserr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I'm just reflecting on the now SFINAE-constrained constructors
+@@ -71095,21 +79345,22 @@ which has IMO several disadvantages:
+ <li>
+ <p>
+ With the availability of template default arguments and
+-decltype, using <tt>enable_if</tt> in C++0x standard library, seems
++decltype, using <tt>enable_if</tt> in the C++0x standard library, seems
+ unnecessary restricting implementation freedom. E.g. there
+-should be not need for a useless specification of a dummy
++should be no need for a useless specification of a dummy
+ default function argument, which only confuses the reader.
+ A more reasonable implementation could e.g. be
+ </p>
+
+-<blockquote><pre>template &lt;class ErrorCodeEnum
++<blockquote><pre>
++template &lt;class ErrorCodeEnum
+ class = typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value&gt;::type&gt;
+ error_code(ErrorCodeEnum e);
+ </pre></blockquote>
+
+ <p>
+ As currently specified, the function signatures are so unreadable,
+-that errors quite easily happen, see e.g. <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1229">1229</a>.
++that errors quite easily happen, see e.g. <a href="lwg-defects.html#1229">1229</a>.
+ </p>
+ </li>
+
+@@ -71119,10 +79370,10 @@ We have a <em>lot</em> of constrained functions in other places, that
+ now have a standard phrase that is easily understandable:
+ </p>
+
+-<blockquote>
+-<i>Remarks:</i> This constructor/function shall participate in overload
++<blockquote><p>
++<i>Remarks:</i> This constructor&#47;function shall participate in overload
+ resolution if and only if X.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ where X describes the condition. Why should these components deviate?
+@@ -71155,24 +79406,24 @@ corresponding resolution.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I support this proposed resolution, and thank Daniel for writing it up.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-10 Santa Cruz:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p><i>[
+-Should this resolution be accepted, I recommend to resolve <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1229">1229</a> as NAD
++Should this resolution be accepted, I recommend to resolve <a href="lwg-defects.html#1229">1229</a> as NAD
+ ]</i></p>
+
+
+@@ -71183,7 +79434,8 @@ In 19.5.2.1 [syserr.errcode.overview]/1, class <tt>error_code</tt>,
+ change as indicated:
+ </p>
+
+-<blockquote><pre>// 19.5.2.2 constructors:
++<blockquote><pre>
++// 19.5.2.2 constructors:
+ error_code();
+ error_code(int val, const error_category&amp; cat);
+ template &lt;class ErrorCodeEnum&gt;
+@@ -71204,7 +79456,8 @@ void clear();
+ Change 19.5.2.2 [syserr.errcode.constructors] around the prototype before p. 7:
+ </p>
+
+-<blockquote><pre>template &lt;class ErrorCodeEnum&gt;
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
+ error_code(ErrorCodeEnum e<del>,
+ typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value&gt;::type * = 0</del>);
+ </pre>
+@@ -71223,15 +79476,16 @@ resolution, unless
+ Change 19.5.2.3 [syserr.errcode.modifiers] around the prototype before p. 3:
+ </p>
+
+-<blockquote><pre>template &lt;class ErrorCodeEnum&gt;
++<blockquote><pre>
++template &lt;class ErrorCodeEnum&gt;
+ <del>typename enable_if&lt;is_error_code_enum&lt;ErrorCodeEnum&gt;::value&gt;::type</del><ins>error_code</ins>&amp;
+ operator=(ErrorCodeEnum e);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <ins><i>Remarks:</i> This operator shall not participate in overload resolution, unless
+ <tt>is_error_code_enum&lt;ErrorCodeEnum&gt;::value == true</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -71241,7 +79495,8 @@ In 19.5.3.1 [syserr.errcondition.overview]/1, class <tt>error_condition</tt>, ch
+ as indicated:
+ </p>
+
+-<blockquote><pre>// 19.5.3.2 constructors:
++<blockquote><pre>
++// 19.5.3.2 constructors:
+ error_condition();
+ error_condition(int val, const error_category&amp; cat);
+ template &lt;class ErrorConditionEnum&gt;
+@@ -71263,15 +79518,16 @@ Change 19.5.3.2 [syserr.errcondition.constructors] around the
+ prototype before p. 7:
+ </p>
+
+-<blockquote><pre>template &lt;class ErrorConditionEnum&gt;
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
+ error_condition(ErrorConditionEnum e<del>,
+ typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value&gt;::type* = 0</del>);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <ins><i>Remarks:</i> This constructor shall not participate in overload
+ resolution, unless
+ <tt>is_error_condition_enum&lt;ErrorConditionEnum&gt;::value == true</tt>.</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+ </li>
+
+@@ -71281,7 +79537,8 @@ Change 19.5.3.3 [syserr.errcondition.modifiers] around the
+ prototype before p. 3:
+ </p>
+
+-<blockquote><pre>template &lt;class ErrorConditionEnum&gt;
++<blockquote><pre>
++template &lt;class ErrorConditionEnum&gt;
+ <del>typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;::value&gt;::type</del><ins>error_condition</ins>&amp;
+ operator=(ErrorConditionEnum e);
+ </pre>
+@@ -71311,18 +79568,20 @@ prototype before p. 3:
+
+
+ <hr>
+-<h3><a name="1240"></a>1240. Deleted comparison functions of std::function not needed</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-18 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1240"></a>1240. Deleted comparison functions of <tt>std::function</tt> not needed</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The class template <tt>std::function</tt> contains the following member
+ declarations:
+ </p>
+
+-<blockquote><pre>// deleted overloads close possible hole in the type system
++<blockquote><pre>
++// deleted overloads close possible hole in the type system
+ template&lt;class R2, class... ArgTypes2&gt;
+ bool operator==(const function&lt;R2(ArgTypes2...)&gt;&amp;) = delete;
+ template&lt;class R2, class... ArgTypes2&gt;
+@@ -71331,14 +79590,16 @@ template&lt;class R2, class... ArgTypes2&gt;
+
+ <p>
+ The leading comment here is part of the history of <tt>std::function</tt>, which
+-was introduced with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1402.html#undefined_operators">N1402</a>.
++was introduced with
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1402.html#undefined_operators">N1402</a>.
+ During that time no explicit conversion functions existed, and the
+ "safe-bool" idiom (based on pointers-to-member) was a popular
+ technique. The only disadvantage of this idiom was that given two
+ objects <tt>f1</tt> and <tt>f2</tt> of type <tt>std::function</tt> the expression
+ </p>
+
+-<blockquote><pre>f1 == f2;
++<blockquote><pre>
++f1 == f2;
+ </pre></blockquote>
+
+ <p>
+@@ -71366,9 +79627,9 @@ Post-Rapperswil
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -71379,10 +79640,11 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.8.14.2 [func.wrap.func]/1, class function change as indicated:
++In 20.9.12.2 [func.wrap.func]/1, class function change as indicated:
+ </p>
+
+-<blockquote><pre>// 20.7.15.2.3, function capacity:
++<blockquote><pre>
++// 20.7.15.2.3, function capacity:
+ explicit operator bool() const;
+
+ <del>// deleted overloads close possible hole in the type system</del>
+@@ -71397,22 +79659,22 @@ explicit operator bool() const;
+
+
+ <hr>
+-<h3><a name="1241"></a>1241. unique_copy needs to require EquivalenceRelation</h3>
+-<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-10-17 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1241"></a>1241. <tt>unique_copy</tt> needs to require <tt>EquivalenceRelation</tt></h3>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ A lot of fixes were silently applied during concept-time and we should
+ not lose them again. The Requires clause of 25.3.9 [alg.unique]/5
+ doesn't mention that <tt>==</tt> and the predicate need to satisfy an
+-<tt>EquivalenceRelation</tt>, as it is correctly said for
+-<tt>unique</tt>. This was intentionally fixed during conceptification,
+-were we had:
++<tt>EquivalenceRelation</tt>, as it is correctly said for <tt>unique</tt>.
++This was intentionally fixed during conceptification, were we had:
+ </p>
+
+-<blockquote><pre>template&lt;InputIterator InIter, class OutIter&gt;
++<blockquote><pre>
++template&lt;InputIterator InIter, class OutIter&gt;
+ requires OutputIterator&lt;OutIter, RvalueOf&lt;InIter::value_type&gt;::type&gt;
+ &amp;&amp; EqualityComparable&lt;InIter::value_type&gt;
+ &amp;&amp; HasAssign&lt;InIter::value_type, InIter::reference&gt;
+@@ -71435,7 +79697,7 @@ Note that EqualityComparable implied an equivalence relation.
+ <p><i>[
+ N.B. <tt>adjacent_find</tt> was also specified to require
+ <tt>EquivalenceRelation</tt>, but that was considered as a defect in
+-concepts, see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1000">1000</a>
++concepts, see <a href="lwg-closed.html#1000">1000</a>
+ ]</i></p>
+
+
+@@ -71444,9 +79706,9 @@ concepts, see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.ht
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -71455,7 +79717,8 @@ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+ Change 25.3.9 [alg.unique]/5 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator, class OutputIterator&gt;
++<blockquote><pre>
++template&lt;class InputIterator, class OutputIterator&gt;
+ OutputIterator
+ unique_copy(InputIterator first, InputIterator last, OutputIterator result);
+
+@@ -71464,7 +79727,7 @@ template&lt;class InputIterator, class OutputIterator, class BinaryPredicate&gt;
+ unique_copy(InputIterator first, InputIterator last,
+ OutputIterator result, BinaryPredicate pred);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> <ins>The comparison function shall be an equivalence
+ relation.</ins> The ranges <tt>[first,last)</tt> and
+ <tt>[result,result+(last-first))</tt> shall not overlap. The expression
+@@ -71474,7 +79737,7 @@ requirements of forward iterator then the value type of
+ <tt>InputIterator</tt> shall be <tt>CopyConstructible</tt> (34) and
+ <tt>CopyAssignable</tt> (table 36). Otherwise <tt>CopyConstructible</tt>
+ is not required.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -71482,22 +79745,65 @@ is not required.
+
+
+ <hr>
++<h3><a name="1244"></a>1244. <tt>wait_*()</tt> in <tt>*future</tt> for synchronous functions</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Detlef Vollmann <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++With the addition of <tt>async()</tt>, a <tt>future</tt> might be
++associated with a function that is not running in a different thread but
++is stored to by run synchronously on the <tt>get()</tt> call. It's not
++clear what the <tt>wait()</tt> functions should do in this case.
++</p>
++
++<p>
++Suggested resolution:
++</p>
++
++<p>
++Throw an exception.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1245"></a>1245. <tt>std::hash&lt;string&gt;</tt> &amp; co</h3>
+-<p><b>Section:</b> 20.8.15 [unord.hash] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2009-10-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.8.15 [unord.hash], <tt>operator()</tt> is specified as
++In 20.9.13 [unord.hash], <tt>operator()</tt> is specified as
+ taking the argument by value. Moreover, it is said that <tt>operator()</tt> shall
+ not throw exceptions.
+ </p>
+
+ <p>
+-However, for the specializations for class types, like <tt>string</tt>, <tt>wstring</tt>,
+-etc, the former requirement seems suboptimal from the performance point
+-of view (a specific PR has been filed about this in the GCC Bugzilla)
++However, for the specializations for class types, like <tt>string</tt>,
++<tt>wstring</tt>, etc, the former requirement seems suboptimal from the
++performance point of view (a specific PR has been filed about this in the GCC Bugzilla)
+ and, together with the latter requirement, hard if not impossible to
+ fulfill. It looks like pass by const reference should be allowed in such
+ cases.
+@@ -71508,11 +79814,11 @@ cases.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I've removed the list of types for which <tt>hash</tt> shall be instantiated
+ because it's already explicit in the synopsis of header
+-<tt>&lt;functional&gt;</tt> in 20.8 [function.objects]/2.
+-</blockquote>
++<tt>&lt;functional&gt;</tt> in 20.9 [function.objects]/2.
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-18: Original wording here:
+@@ -71521,11 +79827,12 @@ because it's already explicit in the synopsis of header
+
+ <blockquote class="note">
+ <p>
+-Add to 20.8.15 [unord.hash]/2:
++Add to 20.9.13 [unord.hash]/2:
+ </p>
+
+ <blockquote>
+-<pre>namespace std {
++<pre>
++namespace std {
+ template &lt;class T&gt;
+ struct hash : public std::unary_function&lt;T, std::size_t&gt; {
+ std::size_t operator()(T val) const;
+@@ -71553,13 +79860,13 @@ types takes its argument by value or const reference.</ins>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I have received community requests to ask for this issue to be reopened.
+ Some users feel that mandating the inheritance is overly constraining.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-2010-01-31 Alisdair: related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#978">978</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1182">1182</a>.
++2010-01-31 Alisdair: related to <a href="lwg-defects.html#978">978</a> and <a href="lwg-defects.html#1182">1182</a>.
+ ]</i></p>
+
+
+@@ -71576,48 +79883,48 @@ Some users feel that mandating the inheritance is overly constraining.
+
+
+ <p><b>Proposed resolution:</b></p>
+- <p><i>Insert a new subclause either before or after the current 20.2.5 [allocator.requirements]:</i></p>
++ <p><i>Insert a new subclause either before or after the current 17.6.3.5 [allocator.requirements]:</i></p>
+ <blockquote>
+
+ <h3><tt>Hash</tt> Requirements [hash.requirements]</h3>
+
+- <p align="left">This subclause defines the named requirement <tt>Hash</tt>,
++ <p>This subclause defines the named requirement <tt>Hash</tt>,
+ used in several clauses of the C++ standard library. A type <tt>H</tt> meets the <tt>Hash</tt> requirement if</p>
+
+ <ul>
+ <li>
+
+- <p align="left">it is a function object type (20.8 [function.objects]).</p>
++ <p>it is a function object type (20.9 [function.objects]).</p>
+
+ </li>
+ <li>
+
+- <p align="left">it satisfies the requirements of <tt>CopyConstructible</tt>, and
+- <tt>Destructible</tt> (20.2.1 [utility.arg.requirements]),</p>
++ <p>it satisfies the requirements of <tt>CopyConstructible</tt>, and
++ <tt>Destructible</tt> (17.6.3.1 [utility.arg.requirements]),</p>
+
+ </li>
+ <li>
+
+- <p align="left">the expressions shown in the following table are valid and have the
++ <p>the expressions shown in the following table are valid and have the
+ indicated semantics, and</p>
+
+ </li>
+ <li>
+
+- <p align="left">it satisfies all other requirements of this subclause.</p>
++ <p>it satisfies all other requirements of this subclause.</p>
+
+ </li>
+ </ul>
+
+- <p align="left">Given <tt>Key</tt> is an argument type for function objects of
++ <p>Given <tt>Key</tt> is an argument type for function objects of
+ type <tt>H</tt>, in the table below <tt>h</tt> is a value of type (possibly <tt>const</tt>)
+ <tt>H</tt>, <tt>u</tt> is an lvalue of type <tt>Key</tt>,&nbsp; and <tt>
+ k</tt>
+ is a value of a type convertible to (possibly <tt>const</tt>) <tt>Key</tt>:</p>
+
+- <p align="center">Table ? - <tt>Hash</tt> requirements</p>
+-<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
+- <tbody><tr>
++<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse">
++ <caption>Table ? &mdash; <tt>Hash</tt> requirements</caption>
++ <tr>
+ <td>Expression</td>
+ <td>Return type</td>
+ <td>Requirement</td>
+@@ -71628,11 +79935,11 @@ Some users feel that mandating the inheritance is overly constraining.
+ <td valign="top">Shall not throw exceptions. The value returned shall depend only on
+ the argument <tt>k</tt>. [<i>Note:</i> Thus all evaluations of the expression <tt>
+ h(k)</tt> with the
+- same value for <tt>k</tt> yield the same result. <i>— end note</i>] [<i>Note:
++ same value for <tt>k</tt> yield the same result. <i>&mdash; end note</i>] [<i>Note:
+ </i>For <tt>t1</tt> and <tt>t2</tt> of different values, the probability that
+ <tt>h(t1)</tt>
+ and <tt>h(t2)</tt> compare equal should be very small, approaching <tt>(1.0/numeric_limits&lt;size_t&gt;::max())</tt>.
+- <i>— end note</i>] <i><span style="background-color: #C0C0C0">Comment
++ <i>&mdash; end note</i>] <i><span style="color:#C0C0C0">Comment
+ (not to go in WP): The wording for the second note is based on a similar
+ note in 22.4.4.1.2 [locale.collate.virtuals]/3</span></i></td>
+ </tr>
+@@ -71641,14 +79948,14 @@ the argument <tt>k</tt>. [<i>Note:</i> Thus all evaluations of the expression <t
+ <td valign="top"><tt>size_t</tt></td>
+ <td valign="top">Shall not modify <tt>u</tt>.</td>
+ </tr>
+- </tbody></table>
++ </table>
+
+ </blockquote>
+
+-<p><i>Change 20.8.15 [unord.hash] as indicated: </i>
++<p><i>Change 20.9.13 [unord.hash] as indicated: </i>
+ </p>
+ <blockquote>
+- <p>1 The unordered associative containers defined in Clause 23.7 [unord] use
++ <p>1 The unordered associative containers defined in Clause 23.5 [unord] use
+ specializations of <ins>the class template</ins> <tt>hash</tt> as the default
+ hash function. <ins>For all object types <tt>T</tt> for which there exists a
+ specialization <tt>hash&lt;T&gt;</tt>, the instantiation <tt>hash&lt;T&gt;</tt> shall:</ins></p>
+@@ -71701,7 +80008,7 @@ equal if the container's equality function object returns <tt>true</tt> when pas
+ values. If <tt>k1</tt> and <tt>k2</tt> are equal, the hash function shall return
+ the same value for both. <ins>[<i>Note:</i> Thus supplying a non-default <tt>Pred</tt>
+ parameter usually implies the need to supply a non-default <tt>Hash</tt>
+-parameter. <i>— end note</i>]</ins></p>
++parameter. <i>&mdash; end note</i>]</ins></p>
+
+ </blockquote>
+
+@@ -71712,20 +80019,20 @@ parameter. <i>
+
+ <hr>
+ <h3><a name="1247"></a>1247. <tt>auto_ptr</tt> is overspecified</h3>
+-<p><b>Section:</b> D.12.1 [auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> X [auto.ptr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#auto.ptr">issues</a> in [auto.ptr].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ This issue is extracted as the ongoing point-of-interest from earlier
+-issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#463">463</a>.
++issue <a href="lwg-closed.html#463">463</a>.
+ </p>
+
+ <p>
+ <tt>auto_ptr</tt> is overspecified as the <tt>auto_ptr_ref</tt>
+ implementation detail is formally specified, and the technique is
+-observable so workarounds for compiler defects can cause a working
++observable so workarounds for compiler defects can cause a working
+ implementation of the primary <tt>auto_ptr</tt> template become
+ non-conforming.
+ </p>
+@@ -71747,10 +80054,10 @@ I wonder, whether the revised wording shouldn't be as straight as
+ for <tt>istream_buf</tt> by adding one further sentence:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ An implementation is permitted to provide equivalent functionality without
+ providing a class with this name.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -71775,7 +80082,7 @@ Add the term "exposition only" in the following two places:
+ </p>
+
+ <p>
+-Ammend D.12.1 [auto.ptr]p2:
++Ammend X [auto.ptr]p2:
+ </p>
+
+ <blockquote>
+@@ -71788,7 +80095,8 @@ passed to and returned from functions.
+ without providing a class with this name.</ins>
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class Y&gt; struct auto_ptr_ref { }; <ins>// exposition only</ins>
+ </pre></blockquote>
+ </blockquote>
+@@ -71798,16 +80106,62 @@ without providing a class with this name.</ins>
+
+
+ <hr>
+-<h3><a name="1249"></a>1249. basic_ios default ctor</h3>
+-<p><b>Section:</b> 27.5.4.1 [basic.ios.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1248"></a>1248. Equality comparison for unordered containers</h3>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Herb Sutter <b>Opened:</b> 2009-10-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The basic_ios default ctor is required to leave the objects members
++See
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>.
++</p>
++
++<p><i>[
++2010-01-22 Alisdair Opens.
++]</i></p>
++
++
++<p><i>[
++2010-01-24 Alisdair provides wording.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf">N3068</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Apply paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2986.pdf">N2986</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1249"></a>1249. <tt>basic_ios</tt> default ctor</h3>
++<p><b>Section:</b> 27.5.5.2 [basic.ios.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.ios.cons">issues</a> in [basic.ios.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>basic_ios</tt> default ctor is required to leave the objects members
+ uninitialized (see below). The paragraph says the object must be
+-initialized by calling basic_ios::init() before it's destroyed by
++initialized by calling <tt>basic_ios::init()</tt> before it's destroyed but
+ I can't find a requirement that it be initialized before calling
+ any of the class other member functions. Am I not looking in the
+ right place or that an issue?
+@@ -71823,22 +80177,22 @@ right place or that an issue?
+ I agree, that your wording makes that clearer, but suggest to write
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ ... calling <tt>basic_ios::init<del>()</del></tt> before ...
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Doing so, I recommend to adapt that of <tt>ios_base();</tt> as well, where
+ we have:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Each <tt>ios_base</tt> member has an indeterminate value
+ after construction. These members shall be initialized by calling
+ <tt>basic_ios::init</tt>. If an <tt>ios_base</tt> object is destroyed
+ before these initializations have taken place, the behavior is
+ undefined.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -71846,9 +80200,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -71859,12 +80213,13 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 27.5.2.7 [ios.base.cons] p1:
++Change 27.5.3.7 [ios.base.cons] p1:
+ </p>
+
+-<blockquote><pre>ios_base();
++<blockquote><pre>
++ios_base();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Each <tt>ios_base</tt> member has an indeterminate value
+ after construction. <del>These</del> <ins>The object's</ins> members shall be initialized by calling
+ <tt>basic_ios::init</tt> <ins>before the object's first use or before
+@@ -71872,16 +80227,17 @@ after construction. <del>These</del> <ins>The object's</ins> members shall be in
+ is undefined.</ins>. <del>If an <tt>ios_base</tt> object is destroyed
+ before these initializations have taken place, the behavior is
+ undefined.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+-Change 27.5.4.1 [basic.ios.cons] p2:
++Change 27.5.5.2 [basic.ios.cons] p2:
+ </p>
+
+-<blockquote><pre>basic_ios();
++<blockquote><pre>
++basic_ios();
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Constructs an object of class <tt>basic_ios</tt>
+ (27.5.2.7) leaving its member objects uninitialized. The object shall be
+ initialized by calling <del>its</del>
+@@ -71889,7 +80245,7 @@ initialized by calling <del>its</del>
+ use or before it is destroyed, whichever comes first; otherwise the
+ behavior is undefined.</ins> <del>member function. If it is destroyed
+ before it has been initialized the behavior is undefined.</del>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -71898,13 +80254,14 @@ before it has been initialized the behavior is undefined.</del>
+
+ <hr>
+ <h3><a name="1250"></a>1250. <tt>&lt;bitset&gt;</tt> still overspecified</h3>
+-<p><b>Section:</b> 20.5 [template.bitset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-29 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.6 [template.bitset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Martin Sebor <b>Opened:</b> 2009-10-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#template.bitset">active issues</a> in [template.bitset].</p>
++<p><b>View all other</b> <a href="lwg-index.html#template.bitset">issues</a> in [template.bitset].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1227">1227</a> — <tt>&lt;bitset&gt;</tt> synopsis overspecified makes the observation
++Issue <a href="lwg-defects.html#1227">1227</a> &mdash; <tt>&lt;bitset&gt;</tt> synopsis overspecified makes the observation
+ that <tt>std::bitset</tt>, and in fact the whole library, may be implemented
+ without needing to <tt>#include &lt;stdexcept&gt;</tt> in any library header. The
+ proposed resolution removes the <tt>#include &lt;stdexcept&gt;</tt> directive from
+@@ -71936,10 +80293,11 @@ removed from the synopsis of <tt>&lt;bitset&gt;</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.5 [template.bitset]:
++Change 20.6 [template.bitset]:
+ </p>
+
+-<blockquote><pre><del>#include &lt;cstddef&gt; // for size_t</del>
++<blockquote><pre>
++<del>#include &lt;cstddef&gt; // for size_t</del>
+ #include &lt;string&gt;
+ #include &lt;iosfwd&gt; // for istream, ostream
+ namespace std {
+@@ -71951,20 +80309,338 @@ namespace std {
+
+
+ <hr>
++<h3><a name="1252"></a>1252. <tt>wbuffer_convert::state_type</tt> inconsistency</h3>
++<p><b>Section:</b> 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.buffer">active issues</a> in [conversions.buffer].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.buffer">issues</a> in [conversions.buffer].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The synopsis for <tt>wbuffer_convert</tt> 22.3.3.2.3 [conversions.buffer]/2 contains
++</p>
++
++<blockquote><pre>
++typedef typename Tr::state_type state_type;
++</pre></blockquote>
++
++<p>
++making <tt>state_type</tt> a synonym for (possibly) some
++<tt>char_traits&lt;x&gt;::state_type</tt>.
++</p>
++
++<p>
++However, in paragraph 9 of the same section, we have
++</p>
++
++<blockquote><pre>
++typedef typename Codecvt::state_type state_type;
++</pre>
++
++<blockquote><p>
++The type shall be a synonym for <tt>Codecvt::state_type</tt>.
++</p></blockquote>
++</blockquote>
++
++<p>
++From what I can see, it might be hard to implement <tt>wbuffer_convert</tt> if
++the types were not both <tt>std::mbstate_t</tt>, but I cannot find a requirement
++that they must be the same type.
++</p>
++
++<p><i>[
++Batavia 2010:
++]</i></p>
++
++
++<p>
++Howard to draft wording, move to Review. Run it by Bill. Need to move this in Madrid.
++</p>
++
++<p><i>[2011-03-06: Howard drafts wording]</i></p>
++
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>Moved to Immediate</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Modify the <tt>state_type</tt> typedef in the synopsis of 22.3.3.2.3 [conversions.buffer] p.2 as shown
++[This makes the synopsis consistent with 22.3.3.2.3 [conversions.buffer] p.9]:</p>
++
++<blockquote><pre>
++namespace std {
++template&lt;class Codecvt,
++ class Elem = wchar_t,
++ class Tr = std::char_traits&lt;Elem&gt; &gt;
++class wbuffer_convert
++ : public std::basic_streambuf&lt;Elem, Tr&gt; {
++public:
++ typedef typename <del>Tr</del><ins>Codecvt</ins>::state_type state_type;
++ [&hellip;]
++};
++}
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1253"></a>1253. invalidation of iterators and <tt>emplace</tt> vs. <tt>insert</tt> inconsistence in assoc. containers</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Boris Du&scaron;ek <b>Opened:</b> 2009-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In the latest published draft
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2960.pdf">N2960</a>,
++section 23.2.4 [associative.reqmts], paragraph 8, it is specified
++that that <tt>insert</tt> does not invalidate any iterators. As per
++23.2.1 [container.requirements.general], paragraph 12, this holds
++true not only for <tt>insert</tt>, but <tt>emplace</tt> as well. This
++gives the <tt>insert</tt> member a special treatment w.r.t.
++<tt>emplace</tt> member in 23.2.4 [associative.reqmts], par. 8,
++since both modify the container. For the sake of consistency, in 23.2.4 [associative.reqmts], par. 8: either reference to <tt>insert</tt>
++should be removed (i.e. count on 23.2.1 [container.requirements.general],
++par. 12), or reference to <tt>emplace</tt> be added (i.e. mention all
++members of assoc. containers that modify it).
++</p>
++
++<p><i>[
++2009-11-18 Chris provided wording.
++]</i></p>
++
++
++<blockquote><p>
++This suggested wording covers both the issue discussed, and a number of other
++identical issues (namely <tt>insert</tt> being discussed without <tt>emplace</tt>). I'm happy to
++go back and split and introduce a new issue if appropriate, but I think the
++changes are fairly mechanical and obvious.
++</p></blockquote>
++
++<p><i>[
++2010-01-23 Daniel Kr&uuml;gler and J. Daniel Garc&iacute;a updated wording to
++make the use of <tt>hint</tt> consistent with <tt>insert</tt>.
++]</i></p>
++
++
++<p><i>[
++2011-02-23 Daniel Kr&uuml;gler adapts wording to numbering changes to match the N3225 draft. During this
++action it was found that 23.2.5 [unord.req] had been changed considerably
++due to acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3068.pdf">N3068</a>
++during the Pittsburgh meeting, such that the suggested wording change to
++p. 6 can no longer be applied. The new wording is more general and should
++now include <tt>insert()</tt> and <tt>emplace()</tt> calls as well ("mutating operations").
++]</i></p>
++
++
++<p><i>[2011-03-06 Daniel Kr&uuml;gler adapts wording to numbering changes to match the N3242 draft]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Modify bullet 1 of 23.2.1 [container.requirements.general], p. 10:
++</p>
++
++<p>
++10 Unless otherwise specified (see [associative.reqmts.except], [unord.req.except], [deque.modifiers], and [vector.modifiers])
++all container types defined in this Clause meet the following additional
++requirements:
++</p>
++
++<ul>
++<li>
++if an exception is thrown by an <tt>insert()</tt> <ins>or
++<tt>emplace()</tt></ins> function while inserting a single element, that
++function has no effects.
++</li>
++<li>...</li>
++</ul>
++
++</li>
++
++<li>
++<p>
++Modify 23.2.4 [associative.reqmts], p. 4:
++</p>
++
++<blockquote><p>
++4 An associative container supports <i>unique keys</i> if it may contain at most
++one element for each key. Otherwise, it supports <i>equivalent keys</i>. The
++<tt>set</tt> and <tt>map</tt> classes support unique keys; the <tt>multiset</tt>
++and <tt>multimap</tt> classes support equivalent keys. For <tt>multiset</tt> and
++<tt>multimap</tt>, <tt>insert</tt><ins>, <tt>emplace</tt>,</ins> and
++<tt>erase</tt> preserve the relative ordering of equivalent elements.
++</p></blockquote>
++
++</li>
++
++<li>
++<p>
++Modify Table 102 &mdash; Associative container requirements in
++23.2.4 [associative.reqmts]:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note<br />pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" style="text-align:center;">[&hellip;]</td>
++</tr>
++
++<tr>
++<td><tt>a_eq.emplace(args)</tt></td>
++<td><tt>iterator</tt></td>
++<td>[&hellip;] <i>Effects:</i> Inserts a <tt>T</tt> object <tt>t</tt> constructed with
++<tt>std::forward&lt;Args&gt;(args)...</tt> and returns the iterator pointing to
++the newly inserted element. <ins>If a range containing elements equivalent to
++<tt>t</tt> exists in <tt>a_eq</tt>, <tt>t</tt> is inserted at the end of that
++range.</ins></td>
++<td>logarithmic</td>
++</tr>
++
++<tr>
++<td><tt>a.emplace_hint(p, args)</tt></td>
++<td><tt>iterator</tt></td>
++<td>equivalent to <tt>a.emplace(std::forward&lt;Args&gt;(args)...)</tt>. Return
++value is an iterator pointing to the element with the key equivalent to the
++newly inserted element. <del>The <tt>const_iterator p</tt> is a hint pointing to
++where the search should start.</del> <ins>The element is inserted as close as
++possible to the position just prior to <tt>p</tt>.</ins> <del>Implementations
++are permitted to ignore the hint.</del></td>
++<td>logarithmic in general, but amortized constant if the element is inserted
++right <del>after</del> <ins>before</ins> <tt>p</tt></td>
++</tr>
++
++<tr>
++<td colspan="4" style="text-align:center;">[&hellip;]</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li>
++<p>
++Modify 23.2.4 [associative.reqmts], p. 9:
++</p>
++
++<blockquote><p>
++9 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
++the validity of iterators and references to the container, and the
++<tt>erase</tt> members shall invalidate only iterators and references to the
++erased elements.
++</p></blockquote>
++
++</li>
++
++<li>
++<p>
++Modify 23.2.4.1 [associative.reqmts.except], p. 2:
++</p>
++
++<blockquote><p>
++2 For associative containers, if an exception is thrown by any operation from
++within an <tt>insert()</tt> <ins> or <tt>emplace()</tt></ins> function inserting
++a single element, the <del><tt>insert()</tt> function</del> <ins>insertion</ins>
++has no effect.
++</p></blockquote>
++
++</li>
++
++<li>
++<p>
++Modify 23.2.5 [unord.req], p. 13 and p. 14:
++</p>
++
++<blockquote>
++<p>
++6 An unordered associative container supports <i>unique keys</i> if it may
++contain at most one element for each key. Otherwise, it supports <i>equivalent
++keys</i>. <tt>unordered_set</tt> and <tt>unordered_map</tt> support unique keys.
++<tt>unordered_multiset</tt> and <tt>unordered_multimap</tt> support equivalent
++keys. In containers that support equivalent keys, elements with equivalent keys
++are adjacent to each other in the iteration order of the container. Thus, although
++the absolute order of elements in an unordered container is not specified, its
++elements are grouped into <i>equivalent-key groups</i> such that all elements of each
++group have equivalent keys. Mutating operations on unordered containers shall
++preserve the relative order of elements within each equivalent-key group unless
++otherwise specified.
++</p>
++
++<p>[&hellip;]</p>
++
++<p>
++13 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
++the validity of references to container elements, but may invalidate all
++iterators to the container. The erase members shall invalidate only iterators
++and references to the erased elements.
++</p>
++
++<p>
++14 The <tt>insert</tt> <ins>and <tt>emplace</tt></ins> members shall not affect
++the validity of iterators if <tt>(N+n) &lt; z * B</tt>, where <tt>N</tt> is the
++number of elements in the container prior to the insert operation, <tt>n</tt> is
++the number of elements inserted, <tt>B</tt> is the container's bucket count, and
++<tt>z</tt> is the container's maximum load factor.
++</p>
++</blockquote>
++
++</li>
++
++<li>
++<p>
++Modify 23.2.5.1 [unord.req.except], p. 2:
++</p>
++
++<blockquote><p>
++2 For unordered associative containers, if an exception is thrown by any
++operation other than the container's hash function from within an
++<tt>insert()</tt> <ins>or <tt>emplace()</tt></ins> function inserting a single
++element, the <del><tt>insert()</tt></del> <ins>insertion</ins>
++<del>function</del> has no effect.
++</p></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1254"></a>1254. Misleading sentence in <tt>vector&lt;bool&gt;::flip</tt></h3>
+-<p><b>Section:</b> 23.4.2 [vector.bool] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2009-11-01 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2009-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The effects of <tt>vector&lt;bool&gt;::flip</tt> has the line:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ It is unspecified whether the function has any effect on allocated but
+ unused bits.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ While this is technically true, it is misleading, as any member function
+@@ -71982,14 +80658,14 @@ to read such memory.
+ <p><b>Proposed resolution:</b></p>
+ <p>
+ Strike second sentence from the definition of <tt>vector&lt;bool&gt;::flip()</tt>,
+-23.4.2 [vector.bool], paragraph 5.
++23.3.7 [vector.bool], paragraph 5.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> Replaces each element in the container with its complement.
+ <del>It is unspecified whether the function has any effect on allocated
+ but unused bits.</del>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -71997,16 +80673,18 @@ but unused bits.</del>
+
+ <hr>
+ <h3><a name="1255"></a>1255. <tt>declval</tt> should be added to the library</h3>
+-<p><b>Section:</b> 20.3 [utility] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-11-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility">issues</a> in [utility].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.2 [utility] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-11-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ During the Santa Cruz meeting it was decided to split off the provision
+-of the library utility <tt>value()</tt> proposed in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2979.html">N2979</a>
++of the library utility <tt>value()</tt> proposed in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2979.html">N2979</a>
+ from the concrete request of the
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2939.html#uk300">UK 300</a>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2939.html#UK300">UK 300</a>
+ comment.
+ The provision of a new library component that allows the production of
+ values in unevaluated expressions is considered as important
+@@ -72020,14 +80698,14 @@ The following proposed resolution is an improvement over that suggested in
+ because the proposed component can now be defined without loss of
+ general usefulness and any <i>use</i> by user-code will make the program ill-formed.
+ A possible prototype implementation that satisfies the core language
+-requirements
+-can be written as:
++requirements can be written as:
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt;
++<blockquote><pre>
++template&lt;class T&gt;
+ struct declval_protector {
+ static const bool stop = false;
+- static typename std::add_rvalue_reference&lt;T&gt;::type delegate(); <font color="#C80000">// undefined</font>
++ static typename std::add_rvalue_reference&lt;T&gt;::type delegate(); <span style="color:#C80000">// undefined</span>
+ };
+
+ template&lt;class T&gt;
+@@ -72066,11 +80744,12 @@ numbering and wording
+ <ol>
+ <li>
+ <p>
+-Change 20.3 [utility], header <tt>&lt;utility&gt;</tt> synopsis
++Change 20.2 [utility], header <tt>&lt;utility&gt;</tt> synopsis
+ as indicated:
+ </p>
+
+-<blockquote><pre>// 20.3.3, forward/move:
++<blockquote><pre>
++// 20.3.3, forward/move:
+ template &lt;class T&gt; struct identity;
+ template &lt;class T, class U&gt; T&amp;&amp; forward(U&amp;&amp;);
+ template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp;);
+@@ -72082,7 +80761,7 @@ template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move
+
+ <li>
+ <p>
+-Immediately after the current section 20.3.3 [forward] insert a
++Immediately after the current section 20.2.4 [forward] insert a
+ new section:
+ </p>
+ <p>
+@@ -72096,7 +80775,8 @@ template parameter <tt>T</tt> of <tt>declval</tt> may
+ be an incomplete type.</ins>
+ </p>
+
+-<pre><ins>template &lt;class T&gt; typename add_rvalue_reference&lt;T&gt;::type declval(); // as unevaluated operand</ins>
++<pre>
++<ins>template &lt;class T&gt; typename add_rvalue_reference&lt;T&gt;::type declval(); // as unevaluated operand</ins>
+ </pre>
+
+ <blockquote>
+@@ -72119,8 +80799,8 @@ decltype(static_cast&lt;To&gt;(declval&lt;From&gt;())) convert(From&amp;&amp;);
+ declares a function template <tt>convert</tt>, which only participates in
+ overloading if the type <tt>From</tt> can be explicitly cast to type <tt>To</tt>.
+ For another example see class template <tt>common_type</tt>
+-(20.7.7.6 [meta.trans.other]).
+-— <i>end example</i>]</ins>
++(20.10.7.6 [meta.trans.other]).
++&mdash; <i>end example</i>]</ins>
+ </p>
+ </blockquote>
+
+@@ -72128,7 +80808,9 @@ For another example see class template <tt>common_type</tt>
+
+ <li>
+ <p>
+-This bullet just makes clear that after applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.html">N2984</a>, the changes in 20.7.4.3 [meta.unary.prop], before
++This bullet just makes clear that after applying
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2984.htm">N2984</a>,
++the changes in 20.10.4.3 [meta.unary.prop], before
+ table Type property queries should <em>not</em> use <tt>declval</tt>,
+ because the well-formedness requirement of the specification of
+ <tt>is_constructible</tt> would become more complicated, because we
+@@ -72139,9 +80821,8 @@ unevaluated context.
+
+ <li>
+ <p>
+-Also 20.7.6 [meta.rel]/4 is not modified similar to the previous bullet,
+-because with
+-the stricter requirements of not using <tt>declval()</tt> the well-formedness condition
++Also 20.10.6 [meta.rel]/4 is not modified similar to the previous bullet,
++because with the stricter requirements of not using <tt>declval()</tt> the well-formedness condition
+ would be harder to specify. The following changes are only editorial ones (e.g.
+ the removal of the duplicate declaration of <tt>create()</tt>):
+ </p>
+@@ -72151,7 +80832,8 @@ the removal of the duplicate declaration of <tt>create()</tt>):
+ Given the following function prototype:
+ </p>
+
+-<blockquote><pre>template &lt;class T&gt;
++<blockquote><pre>
++template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();
+ </pre></blockquote>
+
+@@ -72163,7 +80845,8 @@ including any
+ implicit conversions to the return type of the function:
+ </p>
+
+-<blockquote><pre><del>template &lt;class T&gt;
++<blockquote><pre>
++<del>template &lt;class T&gt;
+ typename add_rvalue_reference&lt;T&gt;::type create();</del>
+ To test() {
+ return create&lt;From&gt;();
+@@ -72174,8 +80857,8 @@ To test() {
+
+ <li>
+ <p>
+-Change the entry in column "Comments" for <tt>common_type</tt> in Table 51 —
+-Other transformations (20.7.7.6 [meta.trans.other]):
++Change the entry in column "Comments" for <tt>common_type</tt> in Table 51 &mdash;
++Other transformations (20.10.7.6 [meta.trans.other]):
+ </p>
+
+ <p><i>[
+@@ -72185,20 +80868,20 @@ all binary type combinations that are supported by <tt>is_convertible</tt>
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The member typedef <tt>type</tt> shall be defined as set out below. All
+ types in the parameter pack <tt>T</tt> shall be complete <ins>or
+ (possibly cv-qualified) <tt>void</tt></ins>. A program may specialize
+ this trait if at least one template parameter in the specialization is a
+ user-defined type. [<i>Note:</i> Such specializations are needed when
+ only explicit conversions are desired among the template arguments.
+-— <i>end note</i>]
+-</blockquote>
++&mdash; <i>end note</i>]
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.7.7.6 [meta.trans.other]/3 as indicated:
++Change 20.10.7.6 [meta.trans.other]/3 as indicated:
+ </p>
+
+ <p><i>[
+@@ -72217,7 +80900,8 @@ The nested typedef <tt>common_type::type</tt> shall be defined as follows:
+ <p>
+ [..]
+ </p>
+-<pre>template &lt;class T, class U&gt;
++<pre>
++template &lt;class T, class U&gt;
+ struct common_type&lt;T, U&gt; {
+ <del>private:
+ static T&amp;&amp; __t();
+@@ -72233,10 +80917,11 @@ public:</del>
+ <li>
+ <p>
+ Change X [func.ret]/1 as indicated
+-[<i>This part solves some main aspects of issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1225">1225</a></i>]:
++[<i>This part solves some main aspects of issue <a href="lwg-defects.html#1225">1225</a></i>]:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class&gt; class result_of; // undefined
+
+ template &lt;class Fn, class... ArgTypes&gt;
+@@ -72266,14 +80951,15 @@ type, and rvalues otherwise.</del>
+
+ <hr>
+ <h3><a name="1256"></a>1256. <tt>weak_ptr</tt> comparison functions should be removed</h3>
+-<p><b>Section:</b> 20.9.10.3 [util.smartptr.weak] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-11-04 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.3 [util.smartptr.weak] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-11-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.weak">issues</a> in [util.smartptr.weak].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Additional to the necessary cleanup of the description of the the
+-<tt>weak_ptr</tt> component from 20.9.10.3 [util.smartptr.weak]
+-described in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1231">1231</a> it turns out that the currently deleted
++<tt>weak_ptr</tt> component from 20.8.2.3 [util.smartptr.weak]
++described in <a href="lwg-defects.html#1231">1231</a> it turns out that the currently deleted
+ comparison functions of <tt>weak_ptr</tt> are not needed at all: There
+ is no safe-bool conversion from <tt>weak_ptr</tt>, and it won't silently
+ chose a conversion to <tt>shared_ptr</tt>.
+@@ -72287,10 +80973,11 @@ chose a conversion to <tt>shared_ptr</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.10.3 [util.smartptr.weak]/1 as indicated:
++Change 20.8.2.3 [util.smartptr.weak]/1 as indicated:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template&lt;class T&gt; class weak_ptr {
+ public:
+ ...
+@@ -72309,10 +80996,10 @@ public:
+
+ <hr>
+ <h3><a name="1257"></a>1257. Header &lt;ios&gt; still contains a <code>concept_map</code></h3>
+-<p><b>Section:</b> 27.5 [iostreams.base] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-11-04 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostreams.base">issues</a> in [iostreams.base].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.5 [iostreams.base] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2009-11-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostreams.base">issues</a> in [iostreams.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current WP still contains a <tt>concept_map</tt>.
+@@ -72330,7 +81017,8 @@ Change Iostreams base classes 27.5 [iostreams.base], Header &lt;ios&gt; synopsis
+ as indicated:
+ </p>
+
+-<blockquote><pre><del>concept_map ErrorCodeEnum&lt;io_errc&gt; { };</del>
++<blockquote><pre>
++<del>concept_map ErrorCodeEnum&lt;io_errc&gt; { };</del>
+ <ins>template &lt;&gt; struct is_error_code_enum&lt;io_errc&gt; : true_type { }</ins>
+ error_code make_error_code(io_errc e);
+ error_condition make_error_condition(io_errc e);
+@@ -72344,21 +81032,22 @@ const error_category&amp; iostream_category();
+
+ <hr>
+ <h3><a name="1258"></a>1258. std::function Effects clause impossible to satisfy</h3>
+-<p><b>Section:</b> 20.8.14.2.2 [func.wrap.func.mod] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-11-05 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.2 [func.wrap.func.mod] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-11-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-As of 20.8.14.2.2 [func.wrap.func.mod]/2+ we have the following
++As of 20.9.12.2.2 [func.wrap.func.mod]/2+ we have the following
+ prototype description:
+ </p>
+
+-<blockquote><pre>template&lt;class F, Allocator Alloc&gt;
++<blockquote><pre>
++template&lt;class F, Allocator Alloc&gt;
+ void assign(F, const Alloc&amp;);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> <tt>function(f, a).swap(*this)</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -72370,7 +81059,8 @@ because there is no constructor that would match the parameter sequence
+ probable candidate is
+ </p>
+
+-<blockquote><pre>template&lt;class F, class A&gt; function(allocator_arg_t, const A&amp;, F);
++<blockquote><pre>
++template&lt;class F, class A&gt; function(allocator_arg_t, const A&amp;, F);
+ </pre></blockquote>
+
+ <p>
+@@ -72389,13 +81079,13 @@ and the effects clause needs to be adapted to use this signature.
+
+ <p><i>[
+ 2010-02-11 Moved to Tentatively NAD Editorial after 5 positive votes on
+-c++std-lib. It was noted that this issue was in partial conflict with <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>, and the two issues were merged in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>.
++c++std-lib. It was noted that this issue was in partial conflict with <a href="lwg-defects.html#1288">1288</a>, and the two issues were merged in <a href="lwg-defects.html#1288">1288</a>.
+ ]</i></p>
+
+
+ <p><b>Rationale:</b></p>
+ <p>
+-Addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1288">1288</a>.
++Addressed by <a href="lwg-defects.html#1288">1288</a>.
+ </p>
+
+
+@@ -72403,7 +81093,7 @@ Addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.ht
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change in 20.8.14.2.2 [func.wrap.func.mod] the complete prototype description as
++Change in 20.9.12.2.2 [func.wrap.func.mod] the complete prototype description as
+ indicated
+ </p>
+ <p><i>[
+@@ -72412,13 +81102,14 @@ the editor: Shouldn't there a paragraph number in front of the Effects clause?
+ ]</i></p>
+
+
+-<blockquote><pre>template&lt;class F, <del>Allocator Alloc</del><ins>class A</ins>&gt;
++<blockquote><pre>
++template&lt;class F, <del>Allocator Alloc</del><ins>class A</ins>>
+ void assign(F <ins>f</ins>, const A<del>lloc</del>&amp; <ins>a</ins>);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <ins>3</ins> <i>Effects:</i> <tt>function(<del>f, a</del><ins>allocator_arg, a,
+ f</ins>).swap(*this)</tt>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -72427,10 +81118,11 @@ f</ins>).swap(*this)</tt>
+
+ <hr>
+ <h3><a name="1260"></a>1260. <tt>is_constructible&lt;int*,void*&gt;</tt> reports true</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-11-07 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2009-11-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The specification of <tt>is_constructible&lt;T,Args...&gt;</tt> in
+@@ -72438,7 +81130,8 @@ The specification of <tt>is_constructible&lt;T,Args...&gt;</tt> in
+ uses
+ </p>
+
+-<blockquote><pre>static_cast&lt;T&gt;(create&lt;Args&gt;()...)
++<blockquote><pre>
++static_cast&lt;T&gt;(create&lt;Args&gt;()...)
+ </pre></blockquote>
+
+ <p>
+@@ -72452,16 +81145,16 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to <del>NAD Editorial</del><ins>Resolved</ins>, this issue is addressed by paper
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3047.html">n3047</a>
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.7.4.3 [meta.unary.prop], p6:
++Change 20.10.4.3 [meta.unary.prop], p6:
+ </p>
+
+ <blockquote>
+@@ -72477,7 +81170,8 @@ definition</ins> would be well-formed:
+ <p>
+ if <tt>sizeof...(Args) == <ins>0</ins> <del>1</del></tt><del>, the expression</del>:
+ </p>
+-<blockquote><pre><del>static_cast&lt;T&gt;(create&lt;Args&gt;()...)</del>
++<blockquote><pre>
++<del>static_cast&lt;T&gt;(create&lt;Args&gt;()...)</del>
+ <ins>T t;</ins>
+ </pre></blockquote>
+ </li>
+@@ -72485,7 +81179,8 @@ if <tt>sizeof...(Args) == <ins>0</ins> <del>1</del></tt><del>, the expression</d
+ <p>
+ otherwise <del>the expression</del>:
+ </p>
+-<blockquote><pre>T<ins> t</ins>(create&lt;Args&gt;()...);
++<blockquote><pre>
++T<ins> t</ins>(create&lt;Args&gt;()...);
+ </pre></blockquote>
+ </li>
+ </ul>
+@@ -72496,22 +81191,22 @@ otherwise <del>the expression</del>:
+
+
+ <hr>
+-<h3><a name="1261"></a>1261. Insufficent overloads for <tt>to_string</tt> / <tt>to_wstring</tt></h3>
+-<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2009-11-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1261"></a>1261. Insufficent overloads for <tt>to_string</tt> &#47; <tt>to_wstring</tt></h3>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2009-11-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Reported on the gcc mailing list.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ The code "<tt>int i; to_string(i);</tt>" fails to compile, as
+ '<tt>int</tt>' is ambiguous between '<tt>long long</tt>' and '<tt>long
+ long unsigned</tt>'. It seems unreasonable to expect users to cast
+ numbers up to a larger type just to use <tt>to_string</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2009-11-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+@@ -72525,7 +81220,8 @@ numbers up to a larger type just to use <tt>to_string</tt>.
+ <tt>to_wstring</tt> to:
+ </p>
+
+-<blockquote><pre><ins>string to_string(int val);</ins>
++<blockquote><pre>
++<ins>string to_string(int val);</ins>
+ <ins>string to_string(unsigned val);</ins>
+ <ins>string to_string(long val);</ins>
+ <ins>string to_string(unsigned long val);</ins>
+@@ -72550,7 +81246,8 @@ wstring to_wstring(long double val);
+ In 21.5 [string.conversions], paragraph 7, change to:
+ </p>
+
+-<blockquote><pre><ins>string to_string(int val);</ins>
++<blockquote><pre>
++<ins>string to_string(int val);</ins>
+ <ins>string to_string(unsigned val);</ins>
+ <ins>string to_string(long val);</ins>
+ <ins>string to_string(unsigned long val);</ins>
+@@ -72561,7 +81258,7 @@ string to_string(unsigned long long val);
+ string to_string(long double val);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 7 <i>Returns:</i> each function returns a <tt>string</tt> object holding
+ the character representation of the value of its argument that would be
+ generated by calling <tt>sprintf(buf, fmt, val)</tt> with a format
+@@ -72570,14 +81267,15 @@ specifier of <ins> <tt>"%d"</tt>, <tt>"%u"</tt>, <tt>"%ld"</tt>,
+ <ins><tt>"%f"</tt>, <tt>"%f"</tt>,</ins> or <tt>"%Lf"</tt>, respectively,
+ where <tt>buf</tt> designates an internal character buffer of sufficient
+ size.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ In 21.5 [string.conversions], paragraph 14, change to:
+ </p>
+
+-<blockquote><pre><ins>wstring to_wstring(int val);</ins>
++<blockquote><pre>
++<ins>wstring to_wstring(int val);</ins>
+ <ins>wstring to_wstring(unsigned val);</ins>
+ <ins>wstring to_wstring(long val);</ins>
+ <ins>wstring to_wstring(unsigned long val);</ins>
+@@ -72588,7 +81286,7 @@ wstring to_wstring(unsigned long long val);
+ wstring to_wstring(long double val);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 14 <i>Returns:</i> Each function returns a <tt>wstring</tt> object
+ holding the character representation of the value of its argument that
+ would be generated by calling <tt>swprintf(buf, buffsz, fmt, val)</tt>
+@@ -72597,7 +81295,7 @@ with a format specifier of <ins> <tt>L"%d"</tt>, <tt>L"%u"</tt>,
+ <tt>L"%llu"</tt>, <ins><tt>L"%f"</tt>, <tt>L"%f"</tt>,</ins> or
+ <tt>L"%Lf"</tt>, respectively, where <tt>buf</tt> designates an internal
+ character buffer of sufficient size <tt>buffsz</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -72606,22 +81304,21 @@ character buffer of sufficient size <tt>buffsz</tt>.
+
+ <hr>
+ <h3><a name="1262"></a>1262. <tt>std::less&lt;std::shared_ptr&lt;T&gt;&gt;</tt> is underspecified</h3>
+-<p><b>Section:</b> 20.9.10.2.7 [util.smartptr.shared.cmp] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.2.2.7 [util.smartptr.shared.cmp] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.9.10.2.7 [util.smartptr.shared.cmp]/5 says:
++20.8.2.2.7 [util.smartptr.shared.cmp]/5 says:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ For templates <tt>greater</tt>, <tt>less</tt>, <tt>greater_equal</tt>, and <tt>less_equal</tt>, the
+ partial specializations for <tt>shared_ptr</tt> shall yield a total order, even if
+-the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>,
+-<tt>&lt;=</tt>, and <tt>&gt;=</tt> do not. Moreover,
+-<tt>less&lt;shared_ptr&lt;T&gt; &gt;::operator()(a, b)</tt> shall return
++the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>, <tt>&lt;=</tt>, and <tt>&gt;=</tt> do not.
++Moreover, <tt>less&lt;shared_ptr&lt;T&gt; &gt;::operator()(a, b)</tt> shall return
+ <tt>std::less&lt;T*&gt;::operator()(a.get(), b.get())</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This is necessary in order to use <tt>shared_ptr</tt> as the key in associate
+@@ -72638,17 +81335,14 @@ apply to <tt>shared_ptr</tt>.
+ Earlier versions of the WP
+ (<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf">n2798</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf">n2857</a>)
+-had the following note on
+-that paragraph:
++had the following note on that paragraph:
+ </p>
+
+-<blockquote>
+-[Editor's
+-note: It's not clear to me whether the first sentence is a requirement
+-or a note. The second
+-sentence seems to be a requirement, but it doesn't really belong here,
+-under <tt>operator&lt;</tt>.]
+-</blockquote>
++<blockquote><p>
++[Editor's note: It's not clear to me whether the first sentence is a requirement
++or a note. The second sentence seems to be a requirement, but it doesn't really belong
++here, under <tt>operator&lt;</tt>.]
++</p></blockquote>
+
+ <p>
+ I agree completely - if partial specializations are needed they should
+@@ -72656,7 +81350,7 @@ be properly specified.
+ </p>
+
+ <p>
+-20.9.10.2.7 [util.smartptr.shared.cmp]/6 has a note saying the comparison operator
++20.8.2.2.7 [util.smartptr.shared.cmp]/6 has a note saying the comparison operator
+ allows <tt>shared_ptr</tt> objects to be used as keys in associative
+ containers, which is misleading because something else like a
+ <tt>std::less</tt> partial specialization is needed. If it is not correct that
+@@ -72664,7 +81358,7 @@ note should be removed.
+ </p>
+
+ <p>
+-20.9.10.2.7 [util.smartptr.shared.cmp]/3 refers to '<tt>x</tt>' and
++20.8.2.2.7 [util.smartptr.shared.cmp]/3 refers to '<tt>x</tt>' and
+ '<tt>y</tt>' but the prototype has parameters '<tt>a</tt>' and
+ '<tt>b</tt>' - that needs to be fixed even if the rest of the issue is
+ NAD.
+@@ -72679,11 +81373,12 @@ other comparisons when defined in terms of <tt>operator&lt;</tt>.
+ <ol>
+ <li>
+ <p>
+-Replace 20.9.10.2.7 [util.smartptr.shared.cmp]/3 with the following and
++Replace 20.8.2.2.7 [util.smartptr.shared.cmp]/3 with the following and
+ remove p5:
+ </p>
+
+-<blockquote><pre>template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
++<blockquote><pre>
++template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+ </pre>
+ <blockquote>
+ <p>
+@@ -72707,7 +81402,7 @@ the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>,
+ <p>
+ 6 [<i>Note:</i> Defining a comparison operator allows
+ <tt>shared_ptr</tt> objects to be used as keys in associative
+-containers. — <i>end note</i>]
++containers. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -72716,20 +81411,22 @@ containers.
+
+ <li>
+ <p>
+-Add to 20.9.10.2 [util.smartptr.shared]/1 (after the <tt>shared_ptr</tt> comparisons)
++Add to 20.8.2.2 [util.smartptr.shared]/1 (after the <tt>shared_ptr</tt> comparisons)
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt; struct greater&lt;shared_ptr&lt;T&gt;&gt;;
++<blockquote><pre>
++template&lt;class T&gt; struct greater&lt;shared_ptr&lt;T&gt;&gt;;
+ template&lt;class T&gt; struct less&lt;shared_ptr&lt;T&gt;&gt;;
+ template&lt;class T&gt; struct greater_equal&lt;shared_ptr&lt;T&gt;&gt;;
+ template&lt;class T&gt; struct less_equal&lt;shared_ptr&lt;T&gt;&gt;;
+ </pre></blockquote>
+
+ <p>
+-Remove 20.9.10.2.7 [util.smartptr.shared.cmp]/5 and /6 and replace with:
++Remove 20.8.2.2.7 [util.smartptr.shared.cmp]/5 and /6 and replace with:
+ </p>
+
+-<blockquote><pre>template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
++<blockquote><pre>
++template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+ </pre>
+ <blockquote>
+ <p>
+@@ -72751,7 +81448,7 @@ the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>,
+ <p><del>
+ 6 [<i>Note:</i> Defining a comparison operator allows
+ <tt>shared_ptr</tt> objects to be used as keys in associative
+-containers. — <i>end note</i>]
++containers. &mdash; <i>end note</i>]
+ </del></p>
+ </blockquote>
+
+@@ -72762,9 +81459,9 @@ binary_function&lt;shared_ptr&lt;T&gt;, shared_ptr&lt;T&gt;, bool&gt; {
+ };
+ </ins></pre>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <tt>operator()</tt> returns <tt>greater&lt;T*&gt;()(a.get(), b.get())</tt>.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <pre><ins>
+ template&lt;class T&gt; struct less&lt;shared_ptr&lt;T&gt;&gt; :
+@@ -72773,9 +81470,9 @@ binary_function&lt;shared_ptr&lt;T&gt;, shared_ptr&lt;T&gt;, bool&gt; {
+ };
+ </ins></pre>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <tt>operator()</tt> returns <tt>less&lt;T*&gt;()(a.get(), b.get())</tt>.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <pre><ins>
+ template&lt;class T&gt; struct greater_equal&lt;shared_ptr&lt;T&gt;&gt; :
+@@ -72784,9 +81481,9 @@ binary_function&lt;shared_ptr&lt;T&gt;, shared_ptr&lt;T&gt;, bool&gt; {
+ };
+ </ins></pre>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <tt>operator()</tt> returns <tt>greater_equal&lt;T*&gt;()(a.get(), b.get())</tt>.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <pre><ins>
+ template&lt;class T&gt; struct less_equal&lt;shared_ptr&lt;T&gt;&gt; :
+@@ -72795,9 +81492,9 @@ binary_function&lt;shared_ptr&lt;T&gt;, shared_ptr&lt;T&gt;, bool&gt; {
+ };
+ </ins></pre>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ <tt>operator()</tt> returns <tt>less_equal&lt;T*&gt;()(a.get(), b.get())</tt>.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ </blockquote>
+ </li>
+@@ -72812,11 +81509,12 @@ binary_function&lt;shared_ptr&lt;T&gt;, shared_ptr&lt;T&gt;, bool&gt; {
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Replace 20.9.10.2.7 [util.smartptr.shared.cmp]/3 with the following and
++Replace 20.8.2.2.7 [util.smartptr.shared.cmp]/3 with the following and
+ remove p5:
+ </p>
+
+-<blockquote><pre>template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
++<blockquote><pre>
++template&lt;class T, class U&gt; bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b);
+ </pre>
+ <blockquote>
+ <p>
+@@ -72840,7 +81538,7 @@ the built-in operators <tt>&lt;</tt>, <tt>&gt;</tt>,
+ <p>
+ 6 [<i>Note:</i> Defining a comparison operator allows
+ <tt>shared_ptr</tt> objects to be used as keys in associative
+-containers. — <i>end note</i>]
++containers. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -72852,10 +81550,10 @@ containers.
+
+ <hr>
+ <h3><a name="1264"></a>1264. <tt>quick_exit</tt> support for freestanding implementations</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-11-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 172</b></p>
+
+@@ -72894,14 +81592,14 @@ supported.
+ Ammend p3 Freestanding implementations 17.6.1.3 [compliance]
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 The supplied version of the header <tt>&lt;cstdlib&gt;</tt> shall
+ declare at least the functions <tt>abort<del>()</del></tt>, <tt>atexit<del>()</del></tt>,
+ <ins><tt>at_quick_exit</tt>,</ins> <del>and</del> <tt>exit<del>()</del></tt><ins>, and
+ <tt>quick_exit</tt></ins>(18.5 [support.start.term]). The other
+ headers listed in this table shall meet the same requirements as for a
+ hosted implementation.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -72909,11 +81607,96 @@ hosted implementation.
+
+
+ <hr>
++<h3><a name="1266"></a>1266. <tt>shared_future::get</tt> and deferred <tt>async</tt> functions</h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++If a <tt>shared_future</tt> is constructed with the result of an <tt>async</tt> call with a
++deferred function, and two or more copies of that <tt>shared_future</tt> are created,
++with multiple threads calling <tt>get()</tt>, it is not clear which thread runs the
++deferred function. 30.6.7 [futures.shared_future]p22 from
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>
++says (minus editor's note):
++</p>
++
++<blockquote><p>
++<i>Effects:</i> if the associated state contains a deferred function, executes
++the deferred function. Otherwise, blocks until the associated state is ready.
++</p></blockquote>
++
++<p>
++In the absence of wording to the contrary, this implies that every thread that
++calls <tt>wait()</tt> will execute the deferred function.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Replace 30.6.7 [futures.shared_future]p22 with the following:
++</p>
++
++<blockquote>
++<p>
++<i>Effects:</i> If the associated state
++<del>contains a deferred function, executes the deferred function. Otherwise,
++blocks until the associated state is ready.</del>
++<ins>was created by a <tt>promise</tt> or <tt>packaged_task</tt> object, block
++until the associated state is ready. If the associated state is associated with
++a thread created for an <tt>async</tt> call (30.6.8 [futures.async]), as
++if <tt>associated-thread.join()</tt>.
++</ins></p>
++
++<p><ins>
++If the associated state contains a deferred function, calls to <tt>wait()</tt>
++on all <tt>shared_future</tt> objects that share the same associated state are
++serialized. The first call to <tt>wait()</tt> that shares a given associated
++state executes the deferred function and stores the return value or exception in
++the associated state.
++</ins></p>
++
++<p><ins>
++<i>Synchronization:</i> if the associated state was created by a
++<tt>promise</tt> object, the completion of <tt>set_value()</tt> or
++<tt>set_exception()</tt> to that <tt>promise</tt> happens before (1.10 [intro.multithread]) <tt>wait()</tt> returns. If the associated state
++was created by a <tt>packaged_task</tt> object, the completion of the associated
++task happens before <tt>wait()</tt> returns. If the associated state is
++associated with a thread created for an <tt>async</tt> call (30.6.8 [futures.async]), the completion of the associated thread happens-before
++<tt>wait()</tt> returns.
++</ins></p>
++
++<p><ins>
++If the associated state contained a deferred function, the invocation of the
++deferred function happens-before any call to <tt>wait()</tt> on a
++<tt>future</tt> that shares that state returns.
++</ins></p>
++</blockquote>
++
++
++
++
++
++<hr>
+ <h3><a name="1267"></a>1267. Incorrect wording for <tt>condition_variable_any::wait_for</tt></h3>
+-<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 30.5.2 [thread.condition.condvarany]p18 and 30.5.2 [thread.condition.condvarany]p27 specify incorrect preconditions for
+@@ -72935,7 +81718,8 @@ such a requirement.
+ Remove 30.5.2 [thread.condition.condvarany]p18 and 30.5.2 [thread.condition.condvarany]p27.
+ </p>
+ <blockquote>
+-<pre>template &lt;class Lock, class Rep, class Period&gt;
++<pre>
++template &lt;class Lock, class Rep, class Period&gt;
+ cv_status wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+ </pre>
+ <blockquote>
+@@ -72956,7 +81740,8 @@ supplied by all concurrently waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or
+
+ <p>...</p>
+
+-<pre>template &lt;class Lock, class Rep, class Period, class Predicate&gt;
++<pre>
++template &lt;class Lock, class Rep, class Period, class Predicate&gt;
+ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
+ </pre>
+
+@@ -72987,10 +81772,10 @@ supplied by all concurrently waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or
+
+ <hr>
+ <h3><a name="1268"></a>1268. The Mutex requirements in 30.4.1 and 30.4.2 are wrong</h3>
+-<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 30.4 [thread.mutex] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex">issues</a> in [thread.mutex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>Mutex</tt> requirements in 30.4.1 [thread.mutex.requirements] and
+@@ -73036,7 +81821,7 @@ Move to open status. Suggest Anthony look at condition_variable_any
+ requirements. Suggest Anthony refine requirements/concepts categories.
+ </p>
+ <p>
+-Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#964">964</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#966">966</a>
++Related to <a href="lwg-defects.html#964">964</a> and <a href="lwg-defects.html#966">966</a>
+ </p>
+ </blockquote>
+
+@@ -73050,25 +81835,27 @@ Related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> would solve this issue.
+-</blockquote>
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a>
++would solve this issue.
++</p></blockquote>
+
+ <p><i>[
+ 2010-11 Batavia:
+ ]</i></p>
+
+
+-<blockquote>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.html">n3197</a>.
+-</blockquote>
++<blockquote><p>
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.htm">n3197</a>.
++</p></blockquote>
+
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new section to 30.2 [thread.req] after 30.2.4 [thread.req.timing] as follows:
++Add a new section to 30.2 [thread.req] after 30.2.4 [thread.req.timing]
++as follows:
+ </p>
+
+ <blockquote>
+@@ -73083,7 +81870,7 @@ specified for either the <tt>Lockable</tt> Requirements or the
+ <tt>TimedLockable</tt> requirements as appropriate to acquire or release
+ ownership of a <tt>lock</tt> by a given <tt>thread</tt>. [<i>Note:</i> the
+ nature of any lock ownership and any synchronization it may entail are not part
+-of these requirements. — <i>end note</i>]
++of these requirements. &mdash; <i>end note</i>]
+ </p>
+
+ <p>
+@@ -73139,8 +81926,8 @@ For a type to qualify as <tt>TimedLockable</tt> it must meet the
+ expressions must be well-formed, with the specified semantics,
+ where <tt>m</tt> is an instance of a type <tt>TL</tt> that supports
+ the <tt>TimedLockable</tt> requirements, <tt>rel_time</tt> denotes
+-instantiation of <tt>duration</tt> (20.11.3 [time.duration]) and <tt>abs_time</tt>
+-denotes an instantiation of <tt>time_point</tt> (20.11.4 [time.point])
++instantiation of <tt>duration</tt> (20.12.5 [time.duration]) and <tt>abs_time</tt>
++denotes an instantiation of <tt>time_point</tt> (20.12.6 [time.point])
+
+ </p>
+
+@@ -73176,7 +81963,7 @@ Replace 30.4.1 [thread.mutex.requirements] paragraph 2 with the
+ following:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 This section describes requirements on <del>template argument types
+ used to instantiate templates defined in</del> <ins>the mutex types
+ supplied by</ins> the C++ standard library. <del>The template
+@@ -73187,42 +81974,42 @@ of <del>a <tt>Mutex</tt> type</del>
+ <ins>one of the standard library mutex types <tt>std::mutex</tt>,
+ <tt>std::recursive_mutex</tt>, <tt>std::timed_mutex</tt> or
+ <tt>std::recursive_timed_mutex</tt>.</ins>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Add the following paragraph after 30.4.1 [thread.mutex.requirements]
+ paragraph 2:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ A <tt>Mutex</tt> type shall conform to the <tt>Lockable</tt>
+ requirements (30.2.5.1).
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Replace 30.4.1.3 [thread.timedmutex.requirements] paragraph 1 with the
+ following:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <ins>The C++ standard library <tt>TimedMutex</tt> types <tt>std::timed_mutex</tt>
+ and <tt>std::recursive_timed_mutex</tt> </ins>
+ <del>A <tt>TimedMutex</tt> type</del> shall meet the requirements for
+ a <tt>Mutex</tt> type. In addition, <del>it</del><ins>they</ins> shall
+ meet the requirements set out <del>in this Clause 30.4.2</del><ins>below</ins>,
+ where <tt>rel_time</tt> denotes an instantiation of <tt>duration</tt>
+-(20.11.3 [time.duration]) and <tt>abs_time</tt> denotes an instantiation
+-of <tt>time_point</tt> (20.11.4 [time.point]).
+-</blockquote>
++(20.12.5 [time.duration]) and <tt>abs_time</tt> denotes an instantiation
++of <tt>time_point</tt> (20.12.6 [time.point]).
++</p></blockquote>
+
+ <p>
+ Add the following paragraph after 30.4.1.3 [thread.timedmutex.requirements] paragraph 1:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ A <tt>TimedMutex</tt> type shall conform to the <tt>TimedLockable</tt>
+ requirements (30.2.5.1).
+-</ins></blockquote>
++</ins></p></blockquote>
+
+
+ <p>
+@@ -73230,18 +82017,17 @@ Add the following paragraph following 30.4.2.1 [thread.lock.guard]
+ paragraph 1:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt>
+-requirements
+-(30.2.5.1).
+-</ins></blockquote>
++requirements (30.2.5.1).
++</ins></p></blockquote>
+
+ <p>
+ Add the following paragraph following 30.4.2.2 [thread.lock.unique]
+ paragraph 1:
+ </p>
+
+-<blockquote><ins>
++<blockquote><p><ins>
+ The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt>
+ requirements
+ (30.2.5.1). <tt>unique_lock&lt;Mutex&gt;</tt> meets the <tt>Lockable</tt>
+@@ -73249,14 +82035,14 @@ requirements. If <tt>Mutex</tt> meets the <tt>TimedLockable</tt>
+ requirements
+ (30.2.5.2) then <tt>unique_lock&lt;Mutex&gt;</tt> also meets the
+ <tt>TimedLockable</tt> requirements.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+ <p>
+ Replace the use of "mutex" or "mutex object" with "lockable object"
+ throughout clause 30.4.2 [thread.lock] paragraph 1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 A lock is an object that holds a reference to
+ a <del>mutex</del><ins>lockable object</ins> and may unlock
+ the <del>mutex</del><ins>lockable object</ins> during the lock's
+@@ -73269,20 +82055,20 @@ object</ins> for a thread of execution. A lock does not manage the
+ lifetime of the <del>mutex</del><ins>lockable object</ins> it
+ references. [ Note: Locks are intended to ease the burden of
+ unlocking the <del>mutex</del><ins>lockable object</ins> under both
+-normal and exceptional circumstances. — end note ]
+-</blockquote>
++normal and exceptional circumstances. &mdash; end note ]
++</p></blockquote>
+
+ <p>30.4.2 [thread.lock] paragaph 2:</p>
+
+-<blockquote>
++<blockquote><p>
+ 2 Some lock constructors take tag types which describe what should be
+ done with the <del>mutex</del><ins>lockable</ins> object during the
+ lock's constuction.
+-</blockquote>
++</p></blockquote>
+
+ <p>30.4.2.1 [thread.lock.guard] paragaph 1:</p>
+
+-<blockquote>
++<blockquote><p>
+ 1 An object of type <tt>lock_guard</tt> controls the ownership of a
+ <del>mutex</del><ins>lockable</ins> object within a scope. A
+ <tt>lock_guard</tt> object maintains ownership of
+@@ -73292,15 +82078,15 @@ is undefined if the <del>mutex</del><ins>lockable object</ins>
+ referenced by <tt>pm</tt> does not exist for the entire lifetime (3.8)
+ of the <tt>lock_guard</tt> object. <ins><tt>Mutex</tt> shall meet
+ the <tt>Lockable</tt> requirements (30.2.5.1).</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p>30.4.2.2 [thread.lock.unique] paragaph 1:</p>
+
+-<blockquote>
++<blockquote><p>
+ 1 An object of type <tt>unique_lock</tt> controls the ownership of
+ a <del>mutex</del><ins>lockable object</ins> within a
+-scope. <del>Mutex</del> <del>o</del><ins>O</ins>wnership <ins>of the
+-lockable object</ins> may be acquired at construction or after
++scope. <Del>Mutex</Del> <del>o</del><ins>O</ins>wnership <Ins>of the
++lockable object</Ins> may be acquired at construction or after
+ construction, and may be transferred, after acquisition, to
+ another <tt>unique_lock</tt> object. Objects of
+ type <tt>unique_lock</tt> are not copyable but are movable. The
+@@ -73309,13 +82095,12 @@ pointer <tt>pm</tt> is not null and the mutex pointed to
+ by <tt>pm</tt> does not exist for the entire remaining lifetime (3.8)
+ of the <tt>unique_lock</tt> object. <ins><tt>Mutex</tt> shall meet
+ the <tt>Lockable</tt> requirements (30.2.5.1).</ins>
+-</blockquote>
++</p></blockquote>
+
+
+ <p>
+ Add the following to the precondition of <tt>unique_lock(mutex_type&amp;
+- m,
+-const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)</tt> in
++m, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)</tt> in
+ 30.4.2.2.1 [thread.lock.unique.cons] paragraph 18:
+ </p>
+
+@@ -73323,12 +82108,11 @@ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)</tt> in
+ unique_lock(mutex_type&amp; m, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 18 <i>Requires:</i> If <tt>mutex_type</tt> is not a recursive mutex
+-the
+-calling thread does not own the mutex. <ins>The supplied <tt>mutex_type</tt>
++the calling thread does not own the mutex. <ins>The supplied <tt>mutex_type</tt>
+ type shall meet the <tt>TimedLockable</tt> requirements (30.2.5.2).</ins>
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -73339,12 +82123,12 @@ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time)</tt> in
+ paragraph 22
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 22 <i>Requires:</i> If <tt>mutex_type</tt> is not a recursive mutex
+ the
+ calling thread does not own the mutex. <ins>The supplied <tt>mutex_type</tt>
+ type shall meet the <tt>TimedLockable</tt> requirements (30.2.5.2).</ins>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ Add the following as a precondition of <tt>bool try_lock_until(const
+@@ -73355,10 +82139,10 @@ chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time)</tt> before
+ <blockquote><pre>template &lt;class Clock, class Duration&gt;
+ bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
+ </pre>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Requires:</i> The supplied <tt>mutex_type</tt> type shall meet the
+ <tt>TimedLockable</tt> requirements (30.2.5.2).
+-</ins></blockquote>
++</ins></p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -73370,10 +82154,10 @@ chrono::duration&lt;Rep, Period&gt;&amp; rel_time)</tt> before
+ <blockquote><pre>template &lt;class Rep, class Period&gt;
+ bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+ </pre>
+-<blockquote><ins>
++<blockquote><p><ins>
+ <i>Requires:</i> The supplied <tt>mutex_type</tt> type shall meet the
+ <tt>TimedLockable</tt> requirements (30.2.5.2).
+-</ins></blockquote>
++</ins></p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -73382,15 +82166,13 @@ Replace 30.4.3 [thread.lock.algorithm] p1 with the following:
+
+ <blockquote><pre>template &lt;class L1, class L2, class... L3&gt; int try_lock(L1&amp;, L2&amp;, L3&amp;...);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 1 <i>Requires:</i> Each template parameter type shall meet the
+ <tt><del>Mutex</del> <ins>Lockable</ins></tt> requirements
+ <ins>(30.2.5.1).</ins><del>, except that a call to <tt>try_lock()</tt>
+-may throw
+-an exception.</del> [<i>Note:</i> The <tt>unique_lock</tt> class
+-template meets
+-these requirements when suitably instantiated. — <i>end note</i>]
+-</blockquote>
++may throw an exception.</del> [<i>Note:</i> The <tt>unique_lock</tt> class
++template meets these requirements when suitably instantiated. &mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -73399,30 +82181,95 @@ Replace 30.4.3 [thread.lock.algorithm] p4 with the following:
+
+ <blockquote><pre>template &lt;class L1, class L2, class... L3&gt; void lock(L1&amp;, L2&amp;, L3&amp;...);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 4 <i>Requires:</i> Each template parameter type shall meet the
+ <tt>Mutex<del>Mutex</del> <ins>Lockable</ins></tt>
+ requirements <ins>(30.2.5.1).</ins><del>, except that a call to
+ <tt>try_lock()</tt> may throw an exception.</del> [<i>Note:</i> The
+ <tt>unique_lock</tt> class template meets these requirements when
+-suitably
+-instantiated. — <i>end note</i>]
+-</blockquote>
++suitably instantiated. &mdash; <i>end note</i>]
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ Replace 30.5.2 [thread.condition.condvarany] paragraph 1 with:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 A <tt>Lock</tt> type shall meet the <del>requirements for a <tt>Mutex</tt>
+ type</del> <ins><tt>Lockable</tt> requirements (30.2.5.1)</ins>, except
+-that
+-<tt>try_lock</tt> is not required. [<i>Note:</i> All of the standard
+-mutex types
+-meet this requirement. — <i>end note</i>]
+-</blockquote>
++that <tt>try_lock</tt> is not required. [<i>Note:</i> All of the standard
++mutex types meet this requirement. &mdash; <i>end note</i>]
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1269"></a>1269. Associated state doesn't account for <tt>async</tt></h3>
++<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.state">issues</a> in [futures.state].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The current description of the associated state in 30.6.4 [futures.state]
++does not allow for futures created by an <tt>async</tt> call. The description
++therefore needs to be extended to cover that.
++</p>
+
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add a new sentence to 30.6.4 [futures.state] p2:
++</p>
++
++<blockquote><p>
++2 This <i>associated state</i> consists of some state information and some
++(possibly not yet evaluated) <i>result</i>, which can be a (possibly
++<tt>void</tt>) value or an exception. <ins>If the associated state was created
++by a call to <tt>async</tt> (30.6.8 [futures.async]) then it may also
++contain a deferred function or an associated <tt>thread</tt>.</ins>
++</p></blockquote>
++
++<p>
++Add an extra bullet to 30.6.4 [futures.state] p3:
++</p>
++
++<blockquote>
++<p>
++The result of an associated state can be set by calling:
++</p>
++<ul>
++<li>
++<tt>promise::set_value</tt>,
++</li>
++<li>
++<tt>promise::set_exception</tt>, <del>or</del>
++</li>
++<li>
++packaged_task::operator()<del>.</del><ins>, or</ins>
++</li>
++<li>
++<ins>a call to <tt>async</tt> (30.6.8 [futures.async]).</ins>
++</li>
++</ul>
++</blockquote>
+
+
+
+@@ -73430,10 +82277,10 @@ meet this requirement.
+
+ <hr>
+ <h3><a name="1270"></a>1270. <tt>result_of</tt> should be moved to <tt>&lt;type_traits&gt;</tt></h3>
+-<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-11-19 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.ret">issues</a> in [func.ret].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> X [func.ret] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-11-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.ret">issues</a> in [func.ret].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 198</b></p>
+
+@@ -73467,7 +82314,7 @@ although a more consistent form for type_traits would reformat this as a table.
+ </p>
+
+ <p>
+-Following the acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>, <tt>result_of</tt> now
++Following the acceptance of <a href="lwg-defects.html#1255">1255</a>, <tt>result_of</tt> now
+ depends on the <tt>declval</tt> function template, tentatively provided
+ in <tt>&lt;utility&gt;</tt> which is <em>not</em> (yet) required of a
+ free-standing implementation.
+@@ -73517,14 +82364,14 @@ The original wording is preserved here:
+ <blockquote>
+
+ <p>
+-Move X [func.ret] to a heading below 20.7 [meta]. Note
++Move X [func.ret] to a heading below 20.10 [meta]. Note
+ that in principle we should not change the tag, although this is a new tag for
+ 0x. If it has been stable since TR1 it is clearly immutable though.
+ </p>
+
+ <p>
+ This wording should obviously adopt any other changes currently in (Tentatively)
+-Ready status that touch this wording, such as <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1255">1255</a>.
++Ready status that touch this wording, such as <a href="lwg-defects.html#1255">1255</a>.
+ </p>
+
+ </blockquote>
+@@ -73538,7 +82385,7 @@ Ready status that touch this wording, such as <a href="http://www.open-std.org/j
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>From Function objects 20.8 [function.objects], Header &lt;functional&gt;
++<p><i>From Function objects 20.9 [function.objects], Header <tt>&lt;functional&gt;</tt>
+ synopsis, remove:</i></p>
+ <blockquote>
+ <pre>// 20.7.4 result_of:
+@@ -73566,24 +82413,24 @@ This sub-section reads:</i></p>
+ corresponding type <code>Ti</code> is an lvalue-reference type, and rvalues
+ otherwise.</p>
+ </blockquote>
+-<p><i>To Header &lt;type_traits&gt; synopsis 20.7.2 [meta.type.synop], add at
++<p><i>To Header &lt;type_traits&gt; synopsis 20.10.2 [meta.type.synop], add at
+ the indicated location:</i></p>
+ <blockquote>
+ <pre>template &lt;class T&gt; struct underlying_type;
+ <ins>template &lt;class T&gt; struct result_of; <i>// not defined
+ </i>template &lt;class Fn, class... ArgTypes&gt; struct result_of&lt;Fn(ArgTypes...)&gt;;</ins></pre>
+ </blockquote>
+-<p><i>To Other transformations 20.7.7.6 [meta.trans.other], Table 51 —
++<p><i>To Other transformations 20.10.7.6 [meta.trans.other], Table 51 &mdash;
+ Other transformations, add:</i></p>
+ <blockquote>
+- <table style="border-collapse: collapse;" border="1" bordercolor="#111111" cellpadding="3" cellspacing="0">
+- <tbody><tr>
++ <table style="border-collapse: collapse;" border="1" cellpadding="3" cellspacing="0">
++ <tr>
+ <td><b>Template</b></td>
+ <td><b>Condition</b></td>
+ <td><b>Comments</b></td>
+ </tr>
+ <tr>
+- <td valign="top"><code>template &lt;class T&gt;<br>
++ <td valign="top"><code>template &lt;class T&gt;<br/>
+ struct underlying_type;</code></td>
+ <td valign="top"><code>T</code> shall be an enumeration type
+ (7.2)</td>
+@@ -73594,16 +82441,16 @@ Other transformations, add:</i></p>
+ <td valign="top"><ins><code>template &lt;class Fn, class... ArgTypes&gt;
+ struct result_of&lt;Fn(ArgTypes...)&gt;;</code></ins></td>
+ <td valign="top"><ins><code>Fn</code> shall be a function object type
+- 20.8 [function.objects], reference to function, or reference to
++ 20.9 [function.objects], reference to function, or reference to
+ function object type.
+ <tt>decltype(declval&lt;Fn&gt;()(declval&lt;ArgTypes&gt;()...))</tt> shall
+ be well formed.</ins></td>
+ <td valign="top"><ins>The member typedef <code>type</code>
+ shall name the type <code>decltype(declval&lt;Fn&gt;()(declval&lt;ArgTypes&gt;()...))</code>.</ins></td>
+ </tr>
+- </tbody></table>
++ </table>
+ </blockquote>
+-<p>At the end of Other transformations 20.7.7.6 [meta.trans.other] add:</p>
++<p>At the end of Other transformations 20.10.7.6 [meta.trans.other] add:</p>
+
+ <blockquote>
+ <p>[<i>Example:</i> Given these definitions:</p>
+@@ -73616,10 +82463,10 @@ struct S {
+ &nbsp; double operator()(char, int&amp;);
+ };</pre>
+ <p>the following assertions will hold:</p>
+- <pre>static_assert(std::is_same&lt;<wbr>std::result_of&lt;S(int)&gt;::type, short&gt;::value, "Error!");
+-static_assert(std::is_same&lt;<wbr>std::result_of&lt;S&amp;(unsigned char, int&amp;)&gt;::type, double&gt;::value, "Error!");
+-static_assert(std::is_same&lt;<wbr>std::result_of&lt;PF1()&gt;::type, bool&gt;::value, "Error!");</pre>
+- <p><i>&nbsp;— end example</i>]</p>
++ <pre>static_assert(std::is_same&lt;std::result_of&lt;S(int)&gt;::type, short&gt;::value, &quot;Error!&quot;);
++static_assert(std::is_same&lt;std::result_of&lt;S&amp;(unsigned char, int&amp;)&gt;::type, double&gt;::value, &quot;Error!&quot;);
++static_assert(std::is_same&lt;std::result_of&lt;PF1()&gt;::type, bool&gt;::value, &quot;Error!&quot;);</pre>
++ <p><i>&nbsp;&mdash; end example</i>]</p>
+ </blockquote>
+
+
+@@ -73627,11 +82474,11 @@ static_assert(std::is_same&lt;<wbr>std::result_of&lt;PF1()&gt;::type, bool&gt;::
+
+
+ <hr>
+-<h3><a name="1271"></a>1271. CR undefined in duration operators</h3>
+-<p><b>Section:</b> 20.11.3.5 [time.duration.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-11-21 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1271"></a>1271. <tt>CR</tt> undefined in duration operators</h3>
++<p><b>Section:</b> 20.12.5.5 [time.duration.nonmember] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-11-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ IMO <tt>CR</tt> alone is not really defined (it should be <tt>CR(Rep1,
+@@ -73646,24 +82493,26 @@ Rep2)</tt>).
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.11.3.5 [time.duration.nonmember] paragraphs 9 and 12:
++Change 20.12.5.5 [time.duration.nonmember] paragraphs 9 and 12:
+ </p>
+
+-<blockquote><pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 9 <i>Returns:</i> <tt>duration&lt;CR<ins>(Rep1, Rep2)</ins>, Period&gt;(d) /= s</tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>template &lt;class Rep1, class Period, class Rep2&gt;
++<pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
+ duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
+ operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 12 <i>Returns:</i> <tt>duration&lt;CR<ins>(Rep1, Rep2)</ins>, Period&gt;(d) %= s</tt>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -73672,17 +82521,297 @@ Change 20.11.3.5 [time.duration.nonmember] paragraphs 9 and 12:
+
+
+ <hr>
++<h3><a name="1272"></a>1272. confusing declarations of <tt>promise::set_value</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The definitions of <tt>promise::set_value</tt> need tidying up, the
++synopsis says:
++</p>
++
++<blockquote><pre>
++// setting the result
++void set_value(const R&amp; r);
++void set_value(<i>see below</i>);
++</pre></blockquote>
++
++<p>
++Why is the first one there? It implies it is always present for all
++specialisations of promise, which is not true.
++</p>
++
++<p>
++The definition says:
++</p>
++
++<blockquote><pre>
++void set_value(const R&amp; r);
++void promise::set_value(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value(R&amp; r);
++void promise&lt;void&gt;::set_value();
++</pre></blockquote>
++
++<p>
++The lack of qualification on the first one again implies it's present
++for all specialisations, again not true.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the synopsis in 30.6.5 [futures.promise]:
++</p>
++
++<blockquote><pre>
++// setting the result
++<del>void set_value(const R&amp; r);</del>
++void set_value(<i>see below</i>);
++</pre></blockquote>
++
++<p>
++And the definition be changed by qualifying the first signature:
++</p>
++
++<blockquote><pre>
++void <ins>promise::</ins>set_value(const R&amp; r);
++void promise::set_value(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value(R&amp; r);
++void promise&lt;void&gt;::set_value();
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1273"></a>1273. <tt>future::valid</tt> should be callable on an invalid future</h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.6.6 [futures.unique_future]/3 says:
++</p>
++
++<blockquote><p>
++The effect of calling any member function other than the destructor or
++the move-assignment operator on a <tt>future</tt> object for which
++<tt>valid() == false</tt> is undefined.
++</p></blockquote>
++
++<p>
++This means calling <tt>future::valid()</tt> is undefined unless it will
++return <tt>true</tt>, so you can only use it if you know the answer!
++</p>
++
++<p><i>[
++2009-12-08 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 30.6.6 [futures.unique_future]/3:
++</p>
++
++<blockquote><p>
++The effect of calling any member function other than the
++destructor<ins>,</ins> or the move-assignment operator<ins>, or
++<tt>valid</tt>,</ins> on a <tt>future</tt> object for which <tt>valid()
++== false</tt> is undefined.
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1274"></a>1274. <tt>atomic_future</tt> constructor</h3>
++<p><b>Section:</b> X [futures.atomic_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In X [futures.atomic_future] this constructor:
++</p>
++
++<blockquote><pre>
++atomic_future(future&lt;R&gt;&amp;&amp;);
++</pre></blockquote>
++
++<p>
++is declared in the synopsis, but not defined. Instead
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2997.htm">n2997</a>
++defines:
++</p>
++
++<blockquote><pre>
++atomic_future(const future&lt;R&gt;&amp;&amp; rhs);
++</pre></blockquote>
++
++<p>
++and
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">n3000</a>
++defines
++</p>
++
++<blockquote><pre>
++atomic_future(atomic_future&lt;R&gt;&amp;&amp; rhs);
++</pre></blockquote>
++
++<p>
++both of which are wrong. The constructor definition should be changed
++to match the synopsis.
++</p>
++
++<p><i>[
++2009-12-12 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Adjust the signature above X [futures.atomic_future]/6 like so:
++</p>
++
++<blockquote><pre>
++atomic_future(<del>atomic_</del>future<ins>&lt;R&gt;</ins>&amp;&amp; rhs);
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1275"></a>1275. Creating and setting futures</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-11-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.6.6 [futures.unique_future]/1 should be updated to mention
++<tt>async</tt>.
++</p>
++
++<p>
++30.6.7 [futures.shared_future]/1 should also be updated for
++<tt>async</tt>. That paragraph also says
++</p>
++
++<blockquote><p>
++... Its value or exception can be set by use of a
++<tt>shared_future</tt>, <tt>promise</tt> (30.6.5 [futures.promise]), or <tt>packaged_task</tt> (30.6.9 [futures.task]) object that shares the same associated state.
++</p></blockquote>
++
++<p>
++How can the value be set by a <tt>shared_future</tt>?
++</p>
++
++<p>
++X [futures.atomic_future]/1 says
++</p>
++
++<blockquote><p>
++An <tt>atomic_future</tt> object can only be created by use of a
++<tt>promise</tt> (30.6.5 [futures.promise]) or
++<tt>packaged_task</tt> (30.6.9 [futures.task]) object.
++</p></blockquote>
++
++<p>
++which is wrong, it's created from a <tt>std::future</tt>, which could
++have been default-constructed. That paragraph should be closer to the
++text of 30.6.7 [futures.shared_future]/1, and should also mention
++<tt>async</tt>.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1276"></a>1276. <tt>forwardlist</tt> missing allocator constructors</h3>
+-<p><b>Section:</b> 23.3.3 [forwardlist] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-12 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.4 [forwardlist] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist">issues</a> in [forwardlist].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I found that forward_list has only
+ </p>
+
+-<blockquote><pre>forward_list(const forward_list&lt;T,Allocator&gt;&amp; x);
++<blockquote><pre>
++forward_list(const forward_list&lt;T,Allocator&gt;&amp; x);
+ forward_list(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
+ </pre></blockquote>
+
+@@ -73690,14 +82819,15 @@ forward_list(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
+ but misses
+ </p>
+
+-<blockquote><pre>forward_list(const forward_list&amp; x, const Allocator&amp;);
++<blockquote><pre>
++forward_list(const forward_list&amp; x, const Allocator&amp;);
+ forward_list(forward_list&amp;&amp; x, const Allocator&amp;);
+ </pre></blockquote>
+
+ <p>
+ Note to other reviewers: I also checked the container adaptors for similar
+ inconsistencies, but as far as I can see these are already handled by the
+-current active issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1194">1194</a> and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1199">1199</a>.
++current active issues <a href="lwg-defects.html#1194">1194</a> and <a href="lwg-defects.html#1199">1199</a>.
+ </p>
+
+ <p><i>[
+@@ -73708,11 +82838,12 @@ current active issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-d
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 23.3.3 [forwardlist]/3, class template forward_list synopsis change as
++In 23.3.4 [forwardlist]/3, class template forward_list synopsis change as
+ indicated:
+ </p>
+
+-<blockquote><pre>forward_list(const forward_list<del>&lt;T,Allocator&gt;</del>&amp; x);
++<blockquote><pre>
++forward_list(const forward_list<del>&lt;T,Allocator&gt;</del>&amp; x);
+ forward_list(forward_list<del>&lt;T,Allocator&gt;</del>&amp;&amp; x);
+ <ins>forward_list(const forward_list&amp;, const Allocator&amp;);</ins>
+ <ins>forward_list(forward_list&amp;&amp;, const Allocator&amp;);</ins>
+@@ -73725,10 +82856,10 @@ forward_list(forward_list<del>&lt;T,Allocator&gt;</del>&amp;&amp; x);
+
+ <hr>
+ <h3><a name="1277"></a>1277. <tt>std::thread::id</tt> should be trivially copyable</h3>
+-<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2009-11-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.id">issues</a> in [thread.thread.id].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The class definition of <tt>std::thread::id</tt> in
+@@ -73736,7 +82867,8 @@ The class definition of <tt>std::thread::id</tt> in
+ is:
+ </p>
+
+-<blockquote><pre>class thread::id {
++<blockquote><pre>
++class thread::id {
+ public:
+ id();
+ };
+@@ -73765,7 +82897,7 @@ copyable.
+ Add a new sentence to 30.3.1.1 [thread.thread.id] p1:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 An object of type <tt>thread::id</tt> provides a unique identifier for
+ each thread of execution and a single distinct value for all
+ <tt>thread</tt> objects that do not represent a thread of execution
+@@ -73777,7 +82909,7 @@ object that does not represent threads of execution. The library may
+ reuse the value of a <tt>thread::id</tt> of a terminated thread that can
+ no longer be joined. <ins><tt>thread::id</tt> shall be a trivially
+ copyable class (9 [class]).</ins>
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -73785,14 +82917,14 @@ copyable class (9 [class]).</ins>
+
+
+ <hr>
+-<h3><a name="1278"></a>1278. inconsistent return values for <tt>forward_list::insert_after</tt></h3>
+-<p><b>Section:</b> 23.3.3.4 [forwardlist.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-11-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1278"></a>1278. Inconsistent return values for <tt>forward_list::insert_after</tt></h3>
++<p><b>Section:</b> 23.3.4.5 [forwardlist.modifiers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-11-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-After applying LDR<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#149">149</a>, <tt>forward_list</tt> now has 5
++After applying LDR<a href="lwg-defects.html#149">149</a>, <tt>forward_list</tt> now has 5
+ overloads of <tt>insert_after</tt>, all returning an iterator.
+ </p>
+
+@@ -73836,30 +82968,31 @@ Additionally <tt>emplace_after</tt>'s return value is unspecified.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We prefer to return an iterator to the last inserted element. Modify the
+ proposed wording and then set to Ready.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-03-15 Howard adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Wording updated and set to Ready.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In <tt>forward_list</tt> modifiers 23.3.3.4 [forwardlist.modifiers]
++In <tt>forward_list</tt> modifiers 23.3.4.5 [forwardlist.modifiers]
+ make the following modifications:
+ </p>
+
+ <blockquote>
+-<pre>iterator insert_after(const_iterator position, size_type n, const T&amp; x);
++<pre>
++iterator insert_after(const_iterator position, size_type n, const T&amp; x);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -73869,7 +83002,8 @@ inserted copy of <tt>x</tt> or <tt>position</tt> if <tt>n == 0</tt>.</ins>
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class InputIterator&gt;
++<pre>
++template &lt;class InputIterator&gt;
+ iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
+ </pre>
+ <blockquote>
+@@ -73881,7 +83015,8 @@ inserted element or <tt>position</tt> if <tt>first == last</tt>.</ins>
+ </p>
+ </blockquote>
+
+-<pre>iterator insert_after(const_iterator position, initializer_list&lt;T&gt; il);
++<pre>
++iterator insert_after(const_iterator position, initializer_list&lt;T&gt; il);
+ </pre>
+ <blockquote>
+ <p>...</p>
+@@ -73892,7 +83027,8 @@ inserted element or <tt>position</tt> if <tt>il</tt> is empty.</ins>
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class... Args&gt;
++<pre>
++template &lt;class... Args&gt;
+ iterator emplace_after(const_iterator position, Args&amp;&amp;... args);
+ </pre>
+ <blockquote>
+@@ -73913,17 +83049,105 @@ args.
+
+
+ <hr>
+-<h3><a name="1280"></a>1280. initialization of stream iterators</h3>
+-<p><b>Section:</b> 24.6.1.1 [istream.iterator.cons], 24.6.2.1 [ostream.iterator.cons.des] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-04 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream.iterator.cons">issues</a> in [istream.iterator.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1279"></a>1279. forbid <tt>[u|bi]nary_function</tt> specialization</h3>
++<p><b>Section:</b> X [depr.base] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2009-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#depr.base">issues</a> in [depr.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++A program should not be allowed to add specialization of class templates
++<tt>unary_function</tt> and <tt>binary_function</tt>, in force of 17.6.4.2.1 [namespace.std]/1.
++If a program were allowed to specialize these templates, the library could no
++longer rely on them to provide the intended typedefs or there might be other
++undesired interactions.
++</p>
++
++<p><i>[
++2010-03-27 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++Accepting issue <a href="lwg-defects.html#1290">1290</a> would resolve this issue as NAD editorial.
++</p></blockquote>
++
++<p><i>[
++2010-10-24 Daniel adds:
++]</i></p>
++
++
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145.html">n3145</a> would resolve this issue as NAD editorial.
++</p></blockquote>
++
++<p><i>[
++2010 Batavia:
++]</i></p>
++
++
++<blockquote><p>
++Pete: Is this issue actually addressed by N3198, or did deprecating unary/binary_function?
++<p/>
++We determined that this issue is NOT resolved and that it must be resolved or else
++N3198 could break code that does specialize unary&#47;binary function.
++<p/>
++Matt: don't move to NAD
++<p/>
++Howard: I suggest we go further and move 1279 to ready for Madrid.
++<p/>
++Group: Agrees move 1279 to ready for Madrid
++</p></blockquote>
++
++<p>
++Previous proposed resolution:
++</p>
++
++<blockquote><p>
++1 The following <del>classes</del> <ins>class templates</ins> are provided to
++simplify the typedefs of the argument and result types<del>:</del><ins>. A
++program shall not declare specializations of these templates.</ins>
++</p></blockquote>
++
++<p><i>[2011-03-06 Daniel comments]</i></p>
++
++
++<blockquote><p>
++This meeting outcome was not properly reflected in the proposed resolution. I
++also adapted the suggested wording to the N3242 numbering and content state.
++During this course of action it turned out that the first suggested wording
++change has already been applied.
++</p></blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change paragraph X [depr.base]/1 as follows:
++</p>
++
++<blockquote><p>
++1 The class templates <tt>unary_function</tt> and <tt>binary_function</tt> are deprecated.
++<ins>A program shall not declare specializations of these templates.</ins>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1280"></a>1280. Initialization of stream iterators</h3>
++<p><b>Section:</b> 24.6.1.1 [istream.iterator.cons], 24.6.2.1 [ostream.iterator.cons.des] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.iterator.cons">issues</a> in [istream.iterator.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 24.6.1.1 [istream.iterator.cons] describes the effects in terms of:
+ </p>
+
+-<blockquote><pre>basic_istream&lt;charT,traits&gt;* in_stream; // exposition only
++<blockquote><pre>
++basic_istream&lt;charT,traits&gt;* in_stream; // exposition only
+ </pre>
+
+ <p>
+@@ -73946,33 +83170,335 @@ That should be <tt>&amp;s</tt> and similarly for 24.6.2.1 [ostream.iterator.cons
+ Change 24.6.1.1 [istream.iterator.cons] like so:
+ </p>
+
+-<blockquote><pre>istream_iterator(istream_type&amp; s);
++<blockquote><pre>
++istream_iterator(istream_type&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 3 <i>Effects:</i> Initializes <i>in_stream</i> with <tt><ins>&amp;</ins>s</tt>.
+ <i>value</i> ...
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+ And 24.6.2.1 [ostream.iterator.cons.des] like so:
+ </p>
+
+-<blockquote><pre>ostream_iterator(ostream_type&amp; s);
++<blockquote><pre>
++ostream_iterator(ostream_type&amp; s);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 1 <i>Effects:</i> Initializes <i>out_stream</i> with <tt><ins>&amp;</ins>s</tt>
+ and <i>delim</i> with null.
+-</blockquote>
++</p></blockquote>
+
+-<pre>ostream_iterator(ostream_type&amp; s, const charT* delimiter);
++<pre>
++ostream_iterator(ostream_type&amp; s, const charT* delimiter);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 2 <i>Effects:</i> Initializes <i>out_stream</i> with <tt><ins>&amp;</ins>s</tt>
+ and <i>delim</i> with <tt>delimiter</tt>.
++</p></blockquote>
+ </blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1281"></a>1281. CopyConstruction and Assignment between ratios having the same normalized form</h3>
++<p><b>Section:</b> 20.11.3 [ratio.ratio] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Vicente Juan Botet Escrib&aacute; <b>Opened:</b> 2009-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++CopyConstruction and Assignment between <tt>ratio</tt>s having the same
++normalized form. Current
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>
++do not allows to copy-construct or assign <tt>ratio</tt> instances of
++<tt>ratio</tt> classes having the same normalized form.
++</p>
++
++<p>
++Two <tt>ratio</tt> classes <tt>ratio&lt;N1,D1&gt;</tt> and
++<tt>ratio&lt;N2,D2&gt;</tt> have the same normalized form if
++</p>
++
++<blockquote><pre>
++ratio&lt;N1, D1&gt;::num == ratio&lt;N2, D2&gt;::num &amp;&amp;
++ratio&lt;N1, D1&gt;::den == ratio&lt;N2, D2&gt;::den
++</pre></blockquote>
++
++<p>
++This simple example
++</p>
++
++<blockquote><pre>
++ratio&lt;1,3&gt; r1;
++ratio&lt;3,9&gt; r2;
++r1 = r2; // (1)
++</pre></blockquote>
++
++<p>
++fails to compile in (1). Other example
++</p>
++
++<blockquote><pre>
++ratio&lt;1,3&gt; r1;
++ratio_subtract&lt;ratio&lt;2,3&gt;, ratio&lt;1,3&gt;&gt;::type r2;
++r1 = r2;
++</pre></blockquote>
++
++<p>
++The nested type of <tt>ratio_subtract&lt;ratio&lt;2,3&gt;,
++ratio&lt;1,3&gt;&gt;</tt> could be <tt>ratio&lt;3,9&gt;</tt> so the compilation
++could fail. It could also be <tt>ratio&lt;1,3&gt;</tt> and the compilation
++succeeds.
++</p>
++
++<p>
++In 20.11.4 [ratio.arithmetic] 3 and similar clauses
++</p>
++
++<blockquote><p>
++3 The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
++T2&gt;</tt> where <tt>T1</tt> has the value <tt>R1::num * R2::den - R2::num *
++R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>.
++</p></blockquote>
++
++<p>
++the meaning of synonym let think that the result shall be a normalized
++<tt>ratio</tt> equivalent to <tt>ratio&lt;T1, T2&gt;</tt>, but there is not an
++explicit definition of what synonym means in this context.
++</p>
++
++<p>
++Additionally we should add a typedef for accessing the normalized
++<tt>ratio</tt>, and change 20.11.4 [ratio.arithmetic] to return only this
++<em>normalized</em> result.
++</p>
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote>
++<p>
++There is no consensus to add the converting copy constructor or converting copy
++assignment operator. However there was consensus to add the typedef.
++</p>
++
++<p>
++Proposed wording modified. Original proposed wording preserved here. Moved to
++Review.
++</p>
++
++<blockquote class="note">
++<p>
++Make <tt>ratio</tt> default constructible, copy-constructible and assignable
++from any <tt>ratio</tt> which has the same reduced form.
++</p>
++
++<p>
++Add to 20.11.3 [ratio.ratio] synopsis
++</p>
++
++<blockquote><pre>
++template &lt;intmax_t N, intmax_t D = 1&gt;
++class ratio {
++public:
++ static constexpr intmax_t num;
++ static constexpr intmax_t den;
++
++ <ins>typedef ratio&lt;num, den&gt; type;</ins>
++
++ <ins>ratio() = default;
++ template &lt;intmax_t N2, intmax_t D2&gt;
++ ratio(const ratio&lt;N2, D2&gt;&amp;);
++ template &lt;intmax_t N2, intmax_t D2&gt;
++ ratio&amp; operator=(const ratio&lt;N2, D2&gt;&amp;);</ins>
++};
++</pre></blockquote>
++
++<p>
++Add to 20.11.3 [ratio.ratio]:
++</p>
++
++<blockquote>
++<p>
++Two ratio classes <tt>ratio&lt;N1,D1&gt;</tt> and <tt>ratio&lt;N2,D2&gt;</tt>
++have the same reduced form if <tt>ratio&lt;N1,D1&gt;::type</tt> is the same
++type as <tt>ratio&lt;N2,D2&gt;::type</tt>
++</p>
++
+ </blockquote>
+
++<p>
++Add a new section: [ratio.cons]
++</p>
++
++<blockquote>
++<p><b>
++Construction and assignment [ratio.cons]
++</b></p>
++
++<pre>
++template &lt;intmax_t N2, intmax_t D2&gt;
++ ratio(const ratio&lt;N2, D2&gt;&amp; r);
++</pre>
++
++<blockquote>
++<p>
++<i>Effects:</i> Constructs a <tt>ratio</tt> object.
++</p>
++<p>
++<i>Remarks:</i> This constructor shall not participate in overload resolution
++unless <tt>r</tt> has the same reduced form as <tt>*this</tt>.
++</p>
++</blockquote>
++
++<pre>
++template &lt;intmax_t N2, intmax_t D2&gt;
++ ratio&amp; operator=(const ratio&lt;N2, D2&gt;&amp; r);
++</pre>
++
++<blockquote>
++<p>
++<i>Effects:</i> None.
++</p>
++<p>
++<i>Returns:</i> <tt>*this</tt>.
++</p>
++<p>
++<i>Remarks:</i> This operator shall not participate in overload resolution
++unless <tt>r</tt> has the same reduced form as <tt>*this</tt>.
++</p>
++</blockquote>
++
++</blockquote>
++
++<p>
++Change 20.11.4 [ratio.arithmetic]
++</p>
++
++<blockquote>
++<p>
++Implementations may use other algorithms to compute these values. If overflow
++occurs, a diagnostic shall be issued.
++</p>
++
++<pre>
++template &lt;class R1, class R2&gt; struct ratio_add {
++ typedef <i>see below</i> type;
++};
++</pre>
++
++<blockquote><p>
++The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
++T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
++R2::den + R2::num * R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den *
++R2::den</tt>.
++</p></blockquote>
++
++<pre>
++template &lt;class R1, class R2&gt; struct ratio_subtract {
++ typedef <i>see below</i> type;
++};
++</pre>
++
++<blockquote><p>
++The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
++T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
++R2::den - R2::num * R1::den</tt> and <tt>T2</tt> has the value <tt>R1::den *
++R2::den</tt>.
++</p></blockquote>
++
++<pre>
++template &lt;class R1, class R2&gt; struct ratio_multiply {
++ typedef <i>see below</i> type;
++};
++</pre>
++
++<blockquote><p>
++The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
++T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
++R2::num</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>.
++</p></blockquote>
++
++<pre>
++template &lt;class R1, class R2&gt; struct ratio_divide {
++ typedef <i>see below</i> type;
++};
++</pre>
++
++<blockquote><p>
++The nested typedef <tt>type</tt> shall be a synonym for <tt>ratio&lt;T1,
++T2&gt;<ins>::type</ins></tt> where <tt>T1</tt> has the value <tt>R1::num *
++R2::den</tt> and <tt>T2</tt> has the value <tt>R1::den * R2::num</tt>.
++</p></blockquote>
++
++</blockquote>
++
++</blockquote>
++
++</blockquote>
++
++<p><i>[
++2010-03-27 Howard adds:
++]</i></p>
++
++
++<blockquote>
++<p>
++Daniel brought to my attention the recent addition of the typedef <tt>type</tt>
++to the FCD
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>:
++</p>
++
++<blockquote><pre>
++typedef ratio type;
++</pre></blockquote>
++
++<p>
++This issue was discussed in Pittsburgh, and the decision there was to accept the
++typedef as proposed and move to Review. Unfortunately the issue was accidently
++applied to the FCD, and incorrectly. The FCD version of the typedef refers to
++<tt>ratio&lt;N, D&gt;</tt>, but the typedef is intended to refer to
++<tt>ratio&lt;num, den&gt;</tt> which in general is not the same type.
++</p>
++
++<p>
++I've updated the wording to diff against
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>.
++</p>
++
++</blockquote>
++
++<p><i>[Batavia: <del>NAD Editorial</del><ins>Resolved</ins> - see rationale below]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p><p>Already fixed in working draft</p>
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add to 20.11.3 [ratio.ratio] synopsis
++</p>
++
++<blockquote><pre>
++template &lt;intmax_t N, intmax_t D = 1&gt;
++class ratio {
++public:
++ static constexpr intmax_t num;
++ static constexpr intmax_t den;
++
++ typedef ratio<ins>&lt;num, den&gt;</ins> type;
++};
++</pre></blockquote>
++
+
+
+
+@@ -73981,10 +83507,10 @@ and <i>delim</i> with <tt>delimiter</tt>.
+ <hr>
+ <h3><a name="1283"></a>1283. <tt>MoveConstructible</tt> and <tt>MoveAssignable</tt> need clarification
+ of moved-from state</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-12 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 150</b></p>
+
+@@ -73992,7 +83518,7 @@ of moved-from state</h3>
+ There is on going confusion over what one can and can not do with a moved-from
+ object (e.g.
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3009.html#UK150">UK 150</a>,
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#910">910</a>).
++<a href="lwg-closed.html#910">910</a>).
+ This issue attempts to clarify that moved-from objects are valid objects with an
+ unknown state.
+ </p>
+@@ -74055,7 +83581,7 @@ and this is an objection that I do want resolved.
+ </blockquote>
+
+ <p><i>[
+-2010-02-10 Reopened. The wording here has been merged into <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>.
++2010-02-10 Reopened. The wording here has been merged into <a href="lwg-defects.html#1309">1309</a>.
+ ]</i></p>
+
+
+@@ -74069,20 +83595,20 @@ c++std-lib. Rationale added below.
+
+ <p><b>Rationale:</b></p>
+ <p>
+-This issue is now addressed by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a>.
++This issue is now addressed by <a href="lwg-defects.html#1309">1309</a>.
+ </p>
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the follwing tables in 20.2.1 [utility.arg.requirements] as shown:
++Change the follwing tables in 17.6.3.1 [utility.arg.requirements] as shown:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<caption>Table 33 — <tt>MoveConstructible</tt> requirements <b>[moveconstructible]</b></caption>
+-<tbody><tr>
++<caption>Table 33 &mdash; <tt>MoveConstructible</tt> requirements <b>[moveconstructible]</b></caption>
++<tr>
+ <th>Expression</th>
+ <th>Post-condition</th>
+ </tr>
+@@ -74100,17 +83626,17 @@ Change the follwing tables in 20.2.1 [utility.arg.requirements] as shown:
+ <del>There is no requirement on the value of <tt>rv</tt> after the
+ construction.</del>
+ <ins><tt>rv</tt> remains a valid object. Its state is unspecified.</ins>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+
+ </blockquote>
+ <blockquote>
+
+ <table border="1">
+-<caption>Table 35 — <tt>MoveAssignable</tt> requirements <b>[moveassignable]</b></caption>
+-<tbody><tr>
++<caption>Table 35 &mdash; <tt>MoveAssignable</tt> requirements <b>[moveassignable]</b></caption>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Return value</th>
+@@ -74136,10 +83662,10 @@ construction.</del>
+ <del>There is no requirement on the value of <tt>rv</tt> after the
+ assignment.</del>
+ <ins><tt>rv</tt> remains a valid object. Its state is unspecified.</ins>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+
+ </blockquote>
+
+@@ -74149,17 +83675,18 @@ assignment.</del>
+
+ <hr>
+ <h3><a name="1284"></a>1284. <tt>vector&lt;bool&gt; initializer_list</tt> constructor missing an allocator argument</h3>
+-<p><b>Section:</b> 23.4.2 [vector.bool] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-12-09 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2009-12-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The specialization for <tt>vector&lt;bool&gt;</tt> (23.4.2 [vector.bool])
++The specialization for <tt>vector&lt;bool&gt;</tt> (23.3.7 [vector.bool])
+ has a constructor
+ </p>
+
+-<blockquote><pre>vector(initializer_list&lt;bool&gt;);
++<blockquote><pre>
++vector(initializer_list&lt;bool&gt;);
+ </pre></blockquote>
+
+ <p>
+@@ -74175,10 +83702,11 @@ that it has no <tt>allocator</tt> parameter.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change the signature in the synopsis of 23.4.2 [vector.bool] to
++Change the signature in the synopsis of 23.3.7 [vector.bool] to
+ </p>
+
+-<blockquote><pre>vector(initializer_list&lt;bool&gt;<ins>, const Allocator&amp; = Allocator()</ins>);
++<blockquote><pre>
++vector(initializer_list&lt;bool&gt;<ins>, const Allocator&amp; = Allocator()</ins>);
+ </pre></blockquote>
+
+
+@@ -74187,13 +83715,13 @@ Change the signature in the synopsis of 23.4.2 [vector.bool] to
+
+ <hr>
+ <h3><a name="1285"></a>1285. <tt>allocator_traits</tt> call to <tt>new</tt></h3>
+-<p><b>Section:</b> 20.9.4.2 [allocator.traits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.traits.members">issues</a> in [allocator.traits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7.8.2 [allocator.traits.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.traits.members">issues</a> in [allocator.traits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#402">402</a> added "<tt>::</tt>" to the call to <tt>new</tt>
++LWG issue <a href="lwg-defects.html#402">402</a> added "<tt>::</tt>" to the call to <tt>new</tt>
+ within <tt>allocator::construct</tt>. I suspect we want to retain that fix.
+ </p>
+
+@@ -74205,16 +83733,16 @@ within <tt>allocator::construct</tt>. I suspect we want to retain that fix.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.2.5 [allocator.requirements], table 40 "Allocator requirements":
++Change 17.6.3.5 [allocator.requirements], table 40 "Allocator requirements":
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 40 — Allocator requirements</caption>
+-<tbody><tr>
++<caption>Table 40 &mdash; Allocator requirements</caption>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Default</th>
+ </tr>
+ <tr>
+@@ -74231,22 +83759,23 @@ Effect: Constructs an object of type <tt>C</tt> at <tt>c</tt>
+ <tt><ins>::</ins>new ((void*)c) C(forward&lt;Args&gt;(args)...)</tt>
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+-Change 20.9.4.2 [allocator.traits.members], p4:
++Change 20.7.8.2 [allocator.traits.members], p4:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class... Args&gt;
++<blockquote><pre>
++template &lt;class T, class... Args&gt;
+ static void construct(Alloc&amp; a, T* p, Args&amp;&amp;... args);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 4 <i>Effects:</i> calls <tt>a.construct(p,
+ std::forward&lt;Args&gt;(args)...)</tt> if that call is well-formed; otherwise,
+ invokes <tt><ins>::</ins>new (static_cast&lt;void*&gt;(p))
+ T(std::forward&lt;Args&gt;(args)...)</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -74255,23 +83784,24 @@ T(std::forward&lt;Args&gt;(args)...)</tt>.
+
+ <hr>
+ <h3><a name="1286"></a>1286. <tt>allocator_traits::select_on_container_copy_construction</tt> type-o</h3>
+-<p><b>Section:</b> 20.9.4.2 [allocator.traits.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-10 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.traits.members">issues</a> in [allocator.traits.members].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7.8.2 [allocator.traits.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2009-12-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.traits.members">issues</a> in [allocator.traits.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <tt>allocator_traits::select_on_container_copy_construction</tt> refers to an
+ unknown "<tt>a</tt>":
+ </p>
+
+-<blockquote><pre>static Alloc select_on_container_copy_construction(const Alloc&amp; rhs);
++<blockquote><pre>
++static Alloc select_on_container_copy_construction(const Alloc&amp; rhs);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 7 <i>Returns:</i> <tt>rhs.select_on_container_copy_construction(a)</tt> if that
+ expression is well-formed; otherwise, <tt>rhs</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p><i>[
+@@ -74283,17 +83813,18 @@ expression is well-formed; otherwise, <tt>rhs</tt>.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.9.4.2 [allocator.traits.members], p7:
++Change 20.7.8.2 [allocator.traits.members], p7:
+ </p>
+
+-<blockquote><pre>static Alloc select_on_container_copy_construction(const Alloc&amp; rhs);
++<blockquote><pre>
++static Alloc select_on_container_copy_construction(const Alloc&amp; rhs);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 7 <i>Returns:</i>
+ <tt>rhs.select_on_container_copy_construction(<del>a</del>)</tt> if that
+ expression is well-formed; otherwise, <tt>rhs</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -74302,10 +83833,10 @@ expression is well-formed; otherwise, <tt>rhs</tt>.
+
+ <hr>
+ <h3><a name="1287"></a>1287. <tt>std::function</tt> requires <tt>CopyConstructible</tt> target object</h3>
+-<p><b>Section:</b> 20.8.14.2.1 [func.wrap.func.con] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ I think <tt>std::function</tt> should require <tt>CopyConstructible</tt> for the
+@@ -74336,19 +83867,20 @@ required.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to 20.8.14.2.1 [func.wrap.func.con] paragraph 9:
++Add to 20.9.12.2.1 [func.wrap.func.con] paragraph 9:
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function(F f);
++<blockquote><pre>
++template&lt;class F&gt; function(F f);
+ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 9 <i>Requires:</i> <ins><tt>F</tt> shall be <tt>CopyConstructible</tt>.</ins>
+ <tt>f</tt> shall be callable for argument types <tt>ArgTypes</tt> and return
+ type <tt>R</tt>. The copy constructor and destructor of <tt>A</tt> shall not
+ throw exceptions.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+
+@@ -74358,16 +83890,17 @@ throw exceptions.
+
+ <hr>
+ <h3><a name="1288"></a>1288. <tt>std::function</tt> assignment from rvalues</h3>
+-<p><b>Section:</b> 20.8.14.2.1 [func.wrap.func.con] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-13 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In 20.8.14.2.1 [func.wrap.func.con]
++In 20.9.12.2.1 [func.wrap.func.con]
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function&amp; operator=(F f);
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(F f);
+ </pre>
+ <blockquote>
+ <p>
+@@ -74383,7 +83916,8 @@ In 20.8.14.2.1 [func.wrap.func.con]
+ This assignment operator can be called such that <tt>F</tt> is an rvalue-reference e.g.
+ </p>
+
+-<blockquote><pre>func.operator=&lt;F&amp;&amp;&gt;(f);
++<blockquote><pre>
++func.operator=&lt;F&amp;&amp;&gt;(f);
+ </pre></blockquote>
+
+ <p>
+@@ -74407,8 +83941,8 @@ The same issues apply to <tt>function::assign</tt>.
+ </p>
+
+ <p>
+-N.B. this issue is not related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1287">1287</a> and applies whether that
+-issue is resolved or not. The wording below assumes the resolution of LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a> has been applied.
++N.B. this issue is not related to <a href="lwg-defects.html#1287">1287</a> and applies whether that
++issue is resolved or not. The wording below assumes the resolution of LWG <a href="lwg-defects.html#1258">1258</a> has been applied.
+ </p>
+
+ <p><i>[
+@@ -74417,7 +83951,7 @@ issue is resolved or not. The wording below assumes the resolution of LWG <a hre
+
+
+ <p><i>[
+-201002-11 Opened by Alisdair for the purpose of merging <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1258">1258</a> into
++201002-11 Opened by Alisdair for the purpose of merging <a href="lwg-defects.html#1258">1258</a> into
+ this issue as there is a minor conflict.
+ ]</i></p>
+
+@@ -74431,10 +83965,11 @@ this issue as there is a minor conflict.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.8.14.2.1 [func.wrap.func.con]
++In 20.9.12.2.1 [func.wrap.func.con]
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function&amp; operator=(F<ins>&amp;&amp;</ins> f);
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(F<ins>&amp;&amp;</ins> f);
+ </pre>
+ <blockquote>
+ <p>
+@@ -74448,10 +83983,11 @@ In 20.8.14.2.1 [func.wrap.func.con]
+ </blockquote>
+
+ <p>
+-In 20.8.14.2.2 [func.wrap.func.mod]
++In 20.9.12.2.2 [func.wrap.func.mod]
+ </p>
+
+-<blockquote><pre>template&lt;class F, <del>Allocator Alloc</del><ins>class A</ins>&gt;
++<blockquote><pre>
++template&lt;class F, <del>Allocator Alloc</del><ins>class A</ins>&gt;
+ void assign(F<ins>&amp;&amp; f</ins>, const A<del>lloc</del>&amp; a);
+ </pre>
+ <blockquote>
+@@ -74463,10 +83999,11 @@ std::forward&lt;F&gt;(f)</ins>).swap(*this);</tt>
+ </blockquote>
+
+ <p>
+-Update member function signature for class template in 20.8.14.2 [func.wrap.func]
++Update member function signature for class template in 20.9.12.2 [func.wrap.func]
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function&amp; operator=(F<ins>&amp;&amp;</ins>);
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(F<ins>&amp;&amp;</ins>);
+
+ template&lt;class F, class A&gt; void assign(F<ins>&amp;&amp;</ins>, const A&amp;);
+ </pre></blockquote>
+@@ -74479,13 +84016,13 @@ template&lt;class F, class A&gt; void assign(F<ins>&amp;&amp;</ins>, const A&amp
+
+ <hr>
+ <h3><a name="1290"></a>1290. Don't require <tt>[u|bi]nary_function</tt> inheritance</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-14 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-This issue is a follow-up of the discussion on issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a> during
++This issue is a follow-up of the discussion on issue <a href="lwg-defects.html#870">870</a> during
+ the 2009 Santa Cruz meeting.
+ </p>
+
+@@ -74494,7 +84031,8 @@ The class templates <tt>unary_function</tt> and <tt>binary_function</tt> are
+ actually very simple typedef providers,
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+
+ template &lt;class Arg, class Result&gt;
+ struct unary_function {
+@@ -74515,11 +84053,13 @@ struct binary_function {
+ <p>
+ which <i>may</i> be used as base classes (similarly to the iterator template),
+ but were originally <i>not</i> intended as a customization point. The SGI
+-documentation introduced the concept <a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">Adaptable Unary
++documentation introduced the concept
++<a href="http://www.sgi.com/tech/stl/AdaptableUnaryFunction.html">Adaptable Unary
+ Function</a> as function objects "with nested typedefs that define its argument
+-type and result type" and a similar definition for <a href="http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html">Adaptable Binary
++type and result type" and a similar definition for
++<a href="http://www.sgi.com/tech/stl/AdaptableBinaryFunction.html">Adaptable Binary
+ Function</a> related to <tt>binary_function</tt>. But as of TR1 a protocol was
+-introduced that relies on inheritance relations based on these types. 20.8.4 [refwrap]/3 b. 3 requires that a specialization of
++introduced that relies on inheritance relations based on these types. 20.9.4 [refwrap]/3 b. 3 requires that a specialization of
+ <tt>reference_wrapper&lt;T&gt;</tt> shall derive from <tt>unary_function</tt>,
+ if type <tt>T</tt> is "a class type that is derived from
+ <tt>std::unary_function&lt;T1, R&gt;</tt>" and a similar inheritance-based rule
+@@ -74527,23 +84067,24 @@ for <tt>binary_function</tt> exists as well.
+ </p>
+
+ <p>
+-As another disadvantage it has been pointed out in the TR1 issue list, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">N1837</a>
+-(see section 10.39), that the requirements of <tt>mem_fn</tt> 20.8.13 [func.memfn]/2+3 to <em>derive</em> from
++As another disadvantage it has been pointed out in the TR1 issue list, <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">N1837</a>
++(see section 10.39), that the requirements of <tt>mem_fn</tt> 20.9.11 [func.memfn]/2+3 to <em>derive</em> from
+ <tt>std::unary_function/std::binary_function</tt> under circumstances, where the
+ provision of corresponding typedefs would be sufficient, unnecessarily prevent
+-implementations that take advantage of empty-base-class- optimizations.
++implementations that take advantage of empty-base-class optimizations.
+ </p>
+
+ <p>
+ Both requirements should be relaxed in the sense that the
+ <tt>reference_wrapper</tt> should provide typedef's <tt>argument_type</tt>,
+ <tt>first_argument_type</tt>, and <tt>second_argument_type</tt> based on similar
+-rules as the <i>weak result type</i> rule (20.8.2 [func.require]/3) does
++rules as the <i>weak result type</i> rule (20.9.2 [func.require]/3) does
+ specify the presence of <tt>result_type</tt> member types.
+ </p>
+
+ <p>
+-For a related issue see also <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a>.
++For a related issue see also <a href="lwg-defects.html#1279">1279</a>.
+ </p>
+
+ <p><i>[
+@@ -74551,9 +84092,10 @@ For a related issue see also <a href="http://www.open-std.org/jtc1/sc22/wg21/doc
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145.html">n3145</a> would resolve this issue as NAD editorial.
+-</blockquote>
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145.html">n3145</a>
++would resolve this issue as NAD editorial.
++</p></blockquote>
+
+
+
+@@ -74562,23 +84104,23 @@ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145
+ ]</i></p>
+
+ <p>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.html">n3198</a>.
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.htm">n3198</a>.
+ </p>
+
+ <p>
+ Previous proposed resolution:
+-
+-</p><p><i>[
++</p>
++<p><i>[
+ The here proposed resolution is an attempt to realize the common denominator of
+ the reflector threads c++std-lib-26011, c++std-lib-26095, and c++std-lib-26124.
+ ]</i></p>
+
+-
++<blockquote class="note">
+ <ol>
+ <li>
+ <p>
+-Change X [base]/1 as indicated: <i>[The intend is to provide an
+-alternative fix for issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#1279">1279</a> and some editorial harmonization
++Change [base]/1 as indicated: <i>[The intend is to provide an
++alternative fix for issue <a href="lwg-defects.html#1279">1279</a> and some editorial harmonization
+ with existing wording in the library, like 24.4.2 [iterator.basic]/1]</i>
+ </p>
+
+@@ -74590,7 +84132,8 @@ function objects. The behavior of a program that adds specializations for any of
+ these templates is undefined.</ins><del>:</del>
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class Arg, class Result&gt;
+ struct unary_function {
+ typedef Arg argument_type;
+@@ -74612,7 +84155,7 @@ namespace std {
+
+ <li>
+ <p>
+-Change 20.8.4 [refwrap], class template <tt>reference_wrapper</tt>
++Change 20.9.4 [refwrap], class template <tt>reference_wrapper</tt>
+ synopsis as indicated: <i>[The intent is to remove the requirement that
+ <tt>reference_wrapper</tt> derives from <tt>unary_function</tt> or
+ <tt>binary_function</tt> if the situation requires the definition of the
+@@ -74625,7 +84168,8 @@ in a function object and it ensures that user-defined function objects which
+ provide typedefs but no such bases are handled as first class citizens.]</i>
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class T&gt; class reference_wrapper
+ <del>: public unary_function&lt;T1, R&gt; // <i>see below</i></del>
+ <del>: public binary_function&lt;T1, T2, R&gt; // <i>see below</i></del>
+@@ -74646,7 +84190,7 @@ provide typedefs but no such bases are handled as first class citizens.]</i>
+
+ <li>
+ <p>
+-Change 20.8.4 [refwrap]/3 as indicated: <i>[The intent is to remove the
++Change 20.9.4 [refwrap]/3 as indicated: <i>[The intent is to remove the
+ requirement that <tt>reference_wrapper</tt> derives from <tt>unary_function</tt>
+ if the situation requires the definition of the typedef <tt>argument_type</tt>
+ and <tt>result_type</tt>. Note that this clause does concentrate on
+@@ -74682,7 +84226,7 @@ the type <tt>T1</tt> is <em>cv</em> <tt>T0*</tt>
+
+ <li>
+ <p>
+-Change 20.8.4 [refwrap]/4 as indicated: <i>[The intent is to remove the
++Change 20.9.4 [refwrap]/4 as indicated: <i>[The intent is to remove the
+ requirement that <tt>reference_wrapper</tt> derives from
+ <tt>binary_function</tt> if the situation requires the definition of the typedef
+ <tt>first_argument_type</tt>, <tt>second_argument_type</tt>, and
+@@ -74724,11 +84268,12 @@ types <tt>first_argument_type</tt>
+
+ <li>
+ <p>
+-Change 20.8.13 [func.memfn]/2+3 as indicated: <i>[The intent is to remove
++Change 20.9.11 [func.memfn]/2+3 as indicated: <i>[The intent is to remove
+ the requirement that mem_fn's return type has to derive
+ from <tt>[u|bi]nary_function</tt>. The reason for suggesting the
+ change here is to better support empty-base-class optimization
+-choices as has been pointed out in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">N1837</a>]</i>
++choices as has been pointed out in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1837.pdf">N1837</a>]</i>
+ </p>
+
+ <blockquote>
+@@ -74754,30 +84299,91 @@ function with cv-qualifier <em>cv</em> and taking one argument of type
+ </li>
+
+ </ol>
+-<p></p>
++</blockquote>
++
++<p><b>Proposed resolution:</b></p><p>
++Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.htm">n3198</a>.
++</p>
++
++
++
++<hr>
++<h3><a name="1291"></a>1291. Exceptions thrown during <tt>promise::set_value</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 30.6.5 [futures.promise]
++</p>
++
++<p>
++Does <tt>promise&lt;R&gt;::set_value</tt> return normally if the copy&#47;move
++constructor of <tt>R</tt> throws?
++</p>
++
++<p>
++The exception could be caught and set using
++<tt>promise&lt;R&gt;::set_exception</tt>, or it could be allowed to leave the
++<tt>set_value</tt> call, but it's not clear which is intended. I suggest the
++exception should not be caught.
++</p>
++
++<p>
++N.B. This doesn't apply to <tt>promise&lt;R&amp;&gt;::set_value</tt> or
++<tt>promise&lt;void&gt;::set_value</tt> because they don't construct a new
++object.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
+
+ <p><b>Proposed resolution:</b></p>
+-Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.html">n3198</a>.
++<p>
++Change 30.6.5 [futures.promise]/18:
++</p>
++
++<blockquote><p>
++18 <i>Throws:</i> <tt>future_error</tt> if its associated state is already
++ready<ins> or, for the first version an exception thrown by the copy constructor
++of <tt>R</tt>, or for the second version an exception thrown by the move
++constructor of <tt>R</tt></ins>.
++</p></blockquote>
++
+
+
+
+
+ <hr>
+ <h3><a name="1292"></a>1292. <tt>std::function</tt> should support all callable types</h3>
+-<p><b>Section:</b> 20.8.14.2.1 [func.wrap.func.con] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-19 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Some parts of the specification of <tt>std::function</tt> is unnecessarily
+-restricted to a subset of all callable types (as defined in 20.8.1 [func.def]/3), even though the intent clearly is to be usable for
+-<em>all</em> of them as described in 20.8.14.2 [func.wrap.func]/1. This
++restricted to a subset of all callable types (as defined in 20.9.1 [func.def]/3), even though the intent clearly is to be usable for
++<em>all</em> of them as described in 20.9.12.2 [func.wrap.func]/1. This
+ argument becomes strengthened by the fact that current C++0x-compatible
+ compilers work fine with them:
+ </p>
+
+-<blockquote><pre>#include &lt;functional&gt;
++<blockquote><pre>
++#include &lt;functional&gt;
+ #include &lt;iostream&gt;
+
+ struct A
+@@ -74810,10 +84416,11 @@ int main()
+ </pre></blockquote>
+
+ <p>
+-The problematics passages are 20.8.14.2.1 [func.wrap.func.con]/10:
++The problematic passages are 20.9.12.2.1 [func.wrap.func.con]/10:
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function(F f);
++<blockquote><pre>
++template&lt;class F&gt; function(F f);
+ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
+ </pre>
+ <blockquote>
+@@ -74823,10 +84430,10 @@ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f)
+ </p>
+ <ul>
+ <li>
+-<tt>f</tt> is a NULL function pointer.
++<tt>f</tt> is a <tt>NULL</tt> function pointer.
+ </li>
+ <li>
+-<tt>f</tt> is a NULL member function pointer.
++<tt>f</tt> is a <tt>NULL</tt> member function pointer.
+ </li>
+ <li>
+ <tt>F</tt> is an instance of the function class template, and <tt>!f</tt>
+@@ -74837,8 +84444,8 @@ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f)
+
+ <p>
+ because it does not consider pointer to data member and all constraints based on
+-<em>function objects</em> which like 20.8.14.2 [func.wrap.func]/2 or 20.8.14.2.5 [func.wrap.func.targ]/3. The latter two will be resolved by the proposed
+-resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#870">870</a> and are therefore not handled here.
++<em>function objects</em> which like 20.9.12.2 [func.wrap.func]/2 or 20.9.12.2.5 [func.wrap.func.targ]/3. The latter two will be resolved by the proposed
++resolution of <a href="lwg-defects.html#870">870</a> and are therefore not handled here.
+ </p>
+
+ <p><i>[
+@@ -74846,9 +84453,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -74859,10 +84466,11 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.14.2.1 [func.wrap.func.con]/10+11 as indicated:
++Change 20.9.12.2.1 [func.wrap.func.con]/10+11 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class F&gt; function(F f);
++<blockquote><pre>
++template&lt;class F&gt; function(F f);
+ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
+ </pre>
+ <blockquote>
+@@ -74872,10 +84480,10 @@ template &lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f)
+ </p>
+ <ul>
+ <li>
+-<tt>f</tt> is a NULL function pointer.
++<tt>f</tt> is a <tt>NULL</tt> function pointer.
+ </li>
+ <li>
+-<tt>f</tt> is a NULL <ins>pointer to</ins> member <del>function pointer</del>.
++<tt>f</tt> is a <tt>NULL</tt> <ins>pointer to</ins> member <del>function pointer</del>.
+ </li>
+ <li>
+ <tt>F</tt> is an instance of the function class template, and <tt>!f</tt>
+@@ -74889,7 +84497,7 @@ to member function, and targets a copy of <tt>mem_fn(f)</tt> if <tt>f</tt> is a
+ pointer to member function</del>. [<i>Note:</i> implementations are encouraged
+ to avoid the use of dynamically allocated memory for small function objects, for
+ example, where <tt>f</tt>'s target is an object holding only a pointer or
+-reference to an object and a member function pointer. — <i>end note</i>]
++reference to an object and a member function pointer. &mdash; <i>end note</i>]
+ </p>
+
+ </blockquote>
+@@ -74901,14 +84509,15 @@ reference to an object and a member function pointer.
+
+ <hr>
+ <h3><a name="1293"></a>1293. <tt>unique_ptr&lt;T[], D&gt;</tt> needs to get rid of <i>unspecified-pointer-type</i></h3>
+-<p><b>Section:</b> 20.9.9.3 [unique.ptr.runtime] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-20 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.8.1.3 [unique.ptr.runtime] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.runtime">issues</a> in [unique.ptr.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses UK 211</b></p>
+
+ <p>
+-As a response to UK 211 LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1021">1021</a> has replaced the
++As a response to UK 211 LWG issue <a href="lwg-defects.html#1021">1021</a> has replaced the
+ <i>unspecified-pointer-type</i> by <tt>nullptr_t</tt> to allow assignment of
+ type-safe null-pointer literals in the non-array form of
+ <tt>unique_ptr::operator=</tt>, but did not the same for the specialization for
+@@ -74927,12 +84536,12 @@ function which is completely unspecified.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ We moved
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">N3073</a>
+ to the formal motions page in Pittsburgh which should obsolete this issue. I've
+ moved this issue to NAD Editorial, solved by N3073.
+-</blockquote>
++</p></blockquote>
+
+
+
+@@ -74944,11 +84553,12 @@ Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.9.9.3 [unique.ptr.runtime], class template <tt>unique_ptr&lt;T[],
++In 20.8.1.3 [unique.ptr.runtime], class template <tt>unique_ptr&lt;T[],
+ D&gt;</tt> synopsis, change as indicated:
+ </p>
+
+-<blockquote><pre>// assignment
++<blockquote><pre>
++// assignment
+ unique_ptr&amp; operator=(unique_ptr&amp;&amp; u);
+ unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del><ins>nullptr_t</ins>);
+ </pre></blockquote>
+@@ -74960,14 +84570,15 @@ unique_ptr&amp; operator=(<del><i>unspecified-pointer-type</i></del><ins>nullptr
+
+ <hr>
+ <h3><a name="1294"></a>1294. Difference between callable wrapper and forwarding call wrapper unclear</h3>
+-<p><b>Section:</b> 20.8.2 [func.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-12-21 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.require">issues</a> in [func.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.2 [func.require] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2009-12-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current wording in the standard makes it hard to discriminate the difference
+-between a "call wrapper" as defined in 20.8.1 [func.def]/5+6:
++between a "call wrapper" as defined in 20.9.1 [func.def]/5+6:
+ </p>
+
+ <blockquote>
+@@ -74981,7 +84592,7 @@ a call operation that forwards to that object.
+ </blockquote>
+
+ <p>
+-and a "forwarding call wrapper" as defined in 20.8.2 [func.require]/4:
++and a "forwarding call wrapper" as defined in 20.9.2 [func.require]/4:
+ </p>
+
+ <blockquote>
+@@ -74991,18 +84602,20 @@ with an argument list. [<i>Note:</i> in a typical implementation forwarding call
+ wrappers have an overloaded function call operator of the form
+ </p>
+
+-<blockquote><pre>template&lt;class... ArgTypes&gt;
++<blockquote><pre>
++template&lt;class... ArgTypes&gt;
+ R operator()(ArgTypes&amp;&amp;... args) <i>cv-qual</i>;
+ </pre></blockquote>
+
+ <p>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+ <p>
+ Reason for this lack of clear difference seems to be that the wording adaption
+-to variadics and rvalues that were applied after it's original proposal in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1673.html#call%20wrapper">N1673</a>:
++to variadics and rvalues that were applied after it's original proposal in <a
++href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1673.html#call%20wrapper">N1673</a>:
+ </p>
+
+ <blockquote>
+@@ -75015,12 +84628,13 @@ a typical implementation forwarding call wrappers have overloaded
+ function call operators of the form
+ </p>
+
+-<blockquote><pre>template&lt;class T1, class T2, ..., class TN&gt;
++<blockquote><pre>
++template&lt;class T1, class T2, ..., class TN&gt;
+ R operator()(T1&amp; t1, T2&amp; t2, ..., TN&amp; tN) <i>cv-qual</i>;
+ </pre></blockquote>
+
+ <p>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -75043,12 +84657,13 @@ typical implementation forwarding call wrappers have an overloaded function call
+ operator of the form
+ </p>
+
+-<blockquote><pre>template&lt;class... ArgTypes&gt;
++<blockquote><pre>
++template&lt;class... ArgTypes&gt;
+ R operator()(ArgTypes&amp;&amp;... args) <i>cv-qual</i>;
+ </pre></blockquote>
+
+ <p>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -75061,7 +84676,7 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.2 [func.require]/4 as indicated:
++Change 20.9.2 [func.require]/4 as indicated:
+ </p>
+
+ <blockquote><p>
+@@ -75072,11 +84687,12 @@ that rvalue arguments are delivered as rvalue-references and lvalue arguments ar
+ form
+ </p>
+
+-<blockquote><pre>template&lt;class... UnBoundArgs&gt;
++<blockquote><pre>
++template&lt;class... UnBoundArgs&gt;
+ R operator()(UnBoundArgs&amp;&amp;... unbound_args) <em>cv-qual</em>;
+ </pre></blockquote>
+ <p>
+-— <em>end note</em> ]
++&mdash; <em>end note</em> ]
+ </p>
+ </blockquote>
+
+@@ -75087,20 +84703,21 @@ R operator()(UnBoundArgs&amp;&amp;... unbound_args) <em>cv-qual</em>;
+
+ <hr>
+ <h3><a name="1295"></a>1295. Contradictory call wrapper requirements</h3>
+-<p><b>Section:</b> 20.8.2 [func.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2009-12-22 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.require">issues</a> in [func.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.2 [func.require] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.8.2 [func.require]/3 b 1 says
++20.9.2 [func.require]/3 b 1 says
+ </p>
+
+ <blockquote>
+ <p>
+-3 If a call wrapper (20.8.1 [func.def]) has a <i>weak result type</i> the
++3 If a call wrapper (20.9.1 [func.def]) has a <i>weak result type</i> the
+ type of its member type <tt>result_type</tt> is based on the type <tt>T</tt> of
+-the wrapper's target object (20.8.1 [func.def]):
++the wrapper's target object (20.9.1 [func.def]):
+ </p>
+
+ <ul>
+@@ -75120,22 +84737,22 @@ can never be valid types for <tt>T</tt>, because
+ </p>
+
+ <p>
+-20.8.1 [func.def]/7
++20.9.1 [func.def]/7
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 7 A <i>target object</i> is the callable object held by a call wrapper.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+-and 20.8.1 [func.def]/3
++and 20.9.1 [func.def]/3
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 A <i>callable type</i> is a pointer to function, a pointer to member function,
+ a pointer to member data, or a class type whose objects can appear immediately
+ to the left of a function call operator.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ exclude functions and references to function as "target objects".
+@@ -75146,9 +84763,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -75159,14 +84776,14 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.2 [func.require]/3 b 1 as indicated:
++Change 20.9.2 [func.require]/3 b 1 as indicated:
+ </p>
+
+ <blockquote>
+ <p>
+-3 If a call wrapper (20.8.1 [func.def]) has a <i>weak result type</i> the
++3 If a call wrapper (20.9.1 [func.def]) has a <i>weak result type</i> the
+ type of its member type <tt>result_type</tt> is based on the type <tt>T</tt> of
+-the wrapper's target object (20.8.1 [func.def]):
++the wrapper's target object (20.9.1 [func.def]):
+ </p>
+
+ <ul>
+@@ -75187,17 +84804,142 @@ function type, <tt>result_type</tt> shall be a synonym for the return type of
+
+
+ <hr>
++<h3><a name="1297"></a>1297. <tt>unique_ptr</tt>'s relational operator functions should induce a total order</h3>
++<p><b>Section:</b> 20.8.1.5 [unique.ptr.special] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2009-12-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The comparison functions of <tt>unique_ptr</tt> currently directly delegate to
++the underlying comparison functions of <tt>unique_ptr&lt;T, D&gt;::pointer</tt>.
++This is disadvantageous, because this would not guarantee to induce a total
++ordering for native pointers and it is hard to define a total order for mixed
++types anyway.
++</p>
++<p>
++The currently suggested resolution for <tt>shared_ptr</tt> comparison as of
++<a href="lwg-defects.html#1262">1262</a> uses a normalization strategy: They perform the comparison on
++the <em>composite pointer type</em> (5.9 [expr.rel]). This is not
++exactly possible for <tt>unique_ptr</tt> in the presence of user-defined
++pointer-like types but the existing definition of <tt>std::duration</tt>
++comparison as of 20.12.5.6 [time.duration.comparisons] via
++<tt>common_type</tt> of both argument types demonstrates a solution of this
++problem. The approach can be seen as the general way to define a <em>composite
++pointer type</em> and this is the approach which is used for here suggested
++wording change.
++</p>
++<p>
++For consistency reasons I would have preferred the same normalization strategy
++for <tt>==</tt> and <tt>!=</tt>, but Howard convinced me not to do so (now).
++</p>
++
++<p><i>[
++2010-11-03 Daniel comments and adjustes the currently proposed wording changes:
++]</i></p>
++
++
++<p>
++Issue <a href="lwg-defects.html#1401">1401</a> is remotely related. <a href="#1401_extra_bullet">Bullet A</a> of its proposed resolution
++provides an alternative solution for issue discussed here and addresses NB comment GB-99.
++Additionally I updated the below suggested wording in regard to the following:
++It is an unncessary requirement that the below defined effective composite pointer-like
++type <tt>CT</tt> satisfies the <tt>LessThanComparable</tt> requirements. All what is
++needed is, that the function object type <tt>less&lt;CT&gt;</tt> induces a strict
++weak ordering on the pointer values.
++</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>Resolved by <a href="lwg-defects.html#1401">1401</a></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Change 20.8.1.5 [unique.ptr.special]/4-7 as indicated: <i>[The implicit
++requirements and remarks imposed on the last three operators are the same as for
++the first one due to the normative "equivalent to" usage within a Requires
++element, see 17.5.1.4 [structure.specifications]/4. The effects of this
++change are that all real pointers wrapped in a <tt>unique_ptr</tt> will order
++like <tt>shared_ptr</tt> does.]</i>
++</p>
++
++<blockquote><pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote>
++<p>
++<ins>? <i>Requires:</i> Let <tt>CT</tt> be <tt>common_type&lt;unique_ptr&lt;T1,
++D1&gt;::pointer, unique_ptr&lt;T2, D2&gt;::pointer&gt;::type</tt>. Then
++the specialization <tt>less&lt;CT&gt;</tt> shall be a function object type ([function.objects])
++that induces a strict weak ordering ([alg.sorting]) on the pointer values.</ins>
++</p>
++
++<p>
++4 <i>Returns:</i> <tt><ins>less&lt;CT&gt;()(x.get(), y.get())</ins><del>x.get()
++&lt; y.get()</del></tt>.
++</p>
++
++<p>
++<ins>? <i>Remarks:</i> If <tt>unique_ptr&lt;T1, D1&gt;::pointer</tt> is not
++implicitly convertible to <tt>CT</tt> or <tt>unique_ptr&lt;T2,
++D2&gt;::pointer</tt> is not implicitly convertible to <tt>CT</tt>, the program
++is ill-formed.</ins>
++</p>
++</blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++5 <ins><i>Effects:</i> Equivalent to <tt>return !(y &lt; x)</tt></ins>
++<del><i>Returns:</i> <tt>x.get() &lt;= y.get()</tt></del>.
++</p></blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++6 <ins><i>Effects:</i> Equivalent to <tt>return (y &lt; x)</tt></ins>
++<del><i>Returns:</i> <tt>x.get() &gt; y.get()</tt></del>.
++</p></blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++7 <ins><i>Effects:</i> Equivalent to <tt>return !(x &lt; y)</tt></ins>
++<del><i>Returns:</i> <tt>x.get() &gt;= y.get()</tt></del>.
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1298"></a>1298. Missing specialization of <tt>ctype_byname&lt;char&gt;</tt></h3>
+-<p><b>Section:</b> 22.2 [locale.syn] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 22.2 [locale.syn] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The <tt>&lt;locale&gt;</tt> synopsis in 22.2 [locale.syn] calls out an
+ explicit specialization for <tt>ctype_byname&lt;char&gt;</tt>, however no such
+ specialization is defined in the standard. The only reference I can find to
+ <tt>ctype_byname&lt;char&gt;</tt> is 22.3.1.1.2 [locale.facet]:Table 77
+-— Required specializations (for facets) which also refers to
++&mdash; Required specializations (for facets) which also refers to
+ <tt>ctype_byname&lt;wchar_t&gt;</tt> which has no special consideration.
+ </p>
+
+@@ -75223,7 +84965,8 @@ different syntax? Should the explicit specialization simply be struck?
+ Strike the explicit specialization for <tt>ctype_byname&lt;char&gt;</tt> from
+ the <tt>&lt;locale&gt;</tt> synopsis
+ </p>
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ template &lt;class charT&gt; class ctype_byname;
+ <del>template &lt;&gt; class ctype_byname&lt;char&gt;; // <i>specialization</i></del>
+ ...
+@@ -75236,17 +84979,18 @@ template &lt;class charT&gt; class ctype_byname;
+
+ <hr>
+ <h3><a name="1299"></a>1299. Confusing typo in specification for <tt>get_time</tt></h3>
+-<p><b>Section:</b> 27.7.4 [ext.manip] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 27.7.5 [ext.manip] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2009-12-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ext.manip">issues</a> in [ext.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Extended Manipulators 27.7.4 [ext.manip] p8 defines the semantics of
++Extended Manipulators 27.7.5 [ext.manip] p8 defines the semantics of
+ <tt>get_time</tt> in terms of a function <tt>f</tt>.
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, struct tm* tmb, const charT* fmt) {
+ typedef istreambuf_iterator&lt;charT, traits&gt; Iter;
+ typedef time_get&lt;charT, Iter&gt; TimeGet;
+@@ -75275,10 +85019,11 @@ type and not an object. I believe this should be <tt>tg.get</tt>, rather than
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 27.7.4 [ext.manip] p8:
++Change 27.7.5 [ext.manip] p8:
+ </p>
+
+-<blockquote><pre>template &lt;class charT, class traits&gt;
++<blockquote><pre>
++template &lt;class charT, class traits&gt;
+ void f(basic_ios&lt;charT, traits&gt;&amp; str, struct tm* tmb, const charT* fmt) {
+ typedef istreambuf_iterator&lt;charT, traits&gt; Iter;
+ typedef time_get&lt;charT, Iter&gt; TimeGet;
+@@ -75298,18 +85043,109 @@ void f(basic_ios&lt;charT, traits&gt;&amp; str, struct tm* tmb, const charT* fmt
+
+
+ <hr>
++<h3><a name="1300"></a>1300. Circular definition of <tt>promise::swap</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2009-12-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++30.6.5 [futures.promise]/12 defines the effects of
++<tt>promise::swap(promise&amp;)</tt> as
++</p>
++
++<blockquote><pre>
++void swap(promise&amp; other);
++</pre>
++<blockquote><p>
++12 <i>Effects:</i> <tt>swap(*this, other)</tt>
++</p></blockquote>
++</blockquote>
++
++<p>
++and 30.6.5 [futures.promise]/25 defines <tt>swap(promise&lt;R&amp;&gt;,
++promise&lt;R&gt;&amp;)</tt> as
++</p>
++
++<blockquote><pre>
++template &lt;class R&gt;
++ void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y);
++</pre>
++<blockquote><p>
++25 <i>Effects:</i> <tt>x.swap(y)</tt>.
++</p></blockquote>
++</blockquote>
++
++<p><i>[
++2010-01-13 Daniel added "Throws: Nothing."
++]</i></p>
++
++
++<p><i>[
++2010-01-14 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change 30.6.5 [futures.promise] paragraph 12
++</p>
++
++<blockquote><pre>
++void swap(promise&amp; other);
++</pre>
++<blockquote>
++<p>
++12 <i>Effects:</i> <del><tt>swap(*this, other)</tt></del> <ins>Exchanges the
++associated
++states of <tt>*this</tt> and <tt>other</tt>.</ins>
++</p>
++<p>
++13 ...
++</p>
++<p><ins>
++<i>Throws:</i> Nothing.
++</ins></p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1303"></a>1303. <tt>shared_ptr</tt>, <tt>unique_ptr</tt>, and rvalue references v2</h3>
+-<p><b>Section:</b> 20.9.9.2 [unique.ptr.single], 20.9.10.2 [util.smartptr.shared] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.8.1.2 [unique.ptr.single], 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">N3000</a>
+-20.9.10.2 [util.smartptr.shared]/1 still says:
++20.8.2.2 [util.smartptr.shared]/1 still says:
+ </p>
+
+-<blockquote><pre>template &lt;class Y, class D&gt; explicit shared_ptr(const unique_ptr&lt;Y, D&gt;&amp; r) = delete;
++<blockquote><pre>
++template &lt;class Y, class D&gt; explicit shared_ptr(const unique_ptr&lt;Y, D&gt;&amp; r) = delete;
+ template &lt;class Y, class D&gt; shared_ptr&amp; operator=(const unique_ptr&lt;Y, D&gt;&amp; r) = delete;
+ </pre></blockquote>
+
+@@ -75329,10 +85165,11 @@ see a Library Issue tracking this.
+ <p><b>Proposed resolution:</b></p>
+
+ <p>
+-Strike from 20.9.9.2 [unique.ptr.single]:
++Strike from 20.8.1.2 [unique.ptr.single]:
+ </p>
+
+-<blockquote><pre>template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
++<blockquote><pre>
++template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr {
+ ...
+ unique_ptr(const unique_ptr&amp;) = delete;
+ <del>template &lt;class U, class E&gt; unique_ptr(const unique_ptr&lt;U, E&gt;&amp;) = delete;</del>
+@@ -75342,10 +85179,11 @@ Strike from 20.9.9.2 [unique.ptr.single]:
+ </pre></blockquote>
+
+ <p>
+-Strike from 20.9.10.2 [util.smartptr.shared]:
++Strike from 20.8.2.2 [util.smartptr.shared]:
+ </p>
+
+-<blockquote><pre>template&lt;class T&gt; class shared_ptr {
++<blockquote><pre>
++template&lt;class T&gt; class shared_ptr {
+ ...
+ <del>template &lt;class Y, class D&gt; explicit shared_ptr(const unique_ptr&lt;Y, D&gt;&amp; r) = delete;</del>
+ ...
+@@ -75360,11 +85198,325 @@ Strike from 20.9.10.2 [util.smartptr.shared]:
+
+
+ <hr>
++<h3><a name="1304"></a>1304. Missing preconditions for <tt>shared_future</tt></h3>
++<p><b>Section:</b> 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.shared_future">issues</a> in [futures.shared_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The revised futures package in the current working paper simplified the
++<tt>is_ready/has_exception/has_value</tt> set of APIs, replacing them with a
++single 'valid' method. This method is used in many places to signal pre- and
++post- conditions, but that edit is not complete. Each method on a
++<tt>shared_future</tt> that requires an associated state should have a
++pre-condition that <tt>valid() == true</tt>.
++</p>
++
++<p><i>[
++2010-01-28 Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh:
++]</i></p>
++
++
++<blockquote><p>
++Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++</p></blockquote>
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Insert the following extra paragraphs:
++</p>
++
++<p>
++In 30.6.7 [futures.shared_future]
++</p>
++
++<blockquote><pre>
++shared_future();
++</pre>
++<blockquote>
++<p>
++4 <i>Effects:</i> constructs ...
++</p>
++
++<p><ins>
++<i>Postcondition:</i> <tt>valid() == false</tt>.
++</ins></p>
++
++<p><ins>
++<i>Throws:</i> nothing.
++</ins></p>
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++void wait() const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++22 <i>Effects:</i> if the associated ...
++</p>
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++ bool wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++23 <i>Effects:</i> if the associated ...
++</p>
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++ bool wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++25 <i>Effects:</i> blocks until ...
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1305"></a>1305. preconditions for <tt>atomic_future</tt></h3>
++<p><b>Section:</b> X [futures.atomic_future] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.atomic_future">issues</a> in [futures.atomic_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The revised futures package in the current working paper simplified the
++<tt>is_ready/has_exception/has_value</tt> set of APIs, replacing them with a
++single 'valid' method. This method is used in many places to signal pre- and
++post- conditions, but that edit is not complete.
++</p>
++
++<p>
++Atomic future retains the extended earlier API, and provides defined,
++synchronized behaviour for all calls. However, some preconditions and throws
++clauses are missing, which can easily be built around the new <tt>valid()</tt>
++api. Note that for consistency, I suggest <tt>is_ready/has_exception/has_value
++throw</tt> an exception if <tt>valid()</tt> is not <tt>true</tt>, rather than
++return <tt>false</tt>. I think this is implied by the existing pre-condition on
++<tt>is_ready</tt>.
++</p>
++
++<p><i>[
++2010-01-23 See discussion starting with Message c++std-lib-26666.
++]</i></p>
++
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3058.html">N3058</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Insert the following extra paragraphs:
++</p>
++
++<p>
++In X [futures.atomic_future]
++</p>
++
++<blockquote><pre>
++bool is_ready() const;
++</pre>
++<blockquote>
++<p>
++17 <i><del>Precondition</del> <ins>Requires</ins>:</i> <tt>valid() == true</tt>.
++</p>
++
++<p>
++18 <i>Returns:</i> <tt>true</tt> only if the associated state is ready.
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++bool has_exception() const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++19 <i>Returns:</i> <tt>true</tt> only if the associated state is ready and
++contains an exception.
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++bool has_value() const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++20 <i>Returns:</i> <tt>true</tt> only if the associated state is ready and
++contains a value.
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++void wait() const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++22 <i>Effects:</i> blocks until ...
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++ bool wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++23 <i>Effects:</i> blocks until ...
++</p>
++
++<p>
++24 <i>Returns:</i> <tt>true</tt> only if ...
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++ bool wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
++</pre>
++<blockquote>
++
++<p><ins>
++<i>Requires:</i> <tt>valid() == true</tt>.
++</ins></p>
++
++<p>
++25 <i>Effects:</i> blocks until ...
++</p>
++
++<p>
++26 <i>Returns:</i> <tt>true</tt> only if ...
++</p>
++
++<p><ins>
++<i>Throws:</i> <tt>future_error</tt> with an error condition of
++<tt>no_state</tt> if the precondition is not met.
++</ins></p>
++
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
+ <h3><a name="1306"></a>1306. <tt>pointer</tt> and <tt>const_pointer</tt> for <tt>&lt;array&gt;</tt></h3>
+-<p><b>Section:</b> 23.3.1 [array] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-24 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#array">issues</a> in [array].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.2 [array] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-01-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#array">active issues</a> in [array].</p>
++<p><b>View all other</b> <a href="lwg-index.html#array">issues</a> in [array].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ Class <tt>&lt;array&gt;</tt> is the only sequence container class that has no
+@@ -75383,10 +85535,11 @@ hand, types <tt>reference</tt> and <tt>const_reference</tt> are defined for
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add to Class template array 23.3.1 [array]:
++Add to Class template array 23.3.2 [array]:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class T, size_t N &gt;
+ struct array {
+ ...
+@@ -75404,11 +85557,10 @@ Add to Class template array 23.3.1 [array]:
+
+ <hr>
+ <h3><a name="1307"></a>1307. <tt>exception_ptr</tt> and <tt>allocator</tt> pointers don't understand !=</h3>
+-<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-01-26 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#propagation">active issues</a> in [propagation].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#propagation">issues</a> in [propagation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-01-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The current requirements for a conforming implementation of
+@@ -75416,7 +85568,8 @@ The current requirements for a conforming implementation of
+ whether the expression
+ </p>
+
+-<blockquote><pre>e1 != e2
++<blockquote><pre>
++e1 != e2
+ e1 != nullptr
+ </pre></blockquote>
+
+@@ -75429,7 +85582,7 @@ the concept <tt>EqualityComparable</tt> does not provide operator <tt>!=</tt>.
+ <p>
+ For the same reason programmers working against the types <tt>X::pointer</tt>,
+ <tt>X::const_pointer</tt>, <tt>X::void_pointer</tt>, and
+-<tt>X::const_void_pointer</tt> of any allocator concept <tt>X</tt> (20.2.5 [allocator.requirements]/4 + Table 40) in a generic context can not rely
++<tt>X::const_void_pointer</tt> of any allocator concept <tt>X</tt> (17.6.3.5 [allocator.requirements]/4 + Table 40) in a generic context can not rely
+ on the availability of the != operation, which is rather unnatural and
+ error-prone.
+ </p>
+@@ -75456,36 +85609,38 @@ Solved by
+
+ <hr>
+ <h3><a name="1309"></a>1309. Missing expressions for <tt>Move/CopyConstructible</tt></h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-02-03 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-Table 33 — MoveConstructible requirements [moveconstructible] and
+-Table 34 — CopyConstructible requirements [copyconstructible] support
++Table 33 &mdash; MoveConstructible requirements [moveconstructible] and
++Table 34 &mdash; CopyConstructible requirements [copyconstructible] support
+ solely the following expression:
+ </p>
+
+-<blockquote><pre>T t(rv)
++<blockquote><pre>
++T t(rv)
+ </pre></blockquote>
+
+ <p>
+ where <tt>rv</tt> is defined to be as "non-const rvalue of type <tt>T</tt>" and
+-<tt>t</tt> as a "modifiable lvalue of type <tt>T</tt>" in 20.2.1 [utility.arg.requirements]/1.
++<tt>t</tt> as a "modifiable lvalue of type <tt>T</tt>" in 17.6.3.1 [utility.arg.requirements]/1.
+ </p>
+
+ <p>
+ This causes two different defects:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ We cannot move/copy-initialize a <em>const</em> lvalue of type <tt>T</tt> as in:
+ </p>
+
+-<blockquote><pre>int get_i();
++<blockquote><pre>
++int get_i();
+
+ const int i1(get_i());
+ </pre></blockquote>
+@@ -75500,7 +85655,8 @@ both in Table 33 and in Table 34.
+ The single support for
+ </p>
+
+-<blockquote><pre>T t(rv)
++<blockquote><pre>
++T t(rv)
+ </pre></blockquote>
+
+ <p>
+@@ -75508,7 +85664,8 @@ in case of <tt>CopyConstructible</tt> means that we cannot provide an
+ lvalue as a source of a copy as in
+ </p>
+
+-<blockquote><pre>const int&amp; get_lri();
++<blockquote><pre>
++const int&amp; get_lri();
+
+ int i2(get_lri());
+ </pre></blockquote>
+@@ -75537,7 +85694,7 @@ output/forward iterator requirements)..
+
+
+ <p><i>[
+-2010-02-10 Reopened. The proposed wording of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1283">1283</a> has been
++2010-02-10 Reopened. The proposed wording of <a href="lwg-defects.html#1283">1283</a> has been
+ merged here.
+ ]</i></p>
+
+@@ -75555,13 +85712,13 @@ merged here.
+
+ <li>
+ <p>
+-Change 20.2.1 [utility.arg.requirements]/1 as indicated: <i>[This change
++Change 17.6.3.1 [utility.arg.requirements]/1 as indicated: <i>[This change
+ suggestion is motivated to make type descriptions clearer: First, <tt>a</tt>,
+ <tt>b</tt>, and <tt>c</tt> <em>may</em> also be non-<tt>const T</tt>. Second, <tt>u</tt>
+ is described in a manner consistent with the container requirements tables.]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 The template definitions in the C++ standard library refer to various named
+ requirements whose details are set out in tables 31-38. In these tables,
+ <tt>T</tt> is a<ins>n object or reference</ins> type to be supplied by a C++
+@@ -75572,21 +85729,21 @@ identifier;</ins> <del>is a value of type (possibly <tt>const</tt>) <tt>T</tt>;
+ and</del> <tt>rv</tt> is a<ins>n</ins> <del>non-const</del> rvalue of type
+ <tt>T</tt><ins>; and <tt>v</tt> is an lvalue of type (possibly <tt>const</tt>)
+ <tt>T</tt> or an rvalue of type <tt>const T</tt></ins>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-In 20.2.1 [utility.arg.requirements] Table 33 ([moveconstructible])
++In 17.6.3.1 [utility.arg.requirements] Table 33 ([moveconstructible])
+ change as indicated <i>[Note: The symbol <tt>u</tt> is defined to be either a
+ const or a non-const value and is the right one we need here]</i>:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 33 — <tt>MoveConstructible</tt> requirements [moveconstructible]</caption>
++<caption>Table 33 &mdash; <tt>MoveConstructible</tt> requirements [moveconstructible]</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Post-condition</th>
+ </tr>
+@@ -75612,15 +85769,15 @@ construction</ins></td>
+ <del>There is no requirement on the value of <tt>rv</tt> after the
+ construction.</del>
+ <ins><tt>rv</tt> remains a valid object. Its state is unspecified.</ins>
+-— <i>end note</i>]</td>
++&mdash; <i>end note</i>]</td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-In 20.2.1 [utility.arg.requirements] Table 34 ([copyconstructible])
++In 17.6.3.1 [utility.arg.requirements] Table 34 ([copyconstructible])
+ change as indicated <i>[Note: The symbol <tt>u</tt> is defined to be either a
+ const or a non-const value and is the right one we need here. The expressions
+ using <tt>a</tt> are recommended to ensure that lvalues are supported as sources
+@@ -75629,10 +85786,10 @@ of the copy expression]</i>:
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 34 — <tt>CopyConstructible</tt> requirements [copyconstructible]<br>
++<caption>Table 34 &mdash; <tt>CopyConstructible</tt> requirements [copyconstructible]<br/>
+ <ins>(in addition to <tt>MoveConstructible</tt>)</ins></caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Post-condition</th>
+ </tr>
+@@ -75658,25 +85815,25 @@ is unchanged and is equivalent to <tt><del>t</del><ins>u</ins></tt>
+ <tr>
+ <td colspan="2"><del>[<i>Note:</i> A type that satisfies the
+ <tt>CopyConstructible</tt> requirements also satisfies the <tt>MoveConstructible</tt>
+-requirements. — <i>end note</i>]</del></td>
++requirements. &mdash; <i>end note</i>]</del></td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-In Table 35 — MoveAssignable requirements [moveassignable] change as
++In Table 35 &mdash; MoveAssignable requirements [moveassignable] change as
+ indicated:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<caption>Table 35 — <tt>MoveAssignable</tt> requirements <b>[moveassignable]</b></caption>
+-<tbody><tr>
++<caption>Table 35 &mdash; <tt>MoveAssignable</tt> requirements <b>[moveassignable]</b></caption>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Return value</th>
+@@ -75702,25 +85859,25 @@ indicated:
+ <del>There is no requirement on the value of <tt>rv</tt> after the
+ assignment.</del>
+ <ins><tt>rv</tt> remains a valid object. Its state is unspecified.</ins>
+-— <i>end note</i>]
++&mdash; <i>end note</i>]
+ </td>
+ </tr>
+-</tbody></table>
++</table>
+
+ </blockquote>
+ </li>
+
+ <li>
+ <p>
+-In 20.2.1 [utility.arg.requirements] change Table 36 as indicated:
++In 17.6.3.1 [utility.arg.requirements] change Table 36 as indicated:
+ </p>
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 36 — <tt>CopyAssignable</tt> requirements
+-[copyassignable]<br><ins>(in addition to <tt>MoveAssignable</tt>)</ins></caption>
++<caption>Table 36 &mdash; <tt>CopyAssignable</tt> requirements
++[copyassignable]<br/><ins>(in addition to <tt>MoveAssignable</tt>)</ins></caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Return value</th>
+@@ -75737,11 +85894,11 @@ In 20.2.1 [utility.arg.requirements] change Table 36 as indicated:
+
+ <tr>
+ <td colspan="4"><del>[<i>Note:</i> A type that satisfies the <tt>CopyAssignable</tt>
+-requirements also satisfies the <tt>MoveAssignable</tt> requirements. —
++requirements also satisfies the <tt>MoveAssignable</tt> requirements. &mdash;
+ <i>end note</i>]</del></td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+ </li>
+ </ol>
+@@ -75752,10 +85909,247 @@ requirements also satisfies the <tt>MoveAssignable</tt> requirements.
+
+
+ <hr>
++<h3><a name="1310"></a>1310. <tt>forward_list splice_after</tt> from lvalues</h3>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-02-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++We've moved <a href="lwg-defects.html#1133">1133</a> to Tentatively Ready and I'm fine with that.
++</p>
++
++<p>
++<a href="lwg-defects.html#1133">1133</a> adds lvalue-references to the <tt>splice</tt> signatures for <tt>list</tt>. So now
++<tt>list</tt> can <tt>splice</tt> from lvalue and rvalue lists (which was the intent of the
++original move papers btw). During the discussion of this issue it was mentioned
++that if we want to give the same treatment to <tt>forward_list</tt>, that should be a
++separate issue.
++</p>
++
++<p>
++This is that separate issue.
++</p>
++
++<p>
++Consider the following case where you want to splice elements from one place in
++a <tt>forward_list</tt> to another. Currently this must be coded like so:
++</p>
++
++<blockquote><pre>
++fl.splice_after(to_here, std::move(fl), from1, from2);
++</pre></blockquote>
++
++<p>
++This looks pretty shocking to me. I would expect to be able to code instead:
++</p>
++
++<blockquote><pre>
++fl.splice_after(to_here, fl, from1, from2);
++</pre></blockquote>
++
++<p>
++but we currently don't allow it.
++</p>
++
++<p>
++When I say <tt>move(fl)</tt>, I consider that as saying that I don't care about
++the value of <tt>fl</tt> any more (until I assign it a new value). But in the
++above example, this simply isn't true. I do care about the value of <tt>fl</tt>
++after the move, and I'm not assigning it a new value. I'm merely permuting its
++current value.
++</p>
++
++<p>
++I propose adding <tt>forward_list&amp;</tt> overloads to the 3
++<tt>splice_after</tt> members. For consistency's sake (principal of least
++surprise) I'm also proposing to overload <tt>merge</tt> this way as well.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Add to the synopsis of 23.3.4.1 [forwardlist.overview]:
++</p>
++
++<blockquote><pre>
++template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
++class forward_list {
++public:
++ ...
++ // <i>[forwardlist.ops], forward_list operations:</i>
++ <ins>void splice_after(const_iterator p, forward_list&amp; x);</ins>
++ void splice_after(const_iterator p, forward_list&amp;&amp; x);
++ <ins>void splice_after(const_iterator p, forward_list&amp; x, const_iterator i);</ins>
++ void splice_after(const_iterator p, forward_list&amp;&amp; x, const_iterator i);
++ <ins>void splice_after(const_iterator p, forward_list&amp; x,
++ const_iterator first, const_iterator last);</ins>
++ void splice_after(const_iterator p, forward_list&amp;&amp; x,
++ const_iterator first, const_iterator last);
++ ...
++ <ins>void merge(forward_list&amp; x);</ins>
++ void merge(forward_list&amp;&amp; x);
++ <ins>template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp);</ins>
++ template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp);
++ ...
++};
++</pre></blockquote>
++
++<p>
++Add to the signatures of 23.3.4.6 [forwardlist.ops]:
++</p>
++
++<blockquote>
++<pre>
++<ins>void splice_after(const_iterator p, forward_list&amp; x);</ins>
++void splice_after(const_iterator p, forward_list&amp;&amp; x);
++</pre>
++<blockquote>
++<p>1 ...</p>
++</blockquote>
++
++<pre>
++<ins>void splice_after(const_iterator p, forward_list&amp; x, const_iterator i);</ins>
++void splice_after(const_iterator p, forward_list&amp;&amp; x, const_iterator i);
++</pre>
++<blockquote>
++<p>4 ...</p>
++</blockquote>
++
++<pre>
++<ins>void splice_after(const_iterator p, forward_list&amp; x,
++ const_iterator first, const_iterator last);</ins>
++void splice_after(const_iterator p, forward_list&amp;&amp; x,
++ const_iterator first, const_iterator last);
++</pre>
++<blockquote>
++<p>7 ...</p>
++</blockquote>
++
++<pre>
++<ins>void merge(forward_list&amp; x);</ins>
++void merge(forward_list&amp;&amp; x);
++<ins>template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp);</ins>
++template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp);
++</pre>
++<blockquote>
++<p>16 ...</p>
++</blockquote>
++
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1311"></a>1311. multi-pass property of Forward Iterator underspecified</h3>
++<p><b>Section:</b> 24.2.5 [forward.iterators] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forward.iterators">issues</a> in [forward.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The following example demonstrates code that would meet the guarantees of a
++Forward Iterator, but only permits a single traversal of the underlying
++sequence:
++</p>
++
++<blockquote><pre>
++template&lt; typename ForwardIterator&gt;
++struct bad_iterator {
++ shared_ptr&lt;ForwardIterator&gt; impl;
++
++ bad_iterator( ForwardIterator iter ) {
++ : impl{new ForwardIterator{iter} }
++ {
++ }
++
++ auto operator*() const -&gt; decltype(*ForwardIterator{}) {
++ return **impl;
++ }
++
++ auto operator-&gt;() const -&gt; ForwardIterator {
++ return *impl;
++ }
++
++ auto operator==(bad_iterator const &amp; rhs) const -&gt; bool {
++ return impl == rhs.impl;
++ }
++
++ auto operator++() -&gt; bad_iterator&amp; {
++ ++(*impl);
++ return *this;
++ }
++ // other operations as necessary...
++};
++</pre></blockquote>
++
++<p>
++Here, we use <tt>shared_ptr</tt> to wrap a forward iterator, so all iterators
++constructed from the same original iterator share the same 'value', and
++incrementing any one copy increments all others.
++</p>
++
++<p>
++There is a missing guarantee, expressed by the following code sequence
++</p>
++
++<blockquote><pre>
++FwdIter x = seq.begin(); // obtain forward iterator from a sequence
++FwdIter y = x; // copy the iterator
++assert(x == y); // iterators must be the same
++++x; // increment *just one* iterator
++assert(x != y); // iterators *must now be different*
++++y; // increment the other iterator
++assert(x == y); // now the iterators must be the same again
++</pre></blockquote>
++
++<p>
++That inequality in the middle is an essential guarantee. Note that this list is
++simplified, as each assertion should also note that they refer to exactly the
++same element <tt>(&amp;*x == &amp;*y)</tt> but I am not complicating the issue
++with tests to support proxy iterators, or value types overloading unary
++<tt>operator+</tt>.
++</p>
++
++<p>
++I have not yet found a perverse example that can meet this additional
++constraint, and not meet the multi-pass expectations of a Forward Iterator
++without also violating other Forward Iterator requirements.
++</p>
++
++<p>
++Note that I do not yet have standard-ready wording to resolve the problem, as
++saying this neatly and succinctly in 'standardese' is more difficult.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
+ <h3><a name="1312"></a>1312. <tt>vector::data</tt> no longer returns a raw pointer</h3>
+-<p><b>Section:</b> 23.4.1.3 [vector.data] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.6.4 [vector.data] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The original intent of <tt>vector::data</tt> was to match <tt>array::data</tt>
+@@ -75776,27 +86170,29 @@ use the typedef.
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-23.4.1 [vector]
++23.3.6 [vector]
+ </p>
+
+ <p>
+ Update the class definition in p2:
+ </p>
+
+-<blockquote><pre>// 23.3.6.3 data access
++<blockquote><pre>
++// 23.3.6.3 data access
+ <del>pointer</del><ins>T *</ins> data();
+ <del>const_pointer</del><ins>const T *</ins> data() const;
+ </pre></blockquote>
+
+ <p>
+-23.4.1.3 [vector.data]
++23.3.6.4 [vector.data]
+ </p>
+
+ <p>
+ Adjust signatures:
+ </p>
+
+-<blockquote><pre><del>pointer</del><ins>T *</ins> data();
++<blockquote><pre>
++<del>pointer</del><ins>T *</ins> data();
+ <del>const_pointer</del><ins>const T *</ins> data() const;
+ </pre></blockquote>
+
+@@ -75806,10 +86202,10 @@ Adjust signatures:
+
+ <hr>
+ <h3><a name="1316"></a>1316. <tt>scoped_allocator_adaptor operator==</tt> has no definition</h3>
+-<p><b>Section:</b> 20.10 [allocator.adaptor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-02-11 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.adaptor">issues</a> in [allocator.adaptor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.13 [allocator.adaptor] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2009-02-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.adaptor">issues</a> in [allocator.adaptor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The WP
+@@ -75835,9 +86231,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -75848,7 +86244,7 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Add a new section after 20.10.3 [allocator.adaptor.members]:
++Add a new section after 20.13.4 [allocator.adaptor.members]:
+ </p>
+
+ <blockquote>
+@@ -75858,20 +86254,20 @@ Add a new section after 20.10.3 [allocator.adaptor.members]:
+ bool operator==(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,
+ const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b);</pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <code>a.outer_allocator() == b.outer_allocator()</code>
+ if <code>sizeof...(InnerAllocs)</code> is zero; otherwise,
+ <code>a.outer_allocator() == b.outer_allocator() &amp;&amp;
+ a.inner_allocator() == b.inner_allocator()</code>.
+-</blockquote>
++</p></blockquote>
+
+ <pre>template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
+ bool operator!=(const scoped_allocator_adaptor&lt;OuterA1, InnerAllocs...&gt;&amp; a,
+ const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; b);</pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Returns:</i> <code>!(a == b)</code>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -75882,11 +86278,11 @@ a.inner_allocator() == b.inner_allocator()</code>.
+
+ <hr>
+ <h3><a name="1319"></a>1319. Containers should require an iterator that is at least a Forward Iterator</h3>
+-<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The requirements on container iterators are spelled out in
+@@ -75895,18 +86291,18 @@ The requirements on container iterators are spelled out in
+
+ <blockquote>
+ <table border="1">
+-<caption>Table 91 — Container requirements</caption>
++<caption>Table 91 &mdash; Container requirements</caption>
+
+-<tbody><tr>
++<tr>
+ <th>Expression</th>
+ <th>Return type</th>
+ <th>Operational semantics</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+ <tr>
+-<td colspan="5"><center>...</center></td>
++<td colspan="5" align="center"><tt>...</tt></td>
+ </tr>
+
+ <tr>
+@@ -75927,10 +86323,10 @@ The requirements on container iterators are spelled out in
+ </tr>
+
+ <tr>
+-<td colspan="5"><center>...</center></td>
++<td colspan="5" align="center"><tt>...</tt></td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ <p>
+@@ -75953,9 +86349,9 @@ catagories. I recommend to say instead that each container::iterator shall satis
+ iterator requirements.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -75967,17 +86363,17 @@ Adopted at 2010-11 Batavia
+ <p><b>Proposed resolution:</b></p>
+
+ <ol>
+-<li>Change Table 93 — Container requirements in [container.requirements.general] as indicated:
++<li>Change Table 93 &mdash; Container requirements in [container.requirements.general] as indicated:
+ <blockquote>
+ <table border="1">
+-<caption>Table 93 — Container requirements</caption>
++<caption>Table 93 &mdash; Container requirements</caption>
+
+ <tbody>
+ <tr>
+ <th>Expression</th>
+ <th>Return type</th>
+-<th>Operational<br>semantics</th>
+-<th>Assertion/note<br>pre-/post-condition</th>
++<th>Operational<br/>semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
+ <th>Complexity</th>
+ </tr>
+
+@@ -75987,17 +86383,19 @@ Adopted at 2010-11 Batavia
+
+ <tr>
+ <td><tt>X::iterator</tt></td>
+-<td>iterator type<br>whose value<br>type is <tt>T</tt></td>
++<td>iterator type<br/>whose value<br/>type is <tt>T</tt></td>
+ <td></td>
+-<td>any iterator category<br><del>except output iterator</del><ins><br>that meets the forward iterator requirements</ins>. convertible<br>to<br><tt>X::const_iterator</tt></td>
++<td>any iterator category<br/><del>except output iterator</del><ins><br/>that
++meets the forward iterator requirements</ins>. convertible<br/>to<br/><tt>X::const_iterator</tt></td>
+ <td>compile time</td>
+ </tr>
+
+ <tr>
+ <td><tt>X::const_iterator</tt></td>
+-<td>constant iterator type<br>whose value<br>type is <tt>T</tt></td>
++<td>constant iterator type<br/>whose value<br/>type is <tt>T</tt></td>
+ <td></td>
+-<td>any iterator category<br><del>except output iterator</del><ins><br>that meets the forward iterator requirements</ins>.</td>
++<td>any iterator category<br/><del>except output iterator</del><ins><br/>that
++meets the forward iterator requirements</ins>.</td>
+ <td>compile time</td>
+ </tr>
+
+@@ -76019,17 +86417,19 @@ Adopted at 2010-11 Batavia
+ <hr>
+ <h3><a name="1321"></a>1321. <tt>scoped_allocator_adaptor construct</tt> and <tt>destroy</tt> don't
+ use <tt>allocator_traits</tt></h3>
+-<p><b>Section:</b> 20.10.3 [allocator.adaptor.members] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2010-11-20</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.13.4 [allocator.adaptor.members] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.adaptor.members">issues</a> in [allocator.adaptor.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-20.10.3 [allocator.adaptor.members] p8-9 says:
++20.13.4 [allocator.adaptor.members] p8-9 says:
+ </p>
+
+ <blockquote>
+
+-<pre>template &lt;class T, class... Args&gt;
++<pre>
++template &lt;class T, class... Args&gt;
+ void construct(T* p, Args&amp;&amp;... args);
+ </pre>
+ <blockquote>
+@@ -76067,18 +86467,19 @@ inner_allocator())</tt>.
+ Otherwise, the program is ill-formed. [<i>Note:</i> an error will result if
+ <tt>uses_allocator</tt> evaluates to <tt>true</tt> but the specific constructor
+ does not take an allocator. This definition prevents a silent failure to pass an
+-inner allocator to a contained element. — <i>end note</i>]
++inner allocator to a contained element. &mdash; <i>end note</i>]
+ </li>
+ </ul>
+
+ </blockquote>
+
+-<pre>template &lt;class T&gt;
++<pre>
++template &lt;class T&gt;
+ void destroy(T* p);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 9 <i>Effects:</i> calls <tt>outer_allocator().destroy(p)</tt>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -76089,12 +86490,13 @@ call members of an allocator directly, but rather does so indirectly via
+ </p>
+
+ <blockquote>
+-<pre>size_type max_size() const;
++<pre>
++size_type max_size() const;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 7 <i>Returns:</i>
+ <tt><b>allocator_traits&lt;OuterAlloc&gt;::</b>max_size(outer_allocator())</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -76125,7 +86527,7 @@ Solved by
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In 20.10.3 [allocator.adaptor.members] move and change p8
++In 20.13.4 [allocator.adaptor.members] move and change p8
+ as indicated, and change p9 as indicated:
+ </p>
+
+@@ -76141,11 +86543,12 @@ does not have an <tt>outer_allocator()</tt> <ins>member</ins> function and
+ <tt><i>OUTERMOST_ALLOC_TRAITS(x)</i></tt> are recursive operations. It is
+ incumbent upon the definition of <tt>outer_allocator()</tt> to ensure that the
+ recursion terminates. It <em>will</em> terminate for all instantiations
+-of <tt>scoped_allocator_adaptor</tt>. — <i>end note</i>]
++of <tt>scoped_allocator_adaptor</tt>. &mdash; <i>end note</i>]
+ </ins>
+ </p>
+
+-<pre>template &lt;class T, class... Args&gt;
++<pre>
++template &lt;class T, class... Args&gt;
+ void construct(T* p, Args&amp;&amp;... args);
+ </pre>
+ <blockquote>
+@@ -76190,20 +86593,21 @@ std::forward&lt;Args&gt;(args)..., inner_allocator() )</tt>.
+ Otherwise, the program is ill-formed. [<i>Note:</i> an error will result if
+ <tt>uses_allocator</tt> evaluates to <tt>true</tt> but the specific constructor
+ does not take an allocator. This definition prevents a silent failure to pass an
+-inner allocator to a contained element. — <i>end note</i>]
++inner allocator to a contained element. &mdash; <i>end note</i>]
+ </li>
+ </ul>
+
+ </blockquote>
+
+-<pre>template &lt;class T&gt;
++<pre>
++template &lt;class T&gt;
+ void destroy(T* p);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 9 <i>Effects:</i> calls <tt><del>outer_allocator().</del>
+ <ins><i>OUTERMOST_ALLOC_TRAITS(outer_allocator())</i>::</ins>destroy(
+ <ins><i>OUTERMOST(outer_allocator())</i>,</ins> p)</tt>.
+-</blockquote>
++</p></blockquote>
+
+ </blockquote>
+
+@@ -76214,13 +86618,13 @@ inner allocator to a contained element.
+
+ <hr>
+ <h3><a name="1322"></a>1322. Explicit <tt>CopyConstructible</tt> requirements are insufficient</h3>
+-<p><b>Section:</b> 20.2.1 [utility.arg.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-02-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-With the acceptance of library defect <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#822">822</a> only
++With the acceptance of library defect <a href="lwg-closed.html#822">822</a> only
+ direct-initialization is supported, and not copy-initialization in the
+ requirement sets <tt>MoveConstructible</tt> and <tt>CopyConstructible</tt>. This
+ is usually a good thing, if only the library implementation needs to obey these
+@@ -76259,15 +86663,16 @@ iterator requirements) and Table 103 (forward iterator requirements) demonstrate
+ quite clearly a strong divergence of copy-semantics: The specified semantics of
+ </p>
+
+-<blockquote><pre>X u(a);
++<blockquote><pre>
++X u(a);
+ X u = a;
+ </pre></blockquote>
+
+ <p>
+ are underspecified compared to the most recent clarifications of the
+-<tt>CopyConstructible</tt> requirements, c.f. issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1309">1309</a> which is
++<tt>CopyConstructible</tt> requirements, c.f. issue <a href="lwg-defects.html#1309">1309</a> which is
+ very unsatisfactory. This will become worse for each further issue that involves
+-the <tt>CopyConstructible</tt> specification (for possible directions see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1173">1173</a>).
++the <tt>CopyConstructible</tt> specification (for possible directions see <a href="lwg-active.html#1173">1173</a>).
+ </p>
+ </li>
+ </ol>
+@@ -76280,7 +86685,7 @@ any other reasonable name like <tt>MoveConvertible</tt> and
+ all three problems mentioned above.
+ </p>
+
+-<p><i>[Batavia: Resolved by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3215.html">n3215</a>.]</i></p>
++<p><i>[Batavia: Resolved by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3215.htm">n3215</a>.]</i></p>
+
+
+
+@@ -76292,18 +86697,18 @@ all three problems mentioned above.
+ <ol>
+ <li>
+ <p>
+-Add the following new table ?? after Table 34 — <tt>MoveConstructible</tt>
++Add the following new table ?? after Table 34 &mdash; <tt>MoveConstructible</tt>
+ requirements [moveconstructible]:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<caption><ins>Table ?? — <tt>Implicit MoveConstructible</tt> requirements
++<caption><ins>Table ?? &mdash; <tt>Implicit MoveConstructible</tt> requirements
+ [implicit.moveconstructible] (in addition to
+ <tt>MoveConstructible</tt>)</ins></caption>
+
+-<tbody><tr>
++<tr>
+ <th><ins>Expression</ins></th>
+ <th><ins>Operational Semantics</ins></th>
+ </tr>
+@@ -76313,25 +86718,25 @@ requirements [moveconstructible]:
+ <td><ins>Equivalent to: <tt>T u(rv);</tt></ins></td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-Add the following new table ?? after Table 35 — <tt>CopyConstructible</tt>
++Add the following new table ?? after Table 35 &mdash; <tt>CopyConstructible</tt>
+ requirements [copyconstructible]:
+ </p>
+
+ <blockquote>
+
+ <table border="1">
+-<caption><ins>Table ?? — <tt>Implicit CopyConstructible</tt> requirements
++<caption><ins>Table ?? &mdash; <tt>Implicit CopyConstructible</tt> requirements
+ [implicit.copyconstructible] (in addition to
+ <tt>CopyConstructible</tt>)</ins></caption>
+
+-<tbody><tr>
++<tr>
+ <th><ins>Expression</ins></th>
+ <th><ins>Operational Semantics</ins></th>
+ </tr>
+@@ -76341,14 +86746,14 @@ requirements [copyconstructible]:
+ <td><ins>Equivalent to: <tt>T u(v);</tt></ins></td>
+ </tr>
+
+-</tbody></table>
++</table>
+ </blockquote>
+
+ </li>
+
+ <li>
+ <p>
+-Change 20.2.3 [nullablepointer.requirements]/1 as follows:
++Change 17.6.3.3 [nullablepointer.requirements]/1 as follows:
+ </p>
+
+ <blockquote>
+@@ -76371,7 +86776,7 @@ values. A type <tt>P</tt> meets the requirements of <tt>NullablePointer</tt> if:
+
+ <li>
+ <p>
+-Change 20.2.4 [hash.requirements]/1 as indicated: <i>[explicit
++Change 17.6.3.4 [hash.requirements]/1 as indicated: <i>[explicit
+ copy-constructible functors could not be provided as arguments
+ to any algorithm that takes these by value. Also a typo is fixed.]</i>
+ </p>
+@@ -76400,7 +86805,7 @@ it satis<ins>fies</ins><del>ifes</del> the requirements of
+
+ <li>
+ <p>
+-Change 20.7.1 [meta.rqmts]/1+2 as indicated:
++Change 20.10.1 [meta.rqmts]/1+2 as indicated:
+ </p>
+
+ <blockquote>
+@@ -76426,35 +86831,35 @@ described. It shall be <tt>DefaultConstructible</tt>,
+
+ <li>
+ <p>
+-Change 20.8.2 [func.require]/4 as indicated: <i>[explicit
++Change 20.9.2 [func.require]/4 as indicated: <i>[explicit
+ copy-constructible functors could not be provided as arguments to any algorithm
+ that takes these by value]</i>
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 4 Every call wrapper (20.8.1) shall be <tt><ins>implicit</ins>
+ MoveConstructible</tt>. A simple call wrapper is a call wrapper that is
+ <tt><ins>implicit</ins> CopyConstructible</tt> and <tt>CopyAssignable</tt> and
+ whose copy constructor, move constructor, and assignment operator do not throw
+ exceptions. [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.4 [refwrap]/1 as indicated:
++Change 20.9.4 [refwrap]/1 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 <tt>reference_wrapper&lt;T&gt;</tt> is a<ins>n <tt>implicit</tt></ins>
+ <tt>CopyConstructible</tt> and <tt>CopyAssignable</tt> wrapper around a
+ reference to an object or function of type <tt>T</tt>.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.8.10.1.2 [func.bind.bind]/5+9 as indicated:
++Change 20.9.10.3 [func.bind.bind]/5+9 as indicated:
+ </p>
+
+ <blockquote>
+@@ -76464,7 +86869,7 @@ Change 20.8.10.1.2 [func.bind.bind]/5+9 as indicated:
+ <tt>TiD</tt> satisfy the requirements of <tt>CopyConstructible</tt>, then the
+ return type shall satisfy the requirements of <tt><ins>implicit</ins>
+ CopyConstructible</tt>. [<i>Note:</i> this implies that all of <tt>FD</tt> and
+-<tt>TiD</tt> are <tt>MoveConstructible</tt>. — <i>end note</i>]
++<tt>TiD</tt> are <tt>MoveConstructible</tt>. &mdash; <i>end note</i>]
+ </p>
+
+ <p>
+@@ -76477,7 +86882,7 @@ CopyConstructible</tt>. [<i>Note:</i> this implies that all of <tt>FD</tt> and
+ <tt>TiD</tt> satisfy the requirements of <tt>CopyConstructible</tt>, then the
+ return type shall satisfy the requirements of <tt><ins>implicit</ins>
+ CopyConstructible</tt>. [<i>Note:</i> this implies that all of <tt>FD</tt> and
+-<tt>TiD</tt> are <tt>MoveConstructible</tt>. — <i>end note</i>]
++<tt>TiD</tt> are <tt>MoveConstructible</tt>. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+
+@@ -76485,21 +86890,21 @@ CopyConstructible</tt>. [<i>Note:</i> this implies that all of <tt>FD</tt> and
+
+ <li>
+ <p>
+-Change 20.8.10.1.3 [func.bind.place] as indicated:
++Change 20.9.10.4 [func.bind.place] as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 1 All placeholder types shall be <tt>DefaultConstructible</tt> and
+ <tt><ins>implicit</ins> CopyConstructible</tt>, and [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.9 [unique.ptr]/5 as indicated:
++Change 20.8.1 [unique.ptr]/5 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 5 Each object of a type <tt>U</tt> instantiated form the <tt>unique_ptr</tt>
+ template specified in this subclause has the strict ownership semantics,
+ specified above, of a unique pointer. In partial satisfaction of these
+@@ -76507,32 +86912,32 @@ semantics, each such <tt>U</tt> is <tt><ins>implicit</ins>
+ MoveConstructible</tt> and <tt>MoveAssignable</tt>, but is not
+ <tt>CopyConstructible</tt> nor <tt>CopyAssignable</tt>. The template parameter
+ <tt>T</tt> of <tt>unique_ptr</tt> may be an incomplete type.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.10.2 [util.smartptr.shared]/2 as indicated:
++Change 20.8.2.2 [util.smartptr.shared]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 Specializations of <tt>shared_ptr</tt> shall be
+ <tt><ins>implicit</ins> CopyConstructible</tt>, <tt>CopyAssignable</tt>, and
+ <tt>LessThanComparable</tt>, [..]
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+ <p>
+-Change 20.9.10.3 [util.smartptr.weak]/2 as indicated:
++Change 20.8.2.3 [util.smartptr.weak]/2 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 Specializations of <tt>weak_ptr</tt> shall be <tt><ins>implicit</ins>
+ CopyConstructible</tt> and <tt>CopyAssignable</tt>, allowing their use in
+ standard containers. The template parameter <tt>T</tt> of <tt>weak_ptr</tt> may
+ be an incomplete type.
+-</blockquote>
++</p></blockquote>
+ </li>
+
+ <li>
+@@ -76562,15 +86967,15 @@ and lvalues of type <tt>X</tt> are swappable (20.2.2), and [..]
+
+ <li>
+ <p>
+-Change D.12.1 [auto.ptr]/3 as indicated:
++Change X [auto.ptr]/3 as indicated:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 3 [..] Instances of <tt>auto_ptr</tt> meet the requirements of
+ <tt><ins>implicit</ins> MoveConstructible</tt> and <tt>MoveAssignable</tt>, but
+ do not meet the requirements of <tt>CopyConstructible</tt> and
+-<tt>CopyAssignable</tt>. — <i>end note</i>]
+-</blockquote>
++<tt>CopyAssignable</tt>. &mdash; <i>end note</i>]
++</p></blockquote>
+ </li>
+
+ </ol>
+@@ -76582,10 +86987,10 @@ do not meet the requirements of <tt>CopyConstructible</tt> and
+
+ <hr>
+ <h3><a name="1323"></a>1323. <tt>basic_string::replace</tt> should use <tt>const_iterator</tt></h3>
+-<p><b>Section:</b> 21.4.6.6 [string::replace] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-02-19 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#string::replace">issues</a> in [string::replace].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 21.4.6.6 [string::replace] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-02-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string::replace">issues</a> in [string::replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+
+ <p>
+@@ -76607,9 +87012,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -76627,7 +87032,8 @@ In 21.4 [basic.string], class template <tt>basic_string</tt> synopsis
+ change as indicated:
+ </p>
+
+-<blockquote><pre>// 21.4.6 modifiers:
++<blockquote><pre>
++// 21.4.6 modifiers:
+ ...
+ basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2,
+ const basic_string&amp; str);
+@@ -76651,7 +87057,8 @@ In 21.4.6.6 [string::replace] before p.18, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, const basic_string&amp; str);
++<blockquote><pre>
++basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, const basic_string&amp; str);
+ </pre></blockquote>
+ </li>
+
+@@ -76661,7 +87068,8 @@ In 21.4.6.6 [string::replace] before p.21, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>basic_string&amp;
++<blockquote><pre>
++basic_string&amp;
+ replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, const charT* s, size_type n);
+ </pre></blockquote>
+ </li>
+@@ -76672,7 +87080,8 @@ In 21.4.6.6 [string::replace] before p.24, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, const charT* s);
++<blockquote><pre>
++basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, const charT* s);
+ </pre></blockquote>
+ </li>
+
+@@ -76682,7 +87091,8 @@ In 21.4.6.6 [string::replace] before p.27, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, size_type n,
++<blockquote><pre>
++basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2, size_type n,
+ charT c);
+ </pre></blockquote>
+ </li>
+@@ -76693,7 +87103,8 @@ In 21.4.6.6 [string::replace] before p.30, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class InputIterator&gt;
++<blockquote><pre>
++template&lt;class InputIterator&gt;
+ basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2,
+ InputIterator j1, InputIterator j2);
+ </pre></blockquote>
+@@ -76705,7 +87116,8 @@ In 21.4.6.6 [string::replace] before p.33, change the following signatures
+ as indicated:
+ </p>
+
+-<blockquote><pre>basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2,
++<blockquote><pre>
++basic_string&amp; replace(<ins>const_</ins>iterator i1, <ins>const_</ins>iterator i2,
+ initializer_list&lt;charT&gt; il);
+ </pre></blockquote>
+ </li>
+@@ -76719,17 +87131,17 @@ as indicated:
+
+ <hr>
+ <h3><a name="1324"></a>1324. Still too many implicit conversions for <tt>pair</tt> and <tt>tuple</tt></h3>
+-<p><b>Section:</b> 20.3.5.2 [pairs.pair], 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-03-20 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 20.3.2 [pairs.pair], 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-03-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In analogy to library defect <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#811">811</a>, <tt>tuple</tt>'s variadic
+-constructor
++In analogy to library defect <a href="lwg-defects.html#811">811</a>, <tt>tuple</tt>'s variadic constructor
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... UTypes&gt;
+ explicit tuple(UTypes&amp;&amp;... u);
+ </pre></blockquote>
+
+@@ -76737,7 +87149,8 @@ explicit tuple(UTypes&amp;&amp;... u);
+ creates the same problem as pair:
+ </p>
+
+-<blockquote><pre>#include &lt;tuple&gt;
++<blockquote><pre>
++#include &lt;tuple&gt;
+
+ int main()
+ {
+@@ -76763,13 +87176,14 @@ the corresponding element types are not implicitly convertible. It seems
+ astonishing that in the following example
+ </p>
+
+-<blockquote><pre>struct A {
++<blockquote><pre>
++struct A {
+ explicit A(int);
+ };
+
+-A a = 1; <font color="#C80000">// Error</font>
++A a = 1; <span style="color:#C80000">// Error</span>
+
+-std::tuple&lt;A&gt; ta = std::make_tuple(1); <font color="#C80000">// # OK?</font>
++std::tuple&lt;A&gt; ta = std::make_tuple(1); <span style="color:#C80000">// # OK?</span>
+ </pre></blockquote>
+
+ <p>
+@@ -76787,10 +87201,11 @@ well-formed anyway.
+
+ <li>
+ <p>
+-Following 20.3.5.2 [pairs.pair]/5 add a new Remarks element:
++Following 20.3.2 [pairs.pair]/5 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -76811,10 +87226,11 @@ and <tt>V</tt> is implicitly convertible to <tt>second_type</tt>.</ins>
+
+ <li>
+ <p>
+-Following 20.3.5.2 [pairs.pair]/6 add a new Remarks element:
++Following 20.3.2 [pairs.pair]/6 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -76837,7 +87253,8 @@ and <tt>V</tt> is implicitly convertible to <tt>second_type</tt>.</ins>
+ Following 20.4.2.1 [tuple.cnstr]/7 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... UTypes&gt;
+ explicit tuple(UTypes&amp;&amp;... u);
+ </pre>
+
+@@ -76867,7 +87284,8 @@ corresponding type in <tt>Types</tt>.</ins>
+ Following 20.4.2.1 [tuple.cnstr]/13 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt; tuple(const tuple&lt;UTypes...&gt;&amp; u);
++<blockquote><pre>
++template &lt;class... UTypes&gt; tuple(const tuple&lt;UTypes...&gt;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -76891,7 +87309,7 @@ corresponding type in <tt>Types</tt>.</ins>
+ <p>
+ 14 [<i>Note:</i> <tt>enable_if</tt> can be used to make the converting
+ constructor and assignment operator exist only in the cases where the source and
+-target have the same number of elements. — <i>end note</i>]
++target have the same number of elements. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -76902,7 +87320,8 @@ target have the same number of elements.
+ Following 20.4.2.1 [tuple.cnstr]/16 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt; tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class... UTypes&gt; tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -76926,7 +87345,7 @@ corresponding type in <tt>Types</tt>.</ins>
+ <p>
+ [<i>Note:</i> <tt>enable_if</tt> can be used to make the converting constructor
+ and assignment operator exist only in the cases where the source and target have
+-the same number of elements. — <i>end note</i>]
++the same number of elements. &mdash; <i>end note</i>]
+ </p>
+ </blockquote>
+ </blockquote>
+@@ -76937,7 +87356,8 @@ the same number of elements.
+ Following 20.4.2.1 [tuple.cnstr]/18 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template &lt;class U1, class U2&gt; tuple(const pair&lt;U1, U2&gt;&amp; u);
++<blockquote><pre>
++template &lt;class U1, class U2&gt; tuple(const pair&lt;U1, U2&gt;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -76967,7 +87387,8 @@ resolution unless <tt>U1</tt> is implicitly convertible to the first type in
+ Following 20.4.2.1 [tuple.cnstr]/20 add a new Remarks element:
+ </p>
+
+-<blockquote><pre>template &lt;class U1, class U2&gt; tuple(pair&lt;U1, U2&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class U1, class U2&gt; tuple(pair&lt;U1, U2&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -76999,25 +87420,26 @@ resolution unless <tt>U1</tt> is implicitly convertible to the first type in
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue.
+-</blockquote>
++<blockquote><p>
++Accepting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>
++would solve this issue.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1325"></a>1325. bitset</h3>
+-<p><b>Section:</b> 20.5.1 [bitset.cons] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1325"></a>1325. <tt>bitset</tt></h3>
++<p><b>Section:</b> 20.6.1 [bitset.cons] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitset.cons">issues</a> in [bitset.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ As mentioned on the boost mailing list:
+@@ -77029,7 +87451,8 @@ between the "<tt>unsigned long long</tt>" and "<tt>char*</tt>"
+ constructors.
+ </p>
+
+-<blockquote><pre>#include &lt;bitset&gt;
++<blockquote><pre>
++#include &lt;bitset&gt;
+ std::bitset&lt;10&gt; b(0);
+ </pre></blockquote>
+
+@@ -77053,7 +87476,8 @@ could be easily added and constitutes an important use-case. For
+ example, the following code would invoke UB with the current
+ P/R:</p>
+ <blockquote>
+-<pre>char s[4] = { '0', '1', '0', '1' }; // notice: not null-terminated!
++<pre>
++char s[4] = { '0', '1', '0', '1' }; // notice: not null-terminated!
+ bitset&lt;4&gt; b(s, 0, 4);
+ </pre></blockquote>
+ because it requires the evaluation (under the as-if rule, to be fair,
+@@ -77070,9 +87494,10 @@ not have a <tt>pos</tt> parameter</p>
+ </li>
+ </ul>
+
+-<blockquote>
+-Moved to Tentatively Ready with revised wording provided by Alberto Ganesh Babati after 5 positive votes on c++std-lib.
+-</blockquote>
++<blockquote><p>
++Moved to Tentatively Ready with revised wording provided by Alberto
++Ganesh Babati after 5 positive votes on c++std-lib.
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -77086,9 +87511,10 @@ Adopted at 2010-11 Batavia
+
+ <ol>
+ <li>In the synopsis of header <tt>&lt;bitset&gt;</tt> in
+-20.5 [template.bitset]/1, replace the fourth bitset constructor:
++20.6 [template.bitset]/1, replace the fourth bitset constructor:
+ <blockquote>
+-<pre><del>explicit bitset(const char *str);</del>
++<pre>
++<del>explicit bitset(const char *str);</del>
+ <ins>template &lt;class charT&gt;
+ explicit bitset(
+ const charT *str,
+@@ -77096,18 +87522,21 @@ Adopted at 2010-11 Batavia
+ charT zero = charT('0'), charT one = charT('1'));</ins>
+ </pre></blockquote>
+ </li>
+-<li>In 20.5.1 [bitset.cons]/8:
++<li>In 20.6.1 [bitset.cons]/8:
+ <blockquote>
+-<pre><del>explicit bitset(const char *str);</del>
++<pre>
++<del>explicit bitset(const char *str);</del>
+ <ins>template &lt;class charT&gt;
+ explicit
+ bitset(const charT *str,
+ typename basic_string&lt;charT&gt;::size_type n = basic_string&lt;charT&gt;::npos,
+ charT zero = charT('0'), charT one = charT('1'));</ins>
+ </pre></blockquote>
++<p>
+ Effects: Constructs an object of class
+ <tt>bitset&lt;N&gt;</tt> as if by
+ <del>bitset(string(str)).</del>
++</p>
+ <blockquote><pre><ins>
+ bitset(
+ n == basic_string&lt;charT&gt;::npos
+@@ -77124,11 +87553,11 @@ bitset(
+
+
+ <hr>
+-<h3><a name="1326"></a>1326. Missing/wrong preconditions for <tt>pair</tt> and <tt>tuple</tt> functions</h3>
+-<p><b>Section:</b> 20.3.5.2 [pairs.pair], 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1326"></a>1326. Missing&#47;wrong preconditions for <tt>pair</tt> and <tt>tuple</tt> functions</h3>
++<p><b>Section:</b> 20.3.2 [pairs.pair], 20.4.2.1 [tuple.cnstr] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ There are several constructors and creation functions of std::tuple
+@@ -77140,25 +87569,26 @@ CopyConstructible requirements are bad descriptions for non-const
+ references. Some examples:
+ </p>
+
+-<ol type="a">
++<ol style="list-style-type:lower-alpha">
+ <li>
+ <p>
+ 20.4.2.1 [tuple.cnstr] before p.4 and p.8, resp.:
+ </p>
+
+-<blockquote><pre>explicit tuple(const Types&amp;...);
++<blockquote><pre>
++explicit tuple(const Types&amp;...);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 4 <i>Requires:</i> Each type in <tt>Types</tt> shall be copy constructible.
+-</blockquote>
++</p></blockquote>
+
+-<pre>tuple(const tuple&amp; u) = default;
++<pre>
++tuple(const tuple&amp; u) = default;
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 8 <i>Requires:</i> Each type in <tt>Types</tt> shall satisfy the requirements of
+ <tt>CopyConstructible</tt> (Table 34).
+-
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -77172,7 +87602,8 @@ non-reference type, this requirement would be wrong as well,
+ because there is no reason to disallow a type such as
+ </p>
+
+-<blockquote><pre>struct NoMoveNoCopy {
++<blockquote><pre>
++struct NoMoveNoCopy {
+ NoMoveNoCopy(NoMoveNoCopy&amp;&amp;) = delete;
+ NoMoveNoCopy(const NoMoveNoCopy&amp;) = delete;
+ ...
+@@ -77206,23 +87637,25 @@ produce a <tt>tuple&lt;C&gt;</tt> that does not satisfy the
+ 20.4.2.1 [tuple.cnstr] before p.6 and p.10, resp.:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... UTypes&gt;
+ explicit tuple(UTypes&amp;&amp;... u);
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ 6 <i>Requires:</i> Each type in <tt>Types</tt> shall satisfy the
+ requirements of <tt>MoveConstructible</tt> (Table 33) from the
+ corresponding type in <tt>UTypes</tt>. <tt>sizeof...(Types) ==
+ sizeof...(UTypes)</tt>.
+-</blockquote>
++</p></blockquote>
+
+-<pre>tuple(tuple&amp;&amp; u);
++<pre>
++tuple(tuple&amp;&amp; u);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 10 <i>Requires:</i> Each <tt>type</tt> in <tt>Types</tt> shall shall
+ satisfy the requirements of <tt>MoveConstructible</tt> (Table 33).
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -77232,20 +87665,20 @@ the <tt>MoveConstructible</tt> requirements. In this case the correct
+ requirements would be
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>is_constructible&lt;Ti, Ui&gt;::value</tt> shall evaluate to true
+ for all <tt>Ti</tt> in <tt>Types</tt> and for all <tt>Ui</tt> in
+ <tt>UTypes</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ and
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <tt>is_constructible&lt;Ti, Ti&gt;::value</tt> shall evaluate to true
+ for all <tt>Ti</tt> in <tt>Types</tt>
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ respectively.
+@@ -77264,12 +87697,12 @@ suggested resolution. Further-on the P/R has been adapted to the FCD numbering.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The issue became updated to fix some minor inconsistencies and to ensure a
+ similarly required fix for <tt>std::pair</tt>, which has the same specification
+ problem as <tt>std::tuple</tt>, since <tt>pair</tt> became extended to support
+ reference members as well.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[Original proposed resolution:]</i></p>
+
+@@ -77277,12 +87710,13 @@ reference members as well.
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/1 as indicated <i>[The changes for the effects
++Change 20.3.2 [pairs.pair]/1 as indicated <i>[The changes for the effects
+ elements are not normative changes, they just ensure
+ harmonization with existing wording style]</i>:
+ </p>
+
+-<blockquote><pre>constexpr pair();
++<blockquote><pre>
++constexpr pair();
+ </pre>
+
+ <blockquote>
+@@ -77304,10 +87738,11 @@ the <tt>DefaultConstructible</tt> requirements.</ins>
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/2 as indicated:
++Change 20.3.2 [pairs.pair]/2 as indicated:
+ </p>
+
+-<blockquote><pre>pair(const T1&amp; x, const T2&amp; y);
++<blockquote><pre>
++pair(const T1&amp; x, const T2&amp; y);
+ </pre>
+
+ <blockquote>
+@@ -77329,10 +87764,11 @@ is <tt>true</tt>.</ins>
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/3 as indicated:
++Change 20.3.2 [pairs.pair]/3 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
+ </pre>
+
+ <blockquote>
+@@ -77362,12 +87798,13 @@ resolution.
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/5 as indicated <i>[The change in the effects
++Change 20.3.2 [pairs.pair]/5 as indicated <i>[The change in the effects
+ element should be non-normatively and is in compatible to the change suggestion
+-of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1324">1324</a>]</i>:
++of <a href="lwg-defects.html#1324">1324</a>]</i>:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -77389,10 +87826,11 @@ argument<del>, performing implicit conversions as needed</del>.
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/6 as indicated:
++Change 20.3.2 [pairs.pair]/6 as indicated:
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -77414,11 +87852,12 @@ Change 20.3.5.2 [pairs.pair]/6 as indicated:
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair]/7+8 as indicated [The deletion in the effects
++Change 20.3.2 [pairs.pair]/7+8 as indicated [The deletion in the effects
+ element should be non-normatively]:
+ </p>
+
+-<blockquote><pre>template&lt;class... Args1, class... Args2&gt;
++<blockquote><pre>
++template&lt;class... Args1, class... Args2&gt;
+ pair(piecewise_construct_t,
+ tuple&lt;Args1...&gt; first_args, tuple&lt;Args2...&gt; second_args);
+ </pre>
+@@ -77453,10 +87892,11 @@ piecewise construction.
+
+ <li>
+ <p>
+-Change 20.3.5.2 [pairs.pair] before 12 as indicated:
++Change 20.3.2 [pairs.pair] before 12 as indicated:
+ </p>
+
+-<blockquote><pre>pair&amp; operator=(pair&amp;&amp; p);
++<blockquote><pre>
++pair&amp; operator=(pair&amp;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -77489,7 +87929,8 @@ alternative could be to write "first_type shall be assignable from an
+ rvalue of U [..]"]
+ </p>
+
+-<blockquote><pre>template&lt;class U, class V&gt; pair&amp; operator=(pair&lt;U, V&gt;&amp;&amp; p);
++<blockquote><pre>
++template&lt;class U, class V&gt; pair&amp; operator=(pair&lt;U, V&gt;&amp;&amp; p);
+ </pre>
+
+ <blockquote>
+@@ -77519,7 +87960,8 @@ and to <tt>second</tt> with <tt>std::move(p.second)</tt>.
+ Change 20.4.2.1 [tuple.cnstr]/4+5 as indicated:
+ </p>
+
+-<blockquote><pre>explicit tuple(const Types&amp;...);
++<blockquote><pre>
++explicit tuple(const Types&amp;...);
+ </pre>
+
+ <blockquote>
+@@ -77545,7 +87987,8 @@ value of the corresponding parameter.
+ Change 20.4.2.1 [tuple.cnstr]/6 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... UTypes&gt;
+ explicit tuple(UTypes&amp;&amp;... u);
+ </pre>
+
+@@ -77573,7 +88016,8 @@ corresponding value in <tt>std::forward&lt;UTypes&gt;(u)</tt>.
+ Change 20.4.2.1 [tuple.cnstr]/8+9 as indicated:
+ </p>
+
+-<blockquote><pre>tuple(const tuple&amp; u) = default;
++<blockquote><pre>
++tuple(const tuple&amp; u) = default;
+ </pre>
+
+ <blockquote>
+@@ -77598,7 +88042,8 @@ of <tt>*this</tt> with the corresponding element of <tt>u</tt>.
+ Change 20.4.2.1 [tuple.cnstr]/10+11 as indicated:
+ </p>
+
+-<blockquote><pre>tuple(tuple&amp;&amp; u);
++<blockquote><pre>
++tuple(tuple&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -77625,7 +88070,8 @@ requirements of <tt>MoveConstructible</tt> (Table 34)</del>.
+ Change 20.4.2.1 [tuple.cnstr]/15+16 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class... UTypes&gt; tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class... UTypes&gt; tuple(tuple&lt;UTypes...&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -77656,7 +88102,8 @@ type in <tt>UTypes</tt></del>. <tt>sizeof...(Types) == sizeof...(UTypes)</tt>.
+ Change 20.4.2.1 [tuple.cnstr]/19+20 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class U1, class U2&gt; tuple(pair&lt;U1, U2&gt;&amp;&amp; u);
++<blockquote><pre>
++template &lt;class U1, class U2&gt; tuple(pair&lt;U1, U2&gt;&amp;&amp; u);
+ </pre>
+
+ <blockquote>
+@@ -77688,7 +88135,8 @@ the second element with
+ Change 20.4.2.4 [tuple.creation]/9-16 as indicated:
+ </p>
+
+-<blockquote><pre>template &lt;class... TTypes, class... UTypes&gt;
++<blockquote><pre>
++template &lt;class... TTypes, class... UTypes&gt;
+ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
+ </pre>
+
+@@ -77714,7 +88162,8 @@ of <tt>u</tt>.
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class... TTypes, class... UTypes&gt;
++<pre>
++template &lt;class... TTypes, class... UTypes&gt;
+ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
+ </pre>
+
+@@ -77745,7 +88194,8 @@ corresponding elements of <tt>t</tt> and copy constructing its last
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class... TTypes, class... UTypes&gt;
++<pre>
++template &lt;class... TTypes, class... UTypes&gt;
+ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);
+ </pre>
+
+@@ -77775,7 +88225,8 @@ corresponding elements of <tt>t</tt> and move constructing its last
+ </p>
+ </blockquote>
+
+-<pre>template &lt;class... TTypes, class... UTypes&gt;
++<pre>
++template &lt;class... TTypes, class... UTypes&gt;
+ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);
+ </pre>
+
+@@ -77814,14 +88265,16 @@ corresponding elements of <tt>t</tt> and move constructing its last
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue.
+-</blockquote>
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>
++would solve this issue.
++</p></blockquote>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
++</p>
+
+
+
+@@ -77829,10 +88282,11 @@ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html"
+
+ <hr>
+ <h3><a name="1327"></a>1327. templates defined in <tt>&lt;cmath&gt;</tt> replacing C macros with the same name</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Michael Wong <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Michael Wong <b>Opened:</b> 2010-03-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In 26.8 [c.math]p12
+@@ -77840,7 +88294,8 @@ The templates defined in <tt>&lt;cmath&gt;</tt> replace the C99 macros
+ with the same names. The templates have the following declarations:
+ </p>
+
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class T&gt; bool signbit(T x);
+ template &lt;class T&gt; int fpclassify(T x);
+ template &lt;class T&gt; bool isfinite(T x);
+@@ -77860,11 +88315,11 @@ template &lt;class T&gt; bool isunordered(T x, T y);
+ and p13:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 13 The templates behave the same as the C99 macros with corresponding
+ names defined in C99 7.12.3, Classification macros, and C99 7.12.14,
+ Comparison macros in the C standard.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ The C Std versions look like this:
+@@ -77881,7 +88336,8 @@ Synopsis
+ <p>
+ 1 <tt>#include &lt;math.h&gt;</tt>
+ </p>
+-<pre>int isgreaterequal(real-floating x, real-floating y);
++<pre>
++int isgreaterequal(real-floating x, real-floating y);
+ </pre>
+ </blockquote>
+ </blockquote>
+@@ -77903,109 +88359,402 @@ two-parameter macros is intended.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ I recommend to resolve this issue as NAD Editorial because
+ the accepted resolution for NB comment <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US136">US-136</a>
+ by motion 27 does address this.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-09-14 Bill comments:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Motion 27 directly addresses LWG 1327 and solves the problem
+ presented there. Moreover, the solution has been aired before
+ WG14 with no dissent. These functions now behave the same for
+ mixed-mode calls in both C and C++
+-</blockquote>
+-
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Apply proposed resolution for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US136">US-136</a>
+
++<p><b>Proposed resolution:</b></p><p>
++Apply proposed resolution for
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US136">US-136</a>
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1328"></a>1328. istream extractors not setting failbit if eofbit is already set</h3>
+-<p><b>Section:</b> 27.7.1.1.3 [istream::sentry] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2010-02-17 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1328"></a>1328. istream extractors not setting <tt>failbit</tt> if <tt>eofbit</tt> is already set</h3>
++<p><b>Section:</b> 27.7.2.1.3 [istream::sentry] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2010-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream::sentry">issues</a> in [istream::sentry].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-basing on the recent discussion on the library reflector, see c++std-lib-27728
++Basing on the recent discussion on the library reflector, see c++std-lib-27728
+ and follow ups, I hereby formally ask for LWG 419 to be re-opened, the rationale
+ being that according to the current specifications, per
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3000.pdf">n3000</a>,
+ it seems actually impossible to seek away from end of file, contrary to the
+-rationale which led <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#342">342</a> to its closure as NAD. My request is also
++rationale which led <a href="lwg-closed.html#342">342</a> to its closure as NAD. My request is also
+ supported by Martin Sebor, and I'd like also to add, as tentative proposed
+ resolution for the re-opened issue, the wording suggested by Sebor, thus, change
+-the beginning of 27.7.1.1.3 [istream::sentry]/2, to:
++the beginning of 27.7.2.1.3 [istream::sentry]/2, to:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 <i>Effects:</i> If <tt><ins>(!noskipws &amp;&amp; !</ins>is.good())</tt> is
+ <tt><del>false</del> <ins>true</ins></tt>, calls <tt>is.setstate(failbit)</tt>.
+ Otherwise prepares for formatted or unformatted input. ...
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+-2010-10 Batavia"
++2010-10 Batavia
+ ]</i></p>
+
++
+ <p>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
++Resolved by adopting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
+ </p>
+
+ <p>
+ Previous proposed resolution:
+-</p><p>
+-Change 27.7.1.1.3 [istream::sentry]/2:
++<p/>
++Change 27.7.2.1.3 [istream::sentry] p.2:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ 2 <i>Effects:</i> If <tt><ins>(!noskipws &amp;&amp; !</ins>is.good())</tt> is
+ <tt><del>false</del> <ins>true</ins></tt>, calls <tt>is.setstate(failbit)</tt>.
+ Otherwise prepares for formatted or unformatted input. ...
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Addressed by paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1329"></a>1329. Data races on <code>vector&lt;bool&gt;</code></h3>
++<p><b>Section:</b> 23.2.2 [container.requirements.dataraces] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jeffrey Yaskin <b>Opened:</b> 2010-03-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.dataraces">issues</a> in [container.requirements.dataraces].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The common implementation of <tt>vector&lt;bool&gt;</tt> is as an
++unsynchronized bitfield. The addition of 23.2.2 [container.requirements.dataraces]/2 would require either a
++change in representation or a change in access synchronization, both of
++which are undesireable with respect to compatibility and performance.
++</p>
++
++<p><i>[
++2010 Pittsburgh: Moved to <del>NAD Editorial</del><ins>Resolved</ins>. Rationale added below.
++]</i></p>
++
++
++
++
++<p><b>Rationale:</b></p>
++<p>
++Solved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3069.html">N3069</a>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Container data races 23.2.2 [container.requirements.dataraces]
++</p>
++
++<p>
++Paragraph 1 is unchanged as follows:
++</p>
++
++<blockquote><p>
++1 For purposes of avoiding data races (17.6.4.8), implementations shall
++consider the following functions to be <code>const</code>:
++<code>begin</code>, <code>end</code>, <code>rbegin</code>,
++<code>rend</code>, <code>front</code>, <code>back</code>,
++<code>data</code>, <code>find</code>, <code>lower_bound</code>,
++<code>upper_bound</code>, <code>equal_range</code>, and, except in
++associative containers, <code>operator[]</code>.
++</p></blockquote>
++
++<p>
++Edit paragraph 2 as follows:
++</p>
++
++<blockquote><p>
++2 Notwithstanding (17.6.4.8), implementations are required to avoid data
++races when the contents of the contained object in different elements in
++the same sequence<ins>, excepting <code>vector&lt;bool&gt;</code>,</ins>
++are modified concurrently.
++</p></blockquote>
++
++<p>
++Edit paragraph 3 as follows:
++</p>
++
++<blockquote><p>
++3 [<i>Note:</i>
++For a <code>vector&lt;int&gt; x</code> with a size greater than one,
++<code>x[1] = 5</code> and <code>*x.begin() = 10</code>
++can be executed concurrently without a data race,
++but <code>x[0] = 5</code> and <code>*x.begin() = 10</code>
++executed concurrently may result in a data race.
++<ins>As an exception to the general rule,
++for a <code>vector&lt;bool&gt; y</code>,
++<code>y[i] = true</code> may race with <code>y[j] = true</code>.</ins>
++&mdash;<i>end note</i>]
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1332"></a>1332. Let Hash objects throw!</h3>
++<p><b>Section:</b> 17.6.3.4 [hash.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-03-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#hash.requirements">issues</a> in [hash.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The currently added <tt>Hash</tt> requirements demand in Table 40 &mdash; <tt>Hash</tt>
++requirements [hash]:
++</p>
++
++<blockquote>
++<table border="1">
++
++<caption>Table 40 &mdash; Hash requirements [hash]</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Requirement</th>
++</tr>
++
++<tr>
++<td><tt>h(k)</tt></td>
++<td><tt>size_t</tt></td>
++<td>Shall not throw exceptions. [..]</td>
++</tr>
++
++</table>
+ </blockquote>
+
++<p>
++While it surely is a generally accepted idea that hash function objects
++<i>should</i> not throw exceptions, this basic constraint for such a fundamental
++requirement set does neither match the current library policy nor real world
++cases:
++</p>
++
++<ol>
++<li>
++There are little known situations where a swap or move operation may throw an
++exception and in some popular domains such functions are <em>required</em> not
++to throw. But the library invested already efforts for good reasons to require
++"working" container implementations in the presence of throwing move or swap
++operations, see e.g. 23.2.4.1 [associative.reqmts.except], 23.2.5.1 [unord.req.except].
++</li>
++
++<li>
++The container library is already specified to cope with potentially throwing
++comparers, predicates, <i>and</i> hash function objects, see above.
++</li>
+
++<li>
++<p>
++The new definition goes beyond the original hash requirements as specified
++by SGI library in regard to the exception requirement:
++</p>
++<blockquote><p>
++<a href="http://www.sgi.com/tech/stl/HashFunction.html">http://www.sgi.com/tech/stl/HashFunction.html</a>
++</p></blockquote>
++</li>
+
+-<p></p>
++<li>
++There are indeed real-world examples of potentially throwing hash functions,
++typically when the proxy pattern is used and when the to-be hashed proxied
++instance is some <i>volatile</i> object, e.g. a file or internet resource, that
++might suddenly be unavailable at the time of hashing.
++</li>
++
++<li>
++With the new <tt>noexcept</tt> language facility libraries can still take
++advantage of no-throw guarantees of hasher functions with stricter guarantees.
++</li>
++</ol>
++
++<p>
++Even though the majority of all known move, swap, and hash functions won't throw
++and in some cases <em>must</em> not throw, it seems like unnecessary
++over-constraining the definition of a Hash functor not to propagate exceptions
++in any case and it contradicts the general principle of C++ to impose such a
++requirement for this kind of fundamental requirement.
++</p>
++
++<p><i>[
++2010-11-11 Daniel asks the working group whether they would prefer a replacement
++for the second bullet of the proposed resolution (a result of discussing this
++with Alberto) of the form:
++]</i></p>
++
++
++<p>
++Add to 20.9.13 [unord.hash]/1 a new bullet:
++</p>
++
++<blockquote>
++<p>
++1 The unordered associative containers defined in Clause 23.5 use
++specializations of the class template <tt>hash</tt>
++as the default hash function. For all object types <tt>Key</tt> for which there
++exists a specialization <tt>hash&lt;Key&gt;</tt>, the
++instantiation <tt>hash&lt;Key&gt;</tt> shall:
++</p>
++<ul>
++<li>
++satisfy the <tt>Hash</tt> requirements (20.2.4), with <tt>Key</tt> as the
++function call argument type, the <tt>DefaultConstructible</tt> requirements
++(33), the <tt>CopyAssignable</tt> requirements (37),
++</li>
++<li>
++be swappable (20.2.2) for lvalues,
++</li>
++<li>
++provide two nested types <tt>result_type</tt> and <tt>argument_type</tt> which
++shall be synonyms for <tt>size_t</tt> and <tt>Key</tt>, respectively,
++</li>
++<li>
++satisfy the requirement that if <tt>k1 == k2</tt> is true, <tt>h(k1) ==
++h(k2)</tt> is also true, where <tt>h</tt> is an object of type
++<tt>hash&lt;Key&gt;</tt> and <tt>k1</tt> and <tt>k2</tt> are objects of type
++<tt>Key</tt><ins>,</ins><del>.</del>
++</li>
++<li>
++<ins>satisfy the requirement <tt>noexcept(h(k)) == true</tt>, where <tt>h</tt> is an object
++of type <tt>hash&lt;Key&gt;</tt> and <tt>k</tt> is an object of type <tt>Key</tt>, unless
++<tt>hash&lt;Key&gt;</tt> is a user-defined specialization that depends on at least one user-defined type.</ins>
++</li>
++</ul>
++</blockquote>
++
++
++
++<p><i>[Batavia: Closed as NAD Future, then reopened. See the wiki for Tuesday.]</i></p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
++<ol>
++<li>
++<p>
++Change Table 26 &mdash; <tt>Hash</tt> requirements [tab:hash] as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++
++<caption>Table 26 &mdash; <tt>Hash</tt> requirements [tab:hash]</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Requirement</th>
++</tr>
++
++<tr>
++<td><tt>h(k)</tt></td>
++<td><tt>size_t</tt></td>
++<td><del>Shall not throw exceptions.</del> [&hellip;]</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li>
++<p>
++Add to 20.9.13 [unord.hash] p. 1 a new bullet:
++</p>
++
++<blockquote>
++<p>
++1 The unordered associative containers defined in Clause 23.5 [unord] use
++specializations of the class template <tt>hash</tt>
++as the default hash function. For all object types <tt>Key</tt> for which there
++exists a specialization <tt>hash&lt;Key&gt;</tt>, the
++instantiation <tt>hash&lt;Key&gt;</tt> shall:
++</p>
++<ul>
++<li>
++satisfy the <tt>Hash</tt> requirements ([hash.requirements]), with <tt>Key</tt> as the
++function call argument type, the <tt>DefaultConstructible</tt> requirements
++(Table [defaultconstructible]), the <tt>CopyAssignable</tt> requirements (Table [copyassignable]),
++</li>
++<li>
++be swappable ([swappable.requirements]) for lvalues,
++</li>
++<li>
++provide two nested types <tt>result_type</tt> and <tt>argument_type</tt> which
++shall be synonyms for <tt>size_t</tt> and <tt>Key</tt>, respectively,
++</li>
++<li>
++satisfy the requirement that if <tt>k1 == k2</tt> is true, <tt>h(k1) ==
++h(k2)</tt> is also true, where <tt>h</tt> is an object of type
++<tt>hash&lt;Key&gt;</tt> and <tt>k1</tt> and <tt>k2</tt> are objects of type
++<tt>Key</tt><ins>,</ins><del>.</del>
++</li>
++<li>
++<ins>satisfy the requirement that the expression <tt>h(k)</tt>, where <tt>h</tt>
++is an object of type <tt>hash&lt;Key&gt;</tt> and <tt>k</tt> is an object of
++type <tt>Key</tt>, shall not throw an exception, unless
++<tt>hash&lt;Key&gt;</tt> is a user-defined specialization that depends on at
++least one user-defined type.</ins>
++</li>
++</ul>
++</blockquote>
++</li>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="1333"></a>1333. Missing forwarding during std::function invocation</h3>
+-<p><b>Section:</b> 20.8.14.2.4 [func.wrap.func.inv] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-03-26 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.inv">issues</a> in [func.wrap.func.inv].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1333"></a>1333. Missing forwarding during <tt>std::function</tt> invocation</h3>
++<p><b>Section:</b> 20.9.12.2.4 [func.wrap.func.inv] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-03-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.inv">issues</a> in [func.wrap.func.inv].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The current wording of 20.8.14.2.4 [func.wrap.func.inv]/1:
++The current wording of 20.9.12.2.4 [func.wrap.func.inv]/1:
+ </p>
+
+-<blockquote><pre>R operator()(ArgTypes... args) const
++<blockquote><pre>
++R operator()(ArgTypes... args) const
+ </pre>
+
+-<blockquote>
++<blockquote><p>
+ <i>Effects:</i> <tt><i>INVOKE</i>(f, t1, t2, ..., tN, R)</tt> (20.8.2), where
+ <tt>f</tt> is the target object (20.8.1) of <tt>*this</tt> and <tt>t1, t2, ...,
+ tN</tt> are the values in <tt>args...</tt>.
+-</blockquote>
++</p></blockquote>
+ </blockquote>
+
+ <p>
+@@ -78019,9 +88768,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78032,10 +88781,11 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 20.8.14.2.4 [func.wrap.func.inv]/1+2 as indicated:
++Change 20.9.12.2.4 [func.wrap.func.inv]/1+2 as indicated:
+ </p>
+
+-<blockquote><pre>R operator()(ArgTypes... args) const
++<blockquote><pre>
++R operator()(ArgTypes... args) const
+ </pre>
+
+ <blockquote>
+@@ -78067,16 +88817,17 @@ exception thrown by the wrapped callable object.
+
+
+ <hr>
+-<h3><a name="1334"></a>1334. Insert iterators are broken for some proxy containers compared to C++03</h3>
+-<p><b>Section:</b> 24.5.2.2.2 [back.insert.iter.op=], 24.5.2.4.2 [front.insert.iter.op=], X [insert.insert.iter.op=] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-03-28 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1334"></a>1334. Insert iterators are broken for some proxy containers compared to C++03</h3>
++<p><b>Section:</b> 24.5.2.2.2 [back.insert.iter.op=], 24.5.2.4.2 [front.insert.iter.op=], X [insert.insert.iter.op=] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-03-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In C++03 this was valid code:
+ </p>
+
+-<blockquote><pre>#include &lt;vector&gt;
++<blockquote><pre>
++#include &lt;vector&gt;
+ #include &lt;iterator&gt;
+
+ int main() {
+@@ -78092,7 +88843,8 @@ In C++0x this code does no longer compile because of an ambiguity error for this
+ <tt>operator=</tt> overload pair:
+ </p>
+
+-<blockquote><pre>back_insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++back_insert_iterator&lt;Container&gt;&amp;
+ operator=(typename Container::const_reference value);
+
+ back_insert_iterator&lt;Container&gt;&amp;
+@@ -78106,7 +88858,8 @@ it's identical to <tt>Container::value_type</tt>, thus forming the ambiguous
+ overload pair
+ </p>
+
+-<blockquote><pre>back_insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++back_insert_iterator&lt;Container&gt;&amp;
+ operator=(bool value);
+
+ back_insert_iterator&lt;Container&gt;&amp;
+@@ -78124,7 +88877,8 @@ container must not be the same as the <tt>value_type</tt>, but this would break
+ earlier valid code. The alternative would be to change the first signature to
+ </p>
+
+-<blockquote><pre>back_insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++back_insert_iterator&lt;Container&gt;&amp;
+ operator=(const typename Container::const_reference&amp; value);
+ </pre></blockquote>
+
+@@ -78145,7 +88899,8 @@ Post-Rapperswil
+ This problem is not restricted to the unspeakable <tt>vector&lt;bool&gt;</tt>, but is already existing for other proxy
+ containers like gcc's <tt>rope</tt> class. The following code does no longer work ([Bug libstdc++/44963]):
+ </p>
+-<blockquote><pre>#include &lt;iostream&gt;
++<blockquote><pre>
++#include &lt;iostream&gt;
+ #include &lt;ext/rope&gt;
+
+ using namespace std;
+@@ -78170,9 +88925,9 @@ The following P/R is a revision of the orignal P/R and was initially suggested b
+ Hinnant. Paolo verified that the approach works in gcc.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording after 6 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78186,7 +88941,8 @@ Adopted at 2010-11 Batavia
+
+ <ol>
+ <li>Change [back.insert.iterator], class <tt>back_insert_iterator</tt> synopsis as indicated:
+-<blockquote><pre>template &lt;class Container&gt;
++<blockquote><pre>
++template &lt;class Container&gt;
+ class back_insert_iterator :
+ public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
+ protected:
+@@ -78202,16 +88958,18 @@ public:
+ </pre></blockquote>
+ </li>
+ <li>Change [back.insert.iter.op=] before p. 1 as indicated:
+-<blockquote><pre>back_insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++back_insert_iterator&lt;Container&gt;&amp;
+ operator=(<ins>const</ins> typename Container::<del>const_reference</del><ins>value_type&amp;</ins> value);
+ </pre>
+-<blockquote>
+-1 <em>Effects</em>: <tt>container-&gt;push_back(value)</tt>;<br>
++<blockquote><p>
++1 <em>Effects</em>: <tt>container-&gt;push_back(value)</tt>;<br/>
+ 2 <em>Returns</em>: <tt>*this</tt>.
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+ </li>
+ <li>Change [front.insert.iterator], class <tt>front_insert_iterator</tt> synposis as indicated:
+-<blockquote><pre>template &lt;class Container&gt;
++<blockquote><pre>
++template &lt;class Container&gt;
+ class front_insert_iterator :
+ public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
+ protected:
+@@ -78227,16 +88985,18 @@ public:
+ </pre></blockquote>
+ </li>
+ <li>Change [front.insert.iter.op=] before p.1 as indicated:
+-<blockquote><pre>front_insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++front_insert_iterator&lt;Container&gt;&amp;
+ operator=(<ins>const</ins> typename Container::<del>const_reference</del><ins>value_type&amp;</ins> value);
+ </pre>
+-<blockquote>
+-1 <em>Effects</em>: <tt>container-&gt;push_front(value)</tt>;<br>
++<blockquote><p>
++1 <em>Effects</em>: <tt>container-&gt;push_front(value)</tt>;<br/>
+ 2 <em>Returns</em>: <tt>*this</tt>.
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+ </li>
+ <li>Change [insert.iterator], class insert_iterator synopsis as indicated:
+-<blockquote><pre>template &lt;class Container&gt;
++<blockquote><pre>
++template &lt;class Container&gt;
+ class insert_iterator :
+ public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
+ protected:
+@@ -78253,16 +89013,18 @@ public:
+ </pre></blockquote>
+ </li>
+ <li>Change [insert.iter.op=] before p. 1 as indicated:
+-<blockquote><pre>insert_iterator&lt;Container&gt;&amp;
++<blockquote><pre>
++insert_iterator&lt;Container&gt;&amp;
+ operator=(<ins>const</ins> typename Container::<del>const_reference</del><ins>value_type&amp;</ins> value);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 1 <em>Effects</em>:
+-<blockquote><pre> iter = container-&gt;insert(iter, value);
++</p><blockquote><pre>
++ iter = container-&gt;insert(iter, value);
+ ++iter;
+-</pre></blockquote>
++</pre></blockquote><p>
+ 2 <em>Returns</em>: <tt>*this</tt>.
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+ </li>
+ </ol>
+
+@@ -78273,21 +89035,22 @@ public:
+
+ <hr>
+ <h3><a name="1335"></a>1335. Insufficient requirements for <tt>tuple::operator&lt;()</tt></h3>
+-<p><b>Section:</b> 20.4.2.7 [tuple.rel] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2010-05-15 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.4.2.7 [tuple.rel] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2010-05-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#tuple.rel">active issues</a> in [tuple.rel].</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.rel">issues</a> in [tuple.rel].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ The requirements section for <tt>std::tuple</tt> says the following:
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ <i>Requires:</i> For all <tt>i</tt>, where <tt>0 &lt;= i and i &lt;
+ sizeof...(Types)</tt>, <tt>get&lt;i&gt;(t) &lt; get&lt;i&gt;(u)</tt> is a valid
+ expression returning a type that is convertible to <tt>bool</tt>.
+ <tt>sizeof...(TTypes) == sizeof...(UTypes)</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p>
+ This is necessary but not sufficient, as the algorithm for comparing
+@@ -78300,9 +89063,10 @@ Post-Rapperswil
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively Ready with updated wording correcting change-bars after 6 positive votes on c++std-lib.
+-</blockquote>
++<blockquote><p>
++Moved to Tentatively Ready with updated wording correcting change-bars after 6
++positive votes on c++std-lib.
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78316,15 +89080,16 @@ Adopted at 2010-11 Batavia
+ <ol>
+ <li>Change [tuple.rel] before p. 4 as indicated [<strong>Remark to the editor: This paragraph doesn't have a number yet,
+ but it seems to me as if it should have one</strong>]:
+-<blockquote><pre>template&lt;class... TTypes, class... UTypes&gt;
++<blockquote><pre>
++template&lt;class... TTypes, class... UTypes&gt;
+ bool operator&lt;(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ <em>Requires</em>: For all <tt>i</tt>, where <tt>0 &lt;= i</tt> and <tt>i &lt; sizeof...(Types)</tt>,
+ <tt>get&lt;i&gt;(t) &lt; get&lt;i&gt;(u)</tt> <ins>and <tt>get&lt;i&gt;(u) &lt; get&lt;i&gt;(t)</tt></ins><del>is
+ a valid expression returning a type that is</del><ins> are valid expressions returning types that
+ are</ins> convertible to <tt>bool</tt>. <tt>sizeof...(TTypes) == sizeof...(UTypes)</tt>.
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+ </li>
+ </ol>
+
+@@ -78335,10 +89100,10 @@ are</ins> convertible to <tt>bool</tt>. <tt>sizeof...(TTypes) == sizeof...(UType
+
+ <hr>
+ <h3><a name="1337"></a>1337. Swapped arguments in <tt>regex_traits::isctype</tt></h3>
+-<p><b>Section:</b> 28.7 [re.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-06-21 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.traits">issues</a> in [re.traits].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 28.7 [re.traits] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.traits">issues</a> in [re.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ 28.7 [re.traits]/12 describes <tt>regex_traits::isctype</tt> in terms
+@@ -78352,9 +89117,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78365,10 +89130,11 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-Change 28.7 [re.traits]/12:
++Change 28.7 [re.traits] p.12:
+ </p>
+
+-<blockquote><pre>bool isctype(charT c, char_class_type f) const;
++<blockquote><pre>
++bool isctype(charT c, char_class_type f) const;
+ </pre>
+ <blockquote>
+ <p>
+@@ -78397,18 +89163,19 @@ getloc())</tt> returns <tt>true</tt>, otherwise returns <tt>false</tt>.
+
+ <hr>
+ <h3><a name="1338"></a>1338. LWG 1205 incorrectly applied</h3>
+-<p><b>Section:</b> 25.2.13 [alg.search] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-06-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.search">issues</a> in [alg.search].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 25.2.13 [alg.search] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-06-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.search">issues</a> in [alg.search].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a> (currently in WP) clarified the return value of several
++LWG <a href="lwg-defects.html#1205">1205</a> (currently in WP) clarified the return value of several
+ algorithms when dealing with empty ranges. In particular it recommended for
+ 25.2.13 [alg.search]:
+ </p>
+
+-<blockquote><pre>template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
+ ForwardIterator1
+ search(ForwardIterator1 first1, ForwardIterator1 last1,
+ ForwardIterator2 first2, ForwardIterator2 last2);
+@@ -78438,7 +89205,8 @@ Unfortunately this got translated to an incorrect specification for what gets
+ returned when no such iterator is found (N3092):
+ </p>
+
+-<blockquote><pre>template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
+ ForwardIterator1
+ search(ForwardIterator1 first1, ForwardIterator1 last1,
+ ForwardIterator2 first2, ForwardIterator2 last2);
+@@ -78462,11 +89230,11 @@ empty or if no such iterator is found.
+ </blockquote>
+
+ <p>
+-LWG <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a> is correct and N3092 is not equivalent nor correct.
++LWG <a href="lwg-defects.html#1205">1205</a> is correct and N3092 is not equivalent nor correct.
+ </p>
+
+ <p>
+-I have not reviewed the other 10 recommendations of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1205">1205</a>.
++I have not reviewed the other 10 recommendations of <a href="lwg-defects.html#1205">1205</a>.
+ </p>
+
+ <p><i>[
+@@ -78474,14 +89242,15 @@ Post-Rapperswil
+ ]</i></p>
+
+
+-<blockquote>
+-It was verified that none of the remaining possibly affected algorithms does have any similar problems and a concrete P/R was added
+-that used a similar style as has been applied to the other cases.
+-</blockquote>
++<blockquote><p>
++It was verified that none of the remaining possibly affected algorithms does
++have any similar problems and a concrete P/R was added that used a similar
++style as has been applied to the other cases.
++</p></blockquote>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78492,8 +89261,9 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+-<li>Change [alg.search]/2 as indicated:
+-<blockquote><pre>template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++<li>Change [alg.search] p.2 as indicated:
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
+ ForwardIterator1
+ search(ForwardIterator1 first1, ForwardIterator1 last1,
+ ForwardIterator2 first2, ForwardIterator2 last2);
+@@ -78507,12 +89277,12 @@ template&lt;class ForwardIterator1, class ForwardIterator2,
+ </pre>
+ <blockquote><p>
+ 1 - [...]
+-</p>
++<p/>
+ 2 - <em>Returns</em>: The first iterator <tt>i</tt> in the range <tt>[first1,last1 - (last2-first2))</tt> such that for any nonnegative
+ integer <tt>n</tt> less than <tt>last2 - first2</tt> the following corresponding conditions hold: <tt>*(i + n) == *(first2 + n)</tt>,
+ <tt>pred(*(i + n), *(first2 + n)) != false</tt>. Returns <tt>first1</tt> if <tt>[first2,last2)</tt> is empty <del>or</del><ins>, otherwise
+ returns <tt>last1</tt></ins> if no such iterator is found.
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+ </li>
+ </ol>
+
+@@ -78522,9 +89292,9 @@ integer <tt>n</tt> less than <tt>last2 - first2</tt> the following corresponding
+
+ <hr>
+ <h3><a name="1339"></a>1339. <tt>uninitialized_fill_n</tt> should return the end of its range</h3>
+-<p><b>Section:</b> 20.9.8.4 [uninitialized.fill.n] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Jared Hoberock <b>Opened:</b> 2010-07-14 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.7.12.4 [uninitialized.fill.n] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jared Hoberock <b>Opened:</b> 2010-07-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092's</a>
+@@ -78544,9 +89314,9 @@ Post-Rapperswil:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78557,26 +89327,29 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <p>
+-In section 20.9 [memory] change:,
++In section 20.7 [memory] change:,
+ </p>
+
+-<blockquote><pre>template &lt;class ForwardIterator, class Size, class T&gt;
++<blockquote><pre>
++template &lt;class ForwardIterator, class Size, class T&gt;
+ <del>void</del> <ins>ForwardIterator</ins> uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
+ </pre></blockquote>
+
+
+ <p>
+-In section 20.9.8.4 [uninitialized.fill.n] change,
++In section 20.7.12.4 [uninitialized.fill.n] change,
+ </p>
+
+-<blockquote><pre>template &lt;class ForwardIterator, class Size, class T&gt;
++<blockquote><pre>
++template &lt;class ForwardIterator, class Size, class T&gt;
+ <del>void</del> <ins>ForwardIterator</ins> uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
+ </pre>
+ <blockquote>
+ <p>
+ 1 <i>Effects:</i>
+ </p>
+-<blockquote><pre>for (; n--; ++first)
++<blockquote><pre>
++for (; n--; ++first)
+ ::new (static_cast&lt;void*&gt;(&amp;*first))
+ typename iterator_traits&lt;ForwardIterator&gt;::value_type(x);
+ <ins>return first;</ins>
+@@ -78591,20 +89364,20 @@ In section 20.9.8.4 [uninitialized.fill.n] change,
+
+ <hr>
+ <h3><a name="1340"></a>1340. Why does <tt>forward_list::resize</tt> take the object to be copied by value?</h3>
+-<p><b>Section:</b> 23.3.3.4 [forwardlist.modifiers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b>
+-James McNellis <b>Opened:</b> 2010-07-16 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 23.3.4.5 [forwardlist.modifiers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> James McNellis <b>Opened:</b> 2010-07-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.modifiers">issues</a> in [forwardlist.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+ In
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>
+-23.3.3.4 [forwardlist.modifiers], the <tt>resize()</tt> member function is
++23.3.4.5 [forwardlist.modifiers], the <tt>resize()</tt> member function is
+ declared as:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, value_type c);
++<blockquote><pre>
++void resize(size_type sz, value_type c);
+ </pre></blockquote>
+
+ <p>
+@@ -78617,17 +89390,18 @@ Is there a reason for this difference? If not, then <tt>resize()</tt> should
+ be declared as:
+ </p>
+
+-<blockquote><pre>void resize(size_type sz, const value_type&amp; c);
++<blockquote><pre>
++void resize(size_type sz, const value_type&amp; c);
+ </pre></blockquote>
+
+ <p>
+ The declaration would need to be changed both at its declaration in the class
+-definition at 23.3.3 [forwardlist]/3 and where its behavior is specified
+-at 23.3.3.4 [forwardlist.modifiers]/22.
++definition at 23.3.4 [forwardlist]/3 and where its behavior is specified
++at 23.3.4.5 [forwardlist.modifiers]/22.
+ </p>
+
+ <p>
+-This would make <tt>forward_list</tt> consistent with the CD1 issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#679">679</a>.
++This would make <tt>forward_list</tt> consistent with the CD1 issue <a href="lwg-defects.html#679">679</a>.
+ </p>
+
+ <p><i>[
+@@ -78636,15 +89410,15 @@ Post-Rapperswil
+
+
+ <p>
+-Daniel changed the P/R slightly, because one paragraph number has been changed since the issue
++Daniel changed the P&#47;R slightly, because one paragraph number has been changed since the issue
+ had been submitted. He also added a similar Requires element that exists in all other containers with
+ a <tt>resize</tt> member function. He deliberately did not touch the wrong usage of "default-constructed" because that
+-will be taken care of by LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#868">868</a>.
++will be taken care of by LWG issue <a href="lwg-defects.html#868">868</a>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with revised wording after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -78658,7 +89432,8 @@ Adopted at 2010-11 Batavia
+
+ <ol>
+ <li>Change [forwardlist]/3, class template <tt>forward_list</tt> synopsis, as indicated:
+-<blockquote><pre>...
++<blockquote><pre>
++...
+ void resize(size_type sz);
+ void resize(size_type sz, <ins>const</ins> value_type<ins>&amp;</ins> c);
+ void clear();
+@@ -78670,14 +89445,14 @@ void clear();
+ void resize(size_type sz);
+ void resize(size_type sz, <ins>const</ins> value_type<ins>&amp;</ins> c);
+ </pre>
+-<blockquote>
++<blockquote><p>
+ 27 <em>Effects</em>: If <tt>sz &lt; distance(begin(), end())</tt>, erases the last <tt>distance(begin(), end()) - sz</tt> elements
+ from the list. Otherwise, inserts <tt>sz - distance(begin(), end())</tt> elements at the end of the list. For the first
+ signature the inserted elements are default constructed, and for the second signature they are copies of <tt>c</tt>.
+-<p>
++<p/>
+ <ins>28 - <em>Requires</em>: <tt>T</tt> shall be <tt>DefaultConstructible</tt> for the first form and it shall be <tt>CopyConstructible</tt>
+- for the second form.</ins></p>
+-</blockquote></blockquote>
++ for the second form.</ins>
++</p></blockquote></blockquote>
+ </li>
+ </ol>
+
+@@ -78687,13 +89462,13 @@ signature the inserted elements are default constructed, and for the second sign
+
+
+ <hr>
+-<h3><a name="1344"></a>1344. [FCD] Replace <tt>throw()</tt> with <tt>noexcept</tt></h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1351">1351</a></p>
++<h3><a name="1344"></a>1344. Replace <tt>throw()</tt> with <tt>noexcept</tt></h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1351">1351</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-60, CH-16</b></p>
+ <p>
+@@ -78717,40 +89492,106 @@ of the form 'throw()' with the 'noexcept' form.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3148.html">n3148</a>
+ would satisfy this request.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-Batavia:
+ ]</i></p>
+
+-<blockquote>
++
++<blockquote><p>
+ Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3148.html">n3148</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3148.html">n3148</a>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3150.html">n3150</a>
+-See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3195.html">n3195</a>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3195.htm">n3195</a>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3155.html">n3155</a>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3156.html">n3156</a>
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1346"></a>1346. [FCD] Apply <tt>noexcept</tt> where library specification does not permit exceptions</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1352">1352</a></p>
++<h3><a name="1345"></a>1345. Library classes should have <tt>noexcept</tt> move operations</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-61</b></p>
++<p>
++All library types should have non-throwing move
++constructors and move-assignment operators unless
++wrapping a type with a potentially throwing move operation.
++When such a type is a class-template, these
++operations should have a conditional <tt>noexcept</tt>
++specification.
++</p>
++<p>
++There are many other places where a <tt>noexcept</tt>
++specification may be considered, but the move operations
++are a special case that must be called out, to effectively
++support the <tt>move_if_noexcept</tt> function template.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++
++<p>
++Review every class and class template in the library. If <tt>noexcept</tt>
++move constructor/assignment operators can be implicitly declared, then they
++should be implicitly declared, or explicitly defaulted. Otherwise, a move
++constructor/move assignment operator with a <tt>noexcept</tt> exception
++specification should be provided.
++</p>
++
++<p><i>[
++2010-10-31 Daniel comments:
++]</i></p>
++
++
++<blockquote><p>
++The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>
++would satisfy this request.
++</p></blockquote>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>Resolved by papers to be listed later</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1346"></a>1346. Apply <tt>noexcept</tt> where library specification does not permit exceptions</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1352">1352</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-62, CH-17</b></p>
+ <p>
+@@ -78768,6 +89609,7 @@ to construct programs taking advantage of the guarantee.
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
++
+ <p>
+ Add a <tt>noexcept</tt> exception specification on each
+ libary API that offers an unconditional <i>Throws</i>:
+@@ -78782,35 +89624,36 @@ constant expression exists.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3149.html">n3149</a>
+ would satisfy this request.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-Batavia:
+ ]</i></p>
+
+-<blockquote>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3149.html">n3149</a>.
+-</blockquote>
+
++<blockquote><p>
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3149.html">n3149</a>.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-This issue is resolved by the adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3195.html">n3195</a>
+
++<p><b>Proposed resolution:</b></p><p>
++This issue is resolved by the adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3195.htm">n3195</a>
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1347"></a>1347. [FCD] Apply <tt>noexcept</tt> judiciously throughout the library</h3>
+-<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#library">active issues</a> in [library].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#library">issues</a> in [library].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1347"></a>1347. Apply <tt>noexcept</tt> judiciously throughout the library</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-63, US-80</b></p>
+ <p>
+@@ -78828,6 +89671,7 @@ efficiency.
+ Resolution proposed by ballot comment
+ ]</i></p>
+
++
+ <p>
+ Review the whole library, and apply the <tt>noexcept</tt>
+ specification where it is appropriate.
+@@ -78838,14 +89682,14 @@ specification where it is appropriate.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution of the combination of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3155.html">n3155</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3156.html">n3156</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3167.html">n3167</a>
+ would satisfy this request. The paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3150.html">n3150</a> is related
+ to this as well.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Batavia:
+@@ -78857,22 +89701,199 @@ While the LWG expects to see further papers in this area, sufficient action was
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3155.html">n3155</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3156.html">n3156</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3157.html">n3157</a>,
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3167.html">n3167</a> and remotely
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3150.html">n3150</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="1349"></a>1349. <tt>swap</tt> should not throw</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-65</b></p>
++<p>
++Nothrowing <tt>swap</tt> operations are key to many C++ idioms,
++notably the common copy/swap idiom to provide the
++strong exception safety guarantee.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
++
++<p>
++Where possible, all library types should provide a
++<tt>swap</tt> operation with an exception specification
++guaranteeing no exception shall propagate.
++Where <tt>noexcept(true)</tt> cannot be guaranteed to
++not terminate the program, and the <tt>swap</tt> in
++questions is a template, an exception specification
++with the appropriate conditional expression could
++be specified.
++</p>
++
++<p><i>[2011-03-13: Daniel comments and drafts wording]</i></p>
++
++
++<p>During a survey of the library some main categories for
++potential <tt>noexcept</tt> <tt>swap</tt> function could be isolated:</p>
++
++<ol>
++<li>Free <tt>swap</tt> functions that are specified in terms of already
++<tt>noexcept</tt> <tt>swap</tt> member functions, like that of <tt>valarray</tt>.</li>
++
++<li>Free <tt>swap</tt> of <tt>std::function</tt>, and member and free <tt>swap</tt>
++functions of stream buffers and streams where considered but rejected as good candidates,
++because of the danger to potentially impose requirements of existing implementations.
++These functions could be reconsidered as candidates in the future.</li>
++</ol>
++
++<p>Negative list:</p>
++
++<ol>
++<li>Algorithms related to swap, like <tt>iter_swap</tt>, have <em>not</em> been touched,
++because there are no fundamental exceptions constraints on iterator operations in general
++(only for specific types, like library container iterators)</li>
++</ol>
++
++<p>While evaluating the current state of <tt>swap</tt> functions
++of library components it was observed that several conditional <tt>noexcept</tt>
++functions have turned into unconditional ones, e.g. in the
++header <tt>&lt;utility&gt;</tt> synopsis:</p>
++
++<blockquote><pre>
++template&lt;class T&gt; void swap(T&amp; a, T&amp; b) noexcept;
++</pre></blockquote>
++
++<p>The suggested resolution shown below also attempts to fix
++these cases.</p>
++
++<p><i>[2011-03-22 Daniel redrafts to satisfy new criteria for applying <tt>noexcept</tt>.
++Parts resolved by N3263-v2 and D3267 are not added here.]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Edit 20.2 [utility] p. 2, header <tt>&lt;utility&gt;</tt> synopsis <em>and</em>
++20.2.2 [utility.swap] before p. 1, as indicated (The intent is to fix an editorial
++omission):</p>
++
++<blockquote><pre>
++template&lt;class T&gt; void swap(T&amp; a, T&amp; b) noexcept<ins>(<i>see below</i>)</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit the prototype declaration in 20.3.2 [pairs.pair] before p. 34 as indicated (The intent
++is to fix an editorial omission):</p>
++
++<blockquote><pre>
++void swap(pair&amp; p) noexcept<ins>(<i>see below</i>)</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit 20.4.1 [tuple.general] p. 2 header <tt>&lt;tuple&gt;</tt> synopsis <em>and</em>
++20.4.2.9 [tuple.special] before p. 1 as indicated (The intent is to fix an editorial omission):</p>
++
++<blockquote><pre>
++template &lt;class... Types&gt;
++void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y) noexcept<ins>(<i>see below</i>)</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit 20.4.2 [tuple.tuple], class template <tt>tuple</tt> synopsis <em>and</em>
++20.4.2.3 [tuple.swap] before p. 1 as indicated (The intent is to fix an editorial omission):</p>
++
++<blockquote><pre>
++void swap(tuple&amp;) noexcept<ins>(<i>see below</i>)</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit 20.7.2 [memory.syn] p. 1, header <tt>&lt;memory&gt;</tt> synopsis as indicated (The
++intent is to fix an editorial omission of the proposing paper N3195).</p>
++
++<blockquote><pre>
++template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b) <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit header <tt>&lt;valarray&gt;</tt> synopsis, 26.6.1 [valarray.syn] <em>and</em>
++26.6.3.4 [valarray.special] before p. 1 as indicated
++<em>[Drafting comment: The corresponding member swap is already noexcept]</em>:</p>
++
++<blockquote><pre>
++template&lt;class T&gt; void swap(valarray&lt;T&gt;&amp;, valarray&lt;T&gt;&amp;) <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1353"></a>1353. Clarify the state of a <i>moved-from</i> object</h3>
++<p><b>Section:</b> 17 [library] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#library">active issues</a> in [library].</p>
++<p><b>View all other</b> <a href="lwg-index.html#library">issues</a> in [library].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-18</b></p>
++<p>
++The general approach on moving is that a library object
++after moving out is in a "valid but unspecified state". But
++this is stated at the single object specifications, which is
++error prone (especially if the move operations are implicit)
++and unnecessary duplication.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
++<p>
++Consider putting a general statement to the same
++effect into clause 17.
++</p>
++
++<p><i>[2010-11-05 Beman provides exact wording.
++The wording was inspired by Dave Abrahams'
++message c++std-lib-28958, and refined with help from Alisdair, Daniel, and Howard.
++]</i></p>
++
++
++<p><i>[2011-02-25 P/R wording superseded by N3241.
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3241.html">N3241</a></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1354"></a>1354. [FCD] The definition of deadlock excludes cases involving a single thread</h3>
+-<p><b>Section:</b> 17.3.8 [defns.deadlock] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1354"></a>1354. The definition of deadlock excludes cases involving a single thread</h3>
++<p><b>Section:</b> 17.3 [defns.deadlock] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-52</b></p>
+ <p>
+@@ -78901,10 +89922,12 @@ Adopted at 2010-11 Batavia
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change 17.3.8 [defns.deadlock] as indicated:
+-<blockquote>
+-<b>deadlock</b>
+ <p>
++Change 17.3 [defns.deadlock] as indicated:
++</p>
++<blockquote><p>
++<b>deadlock</b>
++<p/>
+ <del>two</del><ins>one</ins> or more threads are unable to continue execution because each is blocked waiting for one or more of the
+ others to satisfy some condition.
+ </p></blockquote>
+@@ -78914,10 +89937,10 @@ others to satisfy some condition.
+
+
+ <hr>
+-<h3><a name="1355"></a>1355. [FCD] The definition of move-assignment operator is redundant</h3>
+-<p><b>Section:</b> 17.3.16 [defns.move.assign.op] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1355"></a>1355. The definition of move-assignment operator is redundant</h3>
++<p><b>Section:</b> X [defns.move.assign.op] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-50</b></p>
+ <p>
+@@ -78932,33 +89955,34 @@ operator is defined by the core language in subclause
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a> provides a superior resolution.
+-</blockquote>
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>
++provides a superior resolution.
++</p></blockquote>
+
+ <p><i>[
+ Resolution proposed by ballot comment
+ ]</i></p>
+
+ <p>
+-Strike subclause 17.3.16 [defns.move.assign.op].
++Strike subclause X [defns.move.assign.op].
+ Add a cross-reference to (12.8) to 17.3.12.
+ </p>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1356"></a>1356. [FCD] The definition of move-constructor is redundant</h3>
+-<p><b>Section:</b> 17.3.17 [defns.move.ctor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1356"></a>1356. The definition of move-constructor is redundant</h3>
++<p><b>Section:</b> X [defns.move.ctor] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-51</b></p>
+ <p>
+@@ -78972,9 +89996,9 @@ core language in subclause 12.8p3.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a> provides a superior resolution.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Batavia: resolved as NAD Editorial by adopting paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+@@ -78988,27 +90012,27 @@ Original proposed resolution preserved for reference:
+ Strike subclause 17.3.14, [defns.move.ctor]
+ </p>
+
+-<blockquote><del>
+-<b>17.3.14 [defns.move.ctor]</b><br>
++<blockquote><p><del>
++<b>17.3.14 [defns.move.ctor]</b><br/>
+ move constructor a constructor which accepts only an rvalue argument of the type being constructed and might modify the argument as a side effect during construction.
+-</del></blockquote>
++</del></p></blockquote>
+ </blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1357"></a>1357. [FCD] Library bitmask types to not satisfy the bimask type requirements</h3>
+-<p><b>Section:</b> 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#bitmask.types">issues</a> in [bitmask.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1357"></a>1357. Library bitmask types to not satisfy the bimask type requirements</h3>
++<p><b>Section:</b> 17.5.2.1.3 [bitmask.types] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#bitmask.types">issues</a> in [bitmask.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-53</b></p>
+ <p>
+@@ -79038,19 +90062,19 @@ that this paper will go forward at the next meeting.
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3110.html">n3110</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1360"></a>1360. [FCD] Add <tt>&lt;atomic&gt;</tt> to free-standing implementations</h3>
+-<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#compliance">issues</a> in [compliance].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1360"></a>1360. Add <tt>&lt;atomic&gt;</tt> to free-standing implementations</h3>
++<p><b>Section:</b> 17.6.1.3 [compliance] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#compliance">issues</a> in [compliance].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-57</b></p>
+ <p>
+@@ -79070,24 +90094,24 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Add <tt>&lt;atomic&gt;</tt> to table 15, headers required for a
+ free-standing implementation.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1362"></a>1362. [FCD] Description of binding to rvalue-references should use the new 'xvalue' vocabulary</h3>
+-<p><b>Section:</b> 17.6.3.9 [res.on.arguments] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#res.on.arguments">issues</a> in [res.on.arguments].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1362"></a>1362. Description of binding to rvalue-references should use the new 'xvalue' vocabulary</h3>
++<p><b>Section:</b> 17.6.4.9 [res.on.arguments] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#res.on.arguments">issues</a> in [res.on.arguments].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-82</b></p>
+ <p>
+-17.6.3.9 [res.on.arguments] p.1. b.3: The second Note can benefit by adopting recent nomenclature.
++17.6.4.9 [res.on.arguments] p.1. b.3: The second Note can benefit by adopting recent nomenclature.
+ </p>
+
+
+@@ -79120,9 +90144,13 @@ Adopted at 2010-11 Batavia
+ <p>
+ Amend the note in 17.6.3.9 [res.on.arguments] p1 bullet 3.
+ </p>
+-<blockquote>
+-[ <i>Note</i>: If a program casts an lvalue to an <del>rvalue</del><ins>xvalue</ins> while passing that lvalue to a library function (e.g. by calling the function with the argument <tt>move(x)</tt>), the program is effectively asking that function to treat that lvalue as a temporary. The implementation is free to optimize away aliasing checks which might be needed if the argument was anlvalue. <i>—endnote</i>]
+-</blockquote>
++<blockquote><p>
++[ <i>Note</i>: If a program casts an lvalue to an <del>rvalue</del><ins>xvalue</ins> while
++passing that lvalue to a library function (e.g. by calling the function with the argument
++<tt>move(x)</tt>), the program is effectively asking that function to treat that lvalue as
++a temporary. The implementation is free to optimize away aliasing checks which might be
++needed if the argument was anlvalue. &mdash; <i>end note</i>]
++</p></blockquote>
+
+
+
+@@ -79130,13 +90158,14 @@ Amend the note in 17.6.3.9 [res.on.arguments] p1 bullet 3.
+
+
+ <hr>
+-<h3><a name="1363"></a>1363. [FCD] <tt>offsetof</tt> should be marked <tt>noexcept</tt></h3>
+-<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#support.types">issues</a> in [support.types].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1363"></a>1363. <tt>offsetof</tt> should be marked <tt>noexcept</tt></h3>
++<p><b>Section:</b> 18.2 [support.types] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.types">issues</a> in [support.types].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-68</b></p>
++
+ <p>
+ There is no reason for the offsetof macro to invoke
+ potentially throwing operations, so the result of
+@@ -79153,22 +90182,68 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add to the end of 18.2p4:</p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ No operation invoked by the offsetof macro shall
+ throw an exception, and
+ <tt>noexcept(offsetof(type,member-designator))</tt> shall
+ be true.</ins>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1364"></a>1364. It is not clear how <tt>exception_ptr</tt> is synchronized</h3>
++<p><b>Section:</b> 18.8.5 [propagation] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#propagation">issues</a> in [propagation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-19</b></p>
++<p>
++It is not clear how <tt>exception_ptr</tt> is synchronized.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment
++]</i></p>
++
++<p>
++Make clear that accessing in different threads
++multiple <tt>exception_ptr</tt> objects that all refer to the
++same exception introduce a race.
++</p>
++
++<p><i>[2011-03-08: Lawrence comments and drafts wording]</i></p>
++
++
++<p>I think fundamentally, this issue is NAD, but clarification would not hurt.</p>
++
++<blockquote>
++<p>Proposed resolution</p>
++<p>Add a new paragraph to 18.8.5 [propagation] after paragraph 6 as follows:</p>
++
++<p><ins>
++[<i>Note:</i> Exception objects have no synchronization requirements, and expressions
++using them may conflict (1.10 [intro.multithread]). &mdash; <i>end note</i>]
++</ins></p>
+ </blockquote>
+
+
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
+
+
+ <hr>
+-<h3><a name="1365"></a>1365. [FCD] Thread-safety of handler functions</h3>
+-<p><b>Section:</b> 18.6.2 [alloc.errors] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1365"></a>1365. Thread-safety of handler functions</h3>
++<p><b>Section:</b> 18.6.2 [alloc.errors] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-71</b></p>
+ <p>
+@@ -79182,46 +90257,47 @@ safe manner.
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ The thread safety guarantees for the functions
+ must be specified and new interfaces should be
+ provided to make it possible to query and install
+ handlers in a thread safe way.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-10-31 Daniel comments:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ The proposed resolution of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3122.html">n3122</a>
+-partially addresses this request. This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1366">1366</a>.
+-</blockquote>
++partially addresses this request. This issue is related to <a href="lwg-defects.html#1366">1366</a>.
++</p></blockquote>
+
+
+ <p><i>[
+ 2010-Batavia:
+ ]</i></p>
+
+-<blockquote>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.html">n3189</a>.
+-</blockquote>
++<blockquote><p>
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.htm">n3189</a>.
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved in Batavia by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.html">n3189</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++Resolved in Batavia by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.htm">n3189</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1366"></a>1366. [FCD] New-handler and data races</h3>
+-<p><b>Section:</b> 18.6.1.4 [new.delete.dataraces] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1366"></a>1366. New-handler and data races</h3>
++<p><b>Section:</b> 18.6.1.4 [new.delete.dataraces] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.dataraces">issues</a> in [new.delete.dataraces].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-14</b></p>
+ <p>
+@@ -79245,33 +90321,33 @@ Offer a non-mutating interface to query the current new-handler.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3122.html">n3122</a> would solve this issue.
+-This issue is related to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1365">1365</a>.
+-</blockquote>
++This issue is related to <a href="lwg-defects.html#1365">1365</a>.
++</p></blockquote>
+
+ <p><i>[
+ 2010-Batavia:
+ ]</i></p>
+
+-<blockquote>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.html">n3189</a>.
+-</blockquote>
+-
++<blockquote><p>
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.htm">n3189</a>.
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved in Batavia by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.html">n3189</a>.
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved in Batavia by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.htm">n3189</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1367"></a>1367. [FCD] Deprecate library support for checking dynamic exception specifications</h3>
+-<p><b>Section:</b> D.13 [exception.unexpected] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1367"></a>1367. Deprecate library support for checking dynamic exception specifications</h3>
++<p><b>Section:</b> D.8 [exception.unexpected] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-72</b></p>
+ <p>
+@@ -79290,21 +90366,21 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ With the exception of 18.8.2.1 [bad.exception],
+-move clause 18.8.2 diectly to Annex D.
++move clause 18.8.2 directly to Annex D.
+ [bad.exception] should simply become the new
+ 18.8.2.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1368"></a>1368. [FCD] Thread safety of <tt>std::uncaught_exception()</tt></h3>
+-<p><b>Section:</b> 18.8.4 [uncaught] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1368"></a>1368. Thread safety of <tt>std::uncaught_exception()</tt></h3>
++<p><b>Section:</b> X [uncaught] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-73</b></p>
+ <p>
+@@ -79338,11 +90414,11 @@ Adopted at 2010-11 Batavia
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 18.8.4 [uncaught] p. 1 as follows:</p>
++<p>Change X [uncaught] p. 1 as follows:</p>
+ <p>
+ <i>Returns</i>: <tt>true</tt> after <ins> the current thread has initialized </ins><del>initializing</del>
+ an exception object (15.1) until a handler for the exception (including <tt>unexpected()</tt> or <tt>terminate()</tt>)
+- is activated (15.3). [ <i>Note</i>: This includes stack unwinding (15.2). — <i>end note</i> ]
++ is activated (15.3). [ <i>Note</i>: This includes stack unwinding (15.2). &mdash; <i>end note</i> ]
+ </p>
+
+
+@@ -79351,11 +90427,12 @@ Adopted at 2010-11 Batavia
+
+
+ <hr>
+-<h3><a name="1370"></a>1370. [FCD] <tt>throw_with_nested</tt> should not use perfect forwarding</h3>
+-<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#except.nested">issues</a> in [except.nested].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1370"></a>1370. <tt>throw_with_nested</tt> should not use perfect forwarding</h3>
++<p><b>Section:</b> 18.8.6 [except.nested] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#except.nested">active issues</a> in [except.nested].</p>
++<p><b>View all other</b> <a href="lwg-index.html#except.nested">issues</a> in [except.nested].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-84</b></p>
+ <p>
+@@ -79381,9 +90458,9 @@ requirements on <tt>T</tt> and the use of
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3144.html">n3144</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[2010-11-10 Batavia: LWG accepts Howard's updated wording with
+ corrected boo boos reported by Sebastian Gesemann and Pete Becker,
+@@ -79420,12 +90497,13 @@ Adopted at 2010-11 Batavia
+
+
+ <hr>
+-<h3><a name="1372"></a>1372. [FCD] Adopt recommended practice for standard error categories</h3>
+-<p><b>Section:</b> 19.5.1.5 [syserr.errcat.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1372"></a>1372. Adopt recommended practice for standard error categories</h3>
++<p><b>Section:</b> 19.5.1.5 [syserr.errcat.objects] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-76</b></p>
++
+ <p>
+ The C++0x FCD recommends, in a note (see 19.5.1.1/1), that users
+ create a single <tt>error_category</tt> object for each user defined error
+@@ -79447,20 +90525,21 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+ Append a new sentence to 19.5.1.5 [syserr.errcat.objects]/1, and append
+ the same sentence to 19.5.1.5/3.
+ </p>
+-<blockquote><ins>
++<blockquote><p><ins>
+ All calls of this function return references to the same object.
+-</ins></blockquote>
++</ins></p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1377"></a>1377. [FCD] The revised <tt>forward</tt> is not compatible with access-control</h3>
+-<p><b>Section:</b> 20.3 [utility] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#utility">issues</a> in [utility].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1377"></a>1377. The revised <tt>forward</tt> is not compatible with access-control</h3>
++<p><b>Section:</b> 20.2 [utility] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-90</b></p>
+ <p>
+@@ -79474,7 +90553,8 @@ compile time failure, whereas that was not the case for an
+ implementation along the lines of n2835 (using <tt>enable_if</tt>s
+ instead of concepts for the constraining, of course)
+ </p>
+-<pre>#include &lt;utility&gt;
++<pre>
++#include &lt;utility&gt;
+ struct Base { Base(Base&amp;&amp;); };
+
+ struct Derived
+@@ -79494,32 +90574,33 @@ way, the present status is not acceptable.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3143.html">n3143</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved as NAD Editorial by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3143.html">n3143</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1378"></a>1378. [FCD] <tt>pair</tt> and <tt>tuple</tt> have too many conversions</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1378"></a>1378. <tt>pair</tt> and <tt>tuple</tt> have too many conversions</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-15</b></p>
+ <p>
+ Several function templates of <tt>pair</tt> and <tt>tuple</tt> allow for too
+ many implicit conversions, for example:
+ </p>
+-<pre>#include &lt;tuple&gt;
++<pre>
++#include &lt;tuple&gt;
+ std::tuple&lt;char*&gt; p(0); // Error?
+
+ struct A { explicit A(int){} };
+@@ -79540,26 +90621,26 @@ Consider to add wording to constrain these function templates.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1379"></a>1379. [FCD] <tt>pair</tt> copy-assignment not consistent for references</h3>
+-<p><b>Section:</b> 20.3.5.2 [pairs.pair] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1379"></a>1379. <tt>pair</tt> copy-assignment not consistent for references</h3>
++<p><b>Section:</b> 20.3.2 [pairs.pair] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs.pair">issues</a> in [pairs.pair].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-95</b></p>
+ <p>
+@@ -79577,10 +90658,10 @@ with <tt>tuple</tt>'s assignment operators.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would provide a superior resolution,
+ because <tt>pair</tt> does not depend on the semantic requirements of <tt>CopyAssignable</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11 Batavia
+@@ -79593,16 +90674,16 @@ Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add to <tt>pair</tt> synopsis:
+-<blockquote>
++<p>Add to <tt>pair</tt> synopsis:</p>
++<blockquote><p>
+ <tt>pair&amp; operator=(const pair&amp; p);</tt>
+-</blockquote>
++</p></blockquote>
+ <p>
+ Add before paragraph 9:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>pair&amp; operator=(const pair&amp; p);</tt>
+-<blockquote>
++</p><blockquote>
+ <p>
+ <i>Requires</i>: <tt>T1</tt> and <tt>T2</tt> shall satisfy the
+ requirements of <tt>CopyAssignable</tt>.
+@@ -79620,11 +90701,11 @@ requirements of <tt>CopyAssignable</tt>.
+
+
+ <hr>
+-<h3><a name="1380"></a>1380. [FCD] <tt>pair</tt> and <tt>tuple</tt> of references need to better specify move-semantics</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1380"></a>1380. <tt>pair</tt> and <tt>tuple</tt> of references need to better specify move-semantics</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-16</b></p>
+ <p>
+@@ -79652,33 +90733,33 @@ Replace the usage of <tt>std::move</tt> by that of
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11 Batavia:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1381"></a>1381. [FCD] Ballot Comment GB-85</h3>
+-<p><b>Section:</b> X [pair.range] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1381"></a>1381. Replace <tt>pair</tt>'s range support by proper range facility</h3>
++<p><b>Section:</b> X [pair.range] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-85</b></p>
+ <p>
+@@ -79691,8 +90772,7 @@ existing type with a different semantic.
+ </p>
+
+ <p>
+-If a replacement facility is required for C++0x,
+-consider n2995.
++If a replacement facility is required for C++0x, consider n2995.
+ </p>
+
+ <p><i>[
+@@ -79702,20 +90782,19 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Strike 20.3.5.4 and the matching declarations in
+-20.3 header synopsis.
+-
++<p><b>Proposed resolution:</b></p><p>
++Strike 20.3.5.4 and the matching declarations in 20.3 header synopsis.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1382"></a>1382. [FCD] <tt>pair</tt> and <tt>tuple</tt> constructors should <tt>forward</tt> arguments</h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1382"></a>1382. <tt>pair</tt> and <tt>tuple</tt> constructors should <tt>forward</tt> arguments</h3>
++<p><b>Section:</b> 20.3 [pairs] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-96</b></p>
+ <p>
+@@ -79730,18 +90809,18 @@ wrong.
+ Resolution proposed by ballot comment
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ See Appendix 1 - Additional Details
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11 Batavia
+@@ -79753,119 +90832,122 @@ Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1383"></a>1383. [FCD] Inconsistent defaulted move/copy members in <tt>pair</tt> and <tt>tuple</tt></h3>
+-<p><b>Section:</b> 20.3.5 [pairs] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#pairs">issues</a> in [pairs].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1383"></a>1383. Inconsistent defaulted move&#47;copy members in <tt>pair</tt> and <tt>tuple</tt></h3>
++<p><b>Section:</b> 20.3 [pairs], 20.4 [tuple] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#pairs">issues</a> in [pairs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-97</b></p>
+ <p>
+-<tt>pair</tt>'s class definition in N3092 20.3.5.2 [pairs.pair]
++<tt>pair</tt>'s class definition in N3092 20.3.2 [pairs.pair]
+ contains "<tt>pair(const pair&amp;) = default;</tt>" and
+ "<tt>pair&amp; operator=(pair&amp;&amp; p);</tt>". The latter is described by
+-20.3.5.2 [pairs.pair] p.12-13.
+-</p>
++20.3.2 [pairs.pair] p.12-13.
++<p/>
+ "<tt>pair(const pair&amp;) = default;</tt>" is a user-declared explicitly defaulted
+-copy constructor. According to 12.8 [class.copy]/10, this inhibits
++copy constructor. According to 12.8 [class.copy]&#47;10, this inhibits
+ the implicitly-declared move constructor. <tt>pair</tt> should be move constructible.
+-(12.8 [class.copy]/7 explains that "<tt>pair(pair&lt;U, V&gt;&amp;&amp; p)</tt>"
+-will never be instantiated to move <tt>pair&lt;T1, T2&gt;</tt> to <tt>pair&lt;T1, T2&gt;</tt>.)<br>
++(12.8 [class.copy]&#47;7 explains that "<tt>pair(pair&lt;U, V&gt;&amp;&amp; p)</tt>"
++will never be instantiated to move <tt>pair&lt;T1, T2&gt;</tt> to <tt>pair&lt;T1, T2&gt;</tt>.)<br/>
+ "<tt>pair&amp; operator=(pair&amp;&amp; p);</tt>" is a user-provided move
+-assignment operator (according to 8.4.2 [dcl.fct.def.default]/4: "A
++assignment operator (according to 8.4.2 [dcl.fct.def.default]&#47;4: "A
+ special member function is user-provided if it is user-declared and not explicitly defaulted
+-on its first declaration."). According to 12.8 [class.copy]/20, this inhibits
++on its first declaration."). According to 12.8 [class.copy]&#47;20, this inhibits
+ the implicitly-declared copy assignment operator. <tt>pair</tt>
+-should be copy assignable, and was in C++98/03. (Again,
+-12.8 [class.copy]/7 explains that "<tt>operator=(const pair&lt;U, V&gt;&amp; p)</tt>"
+-will never be instantiated to copy <tt>pair&lt;T1, T2&gt;</tt> to <tt>pair&lt;T1, T2&gt;</tt>.)<br>
++should be copy assignable, and was in C++98&#47;03. (Again,
++12.8 [class.copy]&#47;7 explains that "<tt>operator=(const pair&lt;U, V&gt;&amp; p)</tt>"
++will never be instantiated to copy <tt>pair&lt;T1, T2&gt;</tt> to <tt>pair&lt;T1, T2&gt;</tt>.)<br/>
+ Additionally, "<tt>pair&amp; operator=(pair&amp;&amp; p);</tt>" is
+-unconditionally defined, whereas according to 12.8 [class.copy]/25,
+-defaulted copy/move assignment operators are defined as
++unconditionally defined, whereas according to 12.8 [class.copy]&#47;25,
++defaulted copy&#47;move assignment operators are defined as
+ deleted in several situations, such as when non-static data
+ members of reference type are present.
+-<p>
++<p/>
+ If "<tt>pair(const pair&amp;) = default;</tt>" and "<tt>pair&amp; operator=(pair&amp;&amp; p);</tt>"
+-were removed from <tt>pair</tt>'s class definition in 20.3.5.2 [pairs.pair] and from
+-20.3.5.2 [pairs.pair]/12-13, <tt>pair</tt> would
+-receive implicitly-declared copy/move constructors and
+-copy/move assignment operators, and 12.8 [class.copy]/25 would
+-apply. The implicitly-declared copy/move constructors
+-would be trivial when <tt>T1</tt> and <tt>T2</tt> have trivial copy/move
+-constructors, according to 12.8 [class.copy]/13, and similarly for the
+-assignment operators, according to12.8 [class.copy]/27. Notes could
++were removed from <tt>pair</tt>'s class definition in 20.3.2 [pairs.pair] and from
++20.3.2 [pairs.pair]&#47;12-13, <tt>pair</tt> would
++receive implicitly-declared copy&#47;move constructors and
++copy&#47;move assignment operators, and 12.8 [class.copy]&#47;25 would
++apply. The implicitly-declared copy&#47;move constructors
++would be trivial when <tt>T1</tt> and <tt>T2</tt> have trivial copy&#47;move
++constructors, according to 12.8 [class.copy]&#47;13, and similarly for the
++assignment operators, according to12.8 [class.copy]&#47;27. Notes could
+ be added as a reminder that these functions would be
+ implicitly-declared, but such notes would not be necessary
+ (the Standard Library specification already assumes a
+ high level of familiarity with the Core Language, and
+ casual readers will simply assume that <tt>pair</tt> is copyable
+ and movable).
+-</p><p>
++<p/>
+ Alternatively, <tt>pair</tt> could be given explicitly-defaulted
+-copy/move constructors and copy/move assignment
++copy&#47;move constructors and copy&#47;move assignment
+ operators. This is a matter of style.
+-</p><p>
++<p/>
+ <tt>tuple</tt> is also affected. <tt>tuple</tt>'s class definition in 20.4 [tuple] contains:
+-</p><pre>tuple(const tuple&amp;) = default;
++</p>
++<pre>
++tuple(const tuple&amp;) = default;
+ tuple(tuple&amp;&amp;);
+ tuple&amp; operator=(const tuple&amp;);
+ tuple&amp; operator=(tuple&amp;&amp;);
+ </pre>
++<p>
+ They should all be removed or all be explicitly-defaulted,
+-to be consistent with <tt>pair</tt>. Additionally, 20.4.2.1 [tuple.cnstr]/8-9 specifies the
++to be consistent with <tt>pair</tt>. Additionally, 20.4.2.1 [tuple.cnstr]&#47;8-9 specifies the
+ behavior of an explicitly defaulted function, which is currently inconsistent with
+ <tt>pair</tt>.
+-
++</p>
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Either remove "<tt>pair(const pair&amp;) = default;</tt>" and
+ "<tt>pair&amp; operator=(pair&amp;&amp; p);</tt>" from <tt>pair</tt>'s class
+-definition in 20.3.5.2 [pairs.pair] and from 20.3.5.2 [pairs.pair] p.12-13, or
+-give pair explicitly-defaulted copy/move constructors and copy/move assignment operators.<br>
++definition in 20.3.2 [pairs.pair] and from 20.3.2 [pairs.pair] p.12-13, or
++give pair explicitly-defaulted copy&#47;move constructors and copy&#47;move assignment operators.<BR/>
+ Change <tt>tuple</tt> to match.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a> would solve this issue:
+-The move/copy constructor will be defaulted, but the corresponding assignment operators need a non-default implementation
++The move&#47;copy constructor will be defaulted, but the corresponding assignment operators need a non-default implementation
+ because they are supposed to work for references as well.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1384"></a>1384. [FCD] Ballot Comment US-98</h3>
+-<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1384"></a>1384. Function <tt>pack_arguments</tt> is poorly named</h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-98</b></p>
+ <p>
+-pack_arguments is poorly named. It does not reflect the
++<tt>pack_arguments</tt> is poorly named. It does not reflect the
+ fact that it is a tuple creation function and that it forwards
+ arguments.
+ </p>
+@@ -79877,24 +90959,202 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
++<p><b>Proposed resolution:</b></p><p>
++Rename <tt>pack_arguments</tt> to <tt>forward_as_tuple</tt> throughout the standard.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1385"></a>1385. <tt>tuple_cat</tt> should be a single variadic signature</h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-88</b></p>
++<p>
++The <tt>tuple_cat</tt> template consists of four overloads and that
++can concatenate only two <tt>tuple</tt>s. A single variadic
++signature that can concatenate an arbitrary number of
++<tt>tuple</tt>s would be preferred.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++
++<blockquote><p>
++Adopt a simplified form of the proposal in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2975.pdf">n2975</a>,
++restricted to <tt>tuple</tt>s and neither requiring nor outlawing support for other <tt>tuple</tt>-like types.
++</p></blockquote>
++
++<p><i>[
++2010 Rapperswil: Alisdair to provide wording.
++]</i></p>
++
++
++<p><i>[
++2010-11-06: Daniel comments and proposes some alternative wording:
++]</i></p>
++
++
++<p>
++There are some problems in the wording: First, even though the result type <tt>tuple&lt;<i>see below</i>&gt;</tt>
++implies it, the specification of the contained tuple element types is missing. Second, the term &quot;<tt>tuple</tt>
++protocol&quot; is not defined anywhere and I see no reason why this normative wording should not be a non-normative
++note. We could at least give a better approximation, maybe "tuple-like protocol" as indicated from header
++<tt>&lt;utility&gt;</tt> synopsis. Further, it seems to me that the effects need to contain a combination of <tt>std::forward</tt>
++with the call of <tt>get</tt>. Finally I suggest to replace the requirements <tt>Move/CopyConstructible</tt>
++by proper usage of <tt>is_constructible</tt>, as indicated by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3140.html">n3140</a>.
++</p>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++Moved to Ready with Daniel's improved wording.
++</p>
++
++
+ <p><b>Proposed resolution:</b></p>
+-Rename pack_arguments to forward_as_tuple
+-throughout the standard.
++<p>Note: This alternate proposed resolution works only if <a href="lwg-defects.html#1191">1191</a> has been accepted.</p>
++
++<ol>
++<li>Change 20.4.1 [tuple.general] p. 2, header <tt>&lt;tuple&gt;</tt> synopsis, as indicated:
++<blockquote><pre>
++namespace std {
++
++...
++
++// <i>20.4.2.4, tuple creation functions:</i>
++const unspecified ignore;
++
++template &lt;class... Types&gt;
++ tuple&lt;<i>VTypes</i>...&gt; make_tuple(Types&amp;&amp;...);
++ template &lt;class... Types&gt;
++ tuple&lt;<i>ATypes</i>...&gt; forward_as_tuple(Types&amp;&amp;...);
++
++template&lt;class... Types&gt;
++ tuple&lt;Types&amp;...&gt; tie(Types&amp;...);
++
++<del>template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
++template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, const tuple&lt;UTypes...&gt;&amp;);
++template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;);
++template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp;, tuple&lt;UTypes...&gt;&amp;&amp;);</del>
++<ins>template &lt;class... Tuples&gt;
++ tuple&lt;<i>CTypes</i>...&gt; tuple_cat(Tuples&amp;&amp;...);</ins>
++
++...
++
++</pre></blockquote>
++</li>
++<li>Change 20.4.2.4 [tuple.creation] as indicated:
++<blockquote>
++<pre><del>template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</del></pre>
++<blockquote><p><del>
++8 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35). All the types in
++<tt>UTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35).
++</del></p></blockquote>
++<blockquote><p><del>
++9 <i>Returns</i>: A <tt>tuple</tt> object constructed by copy constructing its first <tt>sizeof...(TTypes)</tt> elements
++from the corresponding elements of <tt>t</tt> and copy constructing its last <tt>sizeof...(UTypes)</tt> elements from the
++corresponding elements of <tt>u</tt>.
++</del></p></blockquote>
++<pre><del>template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, const tuple&lt;UTypes...&gt;&amp; u);</del></pre>
++<blockquote><p><del>
++10 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34). All the types in
++<tt>UTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35).
++</del></p></blockquote>
++<blockquote><p><del>
++11 <i>Returns</i>: A <tt>tuple</tt> object constructed by move constructing its first <tt>sizeof...(TTypes)</tt> elements
++from the corresponding elements of <tt>t</tt> and copy constructing its last <tt>sizeof...(UTypes)</tt> elements from the
++corresponding elements of <tt>u</tt>.
++</del></p></blockquote>
++<pre><del>template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(const tuple&lt;TTypes...&gt;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);</del></pre>
++<blockquote><p><del>
++12 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>CopyConstructible</tt> (Table 35). All the types in
++<tt>UTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34).
++</del></p></blockquote>
++<blockquote><p><del>
++13 <i>Returns</i>: A <tt>tuple</tt> object constructed by copy constructing its first <tt>sizeof...(TTypes)</tt> elements
++from the corresponding elements of <tt>t</tt> and move constructing its last <tt>sizeof...(UTypes)</tt> elements from the
++corresponding elements of <tt>u</tt>.
++</del></p></blockquote>
++<pre><del>template &lt;class... TTypes, class... UTypes&gt;
++ tuple&lt;TTypes..., UTypes...&gt; tuple_cat(tuple&lt;TTypes...&gt;&amp;&amp; t, tuple&lt;UTypes...&gt;&amp;&amp; u);</del></pre>
++<blockquote><p><del>
++14 <i>Requires</i>: All the types in <tt>TTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34). All the types in
++<tt>UTypes</tt> shall be <tt>MoveConstructible</tt> (Table 34).
++</del></p></blockquote>
++<blockquote><p><del>
++15 <i>Returns</i>: A <tt>tuple</tt> object constructed by move constructing its first <tt>sizeof...(TTypes)</tt> elements
++from the corresponding elements of <tt>t</tt> and move constructing its last <tt>sizeof...(UTypes)</tt> elements from the
++corresponding elements of <tt>u</tt>.
++</del></p></blockquote>
++<pre><ins>template &lt;class... Tuples&gt;
++ tuple&lt;<i>CTypes</i>...&gt; tuple_cat(Tuples&amp;&amp;... tpls);
++</ins></pre>
++<blockquote><p><ins>
++8 Let <tt>Ti</tt> be the <tt><i>i</i></tt><sup>th</sup> type in <tt>Tuples</tt>, <tt>Ui</tt> be <tt>remove_reference&lt;Ti&gt;::type</tt>,
++and <tt>tp<sub><i>i</i></sub></tt> be the <tt><i>i</i></tt><sup>th</sup> parameter in the function parameter pack <tt>tpls</tt>, where all
++indexing is zero-based in the following paragraphs of this sub-clause [tuple.creation].
++</ins></p></blockquote>
++<blockquote><p><ins>
++9 <i>Requires</i>: For all <tt><i>i</i></tt>, <tt>Ui</tt> shall be the type <i>cv<sub><tt>i</tt></sub>&nbsp;</i><tt>tuple&lt;Args<sub><i>i</i></sub>...&gt;</tt>,
++where <i>cv<sub><tt>i</tt></sub></i> is the (possibly empty) <tt><i>i</i></tt><sup>th</sup> <i>cv</i>-qualifier-seq, and
++<tt>Args<sub><i>i</i></sub></tt> is the parameter pack representing the element types in <tt>Ui</tt>. Let <tt>Aik</tt> be the
++<tt><i>k<sub>i</sub></i></tt><sup>th</sup> type in <tt>Args<sub><i>i</i></sub></tt>, then for all <tt>Aik</tt> the following
++requirements shall be satisfied: If <tt>Ti</tt> is deduced as an lvalue reference type, then
++<tt>is_constructible&lt;Aik, <i>cv<sub>i</sub>&nbsp;</i>Aik&amp;&gt;::value == true</tt>, otherwise
++<tt>is_constructible&lt;Aik, <i>cv<sub>i</sub>&nbsp;</i>Aik&amp;&amp;&gt;::value == true</tt>.
++</ins></p></blockquote>
++<blockquote><p><ins>
++10 <i>Remarks</i>: The types in <tt><i>CTypes</i></tt> shall be equal to the ordered sequence of the expanded types
++<tt>Args<sub>0</sub>..., Args<sub>1</sub>..., Args<sub><i>n</i>-1</sub>...</tt>, where <tt><i>n</i></tt> equals
++<tt>sizeof...(Tuples)</tt>. Let <tt><i>e<sub>i</sub></i>...</tt> be the <tt><i>i</i></tt><sup>th</sup> ordered
++sequence of tuple elements of the result <tt>tuple</tt> object corresponding to the type sequence
++<tt>Args<sub><i>i</i></sub></tt>.
++</ins></p></blockquote>
++<blockquote><p><ins>
++11 <i>Returns</i>: A <tt>tuple</tt> object constructed by initializing
++the <tt><i>k<sub>i</sub></i></tt><sup>th</sup> type element <tt>eik</tt> in <tt><i>e<sub>i</sub></i>...</tt>
++with <tt>get&lt;<i>k<sub>i</sub></i>&gt;(std::forward&lt;Ti&gt;(tp<sub>i</sub>))</tt>
++for each valid <tt><i>k<sub>i</sub></i></tt> and each element group <tt><i>e<sub>i</sub></i></tt> in order.
++</ins></p></blockquote>
++<blockquote><p><ins>
++12 [<i>Note</i>: An implementation may support additional types in the parameter pack <tt>Tuples</tt>, such as
++<tt>pair</tt> and <tt>array</tt> that support the <tt>tuple</tt>-like protocol. &mdash; <i>end note</i>]
++</ins></p></blockquote>
++</blockquote>
++</li>
++</ol>
++
+
+
+
+
+
+ <hr>
+-<h3><a name="1386"></a>1386. FCD Ballot Comment US-99</h3>
+-<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1386"></a>1386. <tt>pack_arguments</tt> overly complex</h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-99</b></p>
+ <p>
+-pack_arguments is overly complex.
++<tt>pack_arguments</tt> is overly complex.
+ </p>
+
+ <p><i>[
+@@ -79904,35 +91164,34 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ This issue resulted from a lack of understanding of
+ how references are forwarded. The definition of
+-pack_arguments should be simply:<br>
+-template &lt;class... Types&gt;
++<tt>pack_arguments</tt> should be simply:<br/>
++<tt>template &lt;class... Types&gt;
+ tuple&lt;<del>A</del>Types<ins>&amp;&amp;</ins>&gt;
+-pack_arguments(Types&amp;&amp;...t);<br>
+-<del>Types:Let Ti be each type in Types....</del><br>
+-Effects: ...<br>
+-Returns:<br>
+-tuple&lt;<del>A</del>Types<ins>&amp;&amp;</ins>...&gt;(std::forward&lt;Types&gt;(t)...)<br>
+-The synopsis should also change to reflect this
+-simpler signature.
+-
++pack_arguments(Types&amp;&amp;...t);</tt><br/>
++<del>Types: Let <tt>Ti</tt> be each type in <tt>Types</tt>....</del><br/>
++<i>Effects</i>: ...<br/>
++<i>Returns</i>:<br/>
++<tt>tuple&lt;<del>A</del>Types<ins>&amp;&amp;</ins>...&gt;(std::forward&lt;Types&gt;(t)...)</tt><br/>
++The synopsis should also change to reflect this simpler signature.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1387"></a>1387. [FCD] Ballot Comment GB-87</h3>
+-<p><b>Section:</b> X [tuple.range] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1387"></a>1387. Range support by <tt>tuple</tt> should be removed</h3>
++<p><b>Section:</b> X [tuple.range] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-87</b></p>
+ <p>
+ There is no compelling reason to assume a
+ heterogeneous tuple of two elements holds a pair of
+-iterators forming a valid range. Unlike std::pair, there are
++iterators forming a valid range. Unlike <tt>std::pair</tt>, there are
+ no functions in the standard library using this as a return
+ type with a valid range, so there is even less reason to try
+ to adapt this type for the new for-loop syntax.
+@@ -79945,20 +91204,20 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Strike 20.4.2.10 and the matching declarations in
+ the header synopsis in 20.4.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1388"></a>1388. FCD Ballot Comment US-100</h3>
+-<p><b>Section:</b> 20.6.1 [ratio.ratio] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1388"></a>1388. LWG 1281 incorrectly accepted</h3>
++<p><b>Section:</b> 20.11.3 [ratio.ratio] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.ratio">issues</a> in [ratio.ratio].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-100</b></p>
+ <p>
+@@ -79966,8 +91225,8 @@ LWG 1281 was discussed in Pittsburgh, and the decision
+ there was to accept the typedef as proposed and move to
+ Review. Unfortunately the issue was accidentally applied
+ to the FCD, and incorrectly. The FCD version of the
+-typedef refers to ratio&lt;N, D&gt;, but the typedef is intended
+-to refer to ratio&lt;num, den&gt; which in general is not the
++typedef refers to <tt>ratio&lt;N, D&gt;</tt>, but the typedef is intended
++to refer to <tt>ratio&lt;num, den&gt;</tt> which in general is not the
+ same type.
+ </p>
+
+@@ -79978,21 +91237,20 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Accept the current proposed wording of LWG
+-1281 which adds:<br>
+-typedef ratio&lt;num, den&gt; type;
+-
++<p><b>Proposed resolution:</b></p><p>
++Accept the current proposed wording of LWG <a href="lwg-defects.html#1281">1281</a> which adds:<br/>
++<tt>typedef ratio&lt;num, den&gt; type;</tt>
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1389"></a>1389. [FCD] Compile-time rational arithmetic and overflow</h3>
+-<p><b>Section:</b> 20.6.2 [ratio.arithmetic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1389"></a>1389. Compile-time rational arithmetic and overflow</h3>
++<p><b>Section:</b> 20.11.4 [ratio.arithmetic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ratio.arithmetic">issues</a> in [ratio.arithmetic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-89</b></p>
+ <p>
+@@ -80004,7 +91262,7 @@ instantiation. For example
+ alias <tt>ratio&lt;2*LLONG_MAX, LLONG_MAX*2&gt;</tt>, which
+ overflows, so is ill-formed. However, this is trivially equal
+ to <tt>ratio&lt;1, 1&gt;</tt>. It also contradicts the opening statement of
+-20.6.2 [ratio.arithmetic] p. 1 "implementations may use other algorithms to
++20.11.4 [ratio.arithmetic] p. 1 "implementations may use other algorithms to
+ compute these values".
+ </p>
+
+@@ -80013,66 +91271,70 @@ compute these values".
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3131.html">n3131</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+-<p><i>[Batavia: Resoved by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3210.html">n3210</a>.]</i></p>
++<p><i>[Batavia: Resolved by accepting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3210.pdf">n3210</a>.]</i></p>
+
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change the wording in 20.6.2 [ratio.arithmetic] p. 2-5 as follows:
+-<p>
+-</p><blockquote><pre>template &lt;class R1, class R2&gt; using ratio_add = <em>see below</em>;
+-</pre><blockquote>
++<p>Change the wording in 20.11.4 [ratio.arithmetic] p. 2-5 as follows:</p>
++<blockquote><pre>
++template &lt;class R1, class R2&gt; using ratio_add = <em>see below</em>;
++</pre><blockquote><p>
+ 2 The type <tt>ratio_add&lt;R1, R2&gt;</tt> shall be a synonym for <del><tt>ratio&lt;T1, T2&gt;</tt></del>
+ <ins><tt>ratio&lt;U, V&gt;</tt> such that <tt>ratio&lt;U, V&gt;::num</tt> and <tt>ratio&lt;U, V&gt;::den</tt>
+ are the same as the corresponding members of <tt>ratio&lt;T1, T2&gt;</tt> would be in the absence of
+ arithmetic overflow</ins> where <tt>T1</tt> has the value <tt>R1::num * R2::den + R2::num * R1::den</tt>
+ and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>. <ins>If the required values of <tt>ratio&lt;U, V&gt;::num</tt>
+ and <tt>ratio&lt;U, V&gt;::den</tt> cannot be represented in <tt>intmax_t</tt> then the program is ill-formed.</ins>
+-</blockquote></blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; using ratio_subtract = <em>see below</em>;
+-</pre><blockquote>
++</p></blockquote></blockquote>
++<blockquote><pre>
++template &lt;class R1, class R2&gt; using ratio_subtract = <em>see below</em>;
++</pre><blockquote><p>
+ 3 The type <tt>ratio_subtract&lt;R1, R2&gt;</tt> shall be a synonym for <del><tt>ratio&lt;T1, T2&gt;</tt></del>
+ <ins><tt>ratio&lt;U, V&gt;</tt> such that <tt>ratio&lt;U, V&gt;::num</tt> and <tt>ratio&lt;U, V&gt;::den</tt>
+ are the same as the corresponding members of <tt>ratio&lt;T1, T2&gt;</tt> would be in the absence of
+ arithmetic overflow</ins> where <tt>T1</tt> has the value <tt>R1::num * R2::den - R2::num * R1::den</tt>
+ and <tt>T2</tt> has the value <tt>R1::den * R2::den</tt>. <ins>If the required values of <tt>ratio&lt;U, V&gt;::num</tt>
+ and <tt>ratio&lt;U, V&gt;::den</tt> cannot be represented in <tt>intmax_t</tt> then the program is ill-formed.</ins>
+-</blockquote></blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; using ratio_multiply = <em>see below</em>;
+-</pre><blockquote>
++</p></blockquote></blockquote>
++<blockquote><pre>
++template &lt;class R1, class R2&gt; using ratio_multiply = <em>see below</em>;
++</pre><blockquote><p>
+ 4 The type <tt>ratio_multiply&lt;R1, R2&gt;</tt> shall be a synonym for <del><tt>ratio&lt;T1, T2&gt;</tt></del>
+ <ins><tt>ratio&lt;U, V&gt;</tt> such that <tt>ratio&lt;U, V&gt;::num</tt> and <tt>ratio&lt;U, V&gt;::den</tt>
+ are the same as the corresponding members of <tt>ratio&lt;T1, T2&gt;</tt> would be in the absence of
+ arithmetic overflow</ins> where <tt>T1</tt> has the value <tt>R1::num * R2::num</tt> and <tt>T2</tt>
+ has the value <tt>R1::den * R2::den</tt>. <ins>If the required values of <tt>ratio&lt;U, V&gt;::num</tt>
+ and <tt>ratio&lt;U, V&gt;::den</tt> cannot be represented in <tt>intmax_t</tt> then the program is ill-formed.</ins>
+-</blockquote></blockquote>
+-<blockquote><pre>template &lt;class R1, class R2&gt; using ratio_divide = <em>see below</em>;
+-</pre><blockquote>
++</p></blockquote></blockquote>
++<blockquote><pre>
++template &lt;class R1, class R2&gt; using ratio_divide = <em>see below</em>;
++</pre><blockquote><p>
+ 5 The type <tt>ratio_divide&lt;R1, R2&gt;</tt> shall be a synonym for <del><tt>ratio&lt;T1, T2&gt;</tt></del>
+ <ins><tt>ratio&lt;U, V&gt;</tt> such that <tt>ratio&lt;U, V&gt;::num</tt> and <tt>ratio&lt;U, V&gt;::den</tt>
+ are the same as the corresponding members of <tt>ratio&lt;T1, T2&gt;</tt> would be in the absence of
+ arithmetic overflow</ins> where <tt>T1</tt> has the value <tt>R1::num * R2::den</tt> and <tt>T2</tt>
+ has the value <tt>R1::den * R2::num</tt>. <ins>If the required values of <tt>ratio&lt;U, V&gt;::num</tt>
+ and <tt>ratio&lt;U, V&gt;::den</tt> cannot be represented in <tt>intmax_t</tt> then the program is ill-formed.</ins>
+-</blockquote></blockquote>
++</p></blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1390"></a>1390. [FCD] Limit speculative compilation for constructible/convertible traits</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1390"></a>1390. Limit speculative compilation for constructible&#47;convertible traits</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-17</b></p>
+ <p>
+@@ -80086,25 +91348,26 @@ language (see 14.8.2 paragraph 8).
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1391"></a>1391. [FCD] constructible/convertible traits and access control</h3>
+-<p><b>Section:</b> 20.7 [meta] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta">issues</a> in [meta].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1391"></a>1391. constructible&#47;convertible traits and access control</h3>
++<p><b>Section:</b> 20.10 [meta] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta">active issues</a> in [meta].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta">issues</a> in [meta].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-18</b></p>
+ <p>
+@@ -80113,7 +91376,8 @@ Several type traits require compiler support, e.g.
+ Their current specification seems to imply, that the corresponding
+ test expressions should be well-formed, even in absense of access:
+ </p>
+-<pre>class X { X(int){} };
++<pre>
++class X { X(int){} };
+ constexpr bool test = std::is_constructible&lt;X, int&gt;::value;
+ </pre>
+ <p>
+@@ -80130,7 +91394,7 @@ Resolution proposed by ballot comment
+ <p>
+ Specify that <tt>std::is_constructible</tt> and
+ <tt>std::is_convertible</tt> will return <tt>true</tt> only for
+-public constructors/conversion functions.
++public constructors&#47;conversion functions.
+ </p>
+
+ <p><i>[
+@@ -80138,25 +91402,25 @@ public constructors/conversion functions.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1392"></a>1392. [FCD] <tt>result_of</tt> should support pointer-to-data-member</h3>
+-<p><b>Section:</b> 20.7.4 [meta.unary] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1392"></a>1392. <tt>result_of</tt> should support pointer-to-data-member</h3>
++<p><b>Section:</b> 20.10.4 [meta.unary] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-102</b></p>
+ <p>
+@@ -80180,25 +91444,26 @@ functions and pointers to data members.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3123.html">n3123</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3123.html">n3123</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1393"></a>1393. [FCD] Trivial traits imply noexcept</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1393"></a>1393. Trivial traits imply <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-92</b></p>
+ <p>
+@@ -80213,8 +91478,7 @@ Resolution proposed by ballot comment
+
+ <p>
+ For each of the <tt>has_nothrow_<i>something</i></tt> traits,
+-remove all references to the matching
+-<tt>has_trivial_<i>something</i></tt> traits.
++remove all references to the matching <tt>has_trivial_<i>something</i></tt> traits.
+ </p>
+
+ <p><i>[
+@@ -80222,36 +91486,38 @@ remove all references to the matching
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">n3142</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1394"></a>1394. [FCD] Ballot Comment DE-19</h3>
+-<p><b>Section:</b> 20.7.4.3 [meta.unary.prop] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1394"></a>1394. <tt>is_constructible</tt> reports false positives</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-19</b></p>
+ <p>
+-The fundamental trait is_constructible reports false
++The fundamental trait <tt>is_constructible</tt> reports false
+ positives, e.g.
+ </p>
+-<pre>is_constructible&lt;char*, void*&gt;::value
++<pre>
++is_constructible&lt;char*, void*&gt;::value
+ </pre>
+-evaluates to true, even though a corresponding variable
+-initialization would be ill-formed.
+-
++<p>
++evaluates to true, even though a corresponding variable initialization would be ill-formed.
++</p>
+ <p><i>[
+ Resolved in Rapperswil by paper N3047.
+ ]</i></p>
+@@ -80259,25 +91525,24 @@ Resolved in Rapperswil by paper N3047.
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Remove all false positives from the domain of
+-is_constructible.
+-
++<p><b>Proposed resolution:</b></p><p>
++Remove all false positives from the domain of <tt>is_constructible</tt>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1397"></a>1397. [FCD] Deprecate '98 binders</h3>
+-<p><b>Section:</b> 20.8 [function.objects] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#function.objects">issues</a> in [function.objects].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1397"></a>1397. Deprecate '98 binders</h3>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-95</b></p>
+ <p>
+ The adaptable function protocol supported by
+-<tt>unary_function</tt>/<tt>binary_function</tt> has been superceded by
++<tt>unary_function&#47;binary_function</tt> has been superceded by
+ lambda expressions and <tt>std::bind</tt>. Despite the name, the
+ protocol is not very adaptable as it requires intrusive
+ support in the adaptable types, rather than offering an
+@@ -80300,10 +91565,9 @@ Resolution proposed by ballot comment
+ <p>
+ Move clauses 20.8.3, 20.8.9, 20.8.11 and 20.8.12
+ to Annex D.
+-</p>
+-<p>
++<p/>
+ Remove the requirements to conditionally derive from
+-<tt>unary</tt>/<tt>binary_function</tt> from <tt>function</tt>,
++<tt>unary&#47;binary_function</tt> from <tt>function</tt>,
+ <tt>reference_wrapper</tt>, and the results of calling <tt>mem_fn</tt>
+ and <tt>bind</tt>.
+ </p>
+@@ -80313,25 +91577,26 @@ and <tt>bind</tt>.
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3145.html">n3145</a> would solve this issue.
+-</blockquote>
+-
++</p></blockquote>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.html">N3198</a>.
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3198.htm">N3198</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1399"></a>1399. [FCD] <tt>function</tt> does not need an <tt>explicit</tt> default constructor</h3>
+-<p><b>Section:</b> 20.8.14.2 [func.wrap.func] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1399"></a>1399. <tt>function</tt> does not need an <tt>explicit</tt> default constructor</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-3</b></p>
+ <p>
+@@ -80349,8 +91614,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Remove <tt>explicit</tt>.
+-<pre>namespace std {
++<p>Remove <tt>explicit</tt>.</p>
++<pre>
++namespace std {
+ template&lt;class&gt; class function;
+ // undefined
+ template&lt;class R, class... ArgTypes&gt;
+@@ -80371,10 +91637,10 @@ public:typedef R result_type;
+
+ <hr>
+ <h3><a name="1400"></a>1400. FCD <tt>function</tt> does not need an <tt>explicit</tt> default constructor</h3>
+-<p><b>Section:</b> 20.8.14.2.1 [func.wrap.func.con] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-4</b></p>
+ <p>
+@@ -80389,8 +91655,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Remove explicit.
+-<pre>function();
++<p>Remove <tt>explicit</tt>.</p>
++<pre>
++function();
+ template &lt;class A&gt;
+ function(allocator_arg_t, const A&amp; a);
+ </pre>
+@@ -80400,17 +91667,526 @@ function(allocator_arg_t, const A&amp; a);
+
+
+ <hr>
+-<h3><a name="1402"></a>1402. [FCD] <tt>nullptr</tt> constructors for smart pointers should be <tt>constexpr</tt></h3>
+-<p><b>Section:</b> 20.9 [memory] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#memory">issues</a> in [memory].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1401"></a>1401. Provide support for <tt>unique_ptr&lt;T&gt; == nullptr</tt></h3>
++<p><b>Section:</b> 20.7 [memory] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#memory">issues</a> in [memory].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-100</b></p>
++<p><b>Addresses GB-99</b></p>
++<p>
++One reason that the <tt>unique_ptr</tt> constructor taking a
++<tt>nullptr_t</tt> argument is not <tt>explicit</tt> is to allow conversion
++of <tt>nullptr</tt> to <tt>unique_ptr</tt> in contexts like equality
++comparison. Unfortunately <tt>operator==</tt> for <tt>unique_ptr</tt> is a
++little more clever than that, deducing template parameters for both
++arguments. This means that <tt>nullptr</tt> does not get deduced
++as <tt>unique_ptr</tt> type, and there are no other comparison
++functions to match.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Add the following signatures to 20.7 [memory] p.1, <tt>&lt;memory&gt;</tt>
++header synopsis:
++</p><blockquote><pre>
++template&lt;typename T, typename D&gt;
++bool operator==(const unique_ptr&lt;T, D&gt; &amp; lhs, nullptr_t);
++template&lt;typename T, typename D&gt;
++bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt; &amp; rhs);
++template&lt;typename T, typename D&gt;
++bool operator!=(const unique_ptr&lt;T, D&gt; &amp; lhs, nullptr_t);
++template&lt;typename T, typename D&gt;
++bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt; &amp; rhs);
++</pre></blockquote>
++</blockquote>
++
++<p><i>[
++2010-11-02 Daniel comments and provides a proposed resolution:
++]</i></p>
++
++
++<blockquote><p>
++The same problem applies to <tt>shared_ptr</tt> as well: In both cases there are no
++conversions considered because the comparison functions are templates. I agree with
++the direction of the proposed resolution, but I believe it would be very surprising
++and inconsistent, if given a smart pointer object <tt>p</tt>, the expression
++<tt>p == nullptr</tt> would be provided, but not <tt>p &lt; nullptr</tt> and the
++other relational operators. According to 5.9 [expr.rel] they are defined
++if null pointer values meet other pointer values, even though the result is unspecified
++for all except some trivial ones. But null pointer values are nothing special here:
++The Library already defines the relational operators for both <tt>unique_ptr</tt> and
++<tt>shared_ptr</tt> and the outcome of comparing non-null pointer values will be equally
++unspecified. If the idea of supporting <tt>nullptr_t</tt> arguments for relational
++operators is not what the committee prefers, I suggest at least to consider to remove
++the existing relational operators for both <tt>unique_ptr</tt> and <tt>shared_ptr</tt>
++for consistency. But that would not be my preferred resolution of this issue.
++<p/>
++The number of overloads triple the current number, but I think it is much clearer to
++provide them explicitly instead of adding wording that attempts to say that "sufficient overloads" are
++provided. The following proposal makes the declarations explicit.
++<p/>
++Additionally, the proposal adds the missing declarations for some <tt>shared_ptr</tt>
++comparison functions for consistency.
++</p></blockquote>
++
++<p><i>[
++2010-11-03 Daniel adds:
++]</i></p>
++
++
++<p>
++Issue <a href="lwg-defects.html#1297">1297</a> is remotely related. The following proposed resolution splits
++<a href="#1401_extra_bullet">this bullet</a> into sub-bullets A and B. Sub-bullet A would
++also solve <a href="lwg-defects.html#1297">1297</a>, but sub-bullet B would not.
++<p/>
++A further remark in regard to the proposed semantics of the ordering of <tt>nullptr</tt>
++against other pointer(-like) values: One might think that the following definition might
++be superior because of simplicity:
++</p>
++<blockquote><pre>
++template&lt;class T&gt;
++bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t);
++template&lt;class T&gt;
++bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a);
++</pre><blockquote><p>
++<i>Returns</i>: <tt>false</tt>.
++</p></blockquote></blockquote>
++<p>
++The underlying idea behind this approach is the assumption that nullptr corresponds
++to the least ordinal pointer value. But this assertion does not hold for all supported
++architectures, therefore this approach was not followed because it would lead to
++the inconsistency, that the following assertion could fire:
++</p>
++<blockquote><pre>
++shared_ptr&lt;int&gt; p(new int);
++shared_ptr&lt;int&gt; null;
++bool v1 = p &lt; nullptr;
++bool v2 = p &lt; null;
++assert(v1 == v2);
++</pre></blockquote>
++
++<p><i>[2011-03-06: Daniel comments]</i></p>
++
++
++<p>The current issue state is not acceptable, because the Batavia meeting
++did not give advice whether choice A or B of bullet 3 should be applied.
++Option B will now be removed and if this resolution is accepted, issue
++<a href="lwg-defects.html#1297">1297</a> should be declared as resolved by <a href="lwg-defects.html#1401">1401</a>.
++This update also resyncs the wording with N3242.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Wording changes are against N3242.
++</p>
++<ol>
++<li>Change 20.7.2 [memory.syn] p. 1, header <tt>&lt;memory&gt;</tt> synopsis as indicated.
++<tt>noexcept</tt> specifications are only added, where the guarantee exists, that the function
++shall no throw an exception (as replacement of &quot;<i>Throws</i>: Nothing&quot;. Note that
++the <tt>noexcept</tt> additions to the <tt>shared_ptr</tt> comparisons are editorial, because
++they are already part of the accepted paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3195.htm">n3195</a>:
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ // <i>[unique.ptr] Class unique_ptr:</i>
++ template &lt;class T&gt; class default_delete;
++ template &lt;class T&gt; class default_delete&lt;T[]&gt;;
++ template &lt;class T, class D = default_delete&lt;T&gt;&gt; class unique_ptr;
++ template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;
++
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++
++ // <i>[util.smartptr.weakptr], Class bad_weak_ptr:</i>
++ class bad_weak_ptr;
++
++ // <i>[util.smartptr.shared], Class template shared_ptr:</i>
++ template&lt;class T&gt; class shared_ptr;
++
++ // <i>[util.smartptr.shared.cmp], shared_ptr comparisons:</i>
++ template&lt;class T, class U&gt;
++ bool operator==(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++ template&lt;class T, class U&gt;
++ bool operator!=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++ template&lt;class T, class U&gt;
++ bool operator&lt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++ template&lt;class T, class U&gt;
++ bool operator&gt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++ template&lt;class T, class U&gt;
++ bool operator&lt;=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++ template&lt;class T, class U&gt;
++ bool operator&gt;=(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) <ins> noexcept</ins>;
++
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator==(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator==(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator!=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator!=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;=(shared_ptr&lt;T&gt; const&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;=(nullptr_t, shared_ptr&lt;T&gt; const&amp; a) noexcept;</ins>
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++<li>Change the synopsis just after 20.8.1 [unique.ptr] p. 6 as indicated:
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++ template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++ <ins>template &lt;class T, class D&gt;</ins>
++ <ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++
++}
++</pre></blockquote>
++</li>
++<li><a name="1401_extra_bullet">This bullet does now only suggest the first approach:</a>
++<p>Change 20.8.1.5 [unique.ptr.special] p. 4-7 as indicated and add a series of prototype
++descriptions:</p>
++<blockquote><pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote>
++<p>
++<ins>? <i>Requires:</i> Let <tt>CT</tt> be <tt>common_type&lt;unique_ptr&lt;T1,
++D1&gt;::pointer, unique_ptr&lt;T2, D2&gt;::pointer&gt;::type</tt>. Then
++the specialization <tt>less&lt;CT&gt;</tt> shall be a function object type ([function.objects])
++that induces a strict weak ordering ([alg.sorting]) on the pointer values.</ins>
++</p>
++
++<p>
++4 <i>Returns:</i> <tt><ins>less&lt;CT&gt;()(x.get(), y.get())</ins><del>x.get()
++&lt; y.get()</del></tt>.
++</p>
++
++<p>
++<ins>? <i>Remarks:</i> If <tt>unique_ptr&lt;T1, D1&gt;::pointer</tt> is not
++implicitly convertible to <tt>CT</tt> or <tt>unique_ptr&lt;T2,
++D2&gt;::pointer</tt> is not implicitly convertible to <tt>CT</tt>, the program
++is ill-formed.</ins>
++</p>
++</blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++5 <i>Returns:</i> <tt><ins>!(y &lt; x)</ins><del>x.get() &lt;= y.get()</del></tt>.
++</p></blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++6 <i>Returns:</i> <tt><ins>(y &lt; x)</ins><del>x.get() &gt; y.get()</del></tt>.
++</p></blockquote>
++
++<pre>
++template &lt;class T1, class D1, class T2, class D2&gt;
++ bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
++</pre>
++
++<blockquote><p>
++7 <i>Returns:</i> <tt><ins>!(x &lt; y)</ins><del>x.get() &gt;= y.get()</del></tt>.
++</p></blockquote>
++</blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!x</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>(bool) x</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++</pre>
++<blockquote><p>
++<ins>? <i>Requires:</i> The specialization <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;</tt>
++shall be a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting])
++on the pointer values.</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>? <i>Returns</i>: <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;()(x.get(), nullptr)</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++</pre>
++<blockquote><p>
++<ins>? <i>Requires:</i> The specialization <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;</tt>
++shall be a function object type ([function.objects]) that induces a strict weak ordering ([alg.sorting])
++on the pointer values.</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>? <i>Returns</i>: <tt>less&lt;unique_ptr&lt;T, D&gt;::pointer&gt;()(nullptr, x.get())</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!(nullptr &lt; x)</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x);</ins>
++<ins>template &lt;class T, class D&gt;</ins>
++<ins>bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!(x &lt; nullptr)</tt>.</ins>
++</p></blockquote></blockquote>
++
++
++</li>
++<li><p>Change 20.8.2.2 [util.smartptr.shared] p. 1, class template <tt>shared_ptr</tt>
++synopsis as indicated. For consistency reasons the remaining normal relation
++operators are added as well:
++</p>
++<blockquote><pre>
++namespace std {
++
++ [&hellip;]
++
++ // <i>[util.smartptr.shared.cmp], shared_ptr comparisons:</i>
++ template&lt;class T, class U&gt;
++ bool operator==(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
++ template&lt;class T, class U&gt;
++ bool operator!=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
++ template&lt;class T, class U&gt;
++ bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;
++ <ins>template&lt;class T, class U&gt;</ins>
++ <ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
++ <ins>template&lt;class T, class U&gt;</ins>
++ <ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
++ <ins>template&lt;class T, class U&gt;</ins>
++ <ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, const shared_ptr&lt;U&gt;&amp; b) noexcept;</ins>
++
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&lt;class T&gt;</ins>
++ <ins>bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++ <ins>template&gt;class T&gt;</ins>
++ <ins>bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++<li>Add the following series of prototype specifications at the very end of 20.8.2.2.7 [util.smartptr.shared.cmp].
++For mixed comparison the general &quot;generation&quot; rule of 20.2.1 [operators] p. 10 does not apply,
++therefore all of them are defined. Below wording takes advantage of the simplified definition of the
++<em>composite pointer type</em> if one partner is a null pointer constant:
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator==(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator==(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!a</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator!=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator!=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>(bool) a</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&lt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>less&lt;T*&gt;()(a.get(), nullptr)</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&gt;(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>less&lt;T*&gt;()(nullptr, a.get())</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&lt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&gt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!(nullptr &lt; a)</tt>.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&lt;=(nullptr_t, const shared_ptr&lt;T&gt;&amp; a) noexcept;</ins>
++<ins>template&lt;class T&gt;</ins>
++<ins>bool operator&gt;=(const shared_ptr&lt;T&gt;&amp; a, nullptr_t) noexcept;</ins>
++</pre><blockquote><p>
++<ins>? <i>Returns</i>: <tt>!(a &lt; nullptr)</tt>.</ins>
++</p></blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
+
++<hr>
++<h3><a name="1402"></a>1402. <tt>nullptr</tt> constructors for smart pointers should be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 20.7 [memory] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#memory">issues</a> in [memory].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-100</b></p>
++<p>
+ The <tt>unique_ptr</tt> and <tt>shared_ptr</tt> constructors taking
+ <tt>nullptr_t</tt> delegate to a <tt>constexpr</tt> constructor, and could be
+ <tt>constexpr</tt> themselves.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -80420,32 +92196,38 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-In the 20.9.10.2 [unique.ptr.single] synopsis add
+-"constexpr" to unique_ptr(nullptr_t).<br>
+-In the 20.9.10.3 [unique.ptr.runtime] synopsis add
+-"constexpr" to unique_ptr(nullptr_t).<br>
+-In the 20.9.11.2 [util.smartptr.shared] synopsis
+-add "constexpr" to shared_ptr(nullptr_t).
++<p>
++In the 20.8.1.2 [unique.ptr.single] synopsis add
++"constexpr" to <tt>unique_ptr(nullptr_t)</tt>.<br/>
++In the 20.8.1.3 [unique.ptr.runtime] synopsis add
++"constexpr" to <tt>unique_ptr(nullptr_t)</tt>.<br/>
++In the 20.8.2.2 [util.smartptr.shared] synopsis
++add "constexpr" to <tt>shared_ptr(nullptr_t)</tt>.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1403"></a>1403. [FCD] Inconsistent definitions for <tt>allocator_arg</tt></h3>
+-<p><b>Section:</b> 20.9.1 [allocator.tag] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1403"></a>1403. Inconsistent definitions for <tt>allocator_arg</tt></h3>
++<p><b>Section:</b> 20.7.6 [allocator.tag] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-85</b></p>
+ <p>
+ There are inconsistent definitions for <tt>allocator_arg</tt>.
+-In 20.9 [memory] paragraph 1,
++In 20.7 [memory] paragraph 1,
+ </p>
+-<pre>constexpr allocator_arg_t allocator_arg = allocator_arg_t();
++<pre>
++constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+ </pre>
++<p>
+ and in 20.9.1,
+-<pre>const allocator_arg_t allocator_arg = allocator_arg_t();
++</p>
++<pre>
++const allocator_arg_t allocator_arg = allocator_arg_t();
+ </pre>
+
+ <p><i>[
+@@ -80456,9 +92238,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change "const" to "constexpr" in 20.9.1 as
+-follows.
+-<pre>constexpr allocator_arg_t allocator_arg = allocator_arg_t();
++<p>Change "const" to "constexpr" in 20.9.1 as follows.</p>
++<pre>
++constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+ </pre>
+
+
+@@ -80466,10 +92248,10 @@ follows.
+
+
+ <hr>
+-<h3><a name="1404"></a>1404. [FCD] <tt>pointer_traits</tt> should have a <tt>size_type</tt> member</h3>
+-<p><b>Section:</b> 20.9.3 [pointer.traits] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1404"></a>1404. <tt>pointer_traits</tt> should have a <tt>size_type</tt> member</h3>
++<p><b>Section:</b> 20.7.3 [pointer.traits] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-106</b></p>
+ <p>
+@@ -80478,7 +92260,7 @@ follows.
+ <p>
+ Add <tt>typedef <i>see below</i> size_type;</tt> to the generic
+ <tt>pointer_traits</tt> template and <tt>typedef size_t
+-size_type;</tt> to <tt>pointer_traits&lt;T*&gt;</tt>. Use
++size_type;</tt> to <tt>pointer_traits&lt;T*></tt>. Use
+ <tt>pointer_traits::size_type</tt> and
+ <tt>pointer_traits::difference_type</tt> as the defaults for
+ <tt>allocator_traits::size_type</tt> and
+@@ -80505,14 +92287,14 @@ there is no obvious meaning for <tt>size_type</tt> in <tt>pointer_traits</tt>.
+ <p>
+ Alisdair suggested, however, that the natural relationship between
+ <tt>difference_type</tt> and <tt>size_type</tt> can be expressed simply by the
+-<tt>std::make_unsigned&lt;T&gt;</tt> metafunction. Using this metafunction,
++<tt>std::make_unsigned&lt;T></tt> metafunction. Using this metafunction,
+ we can easily define <tt>size_type</tt> for <tt>allocator_traits</tt> without
+ artificially adding <tt>size_type</tt> to <tt>pointer_traits</tt>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -80528,7 +92310,7 @@ In [allocator.requirements], Table 42, change two rows as follows:
+ </p>
+ <blockquote>
+ <table border="1">
+- <tbody><tr>
++ <tr>
+ <td><tt>X::size_type</tt></td>
+ <td>unsigned integral type</td>
+ <td>a type that can represent the size of the largest object in the
+@@ -80548,26 +92330,26 @@ In [allocator.requirements], Table 42, change two rows as follows:
+ <ins>pointer_traits&lt;X::pointer&gt;::difference_type</ins>
+ </tt></td>
+ </tr>
+-</tbody></table>
++</table>
+ </blockquote>
+ <p>
+-In [allocator.traits.types], Change the definition of difference_type and
+-size_type as follows:
++In [allocator.traits.types], Change the definition of <tt>difference_type</tt> and
++<tt>size_type</tt> as follows:
+ </p>
+-<blockquote>
++<blockquote><p>
+ <tt>typedef</tt> <i>see below</i> <tt>difference_type;</tt>
+- <blockquote>
++ </p><blockquote><p>
+ <i>Type:</i> <tt>Alloc::difference_type</tt> if such a type exists,
+ else <tt><del>ptrdiff_t</del>
+ <ins>pointer_traits&lt;pointer&gt;::difference_type</ins></tt>.
+- </blockquote>
+-
++ </p></blockquote>
++ <p>
+ <tt>typedef</tt> <i>see below</i> <tt>size_type;</tt>
+- <blockquote>
++ </p><blockquote><p>
+ <i>Type:</i> <tt>Alloc::size_type</tt> if such a type exists,
+ else <tt><del>size_t</del>
+ <ins>make_unsigned&lt;difference_type&gt;::type</ins></tt>.
+- </blockquote>
++ </p></blockquote>
+ </blockquote>
+
+
+@@ -80575,15 +92357,16 @@ size_type as follows:
+
+
+ <hr>
+-<h3><a name="1405"></a>1405. [FCD] Ballot Comment US-107</h3>
+-<p><b>Section:</b> 20.10 [allocator.adaptor] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#allocator.adaptor">issues</a> in [allocator.adaptor].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1405"></a>1405. Move <tt>scoped_allocator_adaptor</tt> into separate header</h3>
++<p><b>Section:</b> 20.13 [allocator.adaptor] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.adaptor">issues</a> in [allocator.adaptor].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-107</b></p>
+-
+-scoped_allocator_adaptor should have its own header.
++<p>
++<tt>scoped_allocator_adaptor</tt> should have its own header.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -80592,24 +92375,26 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ See Appendix 1 - Additional Details
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1407"></a>1407. [FCD] Synch <tt>shared_ptr</tt> constructors taking movable types</h3>
+-<p><b>Section:</b> 20.9.10.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1407"></a>1407. Synch <tt>shared_ptr</tt> constructors taking movable types</h3>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-108</b></p>
+
++<p>
+ <tt>shared_ptr</tt> should have the same policy for constructing
+ from <tt>auto_ptr</tt> as <tt>unique_ptr</tt>. Currently it does not.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by paper N3109.
+@@ -80619,20 +92404,57 @@ Resolved in Rapperswil by paper N3109.
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add “template &lt;class Y&gt; explicit
+-shared_ptr(auto_ptr&lt;Y&gt;&amp;); to
+-[util.smartptr.shared.const] (and to the synopsis).
++<p>
++Add
++</p><pre>
++template &lt;class Y&gt; explicit shared_ptr(auto_ptr&lt;Y&gt;&amp;);
++</pre><p>
++to [util.smartptr.shared.const] (and to the synopsis).
++</p>
++
++
++
++
++<hr>
++<h3><a name="1408"></a>1408. Allow recycling of pointers after <tt>undeclare_no_pointers</tt></h3>
++<p><b>Section:</b> 20.7.4 [util.dynamic.safety] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.dynamic.safety">issues</a> in [util.dynamic.safety].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-103</b></p>
++<p>
++The precondition to calling <tt>declare_no_pointers</tt> is that no
++bytes in the range "have been previously registered" with
++this call. As written, this precondition includes bytes in
++ranges, even after they have been explicitly unregistered
++with a later call to <tt>undeclare_no_pointers</tt>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Update 20.7.4 [util.dynamic.safety] p.9:
++</p>
++<blockquote><pre>
++void declare_no_pointers(char *p, size_t n);
++</pre><blockquote><p>
++<tt>9</tt> <em>Requires</em>: No bytes in the specified range <del>have been
++previously registered</del><ins>are currently registered</ins> with <tt>declare_no_pointers()</tt>.
++If the specified range is in an allocated object, then it must be entirely within a single allocated object.
++The object must be live until the corresponding <tt>undeclare_no_pointers()</tt> call. [..]
++</p></blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1409"></a>1409. [FCD] Specify whether <tt>monotonic_clock</tt> is a distinct type or a typedef</h3>
+-<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1409"></a>1409. Specify whether <tt>monotonic_clock</tt> is a distinct type or a typedef</h3>
++<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-111</b></p>
+ <p>
+@@ -80653,27 +92475,29 @@ Require that it be a distinct class type.
+ 2010-11-01 Daniel comments:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3128</a> addresses
+ this issue by replacing <tt>monotonic_clock</tt> with <tt>steady_clock</tt>, which is not a typedef.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>.
++<p>
++This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1410"></a>1410. [FCD] Add a feature-detect macro for <tt>monotonic_clock</tt></h3>
+-<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1411">1411</a></p>
++<h3><a name="1410"></a>1410. Add a feature-detect macro for <tt>monotonic_clock</tt></h3>
++<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1411">1411</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-107, DE-20</b></p>
+ <p>
+@@ -80708,27 +92532,27 @@ not present.
+ 2010-11-01 Daniel comments:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3128</a> addresses
+ this issue by replacing <tt>monotonic_clock</tt> with <tt>steady_clock</tt>, which is not conditionally supported,
+ so there is no need to detect it.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1412"></a>1412. [FCD] Make monotonic clocks mandatory</h3>
+-<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1412"></a>1412. Make monotonic clocks mandatory</h3>
++<p><b>Section:</b> X [time.clock.monotonic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.clock.monotonic">issues</a> in [time.clock.monotonic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses CH-21</b></p>
+ <p>
+@@ -80741,65 +92565,65 @@ facilities anyway.
+ 2010-11-01 Daniel comments:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3128</a> addresses
+ this issue by replacing <tt>monotonic_clock</tt> with <tt>steady_clock</tt>, which is mandatory.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11-13 Batavia meeting:
+ ]</i></p>
+
+ <p>
+-This is resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>.
++This is resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>.
+ The original resolution is preserved for reference:
+ </p>
+ <blockquote>
+ <p>Make monotonic clocks mandatory.</p>
+ <p>Strike X [time.clock.monotonic] p.2</p>
+-<blockquote>
++<blockquote><p>
+ <tt>2</tt> <del>The class <tt>monotonic_clock</tt> is conditionally supported.</del>
+-</blockquote>
++</p></blockquote>
+
+ <p>Change 30.2.4 [thread.req.timing] p.2 accordingly</p>
+-<blockquote>
++<blockquote><p>
+ The member functions whose names end in <tt>_for</tt> take an argument that
+ specifies a relative time. Implementations should use a monotonic clock to
+ measure time for these functions. <del>[ <em>Note</em>: Implementations are not
+ required to use a monotonic clock because such a clock may not be available.
+-— <em>end note</em> ]</del>
+-</blockquote>
++&mdash; <em>end note</em> ]</del>
++</p></blockquote>
+ </blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++This is resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1414"></a>1414. [FCD] Fixing remaining dead links to <tt>POS_T</tt> and <tt>OFF_T</tt></h3>
+-<p><b>Section:</b> 21.2.3.2 [char.traits.specializations.char16_t] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1444">1444</a></p>
++<h3><a name="1414"></a>1414. Fixing remaining dead links to <tt>POS_T</tt> and <tt>OFF_T</tt></h3>
++<p><b>Section:</b> 21.2.3.2 [char.traits.specializations.char16_t] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1444">1444</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-109, GB-123</b></p>
+
+ <p>
+ It is not clear what the specification means for
+-u16streampos, u32streampos or wstreampos when they
+-refer to the requirements for POS_T in 21.2.2, as there
++<tt>u16streampos</tt>, <tt>u32streampos</tt> or <tt>wstreampos</tt> when they
++refer to the requirements for <tt>POS_T</tt> in 21.2.2, as there
+ are no longer any such requirements. Similarly the annex
+-D.7 refers to the requirements of type POS_T in 27.3 that
++D.7 refers to the requirements of type <tt>POS_T</tt> in 27.3 that
+ no longer exist either.
+ </p>
+ <p>
+ Clarify the meaning of all cross-reference to the
+-removed type POS_T.
++removed type <tt>POS_T</tt>.
+ </p>
+
+
+@@ -80822,9 +92646,9 @@ Additionally the way of referencing was chosen to follow the style suggested by
+ <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3118.html#GB108">GB 108</a>.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with proposed wording after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -80839,28 +92663,28 @@ Adopted at 2010-11 Batavia
+ </p>
+
+ <ol>
+-<li>Change [char.traits.specializations.char16_t]/1 as indicated:
++<li><p>Change [char.traits.specializations.char16_t]p.1 as indicated:</p>
+ <blockquote><p>
+ 1 - The type <tt>u16streampos</tt> shall be an implementation-defined type that satisfies the requirements
+ for <del><tt>POS_T</tt> in 21.2.2</del><ins><tt>pos_type</tt> in [iostreams.limits.pos]</ins>.
+ </p></blockquote>
+ </li>
+-<li>Change [char.traits.specializations.char32_t]/1 as indicated:
++<li><p>Change [char.traits.specializations.char32_t]p.1 as indicated:</p>
+ <blockquote><p>
+ 1 - The type <tt>u32streampos</tt> shall be an implementation-defined type that satisfies the requirements
+ for <del><tt>POS_T</tt> in 21.2.2</del><ins><tt>pos_type</tt> in [iostreams.limits.pos]</ins>.
+ </p></blockquote>
+ </li>
+-<li>Change [char.traits.specializations.wchar.t]/2 as indicated:
++<li><p>Change [char.traits.specializations.wchar.t]p.2 as indicated:</p>
+ <blockquote><p>
+ 2 - The type <tt>wstreampos</tt> shall be an implementation-defined type that satisfies the requirements
+ for <del><tt>POS_T</tt> in 21.2.2</del><ins><tt>pos_type</tt> in [iostreams.limits.pos]</ins>.
+ </p></blockquote>
+ </li>
+-<li>Change [fpos.operations], Table 124 — Position type requirements as indicated:
+-<blockquote><p>
+-</p><table border="1">
+-<caption>Table 124 — Position type requirements</caption>
++<li><p>Change [fpos.operations], Table 124 &mdash; Position type requirements as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 124 &mdash; Position type requirements</caption>
+
+ <tbody>
+ <tr>
+@@ -80890,17 +92714,17 @@ for <del><tt>POS_T</tt> in 21.2.2</del><ins><tt>pos_type</tt> in [iostreams.limi
+ <td><tt>...</tt></td>
+ </tr>
+ <tr>
+-<td><tt>streamsize(o)</tt><br><tt>O(sz)</tt></td>
+-<td><tt>streamsize</tt><br><del><tt>OFF_T</tt></del><ins><tt>streamoff</tt></ins></td>
++<td><tt>streamsize(o)</tt><br/><tt>O(sz)</tt></td>
++<td><tt>streamsize</tt><br/><del><tt>OFF_T</tt></del><ins><tt>streamoff</tt></ins></td>
+ <td><tt>...</tt></td>
+ </tr>
+
+ </tbody></table>
+-<p></p></blockquote>
++</blockquote>
+ </li>
+-<li>Change [depr.ios.members]/1 as indicated:
+-<p>
+-</p><blockquote><pre>namespace std {
++<li><p>Change [depr.ios.members]p.1 as indicated:</p>
++<blockquote><pre>
++namespace std {
+ class ios_base {
+ public:
+ typedef T1 io_state;
+@@ -80912,9 +92736,8 @@ for <del><tt>POS_T</tt> in 21.2.2</del><ins><tt>pos_type</tt> in [iostreams.limi
+ };
+ }
+ </pre></blockquote>
+-<p></p>
+ </li>
+-<li>Change [depr.ios.members]/5+6 as indicated:
++<li><p>Change [depr.ios.members]p.5+6 as indicated:</p>
+ <blockquote><p>
+ 5 - The type <tt>streamoff</tt> is an implementation-defined type that satisfies the requirements
+ of <del>type <tt>OFF_T</tt> (27.5.1)</del><ins><tt>off_type</tt> in [iostreams.limits.pos]</ins>.
+@@ -80932,19 +92755,22 @@ of <del>type <tt>POS_T</tt> (27.3)</del><ins><tt>pos_type</tt> in [iostreams.lim
+
+
+ <hr>
+-<h3><a name="1416"></a>1416. [FCD] <tt>forward_list::erase_after</tt> should not be allowed to throw</h3>
+-<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-19</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1416"></a>1416. <tt>forward_list::erase_after</tt> should not be allowed to throw</h3>
++<p><b>Section:</b> 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements">active issues</a> in [container.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements">issues</a> in [container.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses DE-21</b></p>
+
+-23.2.1/11 provides a general no-throw guarantee for
++<p>
++23.2.1&#47;11 provides a general no-throw guarantee for
+ erase() container functions, exceptions from this are
+ explicitly mentioned for individual containers. Because of
+ its different name, forward_list's erase_after() function is
+ not ruled by this but should so.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -80964,15 +92790,16 @@ Add a "<i>Throws</i>: Nothing" clause to both
+
+
+ <hr>
+-<h3><a name="1417"></a>1417. [FCD] <tt>front</tt>/<tt>back</tt> on a zero-sized
+-<tt>array</tt> should be undefined</h3>
+-<p><b>Section:</b> 23.3.1.7 [array.zero] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-26</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1417"></a>1417. <tt>front&#47;back</tt> on a zero-sized <tt>array</tt> should be undefined</h3>
++<p><b>Section:</b> 23.3.2.8 [array.zero] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#array.zero">issues</a> in [array.zero].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-112</b></p>
++
+ <p>
+-Should the effect of calling <tt>front</tt>/<tt>back</tt> on a zero-sized
++Should the effect of calling <tt>front&#47;back</tt> on a zero-sized
+ <tt>array</tt> really be implementation defined i.e. require the
+ implementor to define behaviour?
+ </p>
+@@ -80984,25 +92811,173 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Change "implementation defined" to "undefined"
++</p>
++
++
++
++
++<hr>
++<h3><a name="1418"></a>1418. Effects of <tt>resize(size())</tt> on a <tt>deque</tt></h3>
++<p><b>Section:</b> 23.3.3.3 [deque.capacity] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.capacity">issues</a> in [deque.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-113</b></p>
++<p>
++There is no mention of what happens if <tt>sz==size()</tt>. While
++it obviously does nothing I feel a standard needs to say
++this explicitely.
++</p>
++
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++Accepted with a simplified resolution turning one of the <tt>&lt;</tt>
++comparisons into <tt>&lt;=.</tt>
++</p>
++
++<p><b>Proposed resolution:</b></p>
++<p>Ammend [deque.capacity]</p>
++<p><tt>void resize(size_type sz);</tt></p>
++<p>
++<i>Effects</i>: If <tt>sz &lt;<ins>=</ins> size()</tt>, equivalent to <tt>erase(begin() +
++sz, end());</tt>. If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> <del>default
++constructed</del><ins>value initialized</ins> elements to the sequence.
++</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1423"></a>1423. [FCD] Ballot Comment JP-6</h3>
+-<p><b>Section:</b> 23.6.1 [map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#map">issues</a> in [map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1420"></a>1420. Effects of <tt>resize(size())</tt> on a <tt>list</tt></h3>
++<p><b>Section:</b> 23.3.5.3 [list.capacity] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.capacity">issues</a> in [list.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-115</b></p>
++<p>
++There is no mention of what happens if <tt>sz==size()</tt>. While
++it obviously does nothing I feel a standard needs to say
++this explicitely.
++</p>
++
++<p><i>[
++Resolution proposed in ballot comment
++]</i></p>
++
++<p>
++Express the semantics as pseudo-code similarly
++to the way it is done for the copying overload that
++follows (in p3). Include an else clause that does
++nothing and covers the <tt>sz==size()</tt> case.
++</p>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++<p>
++Accepted with a simplified resolution turning one of the <tt>&lt;</tt>
++comparisons into <tt>&lt;=.</tt>
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Ammend [list.capacity] p1:
++</p>
++<blockquote>
++<p><tt>void resize(size_type sz);</tt></p>
++<blockquote><p>
++<i>Effects</i>: If <tt>sz &lt;<ins>=</ins> size()</tt>, equivalent to <tt>list&lt;T&gt;::iterator
++it = begin(); advance(it, sz); erase(it, end());</tt>. If
++<tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> <del>default constructed</del>
++<ins>value initialized</ins> elements to the sequence<del></del>.
++</p></blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1421"></a>1421. Accidental move-only library types due to new core language rules</h3>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> DIN <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1350">1350</a></p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses DE-22, CH-15</b></p>
++<p>
++With the final acceptance of move operations as special
++members and introduction of corresponding suppression
++rules of implicitly generated copy operations the some
++library types that were copyable in C++03 are no longer
++copyable (only movable) in C++03, among them <tt>queue</tt>,
++<tt>priority_queue</tt>, and <tt>stack</tt>.
++</p>
++
++<p><i>[
++2010-10-26: Daniel comments:
++]</i></p>
++
++
++<p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3112.pdf">n3112</a> should fix this.
++</p>
++
++<p><i>[2011-02-17: Lawrence comments:]</i></p>
++
++
++<p>
++The only open issue in CH 15 with respect to the concurrency group
++was the treatment of <tt>atomic_future</tt>. Since we removed <tt>atomic_future</tt>
++in Batavia, I think all that remains is to remove the open issue from
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3112.pdf">N3112</a> and adopt it.
++</p>
++
++<p><i>[2011-03-23 Madrid meeting]</i></p>
++
++
++<p>Resolved by N3264</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3112.pdf">n3112</a>
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1423"></a>1423. <tt>map</tt> constructor accepting an allocator as single parameter should be explicit</h3>
++<p><b>Section:</b> 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map">issues</a> in [map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-6</b></p>
+
+-Constructor accepting an allocator as a single parameter
+-should be qualified as explicit.
+-<pre>namespace std {
++<p>
++Constructor accepting an allocator as a single parameter should be qualified as explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key, class T, class Compare =
+ less&lt;Key&gt;,
+ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
+@@ -81020,15 +92995,16 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key, class T, class Compare =
+ less&lt;Key&gt;,
+ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
+ class map {
+ public:
+ ...
+-explicit map(const Allocator&amp;);
++<ins>explicit</ins> map(const Allocator&amp;);
+ </pre>
+
+
+@@ -81036,13 +93012,17 @@ explicit map(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1424"></a>1424. [FCD] Ballot Comment JP-7</h3>
+-<p><b>Section:</b> 23.6.2 [multimap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1424"></a>1424. <tt>multimap</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.4.5 [multimap] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses JP-7</b></p>
++
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81052,15 +93032,16 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key, class T, class Compare =
+ less&lt;Key&gt;,
+ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
+ class multimap {
+ public:
+ ...
+-explicit multimap(const Allocator&amp;);
++<ins>explicit</ins> multimap(const Allocator&amp;);
+ </pre>
+
+
+@@ -81068,15 +93049,18 @@ explicit multimap(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1425"></a>1425. [FCD] Ballot Comment JP-8</h3>
+-<p><b>Section:</b> 23.6.3 [set] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#set">issues</a> in [set].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1425"></a>1425. <tt>set</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.4.6 [set] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#set">issues</a> in [set].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-8</b></p>
++
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81086,14 +93070,15 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key, class Compare = less&lt;Key&gt;,
+ class Allocator = allocator&lt;Key&gt; &gt;
+ class set {
+ public:
+ ...
+-explicit set(const Allocator&amp;);
++<ins>explicit</ins> set(const Allocator&amp;);
+ </pre>
+
+
+@@ -81101,15 +93086,17 @@ explicit set(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1426"></a>1426. [FCD] Ballot Comment JP-9</h3>
+-<p><b>Section:</b> 23.6.4 [multiset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1426"></a>1426. <tt>multiset</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.4.7 [multiset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-9</b></p>
+
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81119,14 +93106,15 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key, class Compare = less&lt;Key&gt;,
+ class Allocator = allocator&lt;Key&gt; &gt;
+ class multiset {
+ public:
+ ...
+-explicit multiset(const Allocator&amp;);
++<ins>explicit</ins> multiset(const Allocator&amp;);
+ </pre>
+
+
+@@ -81134,16 +93122,18 @@ explicit multiset(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1427"></a>1427. [FCD] Ballot Comment JP-10</h3>
+-<p><b>Section:</b> 23.7.1 [unord.map] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.map">issues</a> in [unord.map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1427"></a>1427. <tt>unordered_map</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.5.4 [unord.map] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.map">issues</a> in [unord.map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-10</b></p>
+
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81153,8 +93143,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key,
+ template &lt;class Key,
+ class T,
+@@ -81166,7 +93157,7 @@ class unordered_map
+ {
+ public:
+ ...
+-explicit unordered_map(const Allocator&amp;);
++<ins>explicit</ins> unordered_map(const Allocator&amp;);
+ </pre>
+
+
+@@ -81174,15 +93165,17 @@ explicit unordered_map(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1428"></a>1428. [FCD] Ballot Comment JP-11</h3>
+-<p><b>Section:</b> 23.7.2 [unord.multimap] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1428"></a>1428. <tt>unordered_multimap</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.5.5 [unord.multimap] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-11</b></p>
+
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81192,8 +93185,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key,
+ class T,
+ class Hash = hash&lt;Key&gt;,
+@@ -81204,7 +93198,7 @@ class unordered_multimap
+ {
+ public:
+ ...
+-explicit unordered_multimap(const Allocator&amp;);
++<ins>explicit</ins> unordered_multimap(const Allocator&amp;);
+ </pre>
+
+
+@@ -81212,15 +93206,17 @@ explicit unordered_multimap(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1429"></a>1429. [FCD] Ballot Comment JP-12</h3>
+-<p><b>Section:</b> 23.7.3 [unord.set] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1429"></a>1429. <tt>unordered_set</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.5.6 [unord.set] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-12</b></p>
+
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81230,8 +93226,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key,
+ class Hash = hash&lt;Key&gt;,
+ class Pred = std::equal_to&lt;Key&gt;,
+@@ -81240,7 +93237,7 @@ class unordered_set
+ {
+ public:
+ ...
+-explicit unordered_set(const Allocator&amp;);
++<ins>explicit</ins> unordered_set(const Allocator&amp;);
+ </pre>
+
+
+@@ -81248,15 +93245,17 @@ explicit unordered_set(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1430"></a>1430. [FCD] Ballot Comment JP-13</h3>
+-<p><b>Section:</b> 23.7.4 [unord.multiset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-10-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1430"></a>1430. <tt>unordered_multiset</tt> constructor accepting an allocator as a single parameter should be explicit</h3>
++<p><b>Section:</b> 23.5.7 [unord.multiset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Japan <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses JP-13</b></p>
+
++<p>
+ Constructor accepting an allocator as a single parameter
+ should be qualified as explicit.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81266,8 +93265,9 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-Add explicit.
+-<pre>namespace std {
++<p>Add explicit.</p>
++<pre>
++namespace std {
+ template &lt;class Key,
+ class Hash = hash&lt;Key&gt;,
+ class Pred = std::equal_to&lt;Key&gt;,
+@@ -81284,16 +93284,18 @@ explicit unordered_multiset(const Allocator&amp;);
+
+
+ <hr>
+-<h3><a name="1431"></a>1431. [FCD] Ballot Comment US-120</h3>
+-<p><b>Section:</b> 25.2.12 [alg.is_permutation] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1431"></a>1431. <tt>is_permutation</tt> must be more restrictive</h3>
++<p><b>Section:</b> 25.2.12 [alg.is_permutation] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-120</b></p>
+
+-is_permutation is underspecified for anything but the
++<p>
++<tt>is_permutation</tt> is underspecified for anything but the
+ simple case where both ranges have the same value type
+ and the comparison function is an equivalence relation.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81302,29 +93304,29 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Restrict is_permutation to the case where it is well
++<p><b>Proposed resolution:</b></p><p>
++Restrict <tt>is_permutation</tt> to the case where it is well
+ specified. See Appendix 1 - Additional Details
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1432"></a>1432. [FCD] random_shuffle signatures</h3>
+-<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1433">1433</a></p>
++<h3><a name="1432"></a>1432. <tt>random_shuffle</tt> signatures are inconsistent</h3>
++<p><b>Section:</b> 25.3.12 [alg.random.shuffle] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.random.shuffle">issues</a> in [alg.random.shuffle].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1433">1433</a></p>
+ <p><b>Discussion:</b></p>
+
+ <p><b>Addresses US-121, GB-119</b></p>
+
+ <p>
+ <tt>random_shuffle</tt> and <tt>shuffle</tt> should be consistent in how
+-they accept their source of randomness: either both by
+-rvalue reference or both by lvalue reference.
++they accept their source of randomness: either both by rvalue reference or
++both by lvalue reference.
+ </p>
+
+ <p><i>[
+@@ -81337,21 +93339,19 @@ The signatures of the <tt>shuffle</tt> and <tt>random_shuffle</tt> algorithms ar
+ in regard to the support of rvalues and lvalues of the provided generator:
+ </p>
+
+-<p>
+-</p><blockquote><pre>template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;
++<blockquote><pre>
++template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;
+ void random_shuffle(RandomAccessIterator first,
+ RandomAccessIterator last,
+ RandomNumberGenerator<b>&amp;&amp;</b> rand);
+ </pre></blockquote>
+-<p></p>
+
+-<p>
+-</p><blockquote><pre>template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
++<blockquote><pre>
++template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
+ void shuffle(RandomAccessIterator first,
+ RandomAccessIterator last,
+ UniformRandomNumberGenerator<b>&amp;</b> g);
+ </pre></blockquote>
+-<p></p>
+
+ <p>
+ The first form uses the perfect forwarding signature and that change compared to
+@@ -81364,8 +93364,7 @@ While it is true, that random generators are excellent examples of stateful
+ functors, there still exist good reasons to support rvalues as arguments:
+ </p>
+
+-<p>
+-</p><ol>
++<ol>
+ <li>If one of the shuffle algorithms is called with the intention to shuffle items with a reproducible ordering
+ from a given generator class, it makes sense to create a generator exactly at the call point.
+ </li>
+@@ -81377,25 +93376,26 @@ unintentionally. Any lvalue generator will deduce an lvalue-reference and behave
+ cases, where rvalues are provided, the argument will be accepted instead of being rejected.
+ </li>
+ </ol>
+-<p></p>
+
+ <p>
+ Arguments have been raised that accepting rvalues is error-prone or even fundamentally wrong. The author of this
+ proposal disagrees with that position for two additional reasons:
+ </p>
+
+-<p>
+-</p><ol>
++<ol>
+ <li>Enforcing lvalues as arguments won't prevent user code to enforce what they
+ want. So given
+-<blockquote><pre>my_generator get_generator(int size);
++<blockquote><pre>
++my_generator get_generator(int size);
+ </pre></blockquote>
+ instead of writing
+-<blockquote><pre>std::vector&lt;int&gt; v = ...;
++<blockquote><pre>
++std::vector&lt;int&gt; v = ...;
+ std::shuffle(v.begin(), v.end(), get_generator(v.size()));
+ </pre></blockquote>
+ they will just write
+-<blockquote><pre>std::vector&lt;int&gt; v = ...;
++<blockquote><pre>
++std::vector&lt;int&gt; v = ...;
+ auto gen = get_generator(v.size());
+ std::shuffle(v.begin(), v.end(), gen);
+ </pre></blockquote>
+@@ -81409,15 +93409,14 @@ Therefore preventing <tt>[random_]shuffle</tt> to accept rvalues is an unnecessa
+ user-error, if there would exist one.
+ </li>
+ </ol>
+-<p></p>
+
+ <p>
+ Thus this proposal recommends to make both <tt>shuffle</tt> functions consistent and perfectly forward-able.
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -81430,13 +93429,15 @@ Adopted at 2010-11 Batavia
+
+ <ol>
+ <li>Change [algorithms.general], header <tt>&lt;algorithm&gt;</tt> synopsis as indicated:
+-<blockquote><pre>template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
++<blockquote><pre>
++template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
+ void shuffle(RandomAccessIterator first, RandomAccessIterator last,
+ UniformRandomNumberGenerator&amp;<ins>&amp;</ins> rand);
+ </pre></blockquote>
+ </li>
+ <li>Change the prototype description of [alg.random.shuffle] as indicated:
+-<blockquote><pre>template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
++<blockquote><pre>
++template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
+ void shuffle(RandomAccessIterator first, RandomAccessIterator last,
+ UniformRandomNumberGenerator&amp;<ins>&amp;</ins> rand);
+ </pre></blockquote>
+@@ -81449,14 +93450,15 @@ UniformRandomNumberGenerator&amp;<ins>&amp;</ins> rand);
+
+
+ <hr>
+-<h3><a name="1435"></a>1435. [FCD] Unclear returns specifications for C99 complex number functions</h3>
+-<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1435"></a>1435. Unclear returns specifications for C99 complex number functions</h3>
++<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-120</b></p>
+
++<p>
+ The complex number functions added for compatibility
+ with the C99 standard library are defined purely as a
+ cross-reference, with no hint of what they should return.
+@@ -81468,6 +93470,7 @@ the name, this is not true of the cproj function, which
+ apparently returns the projection on the Reimann Sphere.
+ A single line description of each function, associated with
+ the cross-reference, will greatly improve clarity.
++</p>
+
+ <p><i>[2010-11-06 Beman provides proposed resolution wording.]</i></p>
+
+@@ -81567,14 +93570,15 @@ Adopted at 2010-11 Batavia
+
+
+ <hr>
+-<h3><a name="1436"></a>1436. [FCD] Random number engine constructor concerns</h3>
+-<p><b>Section:</b> 26.5.3 [rand.eng] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1436"></a>1436. Random number engine constructor concerns</h3>
++<p><b>Section:</b> 26.5.3 [rand.eng] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng">issues</a> in [rand.eng].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-121</b></p>
+
++<p>
+ All the random number engine types in this clause have a
+ constructor taking an unsigned integer type, and a
+ constructor template for seed sequences. This means that
+@@ -81587,6 +93591,7 @@ helpful if at least these anticipated cases produced a
+ defined behaviour, either an erroneous program with
+ diagnostic, or a conversion to unsigned int forwarding to
+ the appropriate constructor.
++</p>
+
+ <p><i>[
+ 2010-11-03 Daniel comments and provides a proposed resolution:
+@@ -81594,7 +93599,7 @@ the appropriate constructor.
+
+
+ <p>
+-I suggest to apply a similar solution as recently suggested for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1234">1234</a>.
++I suggest to apply a similar solution as recently suggested for <a href="lwg-defects.html#1234">1234</a>.
+ It is basically a requirement for an implementation to constrain the template.
+ </p>
+
+@@ -81622,36 +93627,42 @@ Adopted at 2010-11 Batavia
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>
+ Add the following paragraph at the end of 26.5.3 [rand.eng]:
++</p>
+ <blockquote>
+-<blockquote>
++<blockquote><p>
+ 5 Each template specified in this section [rand.eng] requires one or more relationships, involving the value(s) of
+ its non-type template parameter(s), to hold. A program instantiating any of these templates is ill-formed if
+ any such required relationship fails to hold.
+-</blockquote>
++</p></blockquote>
+
+-<blockquote>
++<blockquote><p>
+ <ins>? For every random number engine and for every random number engine adaptor <tt>X</tt> defined in this sub-clause
+-[rand.eng] and in sub-clause [rand.adapt]:</ins>
++[rand.eng] and in sub-clause [rand.adapt]:</ins></p>
+ <ul>
+ <li><ins>If the constructor</ins>
+-<blockquote><pre><ins>template&lt;class Sseq&gt; explicit X(Sseq&amp; q);</ins>
+-</pre></blockquote>
++<blockquote><pre>
++<ins>template&lt;class Sseq&gt; explicit X(Sseq&amp; q);</ins>
++</pre></blockquote><p>
+ <ins>is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this constructor
+ shall not participate in overload resolution.
+-</ins>
++</ins></p>
+ </li>
+ <li><ins>If the member function</ins>
+-<blockquote><pre><ins>template&lt;class Sseq&gt; void seed(Sseq&amp; q);</ins>
+-</pre></blockquote>
++<blockquote><pre>
++<ins>template&lt;class Sseq&gt; void seed(Sseq&amp; q);</ins>
++</pre></blockquote><p>
+ <ins>is called with a type <tt>Sseq</tt> that does not qualify as a seed sequence, then this function
+ shall not participate in overload resolution.
+-</ins>
++</ins></p>
+ </li>
+ </ul>
++<p>
+ <ins>The extent to which an implementation determines that a type cannot be a seed sequence is unspecified,
+ except that as a minimum a type shall not qualify as seed sequence, if it is implicitly convertible
+ to <tt>X::result_type</tt>.</ins>
++</p>
+ </blockquote>
+
+ </blockquote>
+@@ -81661,25 +93672,27 @@ to <tt>X::result_type</tt>.</ins>
+
+
+ <hr>
+-<h3><a name="1437"></a>1437. [FCD] Mersenne twister meaningless for word sizes less than two</h3>
+-<p><b>Section:</b> 26.5.3.2 [rand.eng.mers] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1437"></a>1437. Mersenne twister meaningless for word sizes less than two</h3>
++<p><b>Section:</b> 26.5.3.2 [rand.eng.mers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.eng.mers">issues</a> in [rand.eng.mers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-124</b></p>
+
++<p>
+ The Mersenne twister algorithm is meaningless for word
+ sizes less than two, as there are then insufficient bits
+-available to be “twisted”.
++available to be &#8220;twisted&#8221;.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
++<blockquote><p>
+ Insert the following among the relations that are required to hold: <tt>2u &lt; w</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Batavia: The working group concurred with the issue's Proposed Resolution
+@@ -81694,30 +93707,142 @@ Adopted at 2010-11 Batavia
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change 26.5.3.2 [rand.eng.mers] p. 4 as indicated:
+ <p>
+-</p><blockquote>
++Change 26.5.3.2 [rand.eng.mers] p. 4 as indicated:
++</p>
++<blockquote><p>
+ 4 The following relations shall hold: <tt>0 &lt; m</tt>, <tt>m &lt;= n</tt>, <ins><tt>2u &lt; w</tt>,</ins>
+ <tt>r &lt;= w</tt>, <tt>u &lt;= w</tt>, <tt>s &lt;= w</tt>, <tt>t &lt;= w</tt>,
+ <tt>l &lt;= w</tt>, <tt>w &lt;= numeric_limits&lt;UIntType&gt;::digits</tt>,
+ <tt>a &lt;= (1u&lt;&lt;w) - 1u</tt>, <tt>b &lt;= (1u&lt;&lt;w) - 1u</tt>,
+ <tt>c &lt;= (1u&lt;&lt;w) - 1u</tt>, <tt>d &lt;= (1u&lt;&lt;w) - 1u</tt>,
+ and <tt>f &lt;= (1u&lt;&lt;w) - 1u</tt>.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1438"></a>1438. No definition for <tt>base()</tt></h3>
++<p><b>Section:</b> 26.5.4.2 [rand.adapt.disc] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.adapt.disc">issues</a> in [rand.adapt.disc].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-126</b></p>
++
++<p>Each adaptor has a member function called <tt>base()</tt> which has no definition.</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Give it the obvious definition.
++</p></blockquote>
++
++<p><i>[
++2010-11-03 Daniel comments and provides a proposed resolution:
++]</i></p>
++
++
++<p>The following proposal adds <tt>noexcept</tt> specifiers to the declarations of
++the <tt>base()</tt> functions as replacement for a &quot;<i>Throws</i>: Nothing&quot; element.
++</p>
++
++<p><i>[
++2010 Batavia: The working group reviewed this issue, and recommended to add the following to the Proposed Resolution.
++]</i></p>
++
++<ul><li>
++Append to paragraph 1 of [rand.req.adapt] (or at the Editor's discretion insert as a new paragraph following that paragraph):
++The expression <tt>a.base()</tt> shall be valid and shall return a const reference to <tt>a</tt>'s base engine.
++</li>
++</ul>
++<p>
++After further review, the working group concurred with the Proposed Resolution.
++</p>
++
++
++<p><i>[Batavia: waiting for WEB to review wording]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++Add the following sentence to the end of 26.5.1.5 [rand.req.adapt]/1:
++<blockquote><p>
++A <i>random number engine adaptor</i> (commonly shortened to <i>adaptor</i>) <tt>a</tt> of type <tt>A</tt> is a
++random number engine that takes values produced by some other random number engine, and applies an algorithm to
++those values in order to deliver a sequence of values with different randomness properties. An engine <tt>b</tt>
++of type <tt>B</tt> adapted in this way is termed a <i>base engine</i> in this context.<ins> The expression
++<tt>a.base()</tt> shall be valid and shall return a const reference to <tt>a</tt>'s base engine.</ins>
++</p></blockquote>
++</li>
++<li>Change in [rand.adapt.disc]/3, class template <tt>discard_block_engine</tt> synopsis, the following declaration:
++<blockquote><pre>
++// <em>property functions</em>
++const Engine&amp; base() const <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++<li>Add the following new prototype description at the end of sub-clause 26.5.4.2 [rand.adapt.disc]:
++<blockquote>
++<pre><ins>const Engine&amp; base() const noexcept;</ins>
++</pre>
++<blockquote><p>
++<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
++</p></blockquote>
+ </blockquote>
++</li>
++<li>Change in [rand.adapt.ibits]/4, class template <tt>independent_bits_engine</tt> synopsis, the following declaration:
++<blockquote><pre>
++// <em>property functions</em>
++const Engine&amp; base() const <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++<li>Add the following new prototype description at the end of sub-clause 26.5.4.3 [rand.adapt.ibits]:
++<blockquote>
++<pre><ins>const Engine&amp; base() const noexcept;</ins>
++</pre>
++<blockquote><p>
++<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
++</p></blockquote>
++</blockquote>
++</li>
++<li>Change in 26.5.4.4 [rand.adapt.shuf]/3, class template <tt>shuffle_order_engine</tt> synopsis, the following declaration:
++<blockquote><pre>
++// <em>property functions</em>
++const Engine&amp; base() const <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++<li>Add the following new prototype description at the end of sub-clause 26.5.4.4 [rand.adapt.shuf]:
++<blockquote>
++<pre><ins>const Engine&amp; base() const noexcept;</ins>
++</pre>
++<blockquote><p>
++<ins>? <i>Returns</i>: <tt>e</tt>.</ins>
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1439"></a>1439. [FCD] Return from <tt>densities()</tt> functions?</h3>
+-<p><b>Section:</b> 26.5.8.5.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1439"></a>1439. Return from <tt>densities()</tt> functions?</h3>
++<p><b>Section:</b> 26.5.8.6.2 [rand.dist.samp.pconst] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.dist.samp.pconst">issues</a> in [rand.dist.samp.pconst].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-134</b></p>
+
++<p>
+ These two distributions have a member function called
+ <tt>densities()</tt> which returns a <tt>vector&lt;double&gt;</tt>. The
+ distribution is templated on <tt>RealType</tt>. The distribution
+@@ -81727,24 +93852,26 @@ a <tt>vector&lt;RealType&gt;</tt>. Why doesn't densities return
+ the computed densities property isn't being computed to
+ the precision the client desires. If <tt>RealType</tt> is <tt>float</tt>, the
+ densities vector is taking up twice as much space as the client desires.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+ <blockquote>
++<p>
+ Change the piecewise constant and linear
+ distributions to hold / return the densities in a
+ <tt>vector&lt;result_type&gt;</tt>.
+-<p>
+-If this is not done, at least correct 26.5.8.5.2 [rand.dist.samp.pconst] p. 13 which describes
++<p/>
++If this is not done, at least correct 26.5.8.6.2 [rand.dist.samp.pconst] p. 13 which describes
+ the return of densities as a <tt>vector&lt;result_type&gt;</tt>.
+ </p></blockquote>
+
+ <p><i>[
+ Batavia 2010: After reviewing this issue, the working group concurred with the first of the
+ suggestions proposed by the NB comment: "Change the piecewise constant and linear distributions
+-to hold / return the densities in a vector. "
++to hold&#47;return the densities in a vector. "
+ ]</i></p>
+
+
+@@ -81757,15 +93884,17 @@ Adopted at 2010-11 Batavia
+
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+-<li>Change 26.5.8.5.2 [rand.dist.samp.pconst] p. 2, class template <tt>piecewise_constant_distribution</tt> synopsis
+-and the prototype description 26.5.8.5.2 [rand.dist.samp.pconst] before p. 13 as indicated:
+-<blockquote><pre>vector&lt;<del>double</del><ins>result_type</ins>&gt; densities() const;
++<li>Change 26.5.8.6.2 [rand.dist.samp.pconst] p. 2, class template <tt>piecewise_constant_distribution</tt> synopsis
++and the prototype description 26.5.8.6.2 [rand.dist.samp.pconst] before p. 13 as indicated:
++<blockquote><pre>
++vector&lt;<del>double</del><ins>result_type</ins>&gt; densities() const;
+ </pre></blockquote>
+ </li>
+
+-<li>Change 26.5.8.5.3 [rand.dist.samp.plinear] p. 2, class template <tt>piecewise_linear_distribution</tt> synopsis
+-and the prototype description 26.5.8.5.3 [rand.dist.samp.plinear] before p. 13 as indicated:
+-<blockquote><pre>vector&lt;<del>double</del><ins>result_type</ins>&gt; densities() const;
++<li>Change 26.5.8.6.3 [rand.dist.samp.plinear] p. 2, class template <tt>piecewise_linear_distribution</tt> synopsis
++and the prototype description 26.5.8.6.3 [rand.dist.samp.plinear] before p. 13 as indicated:
++<blockquote><pre>
++vector&lt;<del>double</del><ins>result_type</ins>&gt; densities() const;
+ </pre></blockquote>
+ </li>
+ </ol>
+@@ -81775,27 +93904,29 @@ and the prototype description 26.5.8.5.3 [rand.dist.samp.plinear] before p. 13 a
+
+
+ <hr>
+-<h3><a name="1440"></a>1440. [FCD] Incorrect specification for rand.dist.samp.plinear</h3>
+-<p><b>Section:</b> 26.5.8.5.3 [rand.dist.samp.plinear] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1440"></a>1440. Incorrect specification for <tt>piecewise_linear_distribution</tt></h3>
++<p><b>Section:</b> 26.5.8.6.3 [rand.dist.samp.plinear] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-135</b></p>
+
+-This paragraph says: Let bk = xmin+k·&#948; for k = 0,...,n,
+-and wk = fw(bk +&#948;) for k = 0,...,n.
++<p>
++This paragraph says: Let bk = xmin+k&middot;&delta; for k = 0,...,n,
++and wk = fw(bk +&delta;) for k = 0,...,n.
+ However I believe that fw(bk) would be far more desirable.
+ I strongly suspect that this is nothing but a type-o.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
+-Change p. 10 to read:<br>
+-Let bk = xmin+k·&#948; for k = 0,...,n, and wk = fw(bk)
++<blockquote><p>
++Change p. 10 to read:<br/>
++Let bk = xmin+k&middot;&delta; for k = 0,...,n, and wk = fw(bk)
+ for k = 0,...,n.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11-02 Daniel translates into a proposed resolution
+@@ -81815,27 +93946,31 @@ Adopted at 2010-11 Batavia
+
+
+ <p><b>Proposed resolution:</b></p>
+-Change 26.5.8.5.3 [rand.dist.samp.plinear] p. 10 as indicated:
+-<blockquote>
++<p>Change 26.5.8.6.3 [rand.dist.samp.plinear] p. 10 as indicated:</p>
++<blockquote><p>
+ 10 <em>Effects</em>: Constructs a <tt>piecewise_linear_distribution</tt> object with parameters taken or calculated
+-from the following values: Let <tt><em>b<sub>k</sub></em> = xmin+<em>k</em>·&#948;</tt> for
+-<tt><em>k</em> = 0, . . . , <em>n</em></tt>, and <tt><em>w<sub>k</sub></em> = fw(<em>b</em><sub><em>k</em></sub><del> +&#948;</del>)</tt>
+-for <tt><em>k</em> = 0, . . . , <em>n</em></tt>.</blockquote>
++from the following values: Let <tt><em>b<sub>k</sub></em> = xmin+<em>k</em>&middot;&delta;</tt> for
++<tt><em>k</em> = 0, . . . , <em>n</em></tt>, and <tt><em>w<sub>k</sub></em> = fw(<em>b</em><sub><em>k</em></sub><del> +&delta;</del>)</tt>
++for <tt><em>k</em> = 0, . . . , <em>n</em></tt>.
++</p></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1441"></a>1441. [FCD] Floating-point test functions are incorrectly specified</h3>
+-<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-04</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#c.math">issues</a> in [c.math].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1441"></a>1441. Floating-point test functions are incorrectly specified</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-136</b></p>
+
++<p>
+ Floating-point test functions are incorrectly specified.
++</p>
+
+ <p><i>[
+ Resolved in Rapperswil by a motion to directly apply the words from the ballot comment in N3102.
+@@ -81845,23 +93980,25 @@ Resolved in Rapperswil by a motion to directly apply the words from the ballot c
+
+
+ <p><b>Proposed resolution:</b></p>
+-See Appendix 1 - Additional Details
++<p>See Appendix 1 - Additional Details</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1445"></a>1445. [FCD] Several iostreams member functions incorrectly specified</h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS/PJ Plauger <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1445"></a>1445. Several iostreams member functions incorrectly specified</h3>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS&#47;PJ Plauger <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-137</b></p>
+
++<p>
+ Several iostreams member functions are incorrectly
+ specified.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+@@ -81876,53 +94013,257 @@ See Appendix 1 - Additional Details
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1447"></a>1447. [FCD] Request to resolve issue LWG 1328</h3>
+-<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1447"></a>1447. Request to resolve issue LWG 1328</h3>
++<p><b>Section:</b> 27.7 [iostream.format] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostream.format">issues</a> in [iostream.format].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-139</b></p>
+
++<p>
+ Resolve issue LWG 1328 one way or the other, but
+ preferably in the direction outlined in the proposed
+ resolution, which, however, is not complete as-is: in any
+-case, the sentry must not set ok_ = false if is.good() ==
+-false, otherwise istream::seekg, being an unformatted
++case, the sentry must not set <tt>ok_ = false</tt> if <tt>is.good() == false</tt>,
++otherwise <tt>istream::seekg</tt>, being an unformatted
+ input function, does not take any action because the
+-sentry object returns false when converted to type bool.
++sentry object returns false when converted to type <tt>bool</tt>.
+ Thus, it remains impossible to seek away from end of file.
++</p>
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3168.htm">n3168</a>.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1448"></a>1448. Concerns about <tt>basic_stringbuf::str(basic_string)</tt> postconditions</h3>
++<p><b>Section:</b> 27.8.2.3 [stringbuf.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-124</b></p>
++
++<p>
++N3092 27.8.2.3 [stringbuf.members] contains this text specifying the postconditions of
++<tt>basic_stringbuf::str(basic_string)</tt>:
++</p>
++<blockquote><p>
++Postconditions: If <tt>mode &amp; ios_base::out</tt> is <tt>true</tt>,
++<tt>pbase()</tt> points to the first underlying character and <tt>epptr() >=
++pbase() + s.size()</tt> holds; in addition, if <tt>mode &amp; ios_base::in</tt>
++is <tt>true</tt>, <tt>pptr() == pbase() + s.data()</tt> holds, otherwise
++<tt>pptr() == pbase()</tt> is <tt>true</tt>. [...]
++</p></blockquote>
++<p>
++Firstly, there's a simple mistake: It should be <tt>pbase() + s.length()</tt>,
++not <tt>pbase() + s.data()</tt>.
++</p>
++<p>
++Secondly, it doesn't match existing implementations. As far as I can tell,
++GCC 4.5 does not test for <tt>mode &amp; ios_base::in</tt> in the second part
++of that sentence, but for <tt>mode &amp; (ios_base::app | ios_base_ate)</tt>,
++and Visual C++ 9 for <tt>mode &amp; ios_base::app</tt>. Besides, the wording of
++the C++0x draft doesn't make any sense to me. I suggest changing the second part
++of the sentence to one of the following:
++</p>
++<p>
++Replace <tt>ios_base::in</tt> with <tt>(ios_base::ate | ios_base::app)</tt>,
++but this would require Visual C++ to change (replacing only with
++<tt>ios_base::ate</tt> would require GCC to change, and would make
++<tt>ios_base::app</tt> completely useless with <tt>stringstreams</tt>):
++</p>
++<p>
++in addition, if <tt>mode &amp; (ios_base::ate | ios_base::app)</tt> is <tt>true</tt>,
++<tt>pptr() == pbase() + s.length()</tt> holds, otherwise <tt>pptr() == pbase()</tt>
++is <tt>true</tt>.
++</p>
++<p>
++Leave <tt>pptr()</tt> unspecified if <tt>mode &amp; ios_base::app</tt>, but not
++<tt>mode &amp; ios_base::ate</tt> (implementations already differ in this case, and it
++is always possible to use <tt>ios_base::ate</tt> to get the effect of appending, so it
++is not necessary to require any implementation to change):
++</p>
++<p>
++in addition, if <tt>mode &amp; ios_base::ate</tt> is <tt>true</tt>,
++<tt>pptr() == pbase() + s.length()</tt> holds, if neither <tt>mode &amp; ios_base::ate</tt>
++nor <tt>mode &amp; ios_base::app</tt> is <tt>true</tt>, <tt>pptr() == pbase()</tt> holds,
++otherwise <tt>pptr() >= pbase() &amp;&amp; pptr() &lt;= pbase() + s.length()</tt>
++(which of the values in this range is unspecified).
++</p>
++<p>
++Slightly stricter:
++</p>
++<p>
++in addition, if <tt>mode &amp; ios_base::ate</tt> is <tt>true</tt>,
++<tt>pptr() == pbase() + s.length()</tt> holds, if neither
++<tt>mode &amp; ios_base::ate</tt> nor <tt>mode &amp; ios_base::app</tt> is <tt>true</tt>,
++<tt>pptr() == pbase()</tt> holds, otherwise <tt>pptr() == pbase() || pptr() == pbase() + s.length()</tt>
++(which of these two values is unspecified). A small table might help to better explain the three cases.
++BTW, at the end of the postconditions is this text: &quot;<tt>egptr() == eback() + s.size()</tt> hold&quot;.
++Is there a perference for <tt>basic_string::length</tt> or <tt>basic_string::size</tt>? It doesn't really
++matter, but it looks a bit inconsistent.
++</p>
++
++<p><i>[2011-03-09: Nicolai Josuttis comments and drafts wording]</i></p>
++
++
++<p>First, it seems the current wording is just an editorial mistake.
++When we added issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#432">432</a>
++to the draft standard (in <a href="http://www.open-std.org/jtc1/sc22/wg21/prot/14882fdis/n1733.pdf">n1733</a>),
++the wording in the issue:
++</p>
++
++<blockquote><p>
++If <tt>mode &amp; ios_base::out</tt> is true, initializes the output sequence
++such that <tt>pbase()</tt> points to the first underlying character, <tt>epptr()</tt>
++points one past the last underlying character, and if <tt>(mode &amp; ios_base::ate)</tt> is true,
++<tt>pptr()</tt> is set equal to <tt>epptr()</tt> else <tt>pptr()</tt> is set equal to
++<tt>pbase()</tt>.
++</p></blockquote>
++
++<p>became:</p>
++
++<blockquote><p>
++If <tt>mode &amp; ios_base::out</tt> is true, initializes the output sequence
++such that <tt>pbase()</tt> points to the first underlying character, <tt>epptr()</tt>
++points one past the last underlying character, and <tt>pptr()</tt> is equal to <tt>epptr()</tt>
++if <tt>mode &amp; ios_base::in</tt> is true, otherwise <tt>pptr()</tt> is equal to
++<tt>pbase()</tt>.
++</p></blockquote>
++
++<p>
++which beside some changes of the order of words changed
++</p>
++<blockquote><pre>
++ios_base::ate
++</pre></blockquote>
++<p>
++into
++</p>
++<blockquote><pre>
++ios_base::in
++</pre></blockquote>
++<p>
++So, from this point of view, clearly <tt>mode &amp; ios_base::ate</tt> was meant.
++</p>
++
++<p>
++Nevertheless, with this proposed resolution we'd have no wording regarding <tt>ios_base::app</tt>.
++Currently the only statements about <tt>app</tt> in the Standard are just in two tables:
++</p>
++<ul>
++<li>Table 125 &mdash; &quot;<tt>openmode</tt> effects&quot; says that the effect of
++<tt>app</tt> is "seek to end before each write"
++</li>
++
++<li>Table 132 &mdash; &quot;File open modes&quot; says that the stdio equivalent
++for <tt>app</tt> is <tt>"a"</tt>
++</li>
++</ul>
++<p>
++Indeed we seem to have different behavior currently in respect to <tt>app</tt>: For
++</p>
++
++<blockquote><pre>
++stringstream s2(ios_base::out|ios_base::in|ios_base::app);
++s2.str("s2 hello");
++s1 &lt;&lt; "more";
++</pre></blockquote>
++
++<ul>
++<li>Visual C++ 10 does overwrite (=> <tt>"moreello"</tt>)</li>
++<li>G++ 4.5 does append (=> <tt>"s2 hellomore"</tt>)</li>
++</ul>
++
++<p>BTW, for fstreams, both implementations append when <tt>app</tt> is set:
++If <tt>f2.txt</tt> has contents <tt>"xy"</tt>,</p>
++
++<blockquote><pre>
++fstream f2("f2.txt",ios_base::out|ios_base::in|ios_base::app);
++f1 &lt;&lt; "more";
++</pre></blockquote>
++
++<p>appends <tt>"more"</tt> so that the contents is <tt>"xymore"</tt>.</p>
++
++<p>So IMO <tt>app</tt> should set the write pointer to the end so that each writing
++appends.
++<p/>
++I don't know whether what the standard says is enough. You can argue the
++statement in Table 125 clearly states that such a buffer should always append,
++which of course also applies to <tt>str()</tt> of stringbuffer.
++<p/>
++Nevertheless, it doesn't hurt IMO if we clarify the behavior of <tt>str()</tt>
++here in respect to <tt>app</tt>.
++</p>
++
++<p><i>[2011-03-10: P.J.Plauger comments:]</i></p>
++
++
++<p>I think we should say nothing special about <tt>app</tt> at construction
++time (thus leaving the write pointer at the beginning of the buffer).
++Leave implementers wiggle room to ensure subsequent append writes as they see
++fit, but don't change existing rules for initial seek position.</p>
++
++<p><i>[Madrid meeting: It was observed that a different issue should be opened that
++clarifies the meaning of <tt>app</tt> for <tt>stringstream</tt>]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>Change 27.8.2.3 [stringbuf.members] p. 3 as indicated:</p>
++
++<blockquote><pre>
++void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
++</pre><blockquote>
++<p>
++2 <i>Effects</i>: Copies the content of <tt>s</tt> into the <tt>basic_stringbuf</tt>
++underlying character sequence and initializes the input and output sequences according
++to <tt>mode</tt>.
++<p/>
++3 <i>Postconditions</i>: If <tt>mode &amp; ios_base::out</tt> is true, <tt>pbase()</tt>
++points to the first underlying character and <tt>epptr() &gt;= pbase() + s.size()</tt>
++holds; in addition, if <tt>mode &amp; <del>ios_base::in</del><ins>ios_base::ate</ins></tt>
++is true, <tt>pptr() == pbase() + <del>s.data()</del><ins>s.size()</ins></tt> holds,
++otherwise <tt>pptr() == pbase()</tt> is true. If <tt>mode &amp; ios_base::in</tt>
++is true, <tt>eback()</tt> points to the first underlying character, and both
++<tt>gptr() == eback() and egptr() == eback() + s.size()</tt>
++hold.
++</p>
++</blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1449"></a>1449. [FCD] Incomplete specification of header <tt>&lt;cinttypes&gt;</tt></h3>
+-<p><b>Section:</b> 27.8.2 [istringstream] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1449"></a>1449. Incomplete specification of header <tt>&lt;cinttypes&gt;</tt></h3>
++<p><b>Section:</b> 27.8.3 [istringstream] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses CA-4</b></p>
+
++<p>
+ Subclause 27.9.2 [c.files] specifies that &lt;cinttypes&gt; has
+ declarations for abs() and div(); however, the signatures
+ are not present in this subclause. The signatures
+@@ -81935,6 +94276,7 @@ functions, among other things, are not specified in FCD to
+ be the functions from Subclause 7.8 of the C Standard.
+ Finally, &lt;cinttypes&gt; is not specified in FCD to include
+ &lt;cstdint&gt; (whereas &lt;inttypes.h&gt; includes &lt;stdint.h&gt; in C).
++</p>
+
+ <p><i>[
+ Post-Rapperswil, Daniel provides wording
+@@ -81951,9 +94293,9 @@ FCD to be the functions from subclause 7.8 of the <tt>C</tt> Standard. Finally,
+ in FCD to include <tt>&lt;cstdint&gt;</tt> (whereas <tt>&lt;inttypes.h&gt;</tt> includes <tt>&lt;stdint.h&gt;</tt> in <tt>C</tt>).
+ </p>
+
+-<blockquote>
++<blockquote><p>
+ Moved to Tentatively Ready with proposed wording after 5 positive votes on c++std-lib.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Adopted at 2010-11 Batavia
+@@ -81968,27 +94310,27 @@ Adopted at 2010-11 Batavia
+ </p>
+ <ol>
+ <li>Add the following series of new paragraphs following [c.files] p.1:
+-<blockquote>
++<blockquote><p>
+ Table 132 describes header <tt>&lt;cinttypes&gt;</tt>. [<em>Note</em>: The macros defined by <tt>&lt;cinttypes&gt;</tt> are provided unconditionally.
+ In particular, the symbol <tt>__STDC_FORMAT_MACROS</tt>, mentioned in footnote 182 of the <tt>C</tt> standard, plays no role in <tt>C++</tt>.
+-— <em>end note</em> ]
+-<p>
++&mdash; <em>end note</em> ]
++<p/>
+ <ins>2 - The contents of header <tt>&lt;cinttypes&gt;</tt> are the same as the Standard <tt>C</tt> library header <tt>&lt;inttypes.h&gt;</tt>,
+ with the following changes:</ins>
+-</p>
+-<p>
++<p/>
+ <ins>3 - The header <tt>&lt;cinttypes&gt;</tt> includes the header <tt>&lt;cstdint&gt;</tt> instead of <tt>&lt;stdint.h&gt;</tt>.</ins>
+-</p>
+-<p>
++<p/>
+ <ins>4 - If and only if the type <tt>intmax_t</tt> designates an extended integer type ([basic.fundamental]), the following function
+-signatures are added:
+-</ins></p><blockquote><pre><ins>intmax_t abs(intmax_t);</ins>
++signatures are added:</ins>
++</p>
++<blockquote><pre>
++<ins>intmax_t abs(intmax_t);</ins>
+ <ins>imaxdiv_t div(intmax_t, intmax_t);</ins>
+ </pre></blockquote>
++<p>
+ <ins>which shall have the same semantics as the function signatures <tt>intmax_t imaxabs(intmax_t)</tt> and
+ <tt>imaxdiv_t imaxdiv(intmax_t, intmax_t)</tt>, respectively.</ins>
+-
+-<p></p>
++</p>
+ </blockquote>
+ </li>
+ </ol>
+@@ -81998,60 +94340,210 @@ signatures are added:
+
+
+ <hr>
+-<h3><a name="1453"></a>1453. [FCD] Default constructed match_results behavior for certain operations </h3>
+-<p><b>Section:</b> 28.10.4 [re.results.acc] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#re.results.acc">issues</a> in [re.results.acc].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1450"></a>1450. Contradiction in <tt>regex_constants</tt></h3>
++<p><b>Section:</b> 28.5.2 [re.matchflag] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-127</b></p>
++
++<p>
++The Bitmask Type requirements in 17.5.2.1.3 [bitmask.types] p.3 say that
++all elements on a bitmask type have distinct values, but
++28.5.2 [re.matchflag] defines <tt>regex_constants::match_default</tt> and
++<tt>regex_constants::format_default</tt> as elements of the
++bitmask type <tt>regex_constants::match_flag_type</tt>, both with
++value 0. This is a contradiction.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++One of the bitmask elements should be removed
++from the declaration and should be defined
++separately, in the same manner as
++<tt>ios_base::adjustfield</tt>, <tt>ios_base::basefield</tt> and
++<tt>ios_base::floatfield</tt> are defined by 27.5.3.1.2 [ios::fmtflags] p.2
++and Table 120. These are constants of a bitmask
++type, but are not distinct elements, they have
++more than one value set in the bitmask.
++<tt>regex_constants::format_default</tt> should be
++specified as a constant with the same value as
++<tt>regex_constants::match_default</tt>.
++</p></blockquote>
++
++<p><i>[
++2010-10-31 Daniel comments:
++]</i></p>
++
++<p>
++Strictly speaking, a bitmask type cannot have any element of value 0 at all, because
++any such value would contradict the requirement expressed in 17.5.2.1.3 [bitmask.types] p. 3:
++</p>
++<blockquote><p>
++for any pair <em>Ci</em> and <em>Cj</em>, <em>Ci</em> &amp; <em>Ci</em> is nonzero
++</p></blockquote>
++<p>
++So, actually <em>both</em> <tt>regex_constants::match_default</tt> and
++<tt>regex_constants::format_default</tt> are only constants of the type
++<tt>regex_constants::match_flag_type</tt>, and no bitmask elements.
++</p>
++
++<p><i>[
++2010-11-03 Daniel comments and provides a proposed resolution:
++]</i></p>
++
++
++<p>The proposed resolution is written against N3126 and considered as a further improvement
++of the fixes suggested by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3110.html">n3110</a>.
++</p>
++
++<blockquote>
++<p>
++Add the following sentence to 28.5.2 [re.matchflag] paragraph 1:
++</p>
++<blockquote><p>
++1 The type <tt>regex_constants::match_flag_type</tt> is an implementation-defined bitmask type (17.5.2.1.3).
++Matching a regular expression against a sequence of characters [first,last) proceeds according to the
++rules of the grammar specified for the regular expression object, modified according to the effects listed in
++Table 136 for any bitmask elements set. <ins>Type <tt>regex_constants::match_flag_type</tt> also defines the
++constants <tt>regex_constants::match_default</tt> and <tt>regex_constants::format_default</tt>.</ins>
++</p></blockquote>
++</blockquote>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++It appears the key problem is the phrasing of the bitmask requirements. Jeremiah supplies updated wording.
++</p>
++
++<p>
++Pete Becker has also provided an alternative resolution.
++</p>
++
++<p>
++Ammend 17.5.2.1.3 [bitmask.types]:
++</p>
++<p>
++Change the list of values for "enum bit mask" in p2 from
++</p>
++<p>
++<tt><i>V0</i> = 1 &lt;&lt; 0, <i>V1</i> = 1 &lt;&lt; 1, <i>V2</i> = 1 &lt;&lt; 2, <i>V3</i> = 1 &lt;&lt; 3, ...</tt>.
++</p>
++<p>
++to
++</p>
++<p>
++<tt><i>V0</i> = 0, <i>V1</i> = 1 &lt;&lt; 0, <i>V2</i> = 1 &lt;&lt; 1, <i>V3</i> = 1 &lt;&lt; 2, ...</tt>.
++</p>
++<p>
++Here, the names <i>C0</i>, <i>C1</i>, etc. represent <i>bitmask elements</i> for this particular
++bitmask type. All such <ins>non-zero</ins> elements have distinct values such that, for any pair
++<i>Ci</i> and <i>Cj</i> <ins>where <i>i</i> != <i>j</i></ins>, <del><i>Ci &amp; Ci</i> is nonzero
++and</del> <i>Ci &amp; Cj</i> is zero.
++</p>
++<p>
++Change bullet 3 of paragraph 4:
++</p>
++<p>
++<del>The</del><ins>A non-zero</ins> value Y is set in the object X if the expression X &amp; Y is nonzero.
++</p>
++
++<p><i>[2014-02-13 Issaquah:]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Ammend 17.5.2.1.3 [bitmask.types] p3:
++</p>
++<p>
++Here, the names <i>C0</i>, <i>C1</i>, etc. represent <i>bitmask elements</i> for this particular
++bitmask type. All such elements have distinct<ins>, nonzero</ins> values such that, for any pair
++<i>Ci</i> and <i>Cj</i> <ins>where <i>i</i> != <i>j</i>,</ins> <i>Ci &amp; Ci</i> is nonzero
++and <i>Ci &amp; Cj</i> is zero. <ins>Additionally, the value 0 is used to represent an
++<i>empty bitmask</i>, in which no bitmask elements are set.</ins>
++</p>
++
++<p>
++Add the following sentence to 28.5.2 [re.matchflag] paragraph 1:
++</p>
++<blockquote><p>
++1 The type <tt>regex_constants::match_flag_type</tt> is an implementation-defined bitmask type (17.5.2.1.3).
++<ins>The constants of that type, except for <tt>match_default</tt> and <tt>format_default</tt>, are bitmask
++elements. The <tt>match_default</tt> and <tt>format_default</tt> constants are empty bitmasks.</ins> Matching
++a regular expression against a sequence of characters [first,last) proceeds according to the rules of the
++grammar specified for the regular expression object, modified according to the effects listed in Table 136
++for any bitmask elements set.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1453"></a>1453. Default constructed <tt>match_results</tt> behavior for certain operations </h3>
++<p><b>Section:</b> 28.10.4 [re.results.acc] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results.acc">issues</a> in [re.results.acc].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-126</b></p>
+
++<p>
+ It's unclear how match_results should behave if it has
+ been default-constructed. The sub_match objects
+ returned by operator[], prefix and suffix cannot point to the
+ end of the sequence that was searched if no search was
+ done. The iterators held by unmatched sub_match objects
+ might be singular.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Add to match_results::operator[],
+-match_results::prefix and match_results::suffix:<br>
++match_results::prefix and match_results::suffix:<br/>
+ Requires: !empty()
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
++<p><b>Proposed resolution:</b></p><p>
+ Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a>.
+-
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1455"></a>1455. [FCD] C language compatibility for atomics</h3>
+-<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index-open.html#atomics">active issues</a> in [atomics].</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics">issues</a> in [atomics].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1454">1454</a></p>
++<h3><a name="1455"></a>1455. C language compatibility for atomics</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1454">1454</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses CH-22, GB-128</b></p>
++
+ <p>
+ WG14 currently plans to introduce atomic facilities that are
+ intended to be compatible with the facilities of clause 29.
+@@ -82073,53 +94565,404 @@ standard.
+ ]</i></p>
+
+ <p>
+-Resolved by adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++Resolved by adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ </p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<p><b>Proposed resolution:</b></p><p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1457"></a>1457. Splitting lock-free properties</h3>
++<p><b>Section:</b> 29.2 [atomics.syn] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.syn">issues</a> in [atomics.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-130</b></p>
++
++<p>
++The synopsis for the <tt>&lt;atomic&gt;</tt> header lists the macros
++<tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> and <tt>ATOMIC_ADDRESS_LOCK_FREE</tt>.
++</p>
++<p>
++The <tt>ATOMIC_INTEGRAL_LOCK_FREE</tt> macro has been replaced with a set of macros
++for each integral type, as listed in 29.4 [atomics.lockfree].
++</p>
++
++<p><i>[Proposed resolution as of comment]</i></p>
++
++
++<blockquote>
++<p>
++Against FCD, N3092:
++</p>
++<p>
++In [atomics.syn], header <tt>&lt;atomic&gt;</tt> synopsis replace as indicated:
++</p>
++<blockquote><pre>
++// 29.4, lock-free property
++<del>#define ATOMIC_INTEGRAL_LOCK_FREE <em>unspecified</em></del>
++<ins>#define ATOMIC_CHAR_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_CHAR16_T_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_CHAR32_T_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_WCHAR_T_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_SHORT_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_INT_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_LONG_LOCK_FREE <em>implementation-defined</em></ins>
++<ins>#define ATOMIC_LLONG_LOCK_FREE <em>implementation-defined</em></ins>
++#define ATOMIC_ADDRESS_LOCK_FREE <em>unspecified</em>
++</pre></blockquote>
++</blockquote>
++
++<p><i>[
++2010-10-26: Daniel adds:
++]</i></p>
++
++
++<p>
++The proposed resolution below is against the FCD working draft. After application
++of the editorial issues <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US144">US-144</a>
++and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3162.html#US146">US-146</a> the remaining difference
++against the working draft is the usage of <em>implementation-defined</em> instead of <em>unspecified</em>, effectively
++resulting in this delta:
++</p>
++
++<blockquote><pre>
++// 29.4, lock-free property
++#define ATOMIC_CHAR_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_CHAR16_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_CHAR32_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_WCHAR_T_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_SHORT_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_INT_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_LONG_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_LLONG_LOCK_FREE <del><em>unspecified</em></del><ins><em>implementation-defined</em></ins>
++#define ATOMIC_ADDRESS_LOCK_FREE <em>unspecified</em>
++</pre></blockquote>
+
++<p>
++It is my understanding that the intended wording should be <em>unspecified</em> as for <tt>ATOMIC_ADDRESS_LOCK_FREE</tt>
++but if this is right, we need to use the same wording in 29.4 [atomics.lockfree], which consequently uses
++the term <em>implementation-defined</em>. I recommend to keep 29.2 [atomics.syn] as it currently is and to
++fix 29.4 [atomics.lockfree] instead as indicated:
++</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++<p><i>[2011-02-20: Daniel adapts the proposed wording to N3225 and fixes an editorial omission of
++applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">N3193</a>]</i></p>
++
++
++<p><i>[2011-03-06: Daniel adapts the wording to N3242]</i></p>
++
++
++<p><i>[Proposed Resolution]</i></p>
++
++<blockquote>
++<p>
++Change 29.4 [atomics.lockfree] as indicated:
++</p>
++<blockquote><pre>
++#define ATOMIC_CHAR_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_CHAR16_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_CHAR32_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_WCHAR_T_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_SHORT_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_INT_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_LONG_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++#define ATOMIC_LLONG_LOCK_FREE <del><em>implementation-defined</em></del><ins><em>unspecified</em></ins>
++</pre></blockquote>
++</blockquote>
++
++
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="1460"></a>1460. Missing lock-free property for type <tt>bool</tt> should be added</h3>
++<p><b>Section:</b> 29.4 [atomics.lockfree] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.lockfree">issues</a> in [atomics.lockfree].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-154</b></p>
++
++<p>There is no <tt>ATOMIC_BOOL_LOCK_FREE</tt> macro.</p>
++
++<p>Proposed resolution suggested by the NB comment:</p>
++
++<p>
++Add <tt>ATOMIC_BOOL_LOCK_FREE</tt> to 29.4 [atomics.lockfree] and to 29.2 [atomics.syn]:
++</p>
++<blockquote><pre>
++[..]
++<ins>#define ATOMIC_BOOL_LOCK_FREE <em>unspecified</em></ins>
++#define ATOMIC_CHAR_LOCK_FREE <em>unspecified</em>
++#define ATOMIC_CHAR16_T_LOCK_FREE <em>unspecified</em>
++#define ATOMIC_CHAR32_T_LOCK_FREE <em>unspecified</em>
++[..]
++</pre></blockquote>
++
++
++<p><i>[2011-03-12: Lawrence comments and drafts wording]</i></p>
++
++
++<p>Point: We were missing a macro test for <tt>bool</tt>.</p>
++
++<p>Comment: The <tt>atomic&lt;bool&gt;</tt> type is the easiest to make lock-free.
++There is no harm in providing a macro.</p>
++
++<p>Action: Add an <tt>ATOMIC_BOOL_LOCK_FREE</tt>.</p>
++
++<p>Point: We were missing a macro test for pointers.</p>
++
++<p>Comment: The national body comment noting the missing macro
++for <tt>bool</tt> did not note the lack of a macro for pointers because
++<tt>ATOMIC_ADDRESS_LOCK_FREE</tt> was present at the time of the comment.
++Its removal appears to be an overzealous consequence of removing
++<tt>atomic_address</tt>.</p>
++
++<p>Action: Add an <tt>ATOMIC_POINTER_LOCK_FREE</tt>.</p>
++
++<p>Point: Presumably <tt>atomic_is_lock_free()</tt> will be an inline function
++producing a constant in those cases in which the macros are useful.</p>
++
++<p>Comment: The point is technically correct, but could use some
++exposition. Systems providing forward binary compatibility, e.g.
++mainstream desktop and server systems, would likely have these
++functions as inline constants only when the answer is true.
++Otherwise, the function should defer to a platform-specific dynamic
++library to take advantage of future systems that do provide lock-free
++support.</p>
++
++<p>Comment: Such functions are not useful in the preprocessor, and not
++portably useful in <tt>static_assert</tt>.</p>
++
++<p>Action: Preserve the macros.</p>
++
++<p>Point: The required explicit instantiations are <tt>atomic&lt;X&gt;</tt> for each
++of the types <tt>X</tt> in Table 145. Table 145 does not list <tt>bool</tt>, so
++<tt>atomic&lt;bool&gt;</tt> is not a required instantiation.</p>
++
++<p>Comment: I think specialization was intended in the point instead of
++instantiation. In any event, 29.5 [atomics.types.generic] paragraph 5 does
++indirectly require a specialization for <tt>atomic&lt;bool&gt;</tt>. Confusion
++arises because the specialization for other integral types have a
++wider interface than the generic <tt>atomic&lt;T&gt;</tt>, but
++<tt>atomic&lt;bool&gt;</tt> does not.</p>
++
++<p>Action: Add clarifying text.</p>
++
++<p>Point: The name of Table 145, "atomic integral typedefs", is perhaps
++misleading, since the types listed do not contain all of the
++"integral" types.</p>
++
++<p>Comment: Granted, though the table describe those with extra operations.</p>
++
++<p>Action: Leave the text as is.</p>
++
++<p>Point: The macros correspond to the types in Table 145, "with the
++signed and unsigned variants grouped together". That's a rather
++inartful way of saying that <tt>ATOMIC_SHORT_LOCK_FREE</tt> applies to
++<tt>signed short</tt> and <tt>unsigned short</tt>. Presumably this also means that
++<tt>ATOMIC_CHAR_LOCK_FREE</tt> applies to all three char types.</p>
++
++<p>Comment: Yes, it is inartful.</p>
++
++<p>Comment: Adding additional macros to distinguish signed and unsigned
++would provide no real additional information given the other
++constraints in the language.</p>
++
++<p>Comment: Yes, it applies to all three <tt>char</tt> types.</p>
++
++<p>Action: Leave the text as is.</p>
++
++<p>Point: The standard says that "There are full specializations over the
++integral types (<tt>char</tt>, <tt>signed char</tt>, ...)" <tt>bool</tt>
++is not in the list. But this text is not normative. It simply tells you
++that "there are" specializations, not "there shall be" specializations, which would
++impose a requirement. The requirement, to the extent that there is
++one, is in the header synopsis, which, in N3242, sort of pulls in the
++list of types in Table 145.</p>
++
++<p>Comment: The intent was for the specializations to be normative.
++Otherwise the extra member functions could not be present.</p>
++
++<p>Action: Clarify the text.</p>
++
++<p><i>[Proposed Resolution]</i></p>
++
++<blockquote>
++<ol>
++<li><p>Edit header <tt>&lt;atomic&gt;</tt> synopsis 29.2 [atomics.syn]:</p>
++
++<blockquote><pre>
++namespace std {
++ <i>// 29.3, order and consistency</i>
++ enum memory_order;
++ template &lt;class T&gt;
++ T kill_dependency(T y);
++
++ <i>// 29.4, lock-free property</i>
++ <ins>#define ATOMIC_BOOL_LOCK_FREE <i>unspecified</i></ins>
++ #define ATOMIC_CHAR_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_CHAR16_T_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_CHAR32_T_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_WCHAR_T_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_SHORT_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_INT_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_LONG_LOCK_FREE <i>unspecified</i>
++ #define ATOMIC_LLONG_LOCK_FREE <i>unspecified</i>
++ <ins>#define ATOMIC_POINTER_LOCK_FREE <i>unspecified</i></ins>
++
++ <i>// 29.5, generic types</i>
++ template&lt;class T&gt; struct atomic;
++ template&lt;&gt; struct atomic&lt;<i>integral</i>&gt;;
++ template&lt;class T&gt; struct atomic&lt;T*&gt;;
++
++ <i>// 29.6.1, general operations on atomic types
++ // In the following declarations, </i>atomic_type<i> is either
++ // </i>atomic&lt;T&gt;<i> or a named base class for </i>T<i> from
++ // Table 145 or inferred from
++ // Table 146 </i><ins><i>or from</i> bool</ins><i>.</i>
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Edit the synopsis of 29.4 [atomics.lockfree] and paragraph 1 as follows:</p>
++
++<blockquote><pre>
++<ins>#define ATOMIC_BOOL_LOCK_FREE <i>unspecified</i></ins>
++#define ATOMIC_CHAR_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_CHAR16_T_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_CHAR32_T_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_WCHAR_T_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_SHORT_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_INT_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_LONG_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++#define ATOMIC_LLONG_LOCK_FREE <i><del>implementation-defined</del><ins>unspecified</ins></i>
++<ins>#define ATOMIC_POINTER_LOCK_FREE <i>unspecified</i></ins>
++</pre><blockquote>
++<p>
++1 The <tt>ATOMIC_&hellip;_LOCK_FREE</tt> macros indicate the lock-free property of the corresponding atomic types, with
++the signed and unsigned variants grouped together. The properties also apply to the corresponding <ins>(partial)</ins>
++specializations of the <tt>atomic</tt> template. A value of 0 indicates that the types are never lock-free. A value of 1
++indicates that the types are sometimes lock-free. A value of 2 indicates that the types are always lock-free.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 29.5 [atomics.types.generic] paragraph 3, 4, and 6-8 as follows:</p>
++
++<blockquote><p>
++2 The semantics of the operations on specializations of <tt>atomic</tt> are defined in 29.6 [atomics.types.operations].
++<p/>
++3 Specializations <ins>and instantiations</ins> of the <tt>atomic</tt> template shall have a deleted copy constructor,
++a deleted copy assignment operator, and a <tt>constexpr</tt> value constructor.
++<p/>
++4 There <del>are</del><ins>shall be</ins> full specializations <del>over</del><ins>for</ins> the integral types <del>(</del>
++<tt>char</tt>, <tt>signed char</tt>, <tt>unsigned char</tt>, <tt>short</tt>, <tt>unsigned short</tt>, <tt>int</tt>,
++<tt>unsigned int</tt>, <tt>long</tt>, <tt>unsigned long</tt>, <tt>long long</tt>, <tt>unsigned long long</tt>,
++<tt>char16_t</tt>, <tt>char32_t</tt>, <ins>and</ins> <tt>wchar_t</tt>, and any other types needed by the typedefs in the header
++<tt>&lt;cstdint&gt;</tt><del>)</del> on the <tt>atomic</tt> class
++template. For each integral type integral, the specialization <tt>atomic&lt;<i>integral</i>&gt;</tt> provides additional atomic
++operations appropriate to integral types. <del>[Editor's note: I'm guessing that this is the correct rendering of
++the text in the paper; if this sentence was intended to impose a requirement, rather than a description, it
++will have to be changed.]</del> <ins>There shall be a specialization <tt>atomic&lt;bool&gt;</tt> which provides
++the general atomic operations as specified in 29.6.1 [atomics.types.operations.general].</ins>
++<p/>
++5 The atomic integral specializations and the specialization <tt>atomic&lt;bool&gt;</tt> shall have standard layout. They
++shall each have a trivial default constructor and a trivial destructor. They shall each support aggregate
++initialization syntax.
++<p/>
++6 There <del>are</del><ins>shall be</ins> pointer partial specializations <del>on</del><ins>of</ins> the <tt>atomic</tt>
++class template. These specializations shall have trivial default constructors and trivial destructors.
++<p/>
++7 There <del>are</del><ins>shall be</ins> named types corresponding to the integral specializations of <tt>atomic</tt>, as
++specified in Table 145. <ins>In addition, there shall be named type <code>atomic_bool</code> corresponding to the specialization
++<code>atomic&lt;bool&gt;</code>.</ins> Each named type is <ins>either</ins> a typedef to the corresponding specialization
++or a base class of the corresponding specialization. If it is a base class, it shall support the same member functions
++as the corresponding specialization.
++<p/>
++8 There <del>are</del><ins>shall be</ins> atomic typedefs corresponding to the typedefs in the header <tt>&lt;inttypes.h&gt;</tt>
++as specified in Table 146.
++</p>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1462"></a>1462. [FCD] Ambiguous value assignment to <tt>atomic_bool</tt></h3>
+-<p><b>Section:</b> 29.5.1 [atomics.types.integral] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
+-<p><b>Duplicate of:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#1463">1463</a></p>
++<h3><a name="1462"></a>1462. Ambiguous value assignment to <tt>atomic_bool</tt></h3>
++<p><b>Section:</b> X [atomics.types.integral] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1463">1463</a></p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-132, US-157</b></p>
+
++<p>
+ The <tt>atomic_<em>itype</em></tt> types and <tt>atomic_address</tt> have two
+ overloads of <tt>operator=</tt>; one is <tt>volatile</tt> qualified, and the
+ other is not. <tt>atomic_bool</tt> only has the <tt>volatile</tt> qualified
+ version:
+-<pre><blockquote>
++</p>
++<blockquote><pre>
+ bool operator=(bool) volatile;
+-</blockquote></pre>
++</pre></blockquote>
++<p>
+ On a non-<tt>volatile</tt>-qualified object this is ambiguous with
+ the deleted copy-assignment operator
+-<pre><blockquote>
++</p>
++<blockquote><pre>
+ atomic_bool&amp; operator=(atomic_bool const&amp;) = delete;
+-</blockquote></pre>
++</pre></blockquote>
++<p>
+ due to the need for a single standard conversion in each
+ case when assigning a bool to an <tt>atomic_bool</tt> as in:
+-<pre><blockquote>
++</p>
++<blockquote><pre>
+ atomic_bool b;
+ b = true;
+-</blockquote></pre>
++</pre></blockquote>
++<p>
+ The conversions are:
+-<pre><blockquote>
+-atomic_bool&amp; &#8594; atomic_bool volatile&amp;
+-</blockquote></pre>
++</p>
++<blockquote><pre>
++atomic_bool&amp; &rarr; atomic_bool volatile&amp;
++</pre></blockquote>
++<p>
+ vs
+-<pre><blockquote>
+-bool &#8594; atomic_bool
+-</blockquote></pre>
++</p>
++<blockquote><pre>
++bool &rarr; atomic_bool
++</pre></blockquote>
+
+ <p><i>[
+ Proposed resolution as of NB comment:
+@@ -82127,9 +94970,10 @@ Proposed resolution as of NB comment:
+
+
+ <p>
+-Change 29.5.1 [atomics.types.integral] as indicated:
+-
+-</p><blockquote><pre>namespace std {
++Change X [atomics.types.integral] as indicated:
++</p>
++<blockquote><pre>
++namespace std {
+ typedef struct atomic_bool {
+ [..]
+ bool operator=(bool) volatile;
+@@ -82138,62 +94982,64 @@ Change 29.5.1 [atomics.types.integral] as indicated:
+ [..]
+ }
+ </pre></blockquote>
+-<p></p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue
+ by replacing <tt>atomic_bool</tt> by <tt>atomic&lt;bool&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010 Batavia
+ ]</i></p>
+
+ <p>
+-Resolved by adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++Resolved by adoption of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ </p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1464"></a>1464. [FCD] Underspecified typedefs for atomic integral types</h3>
+-<p><b>Section:</b> 29.5.1 [atomics.types.integral] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1464"></a>1464. Underspecified typedefs for atomic integral types</h3>
++<p><b>Section:</b> X [atomics.types.integral] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.integral">issues</a> in [atomics.types.integral].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-160</b></p>
+
+-The last sentence of 29.5.1 [atomics.types.integral] p.1 says:
++<p>
++The last sentence of X [atomics.types.integral] p.1 says:
++</p>
+ <blockquote><p>
+ Table 143 shows typedefs to atomic integral classes and the corresponding <tt>&lt;cstdint&gt;</tt> typedefs.
+ </p></blockquote>
++<p>
+ That's nice, but nothing says these are supposed to be part of the implementation, and
+ they are not listed in the synopsis.
++</p>
+
+ <p><i>[
+ Proposed resolution as of NB comment
+ ]</i></p>
+
+
+-<p>
+-</p><ol>
+-<li>Remove Table 143 — Atomics for standard typedef types.
++<ol>
++<li>Remove Table 143 &mdash; Atomics for standard typedef types.
+ <p>
+ </p>
+ </li>
+-<li>Change 29.5.1 [atomics.types.integral] p.1 as indicated:
++<li>Change X [atomics.types.integral] p.1 as indicated:
+ <blockquote><p>
+ 1 The name <tt>atomic_<em>itype</em></tt> and the functions operating on it in the preceding synopsis are placeholders for a
+ set of classes and functions. Throughout the preceding synopsis, <tt>atomic_<em>itype</em></tt> should be replaced by each
+@@ -82202,70 +95048,72 @@ class name. <del>Table 143 shows typedefs to atomic integral classes and the cor
+ </p></blockquote>
+ </li>
+ </ol>
+-<p></p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ 2010-11 Batavia
+ ]</i></p>
+
+ <p>
+-Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++Resolved by adopting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ </p>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1465"></a>1465. [FCD] Missing arithmetic operators for <tt>atomic_address</tt></h3>
+-<p><b>Section:</b> 29.5.2 [atomics.types.address] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1465"></a>1465. Missing arithmetic operators for <tt>atomic_address</tt></h3>
++<p><b>Section:</b> X [atomics.types.address] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-161</b></p>
+
++<p>
+ <tt>atomic_address</tt> has <tt>operator+=</tt> and <tt>operator-=</tt>, but no
+ <tt>operator++</tt> or <tt>operator--</tt>. The template specialization
+ <tt>atomic&lt;Ty*&gt;</tt> has all of them.
++</p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue by
+ replacing <tt>atomic_address</tt> by <tt>atomic&lt;void*&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ ]</i></p>
+
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p>Change 29.5.2 [atomics.types.address], class <tt>atomic_address</tt> synopsis, as indicated:
+-</p><blockquote><pre>namespace std {
++<p>Change X [atomics.types.address], class <tt>atomic_address</tt> synopsis, as indicated:</p>
++<blockquote><pre>
++namespace std {
+ typedef struct atomic_address {
+- [..]
++ [&hellip;]
+ void* operator=(const void*) volatile;
+ void* operator=(const void*);
+ <ins>void* operator++(int) volatile;</ins>
+@@ -82281,10 +95129,9 @@ Resolved in Batavia by accepting
+ void* operator-=(ptrdiff_t) volatile;
+ void* operator-=(ptrdiff_t);
+ } atomic_address;
+- [..]
++ [&hellip;]
+ }
+ </pre></blockquote>
+-<p></p>
+
+
+
+@@ -82292,17 +95139,19 @@ Resolved in Batavia by accepting
+
+
+ <hr>
+-<h3><a name="1466"></a>1466. [FCD] Silent <tt>const</tt> breakage by <tt>compare_exchange_*</tt> member functions</h3>
+-<p><b>Section:</b> 29.5.2 [atomics.types.address] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1466"></a>1466. Silent <tt>const</tt> breakage by <tt>compare_exchange_*</tt> member functions</h3>
++<p><b>Section:</b> X [atomics.types.address] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-162</b></p>
+
++<p>
+ The <tt>compare_exchange_weak</tt> and <tt>compare_exchange_strong</tt> member functions that take
+ <tt>const void*</tt> arguments lead to a silent removal of <tt>const</tt>, because the <tt>load</tt>
+ member function and other acessors return the stored value as a <tt>void*</tt>.
++</p>
+
+ <p><i>[
+ Proposed resolution as of NB comment:
+@@ -82310,9 +95159,10 @@ Proposed resolution as of NB comment:
+
+
+ <p>
+-Change 29.5.2 [atomics.types.address], class <tt>atomic_address</tt> synopsis, as indicated:
+-
+-</p><blockquote><pre>namespace std {
++Change X [atomics.types.address], class <tt>atomic_address</tt> synopsis, as indicated:
++</p>
++<blockquote><pre>
++namespace std {
+ typedef struct atomic_address {
+ [..]
+ <del>bool compare_exchange_weak(const void*&amp;, const void*,
+@@ -82337,49 +95187,52 @@ Change 29.5.2 [atomics.types.address], class <tt>atomic_address</tt> synopsis, a
+ }
+ </pre></blockquote>
+
+-<p></p>
+-
+ <p><i>[
+ 2010-10-27 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a>
+ would solve this issue by replacing <tt>atomic_address</tt> by <tt>atomic&lt;void*&gt;</tt>.
+-</blockquote>
++</p></blockquote>
+
+ <p><i>[
+ Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ ]</i></p>
+
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
+-
++<p><b>Proposed resolution:</b></p><p>
++Solved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1467"></a>1467. [FCD] Deriving <tt>atomic&lt;T*&gt;</tt> from <tt>atomic_address</tt> breaks type safety</h3>
+-<p><b>Section:</b> 29.5.2 [atomics.types.address] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1467"></a>1467. Deriving <tt>atomic&lt;T*&gt;</tt> from <tt>atomic_address</tt> breaks type safety</h3>
++<p><b>Section:</b> X [atomics.types.address] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-163</b></p>
+
++<p>
+ Requiring <tt>atomic&lt;T*&gt;</tt> to be derived from <tt>atomic_address</tt> breaks type safety:
+-<blockquote><pre>atomic&lt;double*&gt; ip;
++</p>
++<blockquote><pre>
++atomic&lt;double*&gt; ip;
+ char ch;
+ atomic_store(&amp;ip, &amp;ch);
+ *ip.load() = 3.14159;
+ </pre></blockquote>
++<p>
+ The last line overwrites <tt>ch</tt> with a value of type <tt>double</tt>.
++</p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+@@ -82388,14 +95241,16 @@ The last line overwrites <tt>ch</tt> with a value of type <tt>double</tt>.
+
+ <blockquote>
+ <p>
+-Resolving this issue will also solve <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1469">1469</a>
+-</p>
++Resolving this issue will also solve <a href="lwg-defects.html#1469">1469</a>
++<p/>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue by
+ removing <tt>atomic_address</tt>.
++</p>
+ </blockquote>
++
+ <p><i>[
+ Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ ]</i></p>
+
+
+@@ -82403,7 +95258,8 @@ Resolved in Batavia by accepting
+ <p><b>Proposed resolution:</b></p>
+ <ol>
+ <li>Change 29.5 [atomics.types.generic], class template specialization <tt>atomic&lt;T*&gt;</tt> synopsis, as indicated:
+-<blockquote><pre>namespace std {
++<blockquote><pre>
++namespace std {
+ template &lt;class T&gt; struct atomic&lt;T*&gt; <del>: atomic_address</del> {
+ [..]
+ };
+@@ -82412,11 +95268,11 @@ Resolved in Batavia by accepting
+ </pre></blockquote>
+ </li>
+ <li>Change 29.5 [atomics.types.generic] p. 4 as indicated:
+-<p></p><blockquote>
++<blockquote><p>
+ 4 There are pointer partial specializations on the <tt>atomic</tt> class template. <del>These specializations shall be publicly
+ derived from <tt>atomic_address</tt>.</del> The unit of addition/subtraction for these specializations shall be the size
+ of the referenced type. These specializations shall have trivial default constructors and trivial destructors.
+-</blockquote><p></p>
++</p></blockquote>
+ </li>
+ </ol>
+
+@@ -82426,39 +95282,44 @@ of the referenced type. These specializations shall have trivial default constru
+
+
+ <hr>
+-<h3><a name="1468"></a>1468. [FCD] <tt>atomic_address::compare_exchange_*</tt> member functions should match <tt>atomic_compare_exchange_*</tt> free functions</h3>
+-<p><b>Section:</b> 29.5.2 [atomics.types.address] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1468"></a>1468. <tt>atomic_address::compare_exchange_*</tt> member functions should match <tt>atomic_compare_exchange_*</tt> free functions</h3>
++<p><b>Section:</b> X [atomics.types.address] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.address">issues</a> in [atomics.types.address].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses US-164</b></p>
+
++<p>
+ <tt>atomic_address</tt> has member functions <tt>compare_exchange_weak</tt> and
+ <tt>compare_exchange_strong</tt> that take arguments of type <tt>const void*</tt>,
+ in addition to the <tt>void*</tt> versions. If these member functions survive,
+ there should be corresponding free functions.
++</p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
++<blockquote><p>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue
+ differently by removing the overloads with <tt>const void*</tt> arguments, because they break type-safety.
+-</blockquote>
++</p></blockquote>
+ <p><i>[
+ Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ ]</i></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-Extend the synopsis around <tt>atomic_address</tt> in 29.5.2 [atomics.types.address]
++<p>
++Extend the synopsis around <tt>atomic_address</tt> in X [atomics.types.address]
+ as indicated:
+-<blockquote><pre>namespace std {
++</p>
++<blockquote><pre>
++namespace std {
+ [..]
+ bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*);
+ bool atomic_compare_exchange_weak(atomic_address*, void**, void*);
+@@ -82496,25 +95357,31 @@ as indicated:
+
+
+ <hr>
+-<h3><a name="1469"></a>1469. [FCD] <tt>atomic&lt;T*&gt;</tt> inheritance from <tt>atomic_address</tt> breaks type safety</h3>
+-<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1469"></a>1469. <tt>atomic&lt;T*&gt;</tt> inheritance from <tt>atomic_address</tt> breaks type safety</h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p><b>Addresses GB-133</b></p>
+
++<p>
+ The free functions that operate on <tt>atomic_address</tt> can be
+ used to store a pointer to an unrelated type in an <tt>atomic&lt;T*&gt;</tt>
+ without a cast. e.g.
+-<blockquote><pre>int i;
++</p>
++<blockquote><pre>
++int i;
+ atomic&lt;int*&gt; ai(&amp;i);
+ string s;
+ atomic_store(&amp;ai,&amp;s);
+ </pre></blockquote>
++<p>
+ Overload the <tt>atomic_store</tt>, <tt>atomic_exchange</tt> and
+ <tt>atomic_compare_exchange_[weak/strong]</tt> operations for
+ <tt>atomic&lt;T*&gt;</tt> to allow storing only pointers to <tt>T</tt>.
++</p>
+
+ <p><i>[
+ 2010-10-27 Daniel adds:
+@@ -82523,22 +95390,24 @@ Overload the <tt>atomic_store</tt>, <tt>atomic_exchange</tt> and
+
+ <blockquote>
+ <p>
+-Resolving this issue will also solve <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1467">1467</a>
+-</p>
++Resolving this issue will also solve <a href="lwg-defects.html#1467">1467</a>
++<p/>
+ Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3164.html">n3164</a> would solve this issue by
+ removing <tt>atomic_address</tt>.
++</p>
+ </blockquote>
+
+ <p><i>[Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.html">n3193</a>.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">n3193</a>.
+ ]</i></p>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+ <p>Add the following overloads to 29.5 [atomics.types.generic], the synopsis around the specialization
+-<tt>atomic&lt;T*&gt;</tt>, as indicated:
+-</p><blockquote><pre>namespace std {
++<tt>atomic&lt;T*&gt;</tt>, as indicated:</p>
++<blockquote><pre>
++namespace std {
+ [..]
+ template &lt;class T&gt; struct atomic&lt;T*&gt; : atomic_address {
+ [..]
+@@ -82579,695 +95448,1301 @@ removing <tt>atomic_address</tt>.
+
+ }
+ </pre></blockquote>
+-<p></p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1481"></a>1481. [FCD] Missing Lockable requirements</h3>
+-<p><b>Section:</b> 30.2 [thread.req] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1474"></a>1474. weak compare-and-exchange confusion</h3>
++<p><b>Section:</b> 29.6.5 [atomics.types.operations.req] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.operations.req">active issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations.req">issues</a> in [atomics.types.operations.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Duplicate of:</b> <a href="lwg-closed.html#1470">1470</a>, <a href="lwg-closed.html#1475">1475</a>, <a href="lwg-closed.html#1476">1476</a>, <a href="lwg-closed.html#1477">1477</a></p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-138</b></p>
+
+-The FCD combines the requirements for lockable objects
+-with those for the standard mutex objects. These should
+-be separate. This is LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1268">1268</a>.
+
++
++<p><b>Addresses US-175, US-165, CH-23, GB-135</b></p>
++<p>
++29.6.5 [atomics.types.operations.req] p. 25: The first sentence is grammatically incorrect.
++</p>
+ <p><i>[
+-Resolution proposed by ballot comment:
++2010-10-28 Daniel adds:
+ ]</i></p>
+
+-<blockquote>
+-See attached Appendix 1 - Additional Details
+-</blockquote>
++<p>
++Duplicate issue <a href="lwg-closed.html#1475">1475</a> also has a proposed resolution, but both issues are resolved with
++below proposed resolution.
++</p>
+
+ <p><i>[
+-2010-11-01 Daniel comments:
++2011-02-15 Howard fixes numbering, Hans improves the wording
+ ]</i></p>
+
+-<blockquote>
+-Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> addresses
+-this issue.
+-</blockquote>
+
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 6 votes.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.html">n3197</a>.
++<ol>
++<li>
++<p>Change 29.6.5 [atomics.types.operations.req] p. 23 as indicated:</p>
++
++<blockquote><p>
++[ <em>Note</em>: <ins>For example, t</ins><del>T</del>he effect of
++<del>the compare-and-exchange operations</del><ins><tt>atomic_compare_exchange_strong</tt></ins> is
++</p><blockquote><pre>
++if (memcmp(object, expected, sizeof(*object)) == 0)
++ memcpy(object, &amp;desired, sizeof(*object));
++else
++ memcpy(expected, object, sizeof(*object));
++</pre></blockquote>
++<p> &mdash; <em>end note</em> ] [..]</p>
++</blockquote>
++</li>
++
++<li>
++<p>Change 29.6.5 [atomics.types.operations.req] p. 25 as indicated:</p>
++<blockquote><p>
++25 <em>Remark</em>: <del>The weak compare-and-exchange operations may fail spuriously, that is, return false while
++leaving the contents of memory pointed to by <tt>expected</tt> before the operation is the same that same
++as that of the <tt>object</tt> and the same as that of <tt>expected</tt> after the operation</del><ins>A weak
++compare-and-exchange operation may fail spuriously. That is, even when the contents of memory referred to by
++<tt>expected</tt> and <tt>object</tt> are equal, it may return false and store back to <tt>expected</tt> the same
++memory contents that were originally there.</ins>. [ <em>Note</em>: This spurious
++failure enables implementation of compare-and-exchange on a broader class of machines, e.g., loadlocked
++store-conditional machines. A consequence of spurious failure is that nearly all uses of weak
++compare-and-exchange will be in a loop.
++<p/>
++When a compare-and-exchange is in a loop, the weak version will yield better performance on some
++platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the
++strong one is preferable. &mdash; <em>end note</em> ]
++</p>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1482"></a>1482. [FCD] Timeout operations are under-specified</h3>
+-<p><b>Section:</b> 30.2.4 [thread.req.timing] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.req.timing">issues</a> in [thread.req.timing].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1478"></a>1478. Clarify race conditions in atomics initialization</h3>
++<p><b>Section:</b> 29.6 [atomics.types.operations] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.operations">issues</a> in [atomics.types.operations].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-181</b></p>
+-
+-The timeout operations are under-specified.
+-
++<p><b>Addresses GB-136</b></p>
++<p>
++GB requests normative clarification in 29.6 [atomics.types.operations] p.4 that
++concurrent access constitutes a race, as already done on p.6 and p.7.
++</p>
+ <p><i>[
+-Resolution proposed by ballot comment:
++Resolution proposed in ballot comment:
+ ]</i></p>
+
+
+-<blockquote>
+-Define precise semantics for <tt>timeout_until</tt> and <tt>timeout_for</tt>. See
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> page 193 - Appendix 1 - Additional Details
+-</blockquote>
++<blockquote><p>
++Initialisation of atomics:
++<p/>
++We believe the intent is that for any atomics there is a distinguished
++initialisation write, but that this need not happens-before all the
++other operations on that atomic - specifically so that the
++initialisation write might be non-atomic and hence give rise to a data
++race, and hence undefined behaviour, in examples such as this (from
++Hans):
++</p>
++<blockquote><pre>
++atomic&lt;atomic&lt;int&gt; *&gt; p
++f() |
++{ atomic&lt;int&gt;x; | W_na x
++ p.store(&amp;x,mo_rlx); | W_rlx p=&amp;x
++} |
++</pre></blockquote><p>
++(where na is nonatomic and rlx is relaxed). We suspect also that no
++other mixed atomic/nonatomic access to the same location is intended
++to be permitted. Either way, a note would probably help.
++</p></blockquote>
+
+-<p><i>[
+-2010-11-01 Daniel comments:
+-]</i></p>
++<p><i>[2011-02-26: Hans comments and drafts wording]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3128</a> would solve this issue.
+-</blockquote>
++<p>I think the important point here is to clarify that races on atomics
++are possible, and can be introduced as a result of non-atomic
++initialization operations. There are other parts of this that remain unclear
++to me, such as whether there are other ways to introduce data races on atomics,
++or whether the races with initialization also introduce undefined behavior
++by the 3.8 lifetime rules. But I don't think that it is necessary to resolve
++those issues before releasing the standard. That's particularly true
++since we've introduced <tt>atomic_init</tt>, which allows easier ways to
++construct initialization races.
++</p>
++
++<p><i>[2011-03 Madrid]</i></p>
++
++<p>Accepted to be applied immediately to the WP</p>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3191</a>.
++<ol>
++<li><p>Update 29.6.5 [atomics.types.operations.req] p. 5 as follows:</p>
++
++<blockquote><pre>
++constexpr A::A(C desired);
++</pre><blockquote><p>
++5 <i>Effects</i>: Initializes the object with the value <tt>desired</tt>. <del>[ <i>Note</i>:
++Construction is not atomic. &mdash; <i>end note</i> ]</del><ins> Initialization is not an
++atomic operation (1.10) [intro.multithread]. [<i>Note</i>: It is possible to have an
++access to an atomic object <tt>A</tt> race with its construction, for example
++by communicating the address of the just-constructed object <tt>A</tt> to another thread
++via <code>memory_order_relaxed</code> atomic operations on a suitable atomic pointer variable,
++and then immediately accessing <tt>A</tt> in the receiving thread. This results in undefined
++behavior. &mdash; <i>end note</i>]</ins>
++</p></blockquote></blockquote>
++</li>
++
++<li><p>In response to the editor comment to 29.6.5 [atomics.types.operations.req] p. 8:
++The first <i>Effects</i> element is the correct and intended one:</p>
++
++<blockquote><pre>
++void atomic_init(volatile A *object, C desired);
++void atomic_init(A *object, C desired);
++</pre><blockquote><p>
++8 <i>Effects</i>: Non-atomically initializes <tt>*object</tt> with value <tt>desired</tt>.
++This function shall only be applied to objects that have been default constructed, and then only once.
++[ <i>Note</i>: these semantics ensure compatibility with C. &mdash; <i>end note</i> ] [ <i>Note</i>:
++Concurrent access from another thread, even via an atomic operation, constitutes a data
++race. &mdash; <i>end note</i> ] <del>[<i>Editor's note</i>: The preceding text is from the WD as
++amended by N3196. N3193 makes different changes, marked up in the paper as follows:]
++<i>Effects</i>: Dynamically initializes an atomic variable. Non-atomically That is, non-atomically assigns the
++value desired to <tt>*object</tt>. [ <i>Note</i>: this operation may need to initialize
++locks. &mdash; <i>end note</i> ] Concurrent access from another thread, even via an atomic
++operation, constitutes a data race.</del>
++</p></blockquote></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1490"></a>1490. [FCD] Mutex requirements too stringent</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1479"></a>1479. Fence functions should be <tt>extern "C"</tt></h3>
++<p><b>Section:</b> 29.8 [atomics.fences] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.fences">issues</a> in [atomics.fences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-27</b></p>
+-
+-The mutex requirements force <tt>try_lock</tt> to be
+-<tt>noexcept(true)</tt>. However, where they are used by the
+-generic algorithms, those relax this requirement and say
+-that <tt>try_lock</tt> may throw. This means the requirement is
+-too stringent, also a non-throwing <tt>try_lock</tt> does not allow
+-for a diagnostic such as <tt>system_error</tt> that <tt>lock()</tt>
+-will give us.
++<p><b>Addresses US-179</b></p>
++<p>
++The fence functions (29.8 [atomics.fences] p.5 + p.6) should be <tt>extern "C"</tt>, for <tt>C</tt> compatibility.
++</p>
+
+-<p><i>[
+-Resolution proposed by ballot comment:
+-]</i></p>
++<p><i>[2011-02-16 Reflector discussion]</i></p>
+
+-<blockquote>
+-delete p18, adjust 30.4.4 p1 and p4 accordingly
+-</blockquote>
++<p>
++Moved to Tentatively Ready after 6 votes.
++</p>
+
+-<p><i>[
+-2010-11-01 Daniel comments:
+-]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> would solve this issue.
+-</blockquote>
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>Change 29.2 [atomics.syn], header <tt>&lt;atomic&gt;</tt> synopsis as indicated:
++<blockquote><pre>
++namespace std {
++ [..]
++ // <em>29.8, fences</em>
++ <ins>extern "C"</ins> void atomic_thread_fence(memory_order);
++ <ins>extern "C"</ins> void atomic_signal_fence(memory_order);
++}
++</pre></blockquote>
++</li>
++<li><p>Change 29.8 [atomics.fences], p. 5 and p. 6 as indicated:</p>
++<blockquote><pre>
++<ins>extern "C"</ins> void atomic_thread_fence(memory_order);
++</pre><blockquote><p>
++5 <em>Effects</em>: depending on the value of <tt>order</tt>, this operation: [..]
++</p></blockquote></blockquote>
++<blockquote><pre>
++<ins>extern "C"</ins> void atomic_signal_fence(memory_order);
++</pre><blockquote><p>
++6 <em>Effects</em>: equivalent to <tt>atomic_thread_fence(order)</tt>, except that synchronizes with relationships are
++established only between a thread and a signal handler executed in the same thread.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1480"></a>1480. Atomic fences don't have <em>synchronizes with</em> relation</h3>
++<p><b>Section:</b> 29.8 [atomics.fences] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.fences">issues</a> in [atomics.fences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-137</b></p>
++<p>
++Thread fence not only establish synchronizes with relationships,
++there are semantics of fences that are expressed not in
++terms of <em>synchronizes with</em> relationships (for example see 29.3 [atomics.order] p.5).
++These semantics also need to apply to the use of
++<tt>atomic_signal_fence</tt> in a restricted way.
++</p>
++<p><i>[Batavia: Concurrency group discussed issue, and is OK with the proposed resolution.]</i></p>
++
++
++<p><i>[2011-02-26 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.html">n3197</a>.
++<p>Change 29.8 [atomics.fences] p. 6 as indicated:</p>
++<blockquote><pre>
++void atomic_signal_fence(memory_order);
++</pre><blockquote><p>
++6 <em>Effects</em>: equivalent to <tt>atomic_thread_fence(order)</tt>, except that <del>synchronizes
++with relationships</del><ins>the resulting ordering constraints</ins> are established only between a
++thread and a signal handler executed in the same thread.
++</p></blockquote></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1491"></a>1491. [FCD] <tt>try_lock</tt> does not guarantee forward progress</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1481"></a>1481. Missing Lockable requirements</h3>
++<p><b>Section:</b> 30.2 [thread.req] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-186</b></p>
++<p><b>Addresses GB-138</b></p>
+
+-<tt>try_lock</tt> does not provide a guarantee of forward progress
+-because it is allowed to spuriously fail.
++<p>
++The FCD combines the requirements for lockable objects
++with those for the standard mutex objects. These should
++be separate. This is LWG issue <a href="lwg-defects.html#1268">1268</a>.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
+-The standard mutex types must not fail spuriously
+-in <tt>try_lock</tt>. See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> page 205 - Appendix 1 - Additional Details
+-</blockquote>
++<blockquote><p>
++See attached Appendix 1 - Additional Details
++</p></blockquote>
+
+ <p><i>[
+ 2010-11-01 Daniel comments:
+ ]</i></p>
+
+-<blockquote>
+-Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3152.html">n3152</a> addresses
++<blockquote><p>
++Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> addresses
+ this issue.
+-</blockquote>
++</p></blockquote>
+
+
+
+ <p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3209.html">n3209</a>.
++<p>Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.htm">n3197</a>.</p>
+
+
+
+
+
+ <hr>
+-<h3><a name="1492"></a>1492. [FCD] Mutex requirements should not be bound to threads</h3>
+-<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1482"></a>1482. Timeout operations are under-specified</h3>
++<p><b>Section:</b> 30.2.4 [thread.req.timing] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.req.timing">issues</a> in [thread.req.timing].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-188</b></p>
++<p><b>Addresses US-181</b></p>
+
+-Mutex requirements should not be bound to threads
++<p>
++The timeout operations are under-specified.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
+-See Appendix 1 of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> - Additional Details, p. 208.
+-</blockquote>
++
++<blockquote><p>
++Define precise semantics for <tt>timeout_until</tt> and <tt>timeout_for</tt>. See
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> page 193 - Appendix 1 - Additional Details
++</p></blockquote>
+
+ <p><i>[
+-2010-10-24 Daniel adds:
++2010-11-01 Daniel comments:
+ ]</i></p>
+
+
+-<blockquote>
+-Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> would solve this issue.
+-</blockquote>
+-
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3128</a> would solve this issue.
++</p></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.html">n3197</a>.
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3128.html">n3191</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1498"></a>1498. [FCD] Unclear specification for [thread.condition]</h3>
+-<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-29</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1487"></a>1487. Clock related operations exception specifications conflict</h3>
++<p><b>Section:</b> 30.3.2 [thread.thread.this] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.thread.this">issues</a> in [thread.thread.this].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-29</b></p>
+-
+-It is unclear if a spurious wake-up during the loop and reentering
+-of the blocked state due to a repeated execution
+-of the loop will adjust the timer of the blocking with the
+-respect to the previously specified rel_time value.
+-
++<p><b>Addresses CH-25</b></p>
++<p>
++Clock related operations are currently not required not to
++throw. So "Throws: Nothing." is not always true.
++</p>
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
++<blockquote><p>
++Either require clock related operations not to throw
++(in 20.10) or change the Throws clauses in 30.3.2.
++Also possibly add a note that <tt>abs_time</tt> in the past
++or negative <tt>rel_time</tt> is allowed.
++</p></blockquote>
++
++<p><i>[2011-02-10: Howard Hinnant provides a resolution proposal]</i></p>
++
++
++<p><i>[Previous proposed resolution:]</i></p>
++
++<ol>
++<li>
++<p>Change the Operational semantics of <tt>C1::now()</tt> in 20.12.3 [time.clock.req],
++Table 59 &mdash; <tt>Clock</tt> requirements as follows:
++</p>
+
+ <blockquote>
+-Make it clear (e.g. by a note) that when reexecuting
+-the loop the waiting time when blocked
+-will be adjusted with respect to the elapsed time of
+-the previous loop executions.
++<table border="1">
++<caption>Table 59 &mdash; <tt>Clock</tt> requirements</caption>
++<tr>
++<th>
++Expression
++</th>
++
++<th>
++Return type
++</th>
++
++<th>
++Operational semantics
++</th>
++
++</tr>
++
++<tr>
++<td><tt>C1::now()</tt></td>
++
++<td><tt>C1::time_point</tt></td>
++
++<td>Returns a <tt>time_point</tt> object<br/>
++representing the current point in time.<br/>
++<ins>Shall not throw an exception.</ins></td>
++</tr>
++
++</table>
+ </blockquote>
+
+-<p><i>[
+-2010-08-13 Peter Sommerlad comments and provides wording:
+-]</i></p>
+
++</li>
++</ol>
+
+-<blockquote>
+-Problem: It is unclear if a spurious wake-up during the loop and re-entering of the blocked state due
+-to a repeated execution of the loop will adjust the timer of the blocking with the respect to the
+-previously specified <tt>rel_time</tt> value.
+-<p>
+-Proposed Resolution from CH29:
+-</p><p>
+-Make it clear (e.g. by a note) that when re-executing the loop the waiting time when blocked will be
+-adjusted with respect to the elapsed time of the previous loop executions.
+-</p><p>
+-Discussion in Rapperswil:
+-</p><p>
+-Assuming the introduction of a mandatory <tt>steady_clock</tt> proposed by US-181 to the FCD the
+-specification of <tt>condition_variable::wait_for</tt> can be defined in terms of <tt>wait_until</tt>
+-using the <tt>steady_clock</tt>. This is also interleaving with US-181, because that touches the
+-same paragraph (30.5.1 p 25, p34 and 30.5.2 p 20, p 28 in n3092.pdf)
+-</p><p>
+-(The "as if" in the proposed solutions should be confirmed by the standardization terminology experts)
++<p><i>[2011-02-19: Daniel comments and suggests an alternative wording]</i></p>
++
++
++<p>Imposing the no-throw requirement on <tt>C1::now()</tt> of any clock time
++is an overly radical step: It has the indirect consequences that representation
++types for <tt>C1::rep</tt> can never by types with dynamic memory managment,
++e.g. my <tt>big_int</tt>, which are currently fully supported by the time
++utilities. Further-on this strong constraint does not even solve the problem
++described in the issue, because we are still left with the fact that any
++of the arithmetic operations of <tt>C1::rep</tt>, <tt>C1::duration</tt>,
++and <tt>C1::time_point</tt> may throw exceptions.
++</p>
++<p>The alternative proposal uses the following strategy: The general <tt>Clock</tt>
++requirements remain untouched, but we require that any functions of the library-provided
++clocks from sub-clause 20.12.7 [time.clock] and their associated types shall not
++throw exceptions. Second, we replace existing <tt>noexcept</tt> specifications of
++functions from Clause 30 that depend on durations, clocks, or time points by wording that
++clarifies that these functions can only throw, if the operations of user-provided durations,
++clocks, or time points used as arguments to these functions throw exceptions.
++</p>
++
++<p><i>[2011-03-23 Daniel and Peter check and simplify the proposed resolution resulting in this paper]</i></p>
++
++
++<p>There is an inherent problem with <tt>std::time_point</tt> that it doesn't seem to have an equivalent value
++for <tt>((time_t)-1)</tt> that gets returned by C's <tt>time()</tt> function to signal a problem, e.g., because
++the underlying hardware is unavailable. After a lot of thinking and checks we came to the resolution that
++<tt>timepoint::max()</tt> should be the value to serve as a value signaling errors in cases where we
++prefer to stick with no-throw conditions. Of-course, user-provided representation types don't need to
++follow this approach if they prefer exceptions to signal such failures.
++<p/>
++the functions <tt>now()</tt> and <tt>from_time_t()</tt> can remain <tt>noexcept</tt> with the solution to
++return <tt>timepoint::max()</tt> in case the current time cannot be determined or <tt>(time_t)-1</tt> is passed
++in, respectively.
++<p/>
++Based on the previous proposed solution to LWG 1487 we decided that the new <tt>TrivialClock</tt> requirements
++should define that <tt>now()</tt> mustn't throw and return <tt>timepoint::max()</tt> to signal a problem. That
++is in line with the C standard where <tt>(time_t)-1</tt> signals a problem. Together with a fix to a - we assumed -
++buggy specifcation in 20.11.3 p2 which uses "happens-before" relationship with something that isn't any action:
++</p>
++<blockquote><p>
++2 In Table 59 <tt>C1</tt> and <tt>C2</tt> denote clock types. <tt>t1</tt> and <tt>t2</tt> are values returned by
++<tt>C1::now()</tt> where the call returning <tt>t1</tt> happens before (1.10) the call returning <tt>t2</tt> and
++both of these calls happen before <tt>C1::time_point::max()</tt>.
+ </p></blockquote>
+
+-<p><i>[
+-2010-11 Batavia: Resolved by applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>
++<p><i>[2011-03-23 Review with Concurrency group suggested further simplifications and Howard pointed out, that
++we do not need time_point::max() as a special value.]</i></p>
++
++
++<p>also the second "happens before" will be changed to "occurs before" in the english meaning. this is
++to allow a steady clock to wrap.
++<p/>
++Peter updates issue accordingly to discussion.
++</p>
++
++<p><i>[Note to the editor: we recommend removal of the following redundant paragraphs in
++ 30.5.2 [thread.condition.condvarany] p. 18 to p. 21, p. 27, p. 28, p. 30, and p. 31 that are
++defining details for the wait functions that are given by the <i>Effects</i> element.
+ ]</i></p>
+
+
+-<blockquote>
++<p><i>[Note to the editor: we recommend removal of the following redundant paragraphs in
++30.5.1 [thread.condition.condvar]: p24-p26, p33-p34, and p36-p37 that are defining details for the
++<tt>wait_for</tt> functions. We believe these paragraphs are redundant with respect to the <i>Effects</i> clauses that
++define semantics based on <tt>wait_until</tt>. An example of such a specification is the <tt>wait()</tt> with a predicate.
++]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
+ <ol>
+-<li>Change 30.5.1 [thread.condition.condvar] paragraph 25, <tt>wait_for</tt> <i>Effects</i> as indicated:
+-<blockquote><pre>template &lt;class Rep, class Period&gt;
+-cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+-</pre></blockquote>
+-<blockquote>
+-[..]
+-<p>
+-25 <i>Effects</i>: <ins>as if</ins>
+-</p><blockquote><pre><ins>return wait_until(lock, chrono::steady_clock::now() + rel_time);</ins>
+-</pre></blockquote>
+-<ul>
+-<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.</del>
++<li><p>Change p2 in 20.11.3 [time.clock.req] as follows</p>
++<blockquote><p>
++2 In Table 59 <tt>C1</tt> and <tt>C2</tt> denote clock types. <tt>t1</tt> and
++<tt>t2</tt> are values returned by <tt>C1::now()</tt> where the call returning <tt>t1</tt>
++happens before (1.10) the call returning <tt>t2</tt> and both of these calls <del>happen</del>
++<ins>occur</ins> before <tt>C1::time_point::max()</tt>.
++<ins>[ <i>Note</i>: This means <tt>C1</tt> didn't wrap around between <tt>t1</tt> and <tt>t2</tt> &mdash; <i>end note</i> ]</ins>
++</p></blockquote>
+ </li>
+-<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock), then returns.</del>
++
++<li><p>Add the following new requirement set at the end of sub-clause 20.12.3 [time.clock.req]: [<i>Comment</i>:
++This requirement set is <strong>intentionally</strong> incomplete. The reason for
++this incompleteness is the based on the fact, that if we would make it right for C++0x, we would end up defining
++something like a complete <tt>ArithmeticLike</tt> concept for <tt>TC::rep</tt>, <tt>TC::duration</tt>, and <tt>TC::time_point</tt>.
++But this looks out-of scope for C++0x to me. The effect is that we essentially do not exactly say, which arithmetic
++or comparison operations can be used in the time-dependent functions from Clause 30, even though I expect that
++all declared functions of <tt>duration</tt> and <tt>time_point</tt> are well-formed and well-defined. &mdash; <i>end comment</i>]</p>
++<blockquote><p>
++3 [ <i>Note</i>: the relative difference in durations between those reported by a given clock and the SI definition is
++a measure of the quality of implementation. &mdash; <i>end note</i> ]
++</p></blockquote>
++
++<blockquote><p>
++<ins>? A type <tt>TC</tt> meets the <tt><i>TrivialClock</i></tt> requirements if:</ins>
++</p>
++<ul>
++<li><p>
++<ins><tt>TC</tt> satisfies the <tt>Clock</tt> requirements (20.12.3 [time.clock.req]),</ins>
++</p></li>
++<li><p>
++<ins>the types <tt>TC::rep</tt>, <tt>TC::duration</tt>, and <tt>TC::time_point</tt> satisfy
++the requirements of <tt>EqualityComparable</tt> ( [equalitycomparable]), <tt>LessThanComparable</tt>
++( [lessthancomparable]), <tt>DefaultConstructible</tt> ( [defaultconstructible]),
++<tt>CopyConstructible</tt> ( [copyconstructible]), <tt>CopyAssignable</tt> ( [copyassignable]),
++<tt>Destructible</tt> ( [destructible]), and of numeric types ([numeric.requirements]) [<i>Note</i>: This means in
++particular, that operations of these types will not throw exceptions &mdash; <i>end note</i> ],</ins>
++</p></li>
++<li><p>
++<ins>lvalues of the types <tt>TC::rep</tt>, <tt>TC::duration</tt>, and <tt>TC::time_point</tt> are swappable
++(17.6.3.2 [swappable.requirements]),</ins>
++</p></li>
++<li><p>
++<ins>the function <tt>TC::now()</tt> does not throw exceptions, and</ins>
++</p></li>
++<li><p>
++<ins>the type <tt>TC::time_point::clock</tt> meets the <tt>TrivialClock</tt> requirements, recursively.</ins>
++</p></li>
++</ul>
++</blockquote>
+ </li>
+-<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
+-by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.</del>
++
++<li>
++<p>Modify 20.12.7 [time.clock] p. 1 as follows:</p>
++
++<blockquote><p>
++1 - The types defined in this subclause shall satisfy the <tt><ins>Trivial</ins>Clock</tt> requirements (20.11.1).
++</p></blockquote>
+ </li>
+-<li><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function scope.</del>
++
++<li>
++<p>Modify 20.12.7.1 [time.clock.system] p. 1, class <tt>system_clock</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++class system_clock {
++public:
++ typedef <i>see below</i> rep;
++ typedef ratio&lt;<i>unspecified</i> , <i>unspecified</i> &gt; period;
++ typedef chrono::duration&lt;rep, period&gt; duration;
++ typedef chrono::time_point&lt;system_clock&gt; time_point;
++ static const bool is_monotonic is_steady = <i>unspecified</i>;
++ static time_point now() <ins>noexcept</ins>;
++ // Map to C API
++ static time_t to_time_t (const time_point&amp; t) <ins>noexcept</ins>;
++ static time_point from_time_t(time_t t) <ins>noexcept</ins>;
++};
++</pre></blockquote>
++
+ </li>
+-</ul>
++
++<li>
++<p>Modify the prototype declarations in 20.12.7.1 [time.clock.system] p. 3 + p. 4 as indicated (This
++edit also fixes the miss of the <tt>static</tt> specifier in these prototype declarations):</p>
++
++<blockquote><pre>
++<ins>static</ins> time_t to_time_t(const time_point&amp; t) <ins>noexcept</ins>;
++</pre>
++
++<pre>
++<ins>static</ins> time_point from_time_t(time_t t) <ins>noexcept</ins>;
++</pre>
+ </blockquote>
++
+ </li>
+-<li>Change 30.5.1 [thread.condition.condvar] paragraph 34, <tt>wait_for</tt> with predicate <i>Effects</i> as indicated:
+-<blockquote><pre>template &lt;class Rep, class Period, class Predicate&gt;
+-bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
+- const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
+- Predicate pred);
+-</pre></blockquote>
+-<blockquote>
+-[..]
+-<p>
+-34 <i>Effects</i>: <ins>as if</ins>
+-</p><blockquote><pre><ins>return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));</ins>
++
++<li>
++<p>Modify 20.12.7.2 [time.clock.steady] p. 1, class <tt>steady_clock</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++class steady_clock {
++public:
++ typedef <i>unspecified</i> rep;
++ typedef ratio&lt;<i>unspecified</i> , <i>unspecified</i> &gt; period;
++ typedef chrono::duration&lt;rep, period&gt; duration;
++ typedef chrono::time_point&lt;<i>unspecified</i>, duration&gt; time_point;
++ static const bool is_monotonic is_steady = true;
++
++ static time_point now() <ins>noexcept</ins>;
++};
+ </pre></blockquote>
+-<ul>
+-<li><del>Executes a loop: Within the loop the function first evaluates <tt>pred()</tt> and exits the loop if the
+-result is <tt>true</tt>.
+-</del></li>
+
+-<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
+-</del></li>
++</li>
+
+-<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock).
+-</del></li>
++<li>
++<p> Modify 20.12.7.3 [time.clock.hires] p. 1, class <tt>high_resolution_clock</tt> synopsis, as follows:</p>
+
+-<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
+-by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
+-</del></li>
++<blockquote><pre>
++class high_resolution_clock {
++public:
++ typedef <i>unspecified</i> rep;
++ typedef ratio&lt;<i>unspecified</i> , <i>unspecified</i> &gt; period;
++ typedef chrono::duration&lt;rep, period&gt; duration;
++ typedef chrono::time_point&lt;<i>unspecified</i>, duration&gt; time_point;
++ static const bool is_monotonic is_steady = <i>unspecified</i>;
+
+-<li><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
+-scope.
+-</del></li>
++ static time_point now() <ins>noexcept</ins>;
++};
++</pre></blockquote>
+
+-<li><del>The loop terminates when <tt>pred()</tt> returns <tt>true</tt> or when the time duration specified by <tt>rel_time</tt>
+-has elapsed.
+-</del></li>
++</li>
+
+-</ul>
+-</blockquote>
++<li><p>Add a new paragraph at the end of 30.2.4 [thread.req.timing]:</p>
++
++<blockquote><p>
++6 The resolution of timing provided by an implementation depends on both operating system and hardware.
++The finest resolution provided by an implementation is called the <i>native resolution</i>.
++</p></blockquote>
++
++<blockquote><p>
++<ins>? Implementation-provided clocks that are used for these functions shall meet the <tt>TrivialClock</tt>
++requirements (20.12.3 [time.clock.req]).</ins>
++</p></blockquote>
+ </li>
+
+-<li>Change 30.5.2 [thread.condition.condvarany] paragraph 20, <tt>wait_for</tt> <i>Effects</i> as indicated:
+-<blockquote><pre>template &lt;class Lock, class Rep, class Period&gt;
+-cv_status wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
+-</pre></blockquote>
+-<blockquote>
+-20 <i>Effects</i>: <ins>as if</ins>
+-<blockquote><pre><ins>return wait_until(lock, chrono::steady_clock::now() + rel_time);</ins>
++<li>
++<p>Edit the synopsis of 30.3.2 [thread.thread.this] before p. 1.
++<i>[Note: this duplicates edits also in D/N3267]</i>:
++</p>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++void sleep_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++template &lt;class Rep, class Period&gt;
++void sleep_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
+ </pre></blockquote>
+-<ul>
+-<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
+-</del></li>
++</li>
+
+-<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock), then returns.
+-</del></li>
++<li>
++<p>Modify the prototype specifications in 30.3.2 [thread.thread.this] before p. 4 and p. 6 and
++re-add a <i>Throws</i> element following the <i>Synchronization</i> elements at p. 5 and p. 7:</p>
+
+-<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
+-by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
+-</del></li>
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++void sleep_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++</pre><blockquote><p>
++4 - [...]
++<p/>
++5 - <i>Synchronization</i>: None.
++<p/>
++<ins>? - <i>Throws</i>: Nothing if <tt>Clock</tt> satisfies the <tt>TrivialClock</tt> requirements (20.12.3 [time.clock.req]) and
++operations of <tt>Duration</tt> do not throw exceptions.
++[<i>Note</i>: Instantiations of time point types and clocks supplied by the implementation as specified in 20.12.7 [time.clock]
++do not throw exceptions. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
+
+-<li><del>If the function exits via an exception, <tt>lock.unlock()</tt> shall be called prior to exiting the function
+-scope.
+-</del></li>
+-</ul>
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++void sleep_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
++</pre><blockquote><p>
++6 [...]
++<p/>
++7 <i>Synchronization</i>: None.
++<p/>
++<ins>? <i>Throws</i>: Nothing if operations of <tt>chrono::duration&lt;Rep, Period&gt;</tt> do not throw exceptions.
++[<i>Note</i>: Instantiations of duration types supplied by the implementation as specified in 20.12.7 [time.clock]
++do not throw exceptions. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Fix a minor incorrectness in p. 5: Duration types need to compare against <tt>duration&lt;&gt;::zero()</tt>,
++not <tt>0</tt>:</p>
++
++<blockquote><p>
++3 The expression <tt>m.try_lock_for(rel_time)</tt> shall be well-formed and have the following semantics:
++<p/>
++[...]
++<p/>
++5 <i>Effects</i>: The function attempts to obtain ownership of the mutex within the relative timeout (30.2.4)
++specified by <tt>rel_time</tt>. If the time specified by <tt>rel_time</tt> is less than or equal to <del><tt>0</tt></del><ins><tt>rel_time.zero()</tt></ins>,
++the function attempts to obtain ownership without blocking (as if by calling <tt>try_lock()</tt>). The function shall return
++within the timeout specified by <tt>rel_time</tt> only if it has obtained ownership of the mutex object.
++[ <i>Note</i>: As with <tt>try_lock()</tt>, there is no guarantee that ownership will be obtained if the lock is
++available, but implementations are expected to make a strong effort to do so. &mdash; <i>end note</i> ]
++</p>
+ </blockquote>
+ </li>
+
+-<li>Change 30.5.2 [thread.condition.condvarany] paragraph 28, <tt>wait_for</tt> with predicate <i>Effects</i> as indicated:
+-<blockquote><pre>template &lt;class Lock, class Rep, class Period, class Predicate&gt;
+-bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
++<li><p>Modify the class <tt>timed_mutex</tt> synopsis in 30.4.1.3.1 [thread.timedmutex.class] as indicated:
++<i>[Note: this duplicates edits also in D/N3267]</i>:
++</p>
++
++<blockquote><pre>
++class timed_mutex {
++public:
++ [...]
++ template &lt;class Rep, class Period&gt;
++ bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
++ template &lt;class Clock, class Duration&gt;
++ bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++ [...]
++};
+ </pre></blockquote>
+-<blockquote>
+-28 <i>Effects</i>: <ins>as if</ins>
+-<blockquote><pre><ins>return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));</ins>
++</li>
++
++<li><p>Modify the class <tt>recursive_timed_mutex</tt> synopsis in 30.4.1.3.2 [thread.timedmutex.recursive] as indicated:
++<i>[Note: this duplicates edits also in D/N3267]</i>:
++</p>
++
++<blockquote><pre>
++class recursive_timed_mutex {
++public:
++ [...]
++ template &lt;class Rep, class Period&gt;
++ bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
++ template &lt;class Clock, class Duration&gt;
++ bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++ [...]
++};
+ </pre></blockquote>
+-<ul>
+-<li><del>Executes a loop: Within the loop the function first evaluates <tt>pred()</tt> and exits the loop if the
+-result is <tt>true</tt>.
+-</del></li>
++</li>
+
+-<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
+-</del></li>
++<li><p>Modify the class template <tt>unique_lock</tt> synopsis in 30.4.2.2 [thread.lock.unique] as indicated.
++<i>[Note: this duplicates edits also in D/N3267]</i>:
++</p>
+
+-<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock).
+-</del></li>
++<blockquote><pre>
++template &lt;class Mutex&gt;
++class unique_lock {
++public:
++ [...]
++ template &lt;class Clock, class Duration&gt;
++ unique_lock(mutex_type&amp; m, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++ template &lt;class Rep, class Period&gt;
++ unique_lock(mutex_type&amp; m, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
++ [...]
++};
++</pre></blockquote>
++</li>
+
+-<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
+-by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
+-</del></li>
++<li><p>Modify the constructor prototypes in 30.4.2.2.1 [thread.lock.unique.cons] before p. 14 and p. 17
++<i>[Note: this duplicates edits also in D&#47;N3267]</i>:
++</p>
+
+-<li><del>If the function exits via an exception, <tt>lock.unlock()</tt> shall be called prior to exiting the function
+-scope.
+-</del></li>
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++ unique_lock(mutex_type&amp; m, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) <del>noexcept</del>;
++</pre></blockquote>
+
+-<li><del>The loop terminates when <tt>pred()</tt> returns <tt>true</tt> or when the time duration specified by <tt>rel_time</tt>
+-has elapsed.
+-</del></li>
+-</ul>
+-</blockquote>
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++ unique_lock(mutex_type&amp; m, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) <del>noexcept</del>;
++</pre></blockquote>
+ </li>
+
+-</ol>
+-
+-</blockquote>
+
++</ol>
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.html">n3191</a>.
+
+
+
+
+
+ <hr>
+-<h3><a name="1501"></a>1501. [FCD] spec for managing associated asynchronous
+-state has problems</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1490"></a>1490. Mutex requirements too stringent</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-194</b></p>
++<p><b>Addresses CH-27</b></p>
+
+-The specification for managing associated asynchronous
+-state is confusing, sometimes omitted, and redundantly
+-specified.
++<p>
++The mutex requirements force <tt>try_lock</tt> to be
++<tt>noexcept(true)</tt>. However, where they are used by the
++generic algorithms, those relax this requirement and say
++that <tt>try_lock</tt> may throw. This means the requirement is
++too stringent, also a non-throwing <tt>try_lock</tt> does not allow
++for a diagnostic such as <tt>system_error</tt> that <tt>lock()</tt>
++will give us.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
++<blockquote><p>
++delete p18, adjust 30.4.4 p1 and p4 accordingly
++</p></blockquote>
+
+-<blockquote>
+-Define terms-of-art for releasing, making ready,
+-and abandoning an associated asynchronous
+-state. Use those terms where appropriate. See
+-Appendix 1 - Additional Details
+-</blockquote>
++<p><i>[
++2010-11-01 Daniel comments:
++]</i></p>
+
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3192.html">n3192</a>.
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> would solve this issue.
++</p></blockquote>
++
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.htm">n3197</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1508"></a>1508. [FCD] Rename <tt>packaged_task::operator bool()</tt></h3>
+-<p><b>Section:</b> 30.6.10 [futures.task] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures.task">issues</a> in [futures.task].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1491"></a>1491. <tt>try_lock</tt> does not guarantee forward progress</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses US-201</b></p>
++<p><b>Addresses US-186</b></p>
++
+ <p>
+-<tt>packaged_task</tt> provides <tt>operator bool()</tt> to check whether
+-an object has an associated asynchronous state. The various <tt>future</tt>
+-types provide a member function <tt>valid()</tt> that does the same thing.
+-The names of these members should be the same.
++<tt>try_lock</tt> does not provide a guarantee of forward progress
++because it is allowed to spuriously fail.
+ </p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<blockquote>
+-Replaced the name <tt>packaged_task::operator bool()</tt> with <tt>packaged_task::valid()</tt> in the synopsis
+-(30.6.10 [futures.task]/2) and the member function specification (before 30.6.10.1 [futures.task.members]/15).
+-</blockquote>
++<blockquote><p>
++The standard mutex types must not fail spuriously
++in <tt>try_lock</tt>. See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a>
++page 205 - Appendix 1 - Additional Details
++</p></blockquote>
+
+ <p><i>[
+-2010-11-02 Daniel translates proposed wording changes into a proper proposed resolution
+-and verified that no other places implicitly take advantage of <tt>packaged_task</tt>
+-conversion to bool.
+-]</i></p>
+-
+-
+-<p><i>[Resolved in Batavia by accepting
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3194.html">n3194</a>.
++2010-11-01 Daniel comments:
+ ]</i></p>
+
++<blockquote><p>
++Paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3152.html">n3152</a> addresses
++this issue.
++</p></blockquote>
+
+
+
+-<p><b>Proposed resolution:</b></p>
+-<ol>
+-<li>Change 30.6.10 [futures.task]/2, class template <tt>packaged_task</tt> synopsis as indicated:
+-<blockquote><pre>template&lt;class R, class... ArgTypes&gt;
+-class packaged_task&lt;R(ArgTypes...)&gt; {
+-public:
+- typedef R result_type;
+- [..]
+- <del>explicit operator</del> bool <ins>valid</ins>() const;
+- [..]
+-};
+-</pre></blockquote>
+-</li>
+-<li>Change 30.6.10 [futures.task] before p. 15 as indicated:
+-<blockquote><pre><del>explicit operator</del> bool <ins>valid</ins>() const;
+-</pre><blockquote>
+-15 <em>Returns</em>: true only if <tt>*this</tt> has an associated asynchronous state.
+-<p>
+-16 <em>Throws</em>: nothing.
+-</p></blockquote></blockquote>
+-</li>
+-</ol>
+-
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3209.htm">n3209</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1513"></a>1513. [FCD] 'launch' enum too restrictive</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="1492"></a>1492. Mutex requirements should not be bound to threads</h3>
++<p><b>Section:</b> 30.4.1 [thread.mutex.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#thread.mutex.requirements">active issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.mutex.requirements">issues</a> in [thread.mutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses CH-36</b></p>
++<p><b>Addresses US-188</b></p>
+
+-Providing only three different possible values for the enum
+-<tt>launch</tt> and saying that <tt>launch::any</tt> means either
+-<tt>launch::sync</tt> or <tt>launch::async</tt> is very restricting. This
+-hinders future implementors to provide clever
+-infrastructures that can simply by used by a call to
+-<tt>async(launch::any,...)</tt>. Also there is no hook for an
+-implementation to provide additional alternatives to <tt>launch</tt>
+-enumeration and no useful means to combine those (i.e.
+-interpret them like flags). We believe something like
+-<tt>async(launch::sync | launch::async, ...)</tt> should be allowed
+-and can become especially useful if one could say also
+-something like <tt>async(launch::any &amp; ~launch::sync, ....)</tt>
+-respectively. This flexibility might limit the features usable
+-in the function called through <tt>async()</tt>, but it will allow a
+-path to effortless profit from improved hardware/software
+-without complicating the programming model when just
+-using <tt>async(launch::any,...)</tt>
++<p>
++Mutex requirements should not be bound to threads.
++</p>
+
+ <p><i>[
+ Resolution proposed by ballot comment:
+ ]</i></p>
+
+-<p>
+-Change in 30.6.1 [futures.overview] 'enum class launch' to allow
+-further implementation defined values and provide
+-the following bit-operators on the launch values
+-(<tt>operator|</tt>, <tt>operator&amp;</tt>, <tt>operator~</tt> delivering a
+-<tt>launch</tt> value).
+-</p><p>
+-Note: a possible implementation might use an
+-unsigned value to represent the <tt>launch</tt> enums,
+-but we shouldn't limit the standard to just 32 or 64
+-available bits in that case and also should keep
+-the launch enums in their own enum namespace.
+-</p><p>
+-Change [future.async] p3 according to the
+-changes to <tt>enum launch</tt>. change --<tt>launch::any</tt> to
+-"the implementation may choose any of the
+-policies it provides." Note: this can mean that an
+-implementation may restrict the called function to
+-take all required information by copy in case it will
+-be called in a different address space, or even, on
+-a different processor type. To ensure that a call is
+-either performed like <tt>launch::async</tt> or
+-<tt>launch::sync</tt> describe one should call
+-<tt>async(launch::sync|launch::async,...)</tt>
+-</p>
++<blockquote><p>
++See Appendix 1 of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3141.pdf">n3141</a> - Additional Details, p. 208.
++</p></blockquote>
+
+ <p><i>[
+-2010-11-02 Daniel comments:
++2010-10-24 Daniel adds:
+ ]</i></p>
+
+
+-<blockquote>
+-The new paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3113.html">n3113</a> provides concrete wording.
+-</blockquote>
+-
++<blockquote><p>
++Accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3130.html">n3130</a> would solve this issue.
++</p></blockquote>
+
+-<p><b>Proposed resolution:</b></p>
+-Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3188.html">n3188</a>.
+
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3197.htm">n3197</a>.
++</p>
+
+
+
+
+ <hr>
+-<h3><a name="1516"></a>1516. [FCD] No specification for which header contains <tt>auto_ptr</tt></h3>
+-<p><b>Section:</b> D.12 [depr.auto.ptr] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1494"></a>1494. Term "are serialized" not defined</h3>
++<p><b>Section:</b> 30.4.4.2 [thread.once.callonce] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.once.callonce">issues</a> in [thread.once.callonce].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p><b>Addresses GB-142</b></p>
++<p><b>Addresses US-190</b></p>
+ <p>
+-<tt>auto_ptr</tt> does not appear in the <tt>&lt;memory&gt;</tt> synopsis and
+-[depr.auto.ptr] doesn't say which header declares it.
+-Conversely, the deprecated binders <tt>bind1st</tt> etc. are in the
+-<tt>&lt;functional&gt;</tt> synopsis, this is inconsistent
++The term "are serialized" is never defined (30.4.4.2 [thread.once.callonce] p. 2).
+ </p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
+ <p>
+-Either <tt>auto_ptr</tt> should be declared in the
+-<tt>&lt;memory&gt;</tt> synopsis, or the deprecated binders
+-should be removed from the <tt>&lt;functional&gt;</tt> synopsis
+-and appendix D should say which header declares
+-the binders and <tt>auto_ptr</tt>.
++Remove the sentence with "are serialized" from
++paragraph 2. Add "Calls to <tt>call_once</tt> on the same
++<tt>once_flag</tt> object shall not introduce data races
++(17.6.4.8)." to paragraph 3.
+ </p>
+
+ <p><i>[
+-Post-Rapperswil
++2010-11-01 Daniel translates NB comment into wording
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
+
+ <p><i>[
+-Adopted at 2010-11 Batavia
++2011-02-17: Hans proposes an alternative resolution
++]</i></p>
++
++
++<p><i>[
++2011-02-25: Hans, Clark, and Lawrence update the suggested wording
+ ]</i></p>
+
+
++<p><i>[2011-02-26 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>Change 30.4.4.2 [thread.once.callonce] p.2+3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class Callable, class ...Args&gt;
++void call_once(once_flag&amp; flag, Callable&amp;&amp; func, Args&amp;&amp;... args);
++</pre><blockquote><p>
++[..]
++<p/>
++2 <em>Effects</em>: <del>Calls to <tt>call_once</tt> on the same <tt>once_flag</tt> object are serialized.
++If there has been a prior effective call to <tt>call_once</tt> on the same <tt>once_flag object</tt>, the call to <tt>call_once</tt>
++returns without invoking <tt>func</tt>. If there has been no prior effective call to <tt>call_once</tt>
++on the same <tt>once_flag</tt> object, <tt>INVOKE(decay_copy( std::forward&lt;Callable&gt;(func)),
++decay_copy(std::forward&lt;Args&gt;(args))...)</tt> is executed. The call to <tt>call_once</tt> is effective
++if and only if <tt>INVOKE(decay_copy( std::forward&lt;Callable&gt;(func)), decay_copy(std::forward&lt;Args&gt;(args))...)</tt>
++returns without throwing an exception. If an exception is thrown it is propagated to the caller.</del>
++<ins>An execution of <code>call_once</code> that does not call its <code>func</code> is a passive execution.
++An execution of <code>call_once</code> that calls its <code>func</code> is an active execution.
++An active execution shall call <code><var>INVOKE</var>(decay_copy(std::forward&lt;Callable&gt;(func)),
++decay_copy(std::forward&lt;Args&gt;(args))...)</code>. If such a call to <code>func</code> throws an exception,
++the execution is exceptional, otherwise it is returning.
++An exceptional execution shall propagate the exception to the caller of <code>call_once</code>.
++Among all executions of <code>call_once</code> for any given <code>once_flag</code>: at most one shall be a
++returning execution; if there is a returning execution, it shall be the last active execution; and
++there are passive executions only if there is a returning execution.
++[<i>Note:</i> Passive executions allow other threads to reliably observe the results produced by the
++earlier returning execution. &mdash; <i>end note</i>]</ins>
++<p/>
++3 <em>Synchronization</em>: <del>The completion of an effective call to <tt>call_once</tt> on a <tt>once_flag</tt>
++object <em>synchronizes with</em> (1.10 [intro.multithread]) all subsequent calls to <tt>call_once</tt>
++on the same <tt>once_flag</tt> object.</del><ins>For any given <code>once_flag</code>: all active executions occur in a total
++order; completion of an active execution synchronizes with (1.10 [intro.multithread]) the start of
++the next one in this total order; and the returning execution synchronizes with the return from all passive
++executions.</ins>
++</p></blockquote></blockquote>
+
+-<p>Add the following lines to the synopsis of header <tt>&lt;memory&gt;</tt>
+-in [memory]/1:<br></p>
+-<blockquote>
+-<pre><ins>// [depr.auto.ptr], Class auto_ptr (deprecated):
+-template &lt;class X&gt; class auto_ptr;<br></ins>
+-</pre></blockquote>
+
+
+
+
+
+ <hr>
+-<h3><a name="1517"></a>1517. default_delete's default constructor should be trivial</h3>
+-<p><b>Section:</b> 20.9.9.1.2 [unique.ptr.dltr.dflt] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-09-12 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unique.ptr.dltr.dflt">issues</a> in [unique.ptr.dltr.dflt].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1497"></a>1497. <tt>lock()</tt> postcondition can not be generally achieved</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses CH-30</b></p>
+ <p>
+-The current working draft does specify the default c'tor of <tt>default_delete</tt> in a manner
+-to guarantee static initialization for default-constructed objects of static storage duration
+-as a consequence of the acceptance of the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2976.html">n2976</a>
+-but this paper overlooked the fact that the suggested declaration does not ensure that the type
+-will be a trivial type. The type <tt>default_delete</tt> was always considered as a simple wrapper for
+-calling <tt>delete</tt> or <tt>delete[]</tt>, respectivly and should be a trivial type.
++If <tt>lock.lock()</tt> throws an exception, the postcondition can not be generally achieved.
+ </p>
+-<p>
+-In agreement with the new settled core language rules this easy to realize by just changing the declaration to
+-</p><blockquote><pre>constexpr default_delete()<ins> = default</ins>;
+-</pre></blockquote><p></p>
+-<p>
+-This proposal also automatically solves the problem, that the semantics of the default constructor of the
+-partial specialization <tt>default_delete&lt;T[]&gt;</tt> is not specified at all. By defaulting its default constructor
+-as well, the semantics are well-defined.
+-</p>
+-
+ <p><i>[
+-Post-Rapperswil
++Resolution proposed by ballot comment:
+ ]</i></p>
+
+-
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++<blockquote><p>
++Either state that the postcondition might not be achieved, depending on the error condition, or
++state that <tt>terminate()</tt> is called in this case.
++</p></blockquote>
+
+ <p><i>[
+-Adopted at 2010-11 Batavia
++2010-08-13 Peter Sommerlad comments and provides wording
+ ]</i></p>
+
+
++<blockquote><p>
++30.5.1 [thread.condition.condvar], 30.5.2 [thread.condition.condvarany]
++<p/>
++p. 13, last bullet, and corresponding paragraphs in all wait functions
++<p/>
++Problem:<br/>
++Condition variable wait might fail, because the lock cannot be acquired when notified.
++CH-30 says: "If lock.lock() throws an exception, the postcondition can not be generally achieved."
++CH-30 proposes: "Either state that the postcondition might not be achieved, depending on the error
++condition, or state that terminate() is called in this case."
++<p/>
++The discussion in Rapperswil concluded that calling <tt>terminate()</tt> might be too drastic in
++this case and a corresponding exception should be thrown&#47;passed on and one should use a lock type
++that allows querying its status, which <tt>unique_lock</tt> allows for <tt>std::condition_variable</tt>
++<p/>
++We also had some additional observations while discussing in Rapperswil:
++</p>
++<ul>
++<li>in 30.5.1 [thread.condition.condvar] <tt>wait</tt> with predicate and <tt>wait_until</tt> with
++predicate lack the precondition, postcondition and Error conditions sections. the lack of the precondition
++would allow to call <tt>pred()</tt> without holding the lock.
++</li>
++<li>in 30.5.1 [thread.condition.condvar] <tt>wait_until</tt> and <tt>wait_for</tt> and
++30.5.2 [thread.condition.condvarany] <tt>wait_for</tt> still specify an
++error condition for a violated precondition. This should be removed.
++</li>
++</ul>
++<p>
++and add the following proposed solution:
++</p>
++</blockquote>
++
++<p><i>[2011-02-27: Daniel adapts numbering to n3225]</i></p>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+-<p><i>The following wording changes are against N3126.</i></p>
+-
+ <ol>
+-<li>Change the synopsis of the primary template definition of <tt>default_delete</tt> in [unique.ptr.dltr.dflt] as indicated:
+-<blockquote><pre>namespace std {
+- template &lt;class T&gt; struct default_delete {
+- constexpr default_delete()<ins> = default</ins>;
+- template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp;);
+- void operator()(T*) const;
+- };
+-}
++<li>Change 30.5.1 [thread.condition.condvar] as indicated:
++<blockquote><pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
+ </pre></blockquote>
++<blockquote><p>
++ 9 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
++</p>
++<ul>
++<li>no other thread is waiting on this <tt>condition_variable</tt> object or
+ </li>
+-<li>
+-Remove the prototype specification of the <tt>default_delete</tt> default constructor in [unique.ptr.dltr.dflt]/1. This
+-brings it in harmony with the style used in the partial specialization <tt>default_delete&lt;T[]&gt;</tt>. Since there are
+-neither implied nor explicit members, there is no possibility to misinterpret what the constructor does:
+-<blockquote><pre><del>constexpr default_delete();</del>
+-</pre><blockquote>
+-<del>1 <em>Effects</em>: Default constructs a <tt>default_delete</tt> object.</del>
+-</blockquote></blockquote>
++<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.
+ </li>
+-<li>Change the synopsis of the partial specialization of <tt>default_delete</tt> in [unique.ptr.dltr.dflt1] as indicated:
+-<blockquote><pre>namespace std {
+- template &lt;class T&gt; struct default_delete&lt;T[]&gt; {
+- constexpr default_delete()<ins> = default</ins>;
+- void operator()(T*) const;
+- template &lt;class U&gt; void operator()(U*) const = delete;
+- };
+-}</pre></blockquote>
++</ul>
++</blockquote>
++[..]
++<blockquote><p>
++11 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++</p></blockquote>
++[..]
++<blockquote><pre>
++template &lt;class Predicate&gt;
++void wait(unique_lock&lt;mutex&gt;&amp; lock, Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++<ins>?? <i>Requires</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread, and either</ins>
++</p>
++<ul>
++<li><ins>no other thread is waiting on this <tt>condition_variable</tt> object or</ins>
++</li>
++<li><ins><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.</ins>
++</li>
++</ul>
++</blockquote>
++<blockquote><p>
++14 <i>Effects</i>:
++</p><blockquote><pre>
++while (!pred())
++ wait(lock);
++</pre></blockquote>
++</blockquote>
++
++<blockquote><p>
++<ins>?? <i>Postcondition</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread.</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>?? <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2).</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>?? <em>Error conditions</em>:</ins>
++</p>
++<ul>
++<li><ins>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</ins>
++</li>
++</ul>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++cv_status wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
++</pre></blockquote>
++<blockquote><p>
++15 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
++</p>
++<ul>
++<li>no other thread is waiting on this <tt>condition_variable</tt> object or
++</li>
++<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
++</li>
++</ul>
++</blockquote><p>
++[..]
++</p><blockquote><p>
++17 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++</p></blockquote>
++[..]
++<blockquote><p>
++20 <em>Error conditions</em>:
++</p>
++<ul>
++<li><del><tt>operation_not_permitted</tt> &mdash; if the thread does not own the lock.</del>
++</li>
++<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
++</li>
++</ul>
++</blockquote>
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre></blockquote>
++<blockquote><p>
++21 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
++</p>
++<ul>
++<li>no other thread is waiting on this <tt>condition_variable</tt> object or
++</li>
++<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
++</li>
++</ul>
++</blockquote><p>
++[..]
++</p><blockquote><p>
++24 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++</p></blockquote>
++[..]
++<blockquote><p>
++26 <em>Error conditions</em>:
++</p>
++<ul>
++<li><del><tt>operation_not_permitted</tt> &mdash; if the thread does not own the lock.</del>
++</li>
++<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
++</li>
++</ul>
++</blockquote>
++<blockquote><pre>
++template &lt;class Clock, class Duration, class Predicate&gt;
++bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
++ Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++<ins>?? <i>Requires</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread, and either</ins>
++</p>
++<ul>
++<li><ins>no other thread is waiting on this <tt>condition_variable</tt> object or</ins>
++</li>
++<li><ins><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt> or <tt>timed_wait</tt>) threads.</ins>
++</li>
++</ul>
++</blockquote>
++<blockquote><p>
++27 <i>Effects</i>:
++</p><blockquote><pre>
++while (!pred())
++ if (wait_until(lock, abs_time) == cv_status::timeout)
++ return pred();
++return true;
++</pre></blockquote>
++</blockquote>
++<blockquote><p>
++28 <i>Returns</i>: <tt>pred()</tt>
++</p></blockquote>
++
++<blockquote><p>
++<ins>?? <i>Postcondition</i>: <tt>lock.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt> is locked by the calling thread.</ins>
++</p></blockquote>
++
++<blockquote><p>
++29 [ <i>Note</i>: The returned value indicates whether the predicate evaluates to true regardless of whether the
++timeout was triggered. &mdash; <i>end note</i> ]
++</p></blockquote>
++
++<blockquote><p>
++<ins>?? <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2).</ins>
++</p></blockquote>
++<blockquote><p>
++<ins>?? <em>Error conditions</em>:</ins>
++</p>
++<ul>
++<li><ins>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</ins>
++</li>
++</ul>
++</blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period, class Predicate&gt;
++bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
++ Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++30 <i>Requires</i>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread, and either
++</p>
++<ul>
++<li>no other thread is waiting on this <tt>condition_variable</tt> object or
++</li>
++<li><tt>lock.mutex()</tt> returns the same value for each of the <tt>lock</tt> arguments supplied by all concurrently
++waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.
++</li>
++</ul>
++</blockquote><p>
++[..]
++</p><blockquote><p>
++33 <em>Postcondition</em>: <tt>lock</tt><ins><tt>.owns_lock()</tt> is <tt>true</tt> and <tt>lock.mutex()</tt></ins> is locked by the calling thread.
++</p></blockquote><p>
++[..]
++</p><blockquote><p>
++37 <em>Error conditions</em>:
++</p>
++<ul>
++<li><del><tt>operation_not_permitted</tt> &mdash; if the thread does not own the lock.</del>
++</li>
++<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
++</li>
++</ul>
++</blockquote>
++
++</li>
++
++<li>Change 30.5.2 [thread.condition.condvarany] as indicated:
++<p/>
++[..]
++<blockquote><pre>
++template &lt;class Lock, class Predicate&gt;
++void wait(Lock&amp; lock, Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++<ins>[<i>Note</i>: if any of the wait functions exits with an exception it is indeterminate if the <tt>Lock</tt> is held.
++One can use a <tt>Lock</tt> type that allows to query that, such as the <tt>unique_lock</tt> wrapper. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++<blockquote><p>
++11 <i>Effects</i>:
++</p><blockquote><pre>
++while (!pred())
++ wait(lock);
++</pre></blockquote>
++</blockquote><p>
++[..]
++</p><blockquote><p>
++31 <em>Error conditions</em>:
++</p>
++<ul>
++<li><del><tt>operation_not_permitted</tt> &mdash; if the thread does not own the lock.</del>
++</li>
++<li>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.
+ </li>
++</ul>
++</blockquote>
++</li>
++
+ </ol>
+
+
+@@ -83275,523 +96750,33045 @@ neither implied nor explicit members, there is no possibility to misinterpret wh
+
+
+ <hr>
+-<h3><a name="1518"></a>1518. Waiting for deferred functions</h3>
+-<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2010-09-14 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#futures">issues</a> in [futures].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="1498"></a>1498. Unclear specification for [thread.condition]</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
+ <p><b>Discussion:</b></p>
+-<p>The current WP N3126 contains ambiguous statements about the
+-behaviour of functions <tt>wait_for</tt>/<tt>wait_until</tt> in
+-case the future refers to a deferred function. Moreover, I believe
+-it describes a disputable intent, different from the one contained
+-in the original async proposals, that may have been introduced
+-inadvertently during the "async cleanup" that occurred recently.
+-Consider the following case:</p>
+-<blockquote>
+-<pre>int f();
+-future&lt;int&gt; x = async(launch::deferred, f);
+-future_status s = x.wait_for(chrono::milliseconds(100));
+-</pre></blockquote>
+-<p>This example raises two questions:</p>
+-<ol>
+-<li>is <tt>f</tt> invoked?</li>
+-<li>what is the value of <tt>s</tt>?</li>
+-</ol>
+-<p>According to the current WP, the answer to question 1 is yes,
+-because 30.6.9/3 says "The first call to a function waiting for the
+-associated asynchronous state created by this async call to become
+-ready shall invoke the deferred function in the thread that called
+-the waiting function". The answer to question 2, however, is not as
+-clear. According to 30.6.6/23, s should be
+-<tt>future_status::deferred</tt> because <tt>x</tt> refers to a
+-deferred function that is not running, but it should also be
+-<tt>future_status::ready</tt> because after executing <tt>f</tt>
+-(and we saw that <tt>f</tt> is always executed) the state becomes
+-ready. By the way, the expression "deferred function that is not
+-running" is very unfortunate in itself, because it may apply to
+-both the case where the function hasn't yet started, as well as the
+-case where it was executed and completed.</p>
+-<p>While we clearly have a defect in the WP answering to question
+-2, it is my opinion that the answer to question 1 is wrong, which
+-is even worse. Consider that the execution of the function
+-<tt>f</tt> can take an arbitrarily long time. Having
+-<tt>wait_for()</tt> invoke <tt>f</tt> is a potential violation of
+-the reasonable expectation that the execution of
+-<tt>x.wait_for(chrono::milliseconds(100))</tt> shall take <u>at most</u>
+-100 milliseconds plus a delay dependent on the quality of implementation
+-and the quality of management (as described in paper N3128).
+-In fact, previous versions of the WP
+-clearly specified that only function <tt>wait()</tt> is required to
+-execute the deferred function, while <tt>wait_for()</tt> and
+-<tt>wait_until()</tt> shouldn't.</p>
+-<p>The proposed resolution captures the intent that
+-<tt>wait_for()</tt> and <tt>wait_until()</tt> should never attempt
+-to invoke the deferred function. In other words, the P/R provides
+-the following answers to the two questions above:</p>
+-<ol>
+-<li>no</li>
+-<li><tt>future_status::deferred</tt></li>
+-</ol>
+-<p>In order to simplify the wording, the definition of <i>deferred
+-function</i> has been tweaked so that the function is no longer
+-considered deferred once its evaluation has started, as suggested
+-by Howard.</p>
+-<p>Discussions in the reflector questioned whether
+-<tt>wait_for()</tt> and <tt>wait_until()</tt> should return
+-immediately or actually wait hoping for a second thread to execute
+-the deferred function. I believe that waiting could be useful only
+-in a very specific scenario but detrimental in the general case and
+-would introduce another source of ambiguity: should
+-<tt>wait_for()</tt> return <tt>future_status::deferred</tt> or
+-<tt>future_status::timeout</tt> after the wait? Therefore the P/R
+-specifies that <tt>wait_for</tt>/<tt>wait_until</tt> shall return
+-immediately, which is simpler, easier to explain and more useful in
+-the general case.</p>
++<p><b>Addresses CH-29</b></p>
++
++<p>
++It is unclear if a spurious wake-up during the loop and reentering
++of the blocked state due to a repeated execution
++of the loop will adjust the timer of the blocking with the
++respect to the previously specified <tt>rel_time</tt> value.
++</p>
+
+ <p><i>[
+-Post-Rapperswil
++Resolution proposed by ballot comment:
+ ]</i></p>
+
+
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++<blockquote><p>
++Make it clear (e.g. by a note) that when reexecuting
++the loop the waiting time when blocked
++will be adjusted with respect to the elapsed time of
++the previous loop executions.
++</p></blockquote>
+
+ <p><i>[
+-Adopted at 2010-11 Batavia
++2010-08-13 Peter Sommerlad comments and provides wording:
+ ]</i></p>
+
+
++<blockquote><p>
++Problem: It is unclear if a spurious wake-up during the loop and re-entering of the blocked state due
++to a repeated execution of the loop will adjust the timer of the blocking with the respect to the
++previously specified <tt>rel_time</tt> value.
++<p/>
++Proposed Resolution from CH29:
++<p/>
++Make it clear (e.g. by a note) that when re-executing the loop the waiting time when blocked will be
++adjusted with respect to the elapsed time of the previous loop executions.
++<p/>
++Discussion in Rapperswil:
++<p/>
++Assuming the introduction of a mandatory <tt>steady_clock</tt> proposed by US-181 to the FCD the
++specification of <tt>condition_variable::wait_for</tt> can be defined in terms of <tt>wait_until</tt>
++using the <tt>steady_clock</tt>. This is also interleaving with US-181, because that touches the
++same paragraph (30.5.1 p 25, p34 and 30.5.2 p 20, p 28 in n3092.pdf)
++<p/>
++(The "as if" in the proposed solutions should be confirmed by the standardization terminology experts)
++</p></blockquote>
+
++<p><i>[
++2010-11 Batavia: Resolved by applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>
++]</i></p>
+
+-<p><b>Proposed resolution:</b></p>
+
+-<p>The proposed wording changes are relative to the Final Committee Draft,
+-N3126.</p>
+-<p><b>Note to the editor:</b> the proposed wording is meant not be in conflict
+-with any change proposed by paper N3128 "C++ Timeout Specification".
+-Ellipsis are deliberately used to avoid any unintended overlapping.</p>
++<blockquote>
+ <ol>
+-<li>
+-<p>In [futures.unique_future] 30.6.6/22:</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
+-</li>
+-<li>
+-<p>In [futures.unique_future] 30.6.6/23 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
+-</li>
+-<li>
+-<p>In [futures.unique_future] 30.6.6/25:</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
+-</li>
+-<li>
+-<p>In [futures.unique_future] 30.6.6/26 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
+-</li>
+-<li>
+-<p>In [futures.shared_future] 30.6.7/27</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
++<li>Change 30.5.1 [thread.condition.condvar] paragraph 25, <tt>wait_for</tt> <i>Effects</i> as indicated:
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre></blockquote>
++<blockquote><p>
++[..]
++<p/>
++25 <i>Effects</i>: <ins>as if</ins>
++</p>
++<blockquote><pre>
++<ins>return wait_until(lock, chrono::steady_clock::now() + rel_time);</ins>
++</pre></blockquote>
++<ul>
++<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.</del>
+ </li>
+-<li>
+-<p>In [futures.unique_future] 30.6.7/28 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
++<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock), then returns.</del>
+ </li>
+-<li>
+-<p>In [futures.shared_future] 30.6.6/30:</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
++<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
++by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.</del>
+ </li>
+-<li>
+-<p>In [futures.unique_future] 30.6.7/31 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
++<li><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function scope.</del>
+ </li>
+-<li>
+-<p>In [futures.atomic_future] 30.6.8/23</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
++</ul>
++</blockquote>
+ </li>
+-<li>
+-<p>In [futures.unique_future] 30.6.8/24 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
++<li>Change 30.5.1 [thread.condition.condvar] paragraph 34, <tt>wait_for</tt> with predicate <i>Effects</i> as indicated:
++<blockquote><pre>
++template &lt;class Rep, class Period, class Predicate&gt;
++bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
++ Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++[..]
++<p/>
++34 <i>Effects</i>: <ins>as if</ins>
++</p>
++<blockquote><pre>
++<ins>return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));</ins>
++</pre></blockquote>
++<ul>
++<li><del>Executes a loop: Within the loop the function first evaluates <tt>pred()</tt> and exits the loop if the
++result is <tt>true</tt>.
++</del></li>
++
++<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
++</del></li>
++
++<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock).
++</del></li>
++
++<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
++by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
++</del></li>
++
++<li><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
++scope.
++</del></li>
++
++<li><del>The loop terminates when <tt>pred()</tt> returns <tt>true</tt> or when the time duration specified by <tt>rel_time</tt>
++has elapsed.
++</del></li>
++
++</ul>
++</blockquote>
+ </li>
+-<li>
+-<p>In [futures.atomic_future] 30.6.8/27:</p>
+-<p>Effects: <ins>none if the associated asynchronous state contains
+-a deferred function (30.6.9), otherwise</ins> blocks until the
+-associated asynchronous state is ready or [...].</p>
++
++<li>Change 30.5.2 [thread.condition.condvarany] paragraph 20, <tt>wait_for</tt> <i>Effects</i> as indicated:
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period&gt;
++cv_status wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre></blockquote>
++<blockquote><p>
++20 <i>Effects</i>: <ins>as if</ins>
++</p><blockquote><pre>
++<ins>return wait_until(lock, chrono::steady_clock::now() + rel_time);</ins>
++</pre></blockquote>
++<ul>
++<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
++</del></li>
++
++<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock), then returns.
++</del></li>
++
++<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
++by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
++</del></li>
++
++<li><del>If the function exits via an exception, <tt>lock.unlock()</tt> shall be called prior to exiting the function
++scope.
++</del></li>
++</ul>
++</blockquote>
+ </li>
+-<li>
+-<p>In [futures.unique_future] 30.6.8/28 first bullet:</p>
+-<p>— future_status::deferred if the associated asynchronous
+-state contains a deferred function <del>that is not
+-running</del>.</p>
++
++<li>Change 30.5.2 [thread.condition.condvarany] paragraph 28, <tt>wait_for</tt> with predicate <i>Effects</i> as indicated:
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period, class Predicate&gt;
++bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
++</pre></blockquote>
++<blockquote><p>
++28 <i>Effects</i>: <ins>as if</ins>
++</p><blockquote><pre>
++<ins>return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));</ins>
++</pre></blockquote>
++<ul>
++<li><del>Executes a loop: Within the loop the function first evaluates <tt>pred()</tt> and exits the loop if the
++result is <tt>true</tt>.
++</del></li>
++
++<li><del>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.
++</del></li>
++
++<li><del>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock).
++</del></li>
++
++<li><del>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
++by the elapsed time <tt>rel_time</tt> passing (30.2.4), or spuriously.
++</del></li>
++
++<li><del>If the function exits via an exception, <tt>lock.unlock()</tt> shall be called prior to exiting the function
++scope.
++</del></li>
++
++<li><del>The loop terminates when <tt>pred()</tt> returns <tt>true</tt> or when the time duration specified by <tt>rel_time</tt>
++has elapsed.
++</del></li>
++</ul>
++</blockquote>
+ </li>
+-<li>
+-<p>In [futures.async] 30.6.9/3 second bullet:</p>
+-<p>[...] The first call to a function
+-<del>waiting</del><ins>requiring a non-timed wait</ins> for the
+-associated asynchronous state created by this async call to become
+-ready shall invoke the deferred function in the thread that called
+-the waiting function; <ins>once evaluation of <tt><i>INVOKE</i>(g,
+-xyz)</tt> begins, the function is no longer considered
+-deferred</ins> <del>all other calls waiting for the same associated
+-asynchronous state to become ready shall block until the deferred
+-function has completed</del>.</p>
++
++</ol>
++
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm">n3191</a>.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1501"></a>1501. Specification for managing associated asynchronous state has problems</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-194</b></p>
++
++<p>
++The specification for managing associated asynchronous
++state is confusing, sometimes omitted, and redundantly
++specified.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++
++<blockquote><p>
++Define terms-of-art for releasing, making ready,
++and abandoning an associated asynchronous
++state. Use those terms where appropriate. See
++Appendix 1 - Additional Details
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved in Batavia by accepting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3192.htm">n3192</a>.
++</p>
++
++
++
++
++<hr>
++<h3><a name="1502"></a>1502. Specification of [futures.state] unclear</h3>
++<p><b>Section:</b> 30.6.4 [futures.state] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.state">issues</a> in [futures.state].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-195</b></p>
++
++<p>The intent and meaning of 30.6.4 [futures.state] p10 is not apparent.</p>
++
++<blockquote><p>
++10 Accesses to the same shared state conflict (1.10).
++</p></blockquote>
++
++<p><i>[
++2011-03-07 Jonathan Wakely adds:
++]</i></p>
++
++<blockquote><p>
++It's not clear which paragraph this refers to, I had to go to the
++ballot comments where US-195 reveals it's para 8, which in the FCD
++(N3092) says:
++</p><blockquote><p>
++ Accesses to the same associated asynchronous state conflict (1.10).
++</p></blockquote>
++<p>This is now para 10 in N3242:</p>
++<blockquote><p>
++ Accesses to the same shared state conflict (1.10).
++</p></blockquote>
++</blockquote>
++
++<p><i>[2011-03-07: Lawrence comments and drafts wording]</i></p>
++
++
++<p>The intent of this paragraph is to deal with operations,
++such as <code>shared_future::get()</code>, that return a reference
++to a value held in the shared state. User code could potentially
++conflict when accessing that value.</p>
++
++<p>Lawrence proposed resolution:</p>
++
++<p>Modify 30.6.4 [futures.state] p10 as follows:</p>
++
++<blockquote><p>
++10 <del>Accesses to the same shared state conflict (1.10 [intro.multithread]).</del><ins>Some
++ operations, e.g. <code>shared_future::get()</code>
++ (30.6.7 [futures.shared_future]), may return a reference to a
++ value held in their shared state. Accesses and modifications through
++ those references by concurrent threads to the same
++ shared state may potentially conflict (1.10 [intro.multithread]).
++ [<i>Note:</i> As a consequence, accesses must either use
++ read-only operations or provide additional synchronization.
++ &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++
++<p><i>[2011-03-19: Detlef suggests an alternative resolution, shown below.]</i></p>
++
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++<p>Modify 30.6.4 [futures.state] p10 as follows:</p>
++
++<blockquote><p>
++10 Accesses to the same shared state conflict (1.10 [intro.multithread]). <ins>[<i>Note</i>:
++This explicitely specifies that the shared state is visible in the objects that reference this state
++in the sense of data race avoidance 17.6.5.9 [res.on.data.races]. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="1504"></a>1504. Term "are serialized" is not defined</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-196</b></p>
++<p>
++The term "are serialized" is not defined (30.6.5 [futures.promise] p. 21, 25).
++</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Replace "are serialized" with "shall not introduce a data race (17.6.4.8)".
++</p></blockquote>
++
++<p><i>[
++2010-11-02 Daniel translates proposal into proper wording changes
++]</i></p>
++
++
++<p><i>[2011-03-19: Detlef comments]</i></p>
++
++
++<p>The proposed resolution for <a href="lwg-defects.html#1507">1507</a> would cover this issue as well.</p>
++
++<p><i>[Proposed Resolution]</i></p>
++
++<blockquote>
++<ol>
++<li>Change 30.6.5 [futures.promise] p. 21 as indicated:
++<blockquote><p>
++21 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object <del>are serialized</del><ins>shall not introduce a data race ([res.on.data.races])</ins>.
++[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
++state. &mdash; <em>end note</em> ]
++</p></blockquote>
++</li>
++<li>Change 30.6.5 [futures.promise] p. 25 as indicated:
++<blockquote><p>
++25 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object <del>are serialized</del><ins>shall not introduce a data race ([res.on.data.races])</ins>.
++[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
++state. &mdash; <em>end note</em> ]
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2001-03 Madrid by issue 1507.
++</p>
++
++
++
++<hr>
++<h3><a name="1505"></a>1505. Synchronization between <tt>promise::set_value</tt> and <tt>future::get</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-197</b></p>
++<p>
++There is no defined synchronization between <tt>promise::set_value</tt> and <tt>future::get</tt>
++(30.6.5 [futures.promise] p. 21, 25).
++</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Replace "[<i>Note</i>: and they synchronize and
++serialize with other functions through the referred
++associated asynchronous state. &mdash; <i>end note</i>]" with
++the normative "They synchronize with (1.10) any
++operation on a future object with the same
++associated asynchronous state marked ready."
++</p></blockquote>
++
++<p><i>[
++2010-11-02 Daniel translates proposal into proper wording changes
++]</i></p>
++
++
++<p><i>[2011-03-19: Detlef comments]</i></p>
++
++
++<p>The proposed resolution for <a href="lwg-defects.html#1507">1507</a> would cover this issue as well.
++Effectively it will reject the request but a clarification is added that the
++normative wording is already in 30.6.4 [futures.state].</p>
++
++<blockquote class="note">
++<ol>
++<li>Change 30.6.5 [futures.promise] p. 21 as indicated:
++<blockquote><p>
++21 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object are serialized.
++<del>[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
++state. &mdash; <em>end note</em> ]</del><ins>They <em>synchronize with</em> ([intro.multithread]) any
++operation on a future object with the same associated asynchronous state marked ready.</ins>
++</p></blockquote>
++</li>
++<li>Change 30.6.5 [futures.promise] p. 25 as indicated:
++<blockquote><p>
++25 <em>Synchronization</em>: calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object are serialized.
++<del>[ <em>Note</em>: and they synchronize and serialize with other functions through the referred associated asynchronous
++state. &mdash; <em>end note</em> ]</del><ins>They <em>synchronize with</em> ([intro.multithread]) any
++operation on a future object with the same associated asynchronous state marked ready.</ins>
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2001-03 Madrid by issue 1507.
++</p>
++
++
++
++<hr>
++<h3><a name="1507"></a>1507. <tt>promise::<i>XXX</i>_at_thread_exit</tt> functions have no
++synchronization requirements</h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-199</b></p>
++<p>
++<tt>promise::<i>XXX</i>_at_thread_exit</tt> functions have no
++synchronization requirements. Specifying synchronization
++for these member functions requires coordinating with the
++words in 30.6.5 [futures.promise]/21 and 25, which give synchronization
++requirements for <tt>promise::set_value</tt> and
++<tt>promise::set_exception</tt> (30.6.5 [futures.promise] p. 26 ff., p. 29 ff.).
++</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Change 30.6.5 [futures.promise]/21 to mention <tt>set_value_at_thread_exit</tt> and
++<tt>set_exception_at_thread_exit;</tt> with this text, replace 30.6.5 [futures.promise]/25
++and add two new paragraphs, after 30.6.5 [futures.promise]/28 and 30.6.5 [futures.promise]/31.
++</p></blockquote>
++
++<p><i>[2011-03-8: Lawrence comments and drafts wording]</i></p>
++
++
++<p>This comment applies as well to other <tt>*_at_thread_exit</tt>
++functions. The following resolution adds synchronization paragraphs
++to all of them and edits a couple of related synchronization
++paragraphs.</p>
++
++<p><i>[2011-03-09: Hans and Anthony add some improvements]</i></p>
++
++
++<p><i>[2011-03-19: Detlef comments]</i></p>
++
++
++<p>In regard to the suggested part:</p>
++
++<blockquote><p>
++These operations do not provide any ordering guarantees with
++respect to other operations, except through operations on futures
++that reference the same shared state.
++</p></blockquote>
++
++<p>I would like this to change to:</p>
++
++<blockquote><p>
++These operations do not provide any ordering guarantees with
++respect to other operations on the same promise object.
++[<i>Note</i>: They synchronize with calls to operations on
++objects that refer to the same shared state according to
++30.6.4 [futures.state]. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>The current proposed resolution has exactly the same paragraph at
++for places. I propose to have it only once as new paragraph 2.</p>
++
++<p>This also covers <a href="lwg-defects.html#1504">1504</a> (US-196) and <a href="lwg-defects.html#1505">1505</a> (US-197).
++US-197 is essentially rejected with this resolution, but a clarification is added
++that the normative wording is already in 30.6.4 [futures.state].</p>
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++<ol>
++<li><p>Edit 30.4.1.2 [thread.mutex.requirements.mutex] paragraph 5 as follows:</p>
++
++<blockquote><p>
++5 The implementation shall provide lock and unlock operations, as described below. <del>The implementation
++shall serialize those operations.</del><ins>For purposes of determining the existence of a data race, these
++behave as atomic operations (1.10 [intro.multithread]). The lock and unlock operations on
++a single mutex shall appear to occur in a single total order. [<i>Note</i>: this can be viewed as the
++modification order (1.10 [intro.multithread]) of the mutex. &mdash; <i>end note</i>]</ins> [ <i>Note</i>:
++Construction and destruction of an object of a mutex type need not be thread-safe; other synchronization
++should be used to ensure that mutex objects are initialized and visible to other threads. &mdash; <i>end note</i> ]
++</p></blockquote>
++</li>
++
++<li><p>Edit 30.5 [thread.condition] paragraphs 6-9 as follows:</p>
++
++<blockquote><pre>
++void notify_all_at_thread_exit(condition_variable&amp; cond, unique_lock&lt;mutex&gt; lk);
++</pre>
++<blockquote>
++<p>
++-6- <i>Requires</i>: <tt>lk</tt> is locked by the calling thread and either
++</p>
++<ul>
++<li>no other thread is waiting on <tt>cond</tt>, or</li>
++<li><tt>lk.mutex()</tt> returns the same value for each of the lock arguments supplied by all concurrently
++waiting (via <tt>wait</tt>, <tt>wait_for</tt>, or <tt>wait_until</tt>) threads.</li>
++</ul>
++<p>
++-7- <i>Effects</i>: transfers ownership of the lock associated with <tt>lk</tt> into internal storage and schedules
++<tt>cond</tt> to be notified when the current thread exits, after all objects of thread storage duration
++associated with the current thread have been destroyed. This notification shall be as if
++</p>
++<blockquote><pre>
++lk.unlock();
++cond.notify_all();
++</pre></blockquote>
++<p>
++<ins>-?- <i>Synchronization:</i> The call to <code>notify_all_at_thread_exit</code>
++and the completion of the destructors for all the current thread's variables of
++thread storage duration synchronize with (1.10 [intro.multithread]) calls
++to functions waiting on <code>cond</code>.</ins>
++<p/>
++-8- <i>Note</i>: The supplied lock will be held until the thread exits, and care must be taken to ensure that
++this does not cause deadlock due to lock ordering issues. After calling <tt>notify_all_at_thread_exit</tt>
++it is recommended that the thread should be exited as soon as possible, and that no blocking or
++time-consuming tasks are run on that thread.
++<p/>
++-9- <i>Note</i>: It is the user's responsibility to ensure that waiting threads do not erroneously
++assume that the thread has finished if they experience spurious wakeups. This typically requires
++that the condition being waited for is satisfied while holding the lock on <tt>lk</tt>, and that
++this lock is not released and reacquired prior to calling <tt>notify_all_at_thread_exit</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 30.6.5 [futures.promise], paragraphs 14-27 as follows:</p>
++
++<blockquote><pre>
++void promise::set_value(const R&amp; r);
++void promise::set_value(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value(R&amp; r);
++void promise&lt;void&gt;::set_value();
++</pre>
++<blockquote>
++<p>
++-14- <i>Effects</i>: atomically stores the value <tt>r</tt> in the shared state and makes that state
++ready (30.6.4 [futures.state]).
++<p/>
++-15- <i>Throws</i>:
++</p>
++<ul>
++<li><tt>future_error</tt> if its shared state already has a stored value or exception, or</li>
++<li>for the first version, any exception thrown by the copy constructor of <tt>R</tt>, or</li>
++<li>for the second version, any exception thrown by the move constructor of <tt>R</tt>.</li>
++</ul>
++<p>
++-16- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if its shared state already has a stored value or exception.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++<p>
++-17- <i>Synchronization</i>: <del>calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object are serialized. [ <i>Note</i>: And they synchronize and serialize with other functions
++through the referred shared state. &mdash; <i>end note</i> ]</del><ins>For purposes of determining the
++existence of a data race, <tt>set_value</tt>, <tt>set_exception</tt>, <tt>set_value_at_thread_exit</tt>,
++and <tt>set_exception_at_thread_exit</tt> behave as atomic operations (1.10 [intro.multithread]) on
++the memory location associated with the <tt>promise</tt>. Calls to these operations on a single promise shall
++appear to occur in a single total order. [<i>Note</i>: this can be viewed as the modification order
++(1.10 [intro.multithread]) of the promise. &mdash; <i>end note</i>] These operations do not
++provide any ordering guarantees with respect to other operations, except through operations on futures
++that reference the same shared state.</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++void set_exception(exception_ptr p);
++</pre>
++<blockquote>
++<p>
++-18- <i>Effects</i>: atomically stores the exception pointer <tt>p</tt> in the shared state and makes that
++state ready (30.6.4 [futures.state]).
++</p>
++
++<p>
++-19- <i>Throws</i>: <tt>future_error</tt> if its shared state already has a stored value or exception.
++</p>
++
++<p>
++-20- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if its shared state already has a stored value or exception.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++
++<p>
++-21- <i>Synchronization</i>: <del>calls to <tt>set_value</tt> and <tt>set_exception</tt> on a single
++<tt>promise</tt> object are serialized. [ <i>Note</i>: And they synchronize and serialize with
++other functions through the referred shared state. &mdash; <i>end note</i> ]</del><ins>For purposes of determining the
++existence of a data race, <tt>set_value</tt>, <tt>set_exception</tt>, <tt>set_value_at_thread_exit</tt>,
++and <tt>set_exception_at_thread_exit</tt> behave as atomic operations (1.10 [intro.multithread]) on
++the memory location associated with the <tt>promise</tt>. Calls to these operations on a single promise shall
++appear to occur in a single total order. [<i>Note</i>: this can be viewed as the modification order
++(1.10 [intro.multithread]) of the promise. &mdash; <i>end note</i>] These operations do not
++provide any ordering guarantees with respect to other operations, except through operations on futures
++that reference the same shared state.</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++void promise::set_value_at_thread_exit(const R&amp; r);
++void promise::set_value_at_thread_exit(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value_at_thread_exit(R&amp; r);
++void promise&lt;void&gt;::set_value_at_thread_exit();
++</pre>
++<blockquote>
++<p>
++-22- <i>Effects</i>: Stores the value <tt>r</tt> in the shared state without making that state
++ready immediately. Schedules that state to be made ready when the current thread exits, after
++all objects of thread storage duration associated with the current thread have been destroyed.
++<p/>
++-23- <i>Throws</i>: <tt>future_error</tt> if an error condition occurs.
++<p/>
++-24- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if its shared state already has a stored value or exception.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++<p>
++<ins>-??- <i>Synchronization</i>: For purposes of determining the existence of a data race, <tt>set_value</tt>,
++<tt>set_exception</tt>, <tt>set_value_at_thread_exit</tt>, and <tt>set_exception_at_thread_exit</tt> behave as
++atomic operations (1.10 [intro.multithread]) on the memory location associated with the <tt>promise</tt>.
++Calls to these operations on a single promise shall appear to occur in a single total order. [<i>Note</i>:
++this can be viewed as the modification order (1.10 [intro.multithread]) of the promise. &mdash;
++<i>end note</i>] These operations do not provide any ordering guarantees with respect to other operations,
++except through operations on futures that reference the same shared state.</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++void promise::set_exception_at_thread_exit(exception_ptr p);
++</pre>
++<blockquote>
++<p>
++-25- <i>Effects</i>: Stores the exception pointer <tt>p</tt> in the shared state without
++making that state ready immediately. Schedules that state to be made ready when the current
++thread exits, after all objects of thread storage duration associated with the current
++thread have been destroyed.
++<p/>
++-26- <i>Throws</i>: <tt>future_error</tt> if an error condition occurs.
++<p/>
++-27- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if its shared state already has a stored value or exception.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++<p>
++<ins>-??- <i>Synchronization</i>: For purposes of determining the existence of a data race, <tt>set_value</tt>,
++<tt>set_exception</tt>, <tt>set_value_at_thread_exit</tt>, and <tt>set_exception_at_thread_exit</tt> behave as
++atomic operations (1.10 [intro.multithread]) on the memory location associated with the <tt>promise</tt>.
++Calls to these operations on a single promise shall appear to occur in a single total order. [<i>Note</i>:
++this can be viewed as the modification order (1.10 [intro.multithread]) of the promise. &mdash;
++<i>end note</i>] These operations do not provide any ordering guarantees with respect to other operations,
++except through operations on futures that reference the same shared state.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 30.6.9.1 [futures.task.members], paragraph 15-21 as follows:</p>
++
++<blockquote><pre>
++void operator()(ArgTypes... args);
++</pre>
++<blockquote>
++<p>
++-15- <i>Effects</i>: <tt><var>INVOKE</var>(f, t1, t2, ..., tN, R)</tt>, where <tt>f</tt> is the stored task
++of <tt>*this</tt> and <tt>t1</tt>, <tt>t2</tt>, <tt>...</tt>, <tt>tN</tt> are the values in
++<tt>args...</tt>. If the task returns normally, the return value is stored as the asynchronous
++result in the shared state of <tt>*this</tt>, otherwise the exception thrown by the task is
++stored. The shared state of <tt>*this</tt> is made ready, and any threads blocked in a function
++waiting for the shared state of <tt>*this</tt> to become ready are unblocked.
++<p/>
++-16- <i>Throws</i>: a <tt>future_error</tt> exception object if there is no shared state or the stored
++task has already been invoked.
++<p/>
++-17- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if the shared state is already ready.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++<p>
++-18- <i>Synchronization</i>: a successful call to <tt>operator()</tt> synchronizes with (1.10 [intro.multithread])
++a call to any member function of a <tt>future</tt> or <tt>shared_future</tt> object that shares the
++shared state of <tt>*this</tt>. The completion of the invocation of the stored task and the storage
++of the result (whether normal or exceptional) into the shared state synchronizes with (1.10 [intro.multithread])
++the successful return from any member function that detects that the state is set to ready. [ <i>Note</i>:
++<tt>operator()</tt> synchronizes and serializes with other functions through the shared state. &mdash; <i>end note</i> ]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++void make_ready_at_thread_exit(ArgTypes... args);
++</pre>
++<blockquote>
++<p>
++-19- <i>Effects</i>: <tt><var>INVOKE</var>(f, t1, t2, ..., tN, R)</tt>, where <tt>f</tt> is the
++stored task and <tt>t1</tt>, <tt>t2</tt>, <tt>...</tt>, <tt>tN</tt> are the values in <tt>args...</tt>.
++If the task returns normally, the return value is stored as the asynchronous result in the shared
++state of <tt>*this</tt>, otherwise the exception thrown by the task is stored. In either case,
++this shall be done without making that state ready (30.6.4 [futures.state]) immediately.
++Schedules the shared state to be made ready when the current thread exits, after all objects of
++thread storage duration associated with the current thread have been destroyed.
++<p/>
++-20- <i>Throws</i>: <tt>future_error</tt> if an error condition occurs.
++<p/>
++-21- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>promise_already_satisfied</tt> if the shared state already has a stored value or exception.</li>
++<li><tt>no_state</tt> if <tt>*this</tt> has no shared state.</li>
++</ul>
++<p>
++<ins>-??- <i>Synchronization:</i> a successful call to <code>make_ready_at_thread_exit</code>
++synchronizes with (1.10 [intro.multithread]) a call to any member function of
++a <code>future</code> or <code>shared_future</code> object that shares the shared state of
++<code>*this</code>. The completion of</ins>
++</p>
++<ul>
++<li><p><ins>the invocation of the stored task and the storage of the result (whether normal or
++exceptional) into the shared state</ins></p></li>
++<li><p><ins>the destructors for all the current thread's variables of thread storage duration</ins></p></li>
++</ul>
++<p>
++<ins>synchronize with (1.10 [intro.multithread]) the successful return from any member function
++that detects that the state is set to ready. [<i>Note:</i> <code>make_ready_at_thread_exit</code>
++synchronizes and serializes with other functions through the shared state. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote></blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="1508"></a>1508. Rename <tt>packaged_task::operator bool()</tt></h3>
++<p><b>Section:</b> 30.6.9 [futures.task] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task">issues</a> in [futures.task].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-201</b></p>
++<p>
++<tt>packaged_task</tt> provides <tt>operator bool()</tt> to check whether
++an object has an associated asynchronous state. The various <tt>future</tt>
++types provide a member function <tt>valid()</tt> that does the same thing.
++The names of these members should be the same.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<blockquote><p>
++Replaced the name <tt>packaged_task::operator bool()</tt> with <tt>packaged_task::valid()</tt> in the synopsis
++(30.6.9 [futures.task]/2) and the member function specification (before 30.6.9.1 [futures.task.members]/15).
++</p></blockquote>
++
++<p><i>[
++2010-11-02 Daniel translates proposed wording changes into a proper proposed resolution
++and verified that no other places implicitly take advantage of <tt>packaged_task</tt>
++conversion to bool.
++]</i></p>
++
++
++<p><i>[Resolved in Batavia by accepting
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3194.htm">n3194</a>.
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>Change 30.6.9 [futures.task]/2, class template <tt>packaged_task</tt> synopsis as indicated:
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
++class packaged_task&lt;R(ArgTypes...)&gt; {
++public:
++ typedef R result_type;
++ [..]
++ <del>explicit operator</del> bool <ins>valid</ins>() const;
++ [..]
++};
++</pre></blockquote>
++</li>
++<li>Change 30.6.9 [futures.task] before p. 15 as indicated:
++<blockquote><pre>
++<del>explicit operator</del> bool <ins>valid</ins>() const;
++</pre><blockquote><p>
++15 <em>Returns</em>: true only if <tt>*this</tt> has an associated asynchronous state.
++<p/>
++16 <em>Throws</em>: nothing.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1513"></a>1513. 'launch' enum too restrictive</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Switzerland <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses CH-36</b></p>
++<p>
++Providing only three different possible values for the enum
++<tt>launch</tt> and saying that <tt>launch::any</tt> means either
++<tt>launch::sync</tt> or <tt>launch::async</tt> is very restricting. This
++hinders future implementors to provide clever
++infrastructures that can simply by used by a call to
++<tt>async(launch::any,...)</tt>. Also there is no hook for an
++implementation to provide additional alternatives to <tt>launch</tt>
++enumeration and no useful means to combine those (i.e.
++interpret them like flags). We believe something like
++<tt>async(launch::sync | launch::async, ...)</tt> should be allowed
++and can become especially useful if one could say also
++something like <tt>async(launch::any &amp; ~launch::sync, ....)</tt>
++respectively. This flexibility might limit the features usable
++in the function called through <tt>async()</tt>, but it will allow a
++path to effortless profit from improved hardware/software
++without complicating the programming model when just
++using <tt>async(launch::any,...)</tt>
++</p>
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<p>
++Change in 30.6.1 [futures.overview] 'enum class launch' to allow
++further implementation defined values and provide
++the following bit-operators on the launch values
++(<tt>operator|</tt>, <tt>operator&amp;</tt>, <tt>operator~</tt> delivering a
++<tt>launch</tt> value).
++<p/>
++Note: a possible implementation might use an
++unsigned value to represent the <tt>launch</tt> enums,
++but we shouldn't limit the standard to just 32 or 64
++available bits in that case and also should keep
++the launch enums in their own enum namespace.
++<p/>
++Change [future.async] p3 according to the
++changes to <tt>enum launch</tt>. change --<tt>launch::any</tt> to
++"the implementation may choose any of the
++policies it provides." Note: this can mean that an
++implementation may restrict the called function to
++take all required information by copy in case it will
++be called in a different address space, or even, on
++a different processor type. To ensure that a call is
++either performed like <tt>launch::async</tt> or
++<tt>launch::sync</tt> describe one should call
++<tt>async(launch::sync|launch::async,...)</tt>
++</p>
++
++<p><i>[
++2010-11-02 Daniel comments:
++]</i></p>
++
++
++<blockquote><p>
++The new paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3113.html">n3113</a> provides concrete wording.
++</p></blockquote>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Resolved by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3188.htm">n3188</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1514"></a>1514. <tt>packaged_task</tt> constructors need review</h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-207</b></p>
++<p>
++The constructor that takes <tt>R(*)(ArgTypes...)</tt> is not
++needed; the constructor that takes a callable type works
++for this argument type. More generally, the constructors
++for packaged_task should parallel those for function.
++</p>
++<p><i>[
++US-207 Suggested Resolution:
++]</i></p>
++
++
++<blockquote><p>
++Review the constructors for packaged_task and
++provide the same ones as function, except where
++inappropriate.
++</p></blockquote>
++
++<p><i>[
++2010-10-22 Howard provides wording, as requested by the LWG in Rapperswil.
++]</i></p>
++
++
++<p><i>[2011-02-10 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Alter the list of constructors in both 30.6.9 [futures.task] and in 30.6.9.1 [futures.task.members] as indicated:
++</p>
++<blockquote>
++<pre><del>template &lt;class F&gt;
++explicit packaged_task(F f);
++template &lt;class F, class Allocator&gt;
++explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F f);
++explicit packaged_task(R(*f)(ArgTypes...));</del>
++template &lt;class F&gt;
++explicit packaged_task(F&amp;&amp; f);
++template &lt;class F, class Allocator&gt;
++explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++</pre>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1515"></a>1515. <tt>packaged_task::make_ready_at_thread_exit</tt> has no synchronization requirements</h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> INCITS <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-208</b></p>
++
++<p>
++<tt>packaged_task::make_ready_at_thread_exit</tt> has no synchronization requirements.
++</p>
++
++<p><i>[
++Resolution proposed by ballot comment:
++]</i></p>
++
++<p>
++Figure out what the synchronization requirements
++should be and write them.
++</p>
++
++<p><i>[2011-02-09 Anthony provides a proposed resolution]</i></p>
++
++
++<p><i>[2011-02-19 Additional edits by Hans, shown in the proposed resolution section]</i></p>
++
++
++<p><i>[2011-02-22 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++
++<p>Add a new paragraph following 30.6.9.1 [futures.task.members] p. 19:</p>
++
++<blockquote><pre>
++void make_ready_at_thread_exit(ArgTypes... args);
++</pre></blockquote>
++<blockquote>
++<p>
++19 - ...
++</p>
++<p>
++<ins>?? - <i>Synchronization</i>: Following a successful call to <tt>make_ready_at_thread_exit</tt>, the
++destruction of all objects with thread storage duration associated with
++the current thread happens before the associated asynchronous state is
++made ready. The marking of the associated asynchronous state as ready
++synchronizes with (1.10 [intro.multithread]) the successful return from any function that
++detects that the state is set to ready.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="1516"></a>1516. No specification for which header contains <tt>auto_ptr</tt></h3>
++<p><b>Section:</b> X [depr.auto.ptr] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-142</b></p>
++<p>
++<tt>auto_ptr</tt> does not appear in the <tt>&lt;memory&gt;</tt> synopsis and
++[depr.auto.ptr] doesn't say which header declares it.
++Conversely, the deprecated binders <tt>bind1st</tt> etc. are in the
++<tt>&lt;functional&gt;</tt> synopsis, this is inconsistent
++</p>
++<p>
++Either <tt>auto_ptr</tt> should be declared in the
++<tt>&lt;memory&gt;</tt> synopsis, or the deprecated binders
++should be removed from the <tt>&lt;functional&gt;</tt> synopsis
++and appendix D should say which header declares
++the binders and <tt>auto_ptr</tt>.
++</p>
++
++<p><i>[
++Post-Rapperswil
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>Add the following lines to the synopsis of header <tt>&lt;memory&gt;</tt>
++in [memory]&#47;1:<br/></p>
++<blockquote>
++<pre>
++<ins>// [depr.auto.ptr], Class auto_ptr (deprecated):
++template &lt;class X&gt; class auto_ptr;<br/></ins>
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1517"></a>1517. default_delete's default constructor should be trivial</h3>
++<p><b>Section:</b> 20.8.1.1.2 [unique.ptr.dltr.dflt] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-09-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.dltr.dflt">issues</a> in [unique.ptr.dltr.dflt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The current working draft does specify the default c'tor of <tt>default_delete</tt> in a manner
++to guarantee static initialization for default-constructed objects of static storage duration
++as a consequence of the acceptance of the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2976.html">n2976</a>
++but this paper overlooked the fact that the suggested declaration does not ensure that the type
++will be a trivial type. The type <tt>default_delete</tt> was always considered as a simple wrapper for
++calling <tt>delete</tt> or <tt>delete[]</tt>, respectivly and should be a trivial type.
++</p>
++<p>
++In agreement with the new settled core language rules this easy to realize by just changing the declaration to
++</p>
++<blockquote><pre>
++constexpr default_delete()<ins> = default</ins>;
++</pre></blockquote>
++<p>
++This proposal also automatically solves the problem, that the semantics of the default constructor of the
++partial specialization <tt>default_delete&lt;T[]&gt;</tt> is not specified at all. By defaulting its default constructor
++as well, the semantics are well-defined.
++</p>
++
++<p><i>[
++Post-Rapperswil
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>The following wording changes are against N3126.</i></p>
++
++<ol>
++<li>Change the synopsis of the primary template definition of <tt>default_delete</tt> in [unique.ptr.dltr.dflt] as indicated:
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; struct default_delete {
++ constexpr default_delete()<ins> = default</ins>;
++ template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp;);
++ void operator()(T*) const;
++ };
++}
++</pre></blockquote>
++</li>
++<li>
++Remove the prototype specification of the <tt>default_delete</tt> default constructor in [unique.ptr.dltr.dflt]/1. This
++brings it in harmony with the style used in the partial specialization <tt>default_delete&lt;T[]&gt;</tt>. Since there are
++neither implied nor explicit members, there is no possibility to misinterpret what the constructor does:
++<blockquote><pre>
++<del>constexpr default_delete();</del>
++</pre><blockquote><p>
++<del>1 <em>Effects</em>: Default constructs a <tt>default_delete</tt> object.</del>
++</p></blockquote></blockquote>
++</li>
++<li>Change the synopsis of the partial specialization of <tt>default_delete</tt> in [unique.ptr.dltr.dflt1] as indicated:
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; struct default_delete&lt;T[]&gt; {
++ constexpr default_delete()<ins> = default</ins>;
++ void operator()(T*) const;
++ template &lt;class U&gt; void operator()(U*) const = delete;
++ };
++}</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="1518"></a>1518. Waiting for deferred functions</h3>
++<p><b>Section:</b> 30.6 [futures] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2010-09-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures">issues</a> in [futures].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The current WP N3126 contains ambiguous statements about the
++behaviour of functions <tt>wait_for</tt>/<tt>wait_until</tt> in
++case the future refers to a deferred function. Moreover, I believe
++it describes a disputable intent, different from the one contained
++in the original async proposals, that may have been introduced
++inadvertently during the "async cleanup" that occurred recently.
++Consider the following case:</p>
++<blockquote>
++<pre>
++int f();
++future&lt;int&gt; x = async(launch::deferred, f);
++future_status s = x.wait_for(chrono::milliseconds(100));
++</pre></blockquote>
++<p>This example raises two questions:</p>
++<ol>
++<li>is <tt>f</tt> invoked?</li>
++<li>what is the value of <tt>s</tt>?</li>
++</ol>
++<p>According to the current WP, the answer to question 1 is yes,
++because 30.6.9/3 says "The first call to a function waiting for the
++associated asynchronous state created by this async call to become
++ready shall invoke the deferred function in the thread that called
++the waiting function". The answer to question 2, however, is not as
++clear. According to 30.6.6/23, s should be
++<tt>future_status::deferred</tt> because <tt>x</tt> refers to a
++deferred function that is not running, but it should also be
++<tt>future_status::ready</tt> because after executing <tt>f</tt>
++(and we saw that <tt>f</tt> is always executed) the state becomes
++ready. By the way, the expression "deferred function that is not
++running" is very unfortunate in itself, because it may apply to
++both the case where the function hasn't yet started, as well as the
++case where it was executed and completed.</p>
++<p>While we clearly have a defect in the WP answering to question
++2, it is my opinion that the answer to question 1 is wrong, which
++is even worse. Consider that the execution of the function
++<tt>f</tt> can take an arbitrarily long time. Having
++<tt>wait_for()</tt> invoke <tt>f</tt> is a potential violation of
++the reasonable expectation that the execution of
++<tt>x.wait_for(chrono::milliseconds(100))</tt> shall take <span style="text-decoration:underline">at most</span>
++100 milliseconds plus a delay dependent on the quality of implementation
++and the quality of management (as described in paper N3128).
++In fact, previous versions of the WP
++clearly specified that only function <tt>wait()</tt> is required to
++execute the deferred function, while <tt>wait_for()</tt> and
++<tt>wait_until()</tt> shouldn't.</p>
++<p>The proposed resolution captures the intent that
++<tt>wait_for()</tt> and <tt>wait_until()</tt> should never attempt
++to invoke the deferred function. In other words, the P/R provides
++the following answers to the two questions above:</p>
++<ol>
++<li>no</li>
++<li><tt>future_status::deferred</tt></li>
++</ol>
++<p>In order to simplify the wording, the definition of <i>deferred
++function</i> has been tweaked so that the function is no longer
++considered deferred once its evaluation has started, as suggested
++by Howard.</p>
++<p>Discussions in the reflector questioned whether
++<tt>wait_for()</tt> and <tt>wait_until()</tt> should return
++immediately or actually wait hoping for a second thread to execute
++the deferred function. I believe that waiting could be useful only
++in a very specific scenario but detrimental in the general case and
++would introduce another source of ambiguity: should
++<tt>wait_for()</tt> return <tt>future_status::deferred</tt> or
++<tt>future_status::timeout</tt> after the wait? Therefore the P/R
++specifies that <tt>wait_for</tt>/<tt>wait_until</tt> shall return
++immediately, which is simpler, easier to explain and more useful in
++the general case.</p>
++
++<p><i>[
++Post-Rapperswil
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>The proposed wording changes are relative to the Final Committee Draft,
++N3126.</p>
++<p><b>Note to the editor:</b> the proposed wording is meant not be in conflict
++with any change proposed by paper N3128 "C++ Timeout Specification".
++Ellipsis are deliberately used to avoid any unintended overlapping.</p>
++<ol>
++<li>
++<p>In [futures.unique_future] 30.6.6/22:</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.6/23 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.6/25:</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.6/26 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.shared_future] 30.6.7/27</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.7/28 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.shared_future] 30.6.6/30:</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.7/31 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.atomic_future] 30.6.8/23</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.8/24 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.atomic_future] 30.6.8/27:</p>
++<p>Effects: <ins>none if the associated asynchronous state contains
++a deferred function (30.6.9), otherwise</ins> blocks until the
++associated asynchronous state is ready or [...].</p>
++</li>
++<li>
++<p>In [futures.unique_future] 30.6.8/28 first bullet:</p>
++<p>&mdash; future_status::deferred if the associated asynchronous
++state contains a deferred function <del>that is not
++running</del>.</p>
++</li>
++<li>
++<p>In [futures.async] 30.6.9/3 second bullet:</p>
++<p>[...] The first call to a function
++<del>waiting</del><ins>requiring a non-timed wait</ins> for the
++associated asynchronous state created by this async call to become
++ready shall invoke the deferred function in the thread that called
++the waiting function; <ins>once evaluation of <tt><i>INVOKE</i>(g,
++xyz)</tt> begins, the function is no longer considered
++deferred</ins> <del>all other calls waiting for the same associated
++asynchronous state to become ready shall block until the deferred
++function has completed</del>.</p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="1519"></a>1519. bucketsize() const only for unordered set</h3>
++<p><b>Section:</b> 23.5.4 [unord.map], 23.5.5 [unord.multimap], 23.5.7 [unord.multiset] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-10-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.map">issues</a> in [unord.map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++While <tt>bucket_size()</tt> is const for <tt>unordered_set</tt>, for all other unordered containers it is not defined as
++constant member function.
++</p>
++
++<p><i>[
++Post-Rapperswil
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><i>The wording refers to N3126.</i></p>
++
++<ol>
++<li>Change 23.7.1 Class template unordered_map [unord.map]/3, as indicated:
++<blockquote><pre>
++ namespace std {
++ template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
++ class unordered_map
++ {
++ public:
++ [..]
++ // bucket interface
++ size_type bucket_count() const;
++ size_type max_bucket_count() const;
++ size_type bucket_size(size_type n) <ins>const</ins>;
++ [..]
++</pre></blockquote>
++</li>
++<li>Change 23.7.2 Class template unordered_multimap [unord.multimap]/3, as indicated:
++<blockquote><pre>
++ namespace std {
++ template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
++ class unordered_multimap
++ {
++ public:
++ [..]
++ // bucket interface
++ size_type bucket_count() const;
++ size_type max_bucket_count() const;
++ size_type bucket_size(size_type n) <ins>const</ins>;
++ [..]
++</pre></blockquote>
++</li>
++<li>Change 23.7.4 Class template unordered_multiset [unord.multiset]/3, as indicated:
++<blockquote><pre>
++ namespace std {
++ template &lt;class Key,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Alloc = std::allocator&lt;Key&gt; &gt;
++ class unordered_multiset
++ {
++ public:
++ [..]
++ // bucket interface
++ size_type bucket_count() const;
++ size_type max_bucket_count() const;
++ size_type bucket_size(size_type n) <ins>const</ins>;
++ [..]
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="1520"></a>1520. <tt>INVOKE</tt> on member data pointer with too many arguments</h3>
++<p><b>Section:</b> 20.9.2 [func.require] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-10-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++20.8.2 [func.require] p1 says:
++</p>
++
++<blockquote>
++<p>
++1 Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++</p>
++
++<ul>
++<li>
++<tt>(t1.*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function
++of a class <tt>T</tt> and <tt>t1</tt> is an object of type <tt>T</tt> or a
++reference to an object of type <tt>T</tt> or a reference to an object of a type
++derived from <tt>T</tt>;
++</li>
++<li>
++<tt>((*t1).*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member
++function of a class <tt>T</tt> and <tt>t1</tt> is not one of the types described
++in the previous item;
++</li>
++<li>
++<tt>t1.*f</tt> when <tt>f</tt> is a pointer to member data of a class <tt>T</tt>
++and <tt>t1</tt> is an object of type <tt>T</tt> or a reference to an object of
++type <tt>T</tt> or a reference to an object of a type derived from <tt>T</tt>;
++</li>
++<li>
++<tt>(*t1).*f</tt> when <tt>f</tt> is a pointer to member data of a class
++<tt>T</tt> and <tt>t1</tt> is not one of the types described in the previous
++item;
++</li>
++<li>
++<tt>f(t1, t2, ..., tN)</tt> in all other cases.
++</li>
++</ul>
++</blockquote>
++
++<p>
++The question is: What happens in the 3<sup><i>rd</i></sup> and
++4<sup><i>th</i></sup> bullets when <tt>N &gt; 1</tt>?
++</p>
++
++<p>
++Does the presence of <tt>t2, ..., tN</tt> get ignored, or does it make the
++<tt><i>INVOKE</i></tt> ill formed?
++</p>
++
++<p>
++Here is sample code which presents the problem in a concrete example:
++</p>
++
++<blockquote><pre>
++#include &lt;functional&gt;
++#include &lt;cassert&gt;
++
++struct S {
++ char data;
++};
++
++typedef char S::*PMD;
++
++int main()
++{
++ S s;
++ PMD pmd = &amp;S::data;
++ std::reference_wrapper&lt;PMD&gt; r(pmd);
++ r(s, 3.0) = 'a'; // well formed?
++ assert(s.data == 'a');
++}
++</pre></blockquote>
++
++<p>
++Without the "<tt>3.0</tt>" the example is well formed.
++</p>
++<p>
++[Note: Daniel provided wording to make it explicit that the above example is ill-formed. &mdash; end note ]
++</p>
++
++<p><i>[
++Post-Rapperswil
++]</i></p>
++
++
++<blockquote><p>
++Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++</p></blockquote>
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><i>The wording refers to N3126.</i></p>
++
++<p>
++Change 20.8.2 [func.require]/1 as indicated:
++</p>
++<blockquote>
++<p>
++1 Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++</p>
++
++<ul>
++<li>
++...
++</li>
++<li>
++...
++</li>
++<li>
++<tt>t1.*f</tt> when <ins><tt>N == 1</tt> and</ins> <tt>f</tt> is a pointer to
++member data of a class <tt>T</tt> and <tt>t1</tt> is an object of type
++<tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference to an
++object of a type derived from <tt>T</tt>;
++</li>
++<li>
++<tt>(*t1).*f</tt> when <ins><tt>N == 1</tt> and</ins> <tt>f</tt> is a pointer to
++member data of a class <tt>T</tt> and <tt>t1</tt> is not one of the types
++described in the previous item;
++</li>
++<li>
++...
++</li>
++</ul>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="1522"></a>1522. <tt>conj</tt> specification is now nonsense</h3>
++<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In Pittsburgh, we accepted the resolution of library issue <a href="lwg-defects.html#1137">1137</a>, to add
++a sentence 3 to [cmplx.over]:
++</p>
++<blockquote><p>
++All the specified overloads shall have a return type which is the nested
++<tt>value_type</tt> of the effectively cast arguments.
++</p></blockquote>
++<p>
++This was already true for four of the six functions except <tt>conj</tt> and
++<tt>proj</tt>. It is not completely unreasonable to make <tt>proj</tt> return
++the real value only, but the IEC specification does call for an imaginary part
++of -0 in some circumstances. The people who care about these distinctions really
++care, and it <em>is</em> required by an international standard.
++</p>
++<p>
++Making <tt>conj</tt> return just the real part breaks it horribly, however. It is
++well understood in mathematics that <tt>conj(re + i*im)</tt> is <tt>(re - i*im)</tt>,
++and it is widely used. The accepted new definition makes <tt>conj</tt> useful only
++for pure real operations. This botch <em>absolutely must</em> be fixed.
++</p>
++
++<p><i>[
++2010 Batavia: The working group concurred with the issue's Proposed Resolution
++]</i></p>
++
++
++<p><i>[
++Adopted at 2010-11 Batavia
++]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Remove the recently added paragraph 3 from [cmplx.over]:
++</p>
++<blockquote><p>
++<del>3 All the specified overloads shall have a return type which is the nested
++<tt>value_type</tt> of the effectively cast arguments.</del>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1523"></a>1523. <tt>noexcept</tt> for Clause 29</h3>
++<p><b>Section:</b> 29 [atomics] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2010-11-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics">issues</a> in [atomics].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-63 for Clause 29</b></p>
++
++<p>Clause 29 does not specify noexcept for any of the atomic operations.
++It probably should, though that's not completely clear.
++In particular, atomics may want to throw in implementations that support transactional memory.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Apply paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3251.html">N3251</a>,
++noexcept for the Atomics Library.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="1524"></a>1524. Allocation functions are missing <i>happens-before</i> requirements and guarantees</h3>
++<p><b>Section:</b> 18.6.1.4 [new.delete.dataraces] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2011-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete.dataraces">issues</a> in [new.delete.dataraces].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US-34</b></p>
++
++<p>Technical details:
++<p/>
++When the same unit of storage is allocated and deallocated repeatedly, operations on it can't be allowed to
++race between the allocator and the user program. But I don't see any mention of <i>happens-before</i> in the
++descriptions of allocation and deallocation functions.
++<p/>
++Proposed resolution (not wording yet):
++</p>
++<ul>
++<li><p>The call to an allocation function returning a pointer <tt>P</tt> must happen-before the matching
++deallocation call with <tt>P</tt> as a parameter. Otherwise the behavior is undefined. I don't know whether
++receiving <tt>P</tt> with <tt>memory_order_consume</tt> fits this requirement. <tt>memory_order_relaxed</tt> does not.</p>
++</li>
++<li><p>If some memory is passed to a deallocation function, the implementation must ensure that the
++deallocation call happens-before any allocation call that returns the same memory address.</p>
++</li>
++</ul>
++
++<p><i>[2011-02-26: Hans comments and drafts wording]</i></p>
++
++
++<p>The second requirement already exists, almost verbatim, as 18.6.1.4 [new.delete.dataraces] p. 1.
++I think this is where the statement belongs. However, this paragraph requires work to correctly address
++the first part of the issue.
++</p>
++
++<p><i>[Adopted at Madrid, 2011-03]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Change 18.6.1.4 [new.delete.dataraces] p. 1 as follows:</p>
++
++<blockquote><p>
++1 <del>The library versions of <tt>operator new</tt> and <tt>operator delete</tt>, user replacement versions of global
++<tt>operator new</tt> and <tt>operator delete</tt>, and the C standard library functions <tt>calloc</tt>, <tt>malloc</tt>,
++<tt>realloc</tt>, and <tt>free</tt> shall not introduce data races (1.10 [intro.multithread]) as a result
++of concurrent calls from different threads.</del><ins> For purposes of determining the existence of data races,
++the library versions of <tt>operator new</tt>, user replacement versions of global <tt>operator new</tt>, and the C
++standard library functions <tt>calloc</tt> and <tt>malloc</tt> shall behave as though they accessed and modified only
++the storage referenced by the return value. The library versions of <tt>operator delete</tt>, user replacement
++versions of <tt>operator delete</tt>, and the C standard library function <tt>free</tt> shall behave as though they
++accessed and modified only the storage referenced by their first argument. The C standard library <tt>realloc</tt>
++function shall behave as though it accessed and modified only the storage referenced by its first argument and by
++its return value.</ins> Calls to these functions that allocate or deallocate a particular unit of storage
++shall occur in a single total order, and each such deallocation call shall happen before the next allocation
++(if any) in this order.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1525"></a>1525. Effects of <tt>resize(size())</tt> on a <tt>vector</tt></h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2011-03-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-117</b></p>
++
++<p>23.3.6.3 [vector.capacity] p. 9 (Same as for 23.3.3.3 [deque.capacity] p. 1 i.e.
++<tt>deque::resize</tt>). There is no mention of what happens if <tt>sz==size()</tt>. While
++it obviously does nothing I feel a standard needs to say this explicitely.</p>
++<p>Suggested resolution:</p>
++<p>Append "If <tt>sz == size()</tt>, does nothing" to the effects.</p>
++
++<p><i>[2011-03-24 Daniel comments]</i></p>
++
++
++<p>During the edit of this issue some non-conflicting overlap with <a href="lwg-defects.html#2033">2033</a> became obvious.
++<tt>CopyInsertable</tt> should be <tt>MoveInsertable</tt> and there is missing the <tt>DefaultConstructible</tt>
++requirements, but this should be fixed by <a href="lwg-defects.html#2033">2033</a>.</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Change 23.3.6.3 [vector.capacity] p. 9 as follows:</p>
++
++<blockquote><pre>
++void resize(size_type sz);
++</pre>
++<blockquote><p>
++9 <i>Effects</i>: If <tt>sz &lt;<ins>=</ins> size()</tt>, equivalent to <tt>erase(begin() + sz, end());</tt>.
++If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> value-initialized elements to the sequence.
++<p/>
++10 <i>Requires</i>: <tt>T</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>.
++</p></blockquote></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="1526"></a>1526. C++ should not impose thread safety requirements on C99 library implementations</h3>
++<p><b>Section:</b> 17.6.5.9 [res.on.data.races] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> BSI <b>Opened:</b> 2011-03-24 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB-111</b></p>
++
++<p>Section 17.6.5.9 [res.on.data.races], Data Race Avoidance, requires the C++ Standard Library to avoid data races
++that might otherwise result from two threads making calls to C++ Standard Library functions on
++distinct objects. The C standard library is part of the C++ Standard Library and some C++ Standary library
++functions (parts of the Localization library, as well as Numeric Conversions in 21.5), are specified
++to make use of the C standard library. Therefore, the C++ standard indirectly imposes a requirement
++on the thread safety of the C standard library. However, since the C standard does not address the
++concept of thread safety conforming C implementations exist that do no provide such guarantees.
++This conflict needs to be reconciled.</p>
++
++<p>Suggested resolution by national body comment:</p>
++
++<blockquote><p>
++remove the requirement to make use of <tt>strtol()</tt> and <tt>sprintf()</tt> since these functions depend on the
++global C locale and thus cannot be made thread safe.
++</p></blockquote>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>Deferred</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++<p>
++Alisdair: PJ, does this cause a problem in C?
++</p>
++<p>
++PJ: Every implementation know of is thread safe.
++</p>
++<p>
++Pete: There a couple of effects that are specified on strtol() and sprintf() which is a problem.
++</p>
++<p>
++PJ: When C++ talks about C calls it should be "as if" calling the function.
++</p>
++<p>
++Pete: Culprit is to string stuff. My fault.
++</p>
++<p>
++PJ: Not your fault. You did what you were told. Distinct resolution to change wording.
++</p>
++<p>
++Dietmar: What would we break if we change it back?
++</p>
++<p>
++Pete: Nothing. If implemented on top of thread safe C library you are just fine.
++</p>
++<p>
++Alisdair: Anyone want to clean up wording and put it back to what Pete gave us?
++</p>
++<p>
++Alisdair: No volunteers. Do we want to mark as NAD? We could leave it as deferred.
++</p>
++<p>
++Stefanus: Did original submitter care about this?
++</p>
++<p>
++Lawrence: There is some work to make local calls thread safe. The resolution would be to call those thread safe version.
++</p>
++<p>
++Pete: "As if called under single threaded C program"
++</p>
++<p>
++<b>Action Item</b> (Alisdair): Write wording for this issue.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Re-opened at the request of the concurrency subgroup, who feel there is an issue that needs
++clarifying for the (planned) 2017 standard.
++</p>
++
++<p><b>Rationale:</b></p><p>No consensus to make a change at this time</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++The concurrency subgroup decided to encourage the LWG to consider a change to 17.2 [library.c] or thereabouts
++to clarify that we are requiring C++-like thread-safety for <tt>setlocale</tt>, so that races are not introduced
++by C locale accesses, even when the C library allows it. This would require e.g. adding "and data race avoidance"
++at the end of 17.2 [library.c] p1:
++</p>
++<p>
++"The C++ standard library also makes available the facilities of the C standard library, suitably adjusted to
++ensure static type safety <ins>and data race avoidance</ins>.",
++</p>
++<p>
++with some further clarifications in the sections mentioned in <a href="lwg-defects.html#1526">1526</a>.
++</p>
++<p>
++This seems to be consistent with existing implementations. This would technically not be constraining C implementation,
++but it would be further constraining C libraries used for both C and C++.
++</p>
++
++<p><i>[Lenexa 2015-05-05: Move to Resolved]</i></p>
++
++<p>JW: it's a bit odd that the issue title says sould not impose requirements on C libs, then the P/R does exactly that. Does make sense though, previously we imposed an implicit requirement which would not have been met. Now we say it explicitly and require it is met.</p>
++<p>STL: I think this is Resolved, it has been fixed in the working paper [support.runtime]/6 is an example where we call out where things can race. That implies that for everything else they don't create races.</p>
++<p>JW: I'm not sure, I think we still need the "and data race avoidance" to clarify that the features from C avoid races, even though C99 says no such thing.</p>
++<p>STL: [library.c] says that something like sqrt is part of the C++ Standard LIbrary. [res.on.data.races] then applies to them. Would be OK with a note there, but am uncomfortable with "and data race avoidance" which sounds like it's making a very strong guarantee.</p>
++<p>ACTION ITEM JW to editorially add note to [library.c] p1: "Unless otherwise specified, the C Standard Library functions shall meet the requirements for data race avoidance (xref [res.on.data.races])"</p>
++<p>Move to Resolved?</p>
++<p>10 in favor, 0 opposed, 3 abstentions</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 17.2 [library.c] p1 as indicated:</p>
++
++<blockquote><p>
++-1- The C++ standard library also makes available the facilities of the C standard library, suitably adjusted to
++ensure static type safety <ins>and data race avoidance</ins>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2000"></a>2000. Missing definition of <tt>packaged_task</tt> specialization of <tt>uses_allocator</tt></h3>
++<p><b>Section:</b> 30.6.9.2 [futures.task.nonmembers] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++[futures.task.nonmembers]/3 says:
++</p>
++<blockquote><pre>
++ template &lt;class R, class Alloc&gt;
++ struct uses_allocator&lt;packaged_task&lt;R&gt;, Alloc&gt;;
++</pre></blockquote>
++<p>
++This is a declaration, but should be a definition.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change [futures.task.nonmembers]/3:
++</p>
++
++<blockquote><pre>
++ template &lt;class R, class Alloc&gt;
++ struct uses_allocator&lt;packaged_task&lt;R&gt;, Alloc&gt;<del>;</del>
++ <ins>: true_type {};</ins>
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2001"></a>2001. Class template <tt>basic_regex</tt> uses non existent <tt>string_type</tt></h3>
++<p><b>Section:</b> 28.8.3 [re.regex.assign] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Volker Lukas <b>Opened:</b> 2010-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex.assign">issues</a> in [re.regex.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In working draft N3126, subclause 28.8.3 [re.regex.assign], paragraphs 12, 13 and 19,
++the name <tt>string_type</tt> is used. This is presumably a typedef for <tt>basic_string&lt;value_type&gt;</tt>, where
++<tt>value_type</tt> is the character type used by <tt>basic_regex</tt>. The <tt>basic_regex</tt>
++template however defines no such typedef, and neither does the <tt>&lt;regex&gt;</tt>
++header or the <tt>&lt;initializer_list&gt;</tt> header included by <tt>&lt;regex&gt;</tt>.
++</p>
++
++<p><i>[
++2010-11-03 Daniel comments and suggests alternative wording:
++]</i></p>
++
++<blockquote><p>
++The proposed resolution needs to use <tt>basic_string&lt;<strong>charT</strong>&gt;</tt> instead of <tt>basic_string&lt;char&gt;</tt>
++</p></blockquote>
++
++<p>
++Previous Proposed Resolution:
++<p/>
++Make the following changes to [re.regex.assign]:
++</p>
++<blockquote>
++<pre>
++basic_regex&amp; assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
++</pre>
++<blockquote><p>
++12 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(ptr), f)</tt>.
++</p></blockquote>
++
++<pre>
++basic_regex&amp; assign(const charT* ptr, size_t len,
++ flag_type f = regex_constants::ECMAScript);
++</pre>
++<blockquote><p>
++13 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(ptr, len), f)</tt>.
++</p></blockquote>
++
++<pre>
++[..]
++
++template &lt;class InputIterator&gt;
++ basic_regex&amp; assign(InputIterator first, InputIterator last,
++ flag_type f = regex_constants::ECMAScript);
++</pre>
++
++<blockquote><p>
++18 <i>Requires</i>: The type <tt>InputIterator</tt> shall satisfy the requirements for an Input Iterator (24.2.3).
++</p></blockquote>
++
++<blockquote><p>
++19 <i>Returns</i>: <tt>assign(<del>string_type</del><ins>basic_string&lt;charT&gt;</ins>(first, last), f)</tt>.
++</p></blockquote>
++
++</blockquote>
++
++<p><i>[
++2010 Batavia
++]</i></p>
++
++
++<p>
++Unsure if we should just give <tt>basic_regex</tt> a <tt>string_type</tt> typedef. Looking for when <tt>string_type</tt> was
++introduced into <tt>regex</tt>. Howard to draft wording for <tt>typedef typename traits::string_type string_type</tt>, then move to Review.
++</p>
++
++<p><i>[
++2011-02-16: Daniel comments and provides an alternative resolution.
++]</i></p>
++
++
++<p>
++I'm strongly in favour with the Batavia idea to provide a separate <tt>string_type</tt> within
++<tt>basic_regex</tt>, but it seems to me that the issue resultion should add one more
++important typedef, namely that of the traits type! Currently, <tt>basic_regex</tt> is the
++<em>only</em> template that does not publish the type of the associated traits type. Instead
++of opening a new issue, I added this suggestion as part of the proposed wording.
++</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 6 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the class template <tt>basic_regex</tt> synopsis, 28.8 [re.regex] p. 3, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class charT,
++ class traits = regex_traits&lt;charT&gt; &gt;
++ class basic_regex {
++ public:
++ // types:
++ typedef charT value_type;
++ <ins>typedef traits traits_type;</ins>
++ <ins>typedef typename traits::string_type string_type;</ins>
++ typedef regex_constants::syntax_option_type flag_type;
++ typedef typename traits::locale_type locale_type;
++
++ [..]
++ };
++}
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2002"></a>2002. Class template <tt>match_results</tt> does not specify the semantics of <tt>operator==</tt></h3>
++<p><b>Section:</b> 28.10.8 [re.results.nonmember] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <em>Returns</em> element of <tt>operator==</tt> says:
++</p>
++
++<blockquote><p>
++<tt>true</tt> only if the two objects refer to the same match
++</p></blockquote>
++
++<p>
++It is not really clear what this means: The current specification would allow for an
++implementation to return <tt>true</tt>, only if the address values of <tt>m1</tt> and
++<tt>m2</tt> are the same. While this approach is unproblematic in terms of used operations
++this is also a bit unsatisfactory. With identity equality alone there seems to be no convincing
++reason to provide this operator at all. It could for example also refer to an comparison based
++on iterator values. In this case a user should better know that this will be done, because
++there is no guarantee at all that inter-container comparison of iterators
++is a feasible operation. This was a clear outcome of the resolution provided in
++<a href= "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>
++for LWG issue <a href= "http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#446">446</a>.
++It could also mean that a character-based comparison of the individual <tt>sub_match</tt>
++elements should be done - this would be equivalent to applying <tt>operator==</tt> to
++the subexpressions, prefix and suffix.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a>.</p>
++
++
++
++
++
++<hr>
++<h3><a name="2003"></a>2003. String exception inconsistency in erase.</h3>
++<p><b>Section:</b> 21.4.1 [string.require] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jos&eacute; Daniel Garc&iacute;a S&aacute;nchez <b>Opened:</b> 2010-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.require">issues</a> in [string.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Clause 21.4.1 [string.require]p3 states:
++</p>
++<blockquote><p>
++No <tt>erase()</tt> or <tt>pop_back()</tt> member function shall throw
++any exceptions.
++</p></blockquote>
++<p>
++However in 21.4.6.5 [string::erase] p2 the first version of <tt>erase</tt> has
++</p>
++<blockquote><p>
++<i>Throws</i>: <tt>out_of_range</tt> if <tt>pos > size()</tt>.
++</p></blockquote>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++Beman: Don't want to just change this, can we just say "unless otherwise specified"?
++<p/>
++Alisdair: Leave open, but update proposed resolution to say something like "unless otherwise specified".
++<p/>
++General agreement that it should be corrected but not a stop-ship.
++<p/>
++Action: Update proposed wording for issue 2003 as above, but leave Open.
++</p>
++
++<p><i>[2014-02-12 Issaquah meeting]</i></p>
++
++
++<p>
++Jeffrey: Madrid meeting's proposed wording wasn't applied, and it's better than the original proposed wording.
++However, this sentence is only doing 3 functions' worth of work, unlike the similar paragraphs in 23.2.1 [container.requirements.general].
++Suggest just putting "<i>Throws:</i> Nothing" on the 3 functions.
++</p>
++
++<p><i>[2014-02-13 Issaquah meeting]</i></p>
++
++<p>
++Move as Immmediate
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Remove [string.require]p/3:
++</p>
++<blockquote><p>
++<del>3 No <tt>erase()</tt> or <tt>pop_back()</tt> member function shall throw any exceptions.</del>
++</p></blockquote>
++
++<p>
++Add to the specifications of <tt>iterator erase(const_iterator p);</tt>, <tt>iterator erase(const_iterator first, const_iterator last);</tt>,
++ and <tt>void pop_back();</tt> in 21.4.6.5 [string::erase]:
++</p>
++<blockquote><p><ins><i>Throws:</i> Nothing</ins></p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2004"></a>2004. <tt>duration::operator*</tt> has template parameters in funny order</h3>
++<p><b>Section:</b> 20.12.5.5 [time.duration.nonmember] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In [time] and [time.duration.nonmember] we have:
++</p>
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2>
++ duration&lt;typename common_type&lt;Rep1, Rep2>::type, Period>
++ operator*(const Rep1&amp; s, const duration&lt;Rep2, Period>&amp; d);
++</pre></blockquote>
++<p>
++Everywhere else, we always have <tt>&lt;rep, period></tt> in that order for a given
++type. But here, we have <tt>Period</tt> and <tt>Rep2</tt> in reverse order for
++<tt>&lt;Rep2, Period></tt>. This is probably of little importance, since the
++template parameters are seldom spelled out for a function like this. But changing it
++now will eliminate a potential source of future errors and confusion.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the signature in [time] and [time.duration.nonmember] to:
++</p>
++<blockquote><pre>
++template &lt;class Rep1, class <del>Period</del><ins>Rep2</ins>, class <del>Rep2</del><ins>Period</ins>>
++ duration&lt;typename common_type&lt;Rep1, Rep2>::type, Period>
++ operator*(const Rep1&amp; s, const duration&lt;Rep2, Period>&amp; d);
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2005"></a>2005. <tt>unordered_map::insert(T&amp;&amp;)</tt> protection should apply to <tt>map</tt> too</h3>
++<p><b>Section:</b> 23.4.4.4 [map.modifiers], 23.4.5.3 [multimap.modifiers], 23.5.4.4 [unord.map.modifiers], 23.5.5.3 [unord.multimap.modifiers] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.modifiers">issues</a> in [map.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In [unord.map.modifiers], the signature:
++</p>
++<blockquote><pre>
++template &lt;class P&gt;
++ pair&lt;iterator, bool&gt; insert(P&amp;&amp; obj);
++</pre></blockquote>
++<p>
++now has an added Remarks paragraph:
++</p>
++<blockquote><p>
++<i>Remarks</i>: This signature shall not participate in overload resolution unless <tt>P</tt>
++is implicitly convertible to <tt>value_type</tt>.
++</p></blockquote>
++<p>
++The same is true for <tt>unordered_multimap</tt>.
++<p/>
++But neither <tt>map</tt> nor <tt>multimap</tt> have this constraint, even though it is a
++Good Thing(TM) in those cases as well.
++</p>
++
++<p><i>[
++The submitter suggests: Add the same Remarks clause to [map.modifiers] and [multimap.modifiers].
++]</i></p>
++
++
++<p><i>[
++2010-10-29 Daniel comments:
++]</i></p>
++
++
++<p>
++I believe both paragraphs need more cleanup: First, the current Requires element conflict with the Remark;
++second, it seems to me that the whole single Requires element is intended to be split into a Requires
++and an Effects element; third, the reference to <tt>tuple</tt> is incorrect (noticed by Paolo Carlini);
++fourth, it refers to some non-existing <tt>InputIterator</tt> parameter relevant for a completely different
++overload; sixth, the return type of the overload with hint is wrong.
++The following proposed resolution tries to solve these issues as well and uses similar wording as for
++the corresponding unordered containers. Unfortunately it has some redundancy over Table&nbsp;99, but I did
++not remove the specification because of the more general template parameter <tt>P</tt> - the Table&nbsp;99
++requirements apply only for an argument <em>identical</em> to <tt>value_type</tt>.
++<p/>
++Daniel's Proposed resolution (not current):
++</p>
++
++<blockquote class="note">
++<ol>
++<li>Change 23.4.4.4 [map.modifiers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
++template &lt;class P&gt; <del>pair&lt;</del>iterator<del>, bool&gt;</del> insert(const_iterator position, P&amp;&amp; x);
++</pre><blockquote><p>
++1 <em>Requires</em>: <del><tt>P</tt> shall be convertible to </del><tt>value_type</tt><ins> is constructible
++from <tt>std::forward&lt;P&gt;(x)</tt>.</ins>.
++<p/>
++<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise <tt>x</tt> is considered
++to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map. Specifically, in
++such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt> unless the conversion
++from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>, then <tt>key_type</tt>
++must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters does not require
++<tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced <tt>InputIterator</tt> returns a
++non-const rvalue <tt>pair&lt;key_type,mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt> is required for both
++<tt>key_type</tt> and <tt>mapped_type</tt>.</del><br/>
++<ins>? <em>Effects</em>: Inserts <tt>x</tt> converted to <tt>value_type</tt> if and only if there is no element in the container with
++key equivalent to the key of <tt>value_type(x)</tt>. For the second form, the iterator <tt>position</tt> is a hint pointing to where the
++search should start.</ins>
++<p/>
++<ins>? <em>Returns</em>: For the first form, the <tt>bool</tt> component of the returned <tt>pair</tt> object indicates whether the
++insertion took place and the iterator component - or for the second form the returned iterator - points to the element with key equivalent
++to the key of <tt>value_type(x)</tt>.</ins>
++<p/>
++<ins>? <em>Complexity</em>: Logarithmic in general, but amortized constant if <tt>x</tt> is inserted right before <tt>position</tt>.</ins>
++<p/>
++<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
++is implicitly convertible to <tt>value_type</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++<li>Change 23.4.5.3 [multimap.modifiers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt; iterator insert(P&amp;&amp; x);
++template &lt;class P&gt; iterator insert(const_iterator position, P&amp;&amp; x);
++</pre><blockquote><p>
++1 <em>Requires</em>: <del><tt>P</tt> shall be convertible to </del><tt>value_type</tt> <ins>is constructible from
++<tt>std::forward&lt;P&gt;(x)</tt></ins>.
++<p/>
++<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise
++<tt>x</tt> is considered to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map.
++Specifically, in such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt>
++unless the conversion from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>,
++then <tt>key_type</tt> must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters
++does not require <tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced
++<tt>InputIterator</tt> returns a non-const rvalue <tt>pair&lt;key_type, mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt>
++is required for both <tt>key_type</tt> and <tt>mapped_type</tt>.</del><br/>
++<ins>? <em>Effects</em>: Inserts <tt>x</tt> converted to <tt>value_type</tt>. For the second form, the iterator <tt>position</tt>
++is a hint pointing to where the search should start.</ins>
++<p/>
++<ins>? <em>Returns</em>: An iterator that points to the element with key equivalent to the key of <tt>value_type(x)</tt>.</ins>
++<p/>
++<ins>? <em>Complexity</em>: Logarithmic in general, but amortized constant if <tt>x</tt> is inserted right before <tt>position</tt>.</ins>
++<p/>
++<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless <tt>P</tt>
++is implicitly convertible to <tt>value_type</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[
++2010 Batavia:
++]</i></p>
++
++
++<p>
++We need <tt>is_convertible</tt>, not <tt>is_constructible</tt>, both in ordered and unordered containers.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++The effects of these inserts can be concisely stated in terms of emplace().
++Also, the correct term is "EmplaceConstructible", not "constructible".
++</p>
++
++<p>
++New wording by Pablo, eliminating duplicate requirements already implied by the effects clause. Move to Review.
++</p>
++
++<p><i>[
++2011-10-02 Daniel comments and refines the proposed wording
++]</i></p>
++
++
++<blockquote><p>
++Unfortunately the template constraints expressed as "<tt>P</tt> is implicitly convertible to <tt>value_type</tt>"
++reject the intended effect to support move-only key types, which was the original intention when
++the library became move-enabled through the rvalue-reference proposals by Howard (This can clearly be deduced
++from existing carefully selected wording that emphasizes that <tt>CopyConstructible</tt> is only required
++for special situations involving lvalues or const rvalues as arguments). The root of the problem is based
++on current core rules, where an "implicitly converted" value has copy-initialization semantics. Consider
++a move-only key type <tt>KM</tt>, some mapped type <tt>T</tt>, and a source value <tt>p</tt> of type <tt>P</tt>
++equal to <tt>std::pair&lt;KM, T&gt;</tt>, this is equivalent to:
++</p>
++<blockquote><pre>
++std::pair&lt;const KM, T&gt; dest = std::move(p);
++</pre></blockquote>
++<p>
++Now 8.5 [dcl.init] p16 b6 sb2 says that the effects of this heterogeneous copy-initialization (<tt>p</tt>
++has a different type than <tt>dest</tt>) are as-if a temporary of the target type <tt>std::pair&lt;const KM, T&gt;</tt>
++is produced from the rvalue <tt>p</tt> of type <tt>P</tt> (which is fine), and this temporary is used to initialize
++<tt>dest</tt>. This second step cannot succeed, because we cannot move from <tt>const KM</tt> to <tt>const KM</tt>. This
++means that <tt>std::is_convertible&lt;P, std::pair&lt;const KM, T&gt;&gt;::value</tt> is false.
++<p/>
++But the actual code that is required (with the default allocator) is simply a direct-initialization
++from <tt>P</tt> to <tt>value_type</tt>, so imposing an implicit conversion is more than necessary. Therefore
++I strongly recommend to reduce the "overload participation" constraint to
++<tt>std::is_constructible&lt;std::pair&lt;const KM, T&gt;, P&gt;::value</tt> instead. This change is the
++only change that has been performed to the previous proposed wording from Pablo shown below.
++</p></blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tentatively Ready by the post-Kona issues processing subgroup, after much discussion
++on Daniel's analysis of Copy Initialization and move semantics, which we ultimately agreed with.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li>Change 23.4.4.4 [map.modifiers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
++template &lt;class P&gt; <del>pair&lt;</del>iterator<del>, bool&gt;</del> insert(const_iterator position, P&amp;&amp; x);
++</pre><blockquote>
++<del>1 <em>Requires</em>: <tt>P</tt> shall be convertible to <tt>value_type</tt>.</del>
++<p/>
++<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise <tt>x</tt> is considered
++to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map. Specifically, in
++such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt> unless the conversion
++from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>, then <tt>key_type</tt>
++must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters does not require
++<tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced <tt>InputIterator</tt> returns a
++non-const rvalue <tt>pair&lt;key_type,mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt> is required for both
++<tt>key_type</tt> and <tt>mapped_type</tt>.</del><br/>
++<ins>? <em>Effects</em>: The first form is equivalent to
++<tt>return emplace(std::forward&lt;P&gt;(x))</tt>.
++The second form is equivalent to
++<tt>return emplace_hint(position, std::forward&lt;P&gt;(x))</tt>.</ins>
++<p/>
++<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless
++<tt>std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value</tt> is true.</ins>
++<p/>
++</blockquote></blockquote>
++</li>
++<li>Change 23.4.5.3 [multimap.modifiers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt; iterator insert(P&amp;&amp; x);
++template &lt;class P&gt; iterator insert(const_iterator position, P&amp;&amp; x);
++</pre><blockquote>
++<del>1 <em>Requires</em>: <tt>P</tt> shall be convertible to <tt>value_type</tt>.</del>
++<p/>
++<del>If <tt>P</tt> is instantiated as a reference type, then the argument <tt>x</tt> is copied from. Otherwise
++<tt>x</tt> is considered to be an rvalue as it is converted to <tt>value_type</tt> and inserted into the map.
++Specifically, in such cases <tt>CopyConstructible</tt> is not required of <tt>key_type</tt> or <tt>mapped_type</tt>
++unless the conversion from <tt>P</tt> specifically requires it (e.g., if <tt>P</tt> is a <tt>tuple&lt;const key_type, mapped_type&gt;</tt>,
++then <tt>key_type</tt> must be <tt>CopyConstructible</tt>). The signature taking <tt>InputIterator</tt> parameters
++does not require <tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced
++<tt>InputIterator</tt> returns a non-const rvalue <tt>pair&lt;key_type, mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt>
++is required for both <tt>key_type</tt> and <tt>mapped_type</tt>.</del><br/>
++<ins>? <em>Effects</em>: The first form is equivalent to
++<tt>return emplace(std::forward&lt;P&gt;(x))</tt>.
++The second form is equivalent to
++<tt>return emplace_hint(position, std::forward&lt;P&gt;(x))</tt>.</ins>
++<p/>
++<ins>? <em>Remarks</em>: These signatures shall not participate in overload resolution unless
++<tt>std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value</tt> is true.</ins>
++<p/>
++</blockquote></blockquote>
++</li>
++<li>Change [unord.map.modifers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt;
++pair&lt;iterator, bool&gt; insert(P&amp;&amp; obj);
++</pre>
++<blockquote>
++<del>1 <em>Requires</em>: <tt>value_type</tt> is constructible from <tt>std::forward&lt;P&gt;(obj)</tt>.</del>
++<p/>
++2 <em>Effects</em>:
++<ins>equivalent to <tt>return emplace(std::forward&lt;P&gt;(obj))</tt>.</ins>
++<del>Inserts obj converted to <tt>value_type</tt> if and only if there is no element in the container with
++key equivalent to the key of <tt>value_type(obj)</tt>.</del>
++<p/>
++<del>3 <em>Returns</em>: The bool component of the returned pair object indicates whether the insertion took place
++and the iterator component points to the element with key equivalent to the key of <tt>value_type(obj)</tt>.</del>
++<p/>
++<del>4 <em>Complexity</em>: Average case O(1), worst case O(size()).</del>
++<p/>
++<del>5</del><ins>3</ins> <em>Remarks</em>: This signature shall not participate in overload resolution unless
++<del><tt>P</tt> is implicitly convertible to <tt>value_type</tt></del><ins><tt>std::is_constructible&lt;value_type,
++P&amp;&amp;&gt;::value</tt> is true</ins>.
++<p/>
++</blockquote>
++<pre>template &lt;class P&gt;
++iterator insert(const_iterator hint, P&amp;&amp; obj);
++</pre>
++<blockquote>
++<del>6 <em>Requires</em>: <tt>value_type</tt> is constructible from <tt>std::forward&lt;P&gt;(obj)</tt>.</del>
++<p/>
++<del>7</del><em>?</em> <em>Effects</em>:
++<ins>equivalent to <tt>return emplace_hint(hint, std::forward&lt;P&gt;(obj))</tt>.</ins>
++<del>Inserts obj converted to <tt>value_type</tt> if and only if there is no element in the container with
++key equivalent to the key of <tt>value_type(obj)</tt>. The iterator hint is a hint pointing to where the
++search should start.</del>
++<p/>
++<del>8 <em>Returns</em>: An iterator that points to the element with key equivalent to the key of
++<tt>value_type(obj)</tt>.</del>
++<p/>
++<del>9 <em>Complexity</em>: Average case O(1), worst case O(size()).</del>
++<p/>
++<del>10</del><em>?</em> <em>Remarks</em>: This signature shall not participate in overload resolution unless
++<del><tt>P</tt> is implicitly convertible to <tt>value_type</tt></del><ins><tt>std::is_constructible&lt;value_type,
++P&amp;&amp;&gt;::value</tt> is true</ins>.
++</blockquote></blockquote>
++</li>
++<li>Change [unord.multimap.modifers] around p. 1 as indicated:
++<blockquote><pre>
++template &lt;class P&gt;
++iterator insert(P&amp;&amp; obj);
++</pre>
++<blockquote>
++<del>1 <em>Requires</em>: <tt>value_type</tt> is constructible from <tt>std::forward&lt;P&gt;(obj)</tt>.</del>
++<p/>
++2 <em>Effects</em>:
++<ins>equivalent to <tt>return emplace(std::forward&lt;P&gt;(obj))</tt>.</ins>
++<del>Inserts obj converted to <tt>value_type</tt>.</del>
++<p/>
++<del>3 <em>Returns</em>: An iterator that points to the element with key equivalent to the key of <tt>value_type(obj)</tt>.</del>
++<p/>
++<del>4 <em>Complexity</em>: Average case O(1), worst case O(size()).</del>
++<p/>
++<del>5</del><ins>3</ins> <em>Remarks</em>: This signature shall not participate in overload resolution
++unless <del><tt>P</tt> is implicitly convertible to <tt>value_type</tt></del><ins><tt>std::is_constructible&lt;value_type,
++P&amp;&amp;&gt;::value</tt> is true</ins>.
++</blockquote>
++<pre>
++template &lt;class P&gt;
++iterator insert(const_iterator hint, P&amp;&amp; obj);
++</pre>
++<blockquote>
++<del>6 <em>Requires</em>: <tt>value_type</tt> is constructible from <tt>std::forward&lt;P&gt;(obj)</tt>.</del>
++<p/>
++<del>7</del><em>?</em> <em>Effects</em>:
++<ins>equivalent to <tt>return emplace_hint(hint, std::forward&lt;P&gt;(obj))</tt>.</ins>
++<del>Inserts obj converted to <tt>value_type</tt>. The iterator hint is a hint pointing to where the search
++should start.</del>
++<p/>
++<del>8 <em>Returns</em>: An iterator that points to the element with key equivalent to the key of <tt>value_type</tt>(obj).</del>
++<p/>
++<del>9 <em>Complexity</em>: Average case O(1), worst case O(size()).</del>
++<p/>
++<del>10</del><ins><em>?</em></ins> <em>Remarks</em>: This signature shall not participate in overload resolution
++unless <del><tt>P</tt> is implicitly convertible to <tt>value_type</tt></del><ins><tt>std::is_constructible&lt;value_type,
++P&amp;&amp;&gt;::value</tt> is true</ins>.
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2007"></a>2007. Incorrect specification of return value for <tt>map&lt;&gt;::at()</tt></h3>
++<p><b>Section:</b> 23.4.4.3 [map.access] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2010-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.access">issues</a> in [map.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In [map.access]/9, the <i>Returns</i> clause for <tt>map&lt;Key, T&gt;::at(x)</tt> says
++that it returns "a reference to the element whose key is equivalent to <tt>x</tt>." That can't be right.
++The signature for <tt>at()</tt> says that its return type is <tt>T</tt>, but the elements
++of <tt>map&lt;Key, T&gt;</tt> have type <tt>pair&lt;const K, T&gt;</tt>. (I checked [unord.map.elem]
++and found that its specification of <tt>at()</tt> is correct. This is a problem for <tt>map</tt> only.)
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Change the wording in [map.access]/9 so it's identical to what we already say for <tt>operator[]</tt>,
++which is unambiguous and correct.
++</p>
++<blockquote><p>
++<i>Returns</i>: A reference to the <del>element whose key is equivalent</del><ins><tt>mapped_type</tt>
++corresponding</ins> to <tt>x</tt><ins> in <tt>*this</tt></ins>.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2008"></a>2008. Conflicting Error Conditions for <tt>packaged_task::operator()</tt></h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2010-06-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The Throws clause for <tt>packaged_task::operator()</tt> says that it throws "a
++<tt>future_error</tt> exception object if there is no associated asynchronous
++state or the stored task has already been invoked." However, the Error
++Conditions clause does not define an error condition when the stored task has
++already been invoked, only when the associated state is already ready (i.e. the
++invocation has completed).
++</p>
++
++<p><i>[2011-02-17 Anthony provides an alternative resolution]</i></p>
++
++
++<p><strong>Previous</strong> proposed resolution:</p>
++
++<p>
++Change the first bullet item in 30.6.9.1 [futures.task.members] /22:
++</p>
++
++<blockquote><pre>
++void operator()(ArgTypes... args);
++</pre>
++<blockquote>
++<p>
++20 ...
++</p>
++<p>
++21 ...
++</p>
++<p>
++22 <i>Error conditions:</i>
++</p>
++<ul>
++<li>
++<tt>promise_already_satisfied</tt> if <del>the associated asynchronous state is
++already ready</del> <ins><tt>operator()</tt> has already been called</ins>.
++</li>
++<li>
++<tt>no_state</tt> if <tt>*this</tt> has no associated asynchronous state.
++</li>
++</ul>
++</blockquote>
++</blockquote>
++
++<p><i>[Adopted at Madrid, 2011-03]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Change the first bullet item in 30.6.9.1 [futures.task.members] p. 17:
++</p>
++
++<blockquote><pre>
++void operator()(ArgTypes... args);
++</pre>
++<blockquote>
++<p>
++15 ...
++</p>
++<p>
++16 ...
++</p>
++<p>
++17 <i>Error conditions:</i>
++</p>
++<ul>
++<li>
++<tt>promise_already_satisfied</tt> if the <del>associated asynchronous state is already
++ready</del><ins>stored task has already been invoked</ins>.
++</li>
++<li>
++<tt>no_state</tt> if <tt>*this</tt> has no associated asynchronous state.
++</li>
++</ul>
++</blockquote>
++</blockquote>
++</li>
++
++<li>
++<p>
++Change the first bullet item in 30.6.9.1 [futures.task.members] p. 21:
++</p>
++
++<blockquote><pre>
++void make_ready_at_thread_exit(ArgTypes... args);
++</pre>
++<blockquote>
++<p>
++19 ...
++</p>
++<p>
++20 ...
++</p>
++<p>
++21 <i>Error conditions:</i>
++</p>
++<ul>
++<li>
++<tt>promise_already_satisfied</tt> if the <del>associated asynchronous state already has a stored value or
++exception</del><ins>stored task has already been invoked</ins>.
++</li>
++<li>
++<tt>no_state</tt> if <tt>*this</tt> has no associated asynchronous state.
++</li>
++</ul>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2009"></a>2009. Reporting out-of-bound values on numeric string conversions</h3>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2010-07-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The functions (<tt>w</tt>)<tt>stoi</tt> and (<tt>w</tt>)<tt>stof</tt>
++are specified in terms of calling C library APIs for potentially wider
++types. The integer and floating-point versions have subtly different
++behaviour when reading values that are too large to convert. The
++floating point case will throw <tt>out_of_bound</tt> if the read value
++is too large to convert to the wider type used in the implementation,
++but behaviour is undefined if the converted value cannot narrow to a
++float. The integer case will throw <tt>out_of_bounds</tt> if the
++converted value cannot be represented in the narrower type, but throws
++<tt>invalid_argument</tt>, rather than <tt>out_of_range</tt>, if the
++conversion to the wider type fails due to overflow.
++</p>
++
++<p>
++Suggest that the Throws clause for both specifications should be
++consistent, supporting the same set of fail-modes with the matching set
++of exceptions.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++21.5p3 [string.conversions]
++</p>
++
++<blockquote><pre>
++int stoi(const string&amp; str, size_t *idx = 0, int base = 10);
++long stol(const string&amp; str, size_t *idx = 0, int base = 10);
++unsigned long stoul(const string&amp; str, size_t *idx = 0, int base = 10);
++long long stoll(const string&amp; str, size_t *idx = 0, int base = 10);
++unsigned long long stoull(const string&amp; str, size_t *idx = 0, int base = 10);
++</pre>
++
++<blockquote>
++<p>
++...
++</p>
++<p>
++3 <i>Throws:</i> <tt>invalid_argument</tt> if <tt>strtol</tt>,
++<tt>strtoul</tt>, <tt>strtoll</tt>, or <tt>strtoull</tt> reports that no
++conversion could be performed. Throws <tt>out_of_range</tt> if
++<ins><tt>strtol</tt>, <tt>strtoul</tt>, <tt>strtoll</tt> or
++<tt>strtoull</tt> sets <tt>errno</tt> to <tt>ERANGE</tt>, or if</ins>
++the converted value is outside the range of representable values for the
++return type.
++</p>
++</blockquote>
++</blockquote>
++
++<p>
++21.5p6 [string.conversions]
++</p>
++
++<blockquote><pre>
++float stof(const string&amp; str, size_t *idx = 0);
++double stod(const string&amp; str, size_t *idx = 0);
++long double stold(const string&amp; str, size_t *idx = 0);
++</pre>
++
++<blockquote>
++<p>
++...
++</p>
++<p>
++6 <i>Throws:</i> <tt>invalid_argument</tt> if <tt>strtod</tt> or
++<tt>strtold</tt> reports that no conversion could be performed. Throws
++<tt>out_of_range</tt> if <tt>strtod</tt> or <tt>strtold</tt> sets
++<tt>errno</tt> to <tt>ERANGE</tt> <ins> or if the converted value is
++outside the range of representable values for the return type</ins>.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2010"></a>2010. <tt>is_* traits</tt> for binding operations can't be meaningfully specialized</h3>
++<p><b>Section:</b> 20.9.10.1 [func.bind.isbind] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Sean Hunt <b>Opened:</b> 2010-07-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.isbind">issues</a> in [func.bind.isbind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.9.10.1 [func.bind.isbind] says for <tt>is_bind_expression</tt>:
++</p>
++
++<blockquote><p>
++Users may specialize this template to indicate that a type should be
++treated as a subexpression in a <tt>bind</tt> call.
++</p></blockquote>
++
++<p>
++But it also says:
++</p>
++
++<blockquote><p>
++If <tt>T</tt> is a type returned from <tt>bind</tt>,
++<tt>is_bind_expression&lt;T&gt;</tt> shall be publicly derived from
++<tt>integral_constant&lt;bool, true&gt;</tt>, otherwise from
++<tt>integral_constant&lt;bool, false&gt;</tt>.
++</p></blockquote>
++
++<p>
++This means that while the user is free to specialize, any specialization
++would have to be <tt>false</tt> to avoid violating the second
++requirement. A similar problem exists for <tt>is_placeholder</tt>.
++</p>
++
++<p><i>[
++2010 Batavia (post meeting session)
++]</i></p>
++
++<p>
++Alisdair recognises this is clearly a bug introduced by some wording he
++wrote, the sole purpose of this metafunction is as a customization point
++for users to write their own <tt>bind</tt>-expression types that participate
++in the standard library <tt>bind</tt> protocol. The consensus was that this
++should be fixed in Madrid, moved to Open.
++</p>
++
++<p><i>[2011-05-13 Jonathan Wakely comments and provides proposed wording]</i></p>
++
++
++<p>
++The requirements are that <tt>is_bind_expression&lt;T&gt;::value</tt> is true when <tt>T</tt>
++is a type returned from <tt>bind</tt>, false for any other type, except when
++there's a specialization involving a user-defined type (N.B. 17.6.4.2.1 [namespace.std]
++means we don't need to say e.g. <tt>is_bind_expression&lt;string&gt;</tt> is false.)
++<p/>
++The obvious way to meet the requirements is for the primary template
++to derive from <tt>integral_constant&lt;bool, false&gt;</tt> and for implementations
++to provide specializations for the unspecified types returned from
++<tt>bind</tt>. User-defined specializations can do whatever they like, as long
++as <tt>is_bind_expression::value</tt> is sane. There's no reason to forbid
++users from defining <tt>is_bind_expression&lt;<i>user_defined_type</i>&gt;::value=false</tt>
++if that's what they want to do.
++<p/>
++Similar reasoning applies to <tt>is_placeholder</tt>, but a further issue is
++that 20.9.10.1 [func.bind.isbind] contains wording for <tt>is_placeholder</tt> but
++contains no definition of it and the sub-clause name only refers to
++<tt>is_bind_expression</tt>. The wording below proposes splitting paragraphs 3
++and 4 of 20.9.10.1 [func.bind.isbind] into a new sub-clause covering
++<tt>is_placeholder</tt>.
++<p/>
++If the template specializations added by the proposed wording are too
++vague then they could be preceded by "for exposition only" comments
++</p>
++
++<p><i>[2011-05-18 Daniel comments and provides some refinements to the P&#47;R]</i></p>
++
++
++<p>
++Both <tt>bind</tt>-related type traits should take advantage of the
++UnaryTypeTrait requirements. Additionally, the updated wording does not
++imply that the implementation provides several specializations. Wording was
++used similar to the specification of the <tt>uses_allocator</tt> type trait
++(which unfortunately is not expressed in terms of BinaryTypeTrait requirements).
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Change 20.9.10.1 [func.bind.isbind] to:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class T&gt; struct is_bind_expression<ins>; <i>// see below</i></ins>
++ <del>: integral_constant&lt;bool, <i>see below</i>&gt; { };</del>
++}
++</pre><blockquote><p>
++-1- <tt>is_bind_expression</tt> can be used to detect function objects generated by <tt>bind</tt>. <tt>bind</tt>
++uses <tt>is_bind_expression</tt> to detect subexpressions. <del>Users may specialize this template to indicate
++that a type should be treated as a subexpression in a <tt>bind</tt> call.</del>
++<p/>
++-2- <del>If <tt>T</tt> is a type returned from <tt>bind</tt>, <tt>is_bind_expression&lt;T&gt;</tt> shall
++be publicly derived from <tt>integral_constant&lt;bool, true&gt;</tt>, otherwise from
++<tt>integral_constant&lt;bool, false&gt;</tt></del><ins>Instantiations of the <tt>is_bind_expression</tt> template
++shall meet the UnaryTypeTrait requirements ([meta.rqmts]). The implementation shall provide a definition
++that has a BaseCharacteristic of <tt>true_type</tt> if <tt>T</tt> is a type returned from <tt>bind</tt>, otherwise
++it shall have a BaseCharacteristic of <tt>false_type</tt>. A program may specialize this template for a user-defined
++type <tt>T</tt> to have a BaseCharacteristic of <tt>true_type</tt> to indicate that <tt>T</tt> should be treated
++as a subexpression in a <tt>bind</tt> call.</ins>.
++<p/>
++<del>-3- <tt>is_placeholder</tt> can be used to detect the standard placeholders <tt>_1</tt>, <tt>_2</tt>, and so on.
++<tt>bind</tt> uses <tt>is_placeholder</tt> to detect placeholders. Users may specialize this template to indicate
++a placeholder type.</del>
++<p/>
++<del>-4- If <tt>T</tt> is the type of <tt>std::placeholders::_J</tt>, <tt>is_placeholder&lt;T&gt;</tt> shall be
++publicly derived from <tt>integral_constant&lt;int, J&gt;</tt>, otherwise from <tt>integral_constant&lt;int, 0&gt;</tt>.</del>
++</p></blockquote></blockquote>
++</li>
++<li><p>Insert a new sub-clause immediately following sub-clause 20.9.10.1 [func.bind.isbind], the suggested
++sub-clause tag is [func.bind.isplace]:
++</p>
++<h3><ins>20.8.9.1.? Class template <tt>is_placeholder</tt> [func.bind.isplace]</ins></h3>
++<blockquote><pre>
++<ins>namespace std {
++ template&lt;class T&gt; struct is_placeholder; <i>// see below</i>
++}</ins>
++</pre><blockquote><p>
++<ins>-?- <tt>is_placeholder</tt> can be used to detect the standard placeholders <tt>_1</tt>, <tt>_2</tt>, and so on.
++<tt>bind</tt> uses <tt>is_placeholder</tt> to detect placeholders.</ins>
++<p/>
++<ins>-?- Instantiations of the <tt>is_placeholder</tt> template shall meet the UnaryTypeTrait requirements ([meta.rqmts]).
++The implementation shall provide a definition that has a BaseCharacteristic of <tt>integral_constant&lt;int, J&gt;</tt>
++if <tt>T</tt> is the type of <tt>std::placeholders::_J</tt>, otherwise it shall have a BaseCharacteristic of
++<tt>integral_constant&lt;int, 0&gt;</tt>. A program may specialize this template for a user-defined type <tt>T</tt>
++to have a BaseCharacteristic of <tt>integral_constant&lt;int, <i>N</i>&gt;</tt> with <tt><i>N</i> &gt; 0</tt>
++to indicate that <tt>T</tt> should be treated as a placeholder type.</ins>
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2011"></a>2011. Unexpected output required of strings</h3>
++<p><b>Section:</b> 21.4.8.9 [string.io] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> James Kanze <b>Opened:</b> 2010-07-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.io">issues</a> in [string.io].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++What should the following code output?
++</p>
++
++<blockquote><pre>
++#include &lt;string&gt;
++#include &lt;iostream&gt;
++#include &lt;iomanip&gt;
++
++int main()
++{
++ std::string test("0X1Y2Z");
++ std::cout.fill('*');
++ std::cout.setf(std::ios::internal, std::ios::adjustfield);
++ std::cout &lt;&lt; std::setw(8) &lt;&lt; test &lt;&lt; std::endl;
++}
++</pre></blockquote>
++
++<p>
++I would expect "<tt>**0X1Y2Z</tt>", and this is what the compilers I have access
++to (VC++, g++ and Sun CC) do. But according to the standard, it should be
++"<tt>0X**1Y2Z</tt>":
++</p>
++
++<p>
++21.4.8.9 [string.io]&#47;5:
++</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++ basic_ostream&lt;charT, traits&gt;&amp;
++ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
++</pre><blockquote><p>
++<i>Effects:</i> Behaves as a formatted output function (27.7.3.6.1 [ostream.formatted.reqmts]). After constructing
++a <tt>sentry</tt> object, if this object returns <tt>true</tt> when converted to a value of type <tt>bool</tt>,
++determines padding as described in 22.4.2.2.2 [facet.num.put.virtuals], then inserts the resulting sequence of
++characters seq as if by calling <tt>os.rdbuf()-&gt;sputn(seq, n)</tt>, where <tt>n</tt> is the larger of
++<tt>os.width()</tt> and <tt>str.size()</tt>; then calls <tt>os.width(0)</tt>.
++</p></blockquote>
++</blockquote>
++
++<p>
++22.4.2.2.2 [facet.num.put.virtuals]&#47;5:
++</p>
++
++<blockquote>
++<p>
++[&hellip;]
++</p>
++
++<p>
++<b>Stage 3:</b> A local variable is initialized as
++</p>
++
++<blockquote><pre>
++fmtflags adjustfield= (flags &amp; (ios_base::adjustfield));
++</pre></blockquote>
++
++<p>
++The location of any padding is determined according to Table 88.
++</p>
++
++<p>
++If <tt>str.width()</tt> is nonzero and the number of <tt>charT</tt>'s in the
++sequence after stage 2 is less than <tt>str.width()</tt>, then enough fill
++characters are added to the sequence at the position indicated for padding to
++bring the length of the sequence to <tt>str.width()</tt>. <tt>str.width(0)</tt>
++is called.
++</p>
++
++<table border="1">
++<caption>Table 88 &mdash; Fill padding</caption>
++<tr>
++<th>State</th>
++<th>Location</th>
++</tr>
++
++<tr>
++<td><tt>adjustfield == ios_base::left</tt></td>
++<td>pad after</td>
++</tr>
++
++<tr>
++<td><tt>adjustfield == ios_base::right</tt></td>
++<td>pad before</td>
++</tr>
++
++<tr>
++<td><tt>adjustfield == internal</tt> and a sign occurs in the representation</td>
++<td>pad after the sign</td>
++</tr>
++
++<tr>
++<td><tt>adjustfield == internal</tt> and representation after stage 1 began with 0x or 0X</td>
++<td>pad after x or X</td>
++</tr>
++
++<tr>
++<td><i>otherwise</i></td>
++<td>pad before</td>
++</tr>
++</table>
++
++</blockquote>
++
++<p>
++Although it's not 100% clear what "the sequence after stage 2" should mean here,
++when there is no stage 2, the only reasonable assumption is that it is the
++contents of the string being output. In the above code, the string being output
++is "<tt>0X1Y2Z</tt>", which starts with "<tt>0X</tt>", so the padding should be
++inserted "after x or X", and not before the string. I believe that this is a
++defect in the standard, and not in the three compilers I tried.
++</p>
++
++<p><i>[
++2010 Batavia (post meeting session)
++]</i></p>
++
++<p>
++Consensus that all known implementations are consistent, and disagree with the
++standard. Preference is to fix the standard before implementations start trying
++to conform to the current spec, as the current implementations have the preferred
++form. Howard volunteered to drught for Madrid, move to Open.
++</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++Daniel Kr&uuml;gler volunteered to provide wording, interacting with Dietmar and
++Bill.
++</p>
++
++<p><i>[2011-06-24 Daniel comments and provides wording]</i></p>
++
++
++<p>
++The same problem applies to the output provided by <tt>const char*</tt> and similar
++character sequences as of 27.7.3.6.4 [ostream.inserters.character] p. 5. and even for
++single character output (!) as described in 27.7.3.6.4 [ostream.inserters.character] p. 1,
++just consider the character value '-' where '-' is the sign character. In this case
++Table 91 &mdash; "Fill padding" requires to pad after the sign, i.e. the output
++for the program
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;iomanip&gt;
++
++int main()
++{
++ char c = '-';
++ std::cout.fill('*');
++ std::cout.setf(std::ios::internal, std::ios::adjustfield);
++ std::cout &lt;&lt; std::setw(2) &lt;&lt; c &lt;&lt; std::endl;
++}
++</pre></blockquote>
++
++<p>
++According to the current wording this program should output "<tt>-*</tt>", but
++all tested implementations output "<tt>*-</tt>" instead.
++
++<p/>
++I suggest to replace the reference to 22.4.2.2.2 [facet.num.put.virtuals] in all three places.
++It is not very complicated to describe the padding rules for simple character sequences "inline".
++A similar approach is used as for the <tt>money_put</tt> functions.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Move to Review, the resolution seems correct but it would be nice if some factoring of the
++common words were proposed.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tentatively Ready by the post-Kona issues processing subgroup.
++</p>
++<p>
++While better factoring of the common words is desirable, it is also editorial and
++should not hold up the progress of this issue. As the edits impact two distinct
++clauses, it is not entirely clear what a better factoring should look like.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++The new wording refers to the FDIS numbering.
++</p>
++<ol>
++<li><p>Change 21.4.8.9 [string.io]&#47;5 as indicated:</p>
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++ basic_ostream&lt;charT, traits&gt;&amp;
++ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
++</pre><blockquote><p>
++-5- <i>Effects</i>: Behaves as a formatted output function ([ostream.formatted.reqmts]). After constructing a sentry object,
++if this object returns <tt>true</tt> when converted to a value of type <tt>bool</tt>, determines padding as <del>described
++in [facet.num.put.virtuals],</del><ins>follows: A <tt>charT</tt> character sequence is produced, initially consisting of
++the elements defined by the range <tt>[str.begin(), str.end())</tt>. If <tt>str.size()</tt> is less than <tt>os.width()</tt>,
++then enough copies of <tt>os.fill()</tt> are added to this sequence as necessary to pad to a width of <tt>os.width()</tt>
++characters. If <tt>(os.flags() &amp; ios_base::adjustfield) == ios_base::left</tt> is <tt>true</tt>, the fill characters
++are placed after the character sequence; otherwise, they are placed before the character sequence. T</ins><del>t</del>hen
++inserts the resulting sequence of characters <tt>seq</tt> as if by calling <tt>os.rdbuf()-&gt;sputn(seq, n)</tt>, where
++<tt>n</tt> is the larger of <tt>os.width()</tt> and <tt>str.size()</tt>; then calls <tt>os.width(0)</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Change 27.7.3.6.4 [ostream.inserters.character]&#47;1 as indicated (An additional editorial
++fix is suggested for the first prototype declaration):</p>
++<blockquote><pre>
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ charT c<del>}</del><ins>)</ins>;
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ char c);
++<i>// specialization</i>
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ char c);
++<i>// signed and unsigned</i>
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ signed char c);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ unsigned char c);
++</pre><blockquote><p>
++-1- <i>Effects</i>: Behaves like a formatted inserter (as described in [ostream.formatted.reqmts]) of <tt>out</tt>.
++After a sentry object is constructed it inserts characters. In case <tt>c</tt> has type <tt>char</tt> and the
++character type of the stream is not <tt>char</tt>, then the character to be inserted is <tt>out.widen(c)</tt>;
++otherwise the character is <tt>c</tt>. Padding is determined as <del>described in [facet.num.put.virtuals]</del><ins>follows:
++A character sequence is produced, initially consisting of the insertion character. If <tt>out.width()</tt> is greater
++than one, then enough copies of <tt>out.fill()</tt> are added to this sequence as necessary to pad to a width of
++<tt>out.width()</tt> characters. If <tt>(out.flags() &amp; ios_base::adjustfield) == ios_base::left</tt> is <tt>true</tt>,
++the fill characters are placed after the insertion character; otherwise, they are placed before the insertion
++character</ins>. <del><tt>width(0)</tt> is called.</del> The insertion character and any required padding are
++inserted into <tt>out</tt><ins>; then calls <tt>os.width(0)</tt></ins>.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Change 27.7.3.6.4 [ostream.inserters.character]&#47;5 as indicated:</p>
++<blockquote><pre>
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ const charT* s);
++template&lt;class charT, class traits&gt;
++ basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp; out,
++ const char* s);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const char* s);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const signed char* s);
++template&lt;class traits&gt;
++ basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp; out,
++ const unsigned char* s);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-5- Padding is determined as <del>described in [facet.num.put.virtuals]. The <tt>n</tt> characters starting at <tt>s</tt>
++are widened using <tt>out.widen</tt> ([basic.ios.members])</del><ins>follows: A character sequence is produced, initially
++consisting of the elements defined by the <tt>n</tt> characters starting at <tt>s</tt> widened using
++<tt>out.widen</tt> ([basic.ios.members]). If <tt>n</tt> is less than <tt>out.width()</tt>, then enough copies of
++<tt>out.fill()</tt> are added to this sequence as necessary to pad to a width of <tt>out.width()</tt> characters.
++If <tt>(out.flags() &amp; ios_base::adjustfield) == ios_base::left</tt> is <tt>true</tt>, the fill characters are
++placed after the character sequence; otherwise, they are placed before the character sequence</ins>. The
++widened characters and any required padding are inserted into <tt>out</tt>. Calls <tt>width(0)</tt>.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2012"></a>2012. Associative maps should insert <tt>pair</tt>, not <tt>tuple</tt></h3>
++<p><b>Section:</b> 23.4 [associative] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2010-10-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative">active issues</a> in [associative].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative">issues</a> in [associative].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I'm seeing something strange in the paragraphs 23.4.4.4 [map.modifiers] and 23.4.5.3 [multimap.modifiers]:
++they both talk about <tt>tuple&lt;const key_type, mapped_type&gt;</tt> but I think they
++should be talking about <tt>pair&lt;const key_type, mapped_type&gt;</tt> because, among
++other reasons, a <tt>tuple</tt> is not convertible to a <tt>pair</tt>. If I replace <tt>tuple</tt>
++with <tt>pair</tt> everything makes sense to me.
++<p/>
++The proposed resolution is obvious.
++</p>
++
++<p><i>[
++2010-11-07 Daniel comments
++]</i></p>
++
++
++<p>
++This is by far not the only necessary fix within both sub-clauses. For details see the 2010-10-29 comment in
++<a href="lwg-defects.html#2005">2005</a>.
++</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++Paolo: Don't think we can do it now.
++<p/>
++Daniel K: Agrees.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Consensus that this issue will be resolved by <a href="lwg-defects.html#2005">2005</a>, but held open until that issue is resolved.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Apply the resolution proposed by the 2010-10-29 comment in <a href="lwg-defects.html#2005">2005</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2013"></a>2013. Do library implementers have the freedom to add <tt>constexpr</tt>?</h3>
++<p><b>Section:</b> 17.6.5.6 [constexpr.functions] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2010-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>Suppose that a particular function is not tagged as constexpr in the standard,
++but that, in some particular implementation, it is possible to write it within
++the constexpr constraints. If an implementer tags such a function as constexpr,
++is that a violation of the standard or is it a conforming extension?</p>
++
++<p>There are two questions to consider. First, is this allowed under the
++as-if rule? Second, if it does not fall under as-if, is there
++(and should there be) any special license granted to implementers
++to do this anyway, sort of the way we allow elision of copy constructors
++even though it is detectable by users?</p>
++
++<p>I believe that this does not fall under "as-if", so implementers
++probably don't have that freedom today. I suggest changing the WP
++to grant it. Even if we decide otherwise, however, I suggest that
++we make it explicit.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++General surprise this was not already in 'Ready' status, and so moved.
++</p>
++
++<p><i>[
++2012 Kona
++]</i></p>
++
++
++<p>
++Some concern expressed when presented to full committee for the vote to WP status
++that this issue had been resolved without sufficient thought of the consequences
++for diverging library implementations, as users may use SFINAE to observe
++different behavior from otherwise identical code. Issue moved back to Review
++status, and will be discussed again in Portland with a larger group.
++
++Note for Portland: John Spicer has agreed to represent Core's concerns during
++any such discussion within LWG.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++
++<p>
++Straw poll: LWG strongly favoured to remove from implementations the freedom to add <tt>constexpr</tt>.
++</p>
++<p>
++Matt provides new wording.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++
++<p>
++Move to Immediate after reviewing Matt's new wording, apply the new wording to the Working Paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>In 17.6.5.6 [constexpr.functions], change paragraph 1 to:</i></p>
++
++<blockquote><p>
++<ins>This standard explicitly requires that certain standard library functions
++are <tt>constexpr</tt> [dcl.constexpr].
++An implementation shall not declare any standard library function signature as <tt>constexpr</tt>
++except for those where it is explicitly required.</ins>
++Within any header that provides any non-defining declarations of <tt>constexpr</tt>
++functions or constructors an implementation shall provide corresponding definitions.
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2014"></a>2014. More restrictions on macro names</h3>
++<p><b>Section:</b> 17.6.4.3.1 [macro.names] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#macro.names">issues</a> in [macro.names].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++A program is currently forbidden to use keywords as macro names. This restriction should be strengthened to include all identifiers
++that could be used by the library as attribute-tokens (for example <tt>noreturn</tt>, which is used by header <tt>&lt;cstdlib&gt;</tt>)
++and the special identifiers introduced recently for override control (these are not currently used in the library public interface,
++but could potentially be used by the implementation or in future revisions of the library).
++</p>
++<p><i>[2011-02-10 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Modify 17.6.4.3.1 [macro.names] paragraph 2 as follows:</p>
++
++<blockquote><p>
++A translation unit shall not <tt>#define</tt> or <tt>#undef</tt> names
++lexically identical to keywords<ins>, to the identifiers listed in Table
++X [Identifiers with special meaning], or to the <i>attribute-tokens</i>
++described in clause 7.6 [dcl.attr]</ins>.
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2015"></a>2015. Incorrect pre-conditions for some type traits</h3>
++<p><b>Section:</b> 20.10.4 [meta.unary] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2010-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary">issues</a> in [meta.unary].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>According to N3126&nbsp;&#x2011;&nbsp;3.9/9,</p>
++
++<p>&quot;Scalar types, trivial class types (Clause 9), arrays of such types
++and <i>cv</i>&#x2011;qualified versions of these types (3.9.3) are collectively
++called <i>trivial types</i>.&quot;</p>
++
++<p>Thus, an array (possibly of unknown bound) can be trivial type, non&#x2011;trivial type,
++or an array type whose triviality cannot be determined because its element type is incomplete.</p>
++
++<p>According to N3126&nbsp;&#x2011;&nbsp;Table 45, preconditions for <tt>std::is_trivial</tt> are
++defined as follows:</p>
++
++<p>&quot;<tt>T</tt> shall be a complete type, (possibly <i>cv</i>-qualified) <tt>void</tt>,
++or an array of unknown bound&quot;</p>
++
++<p>It seems that &quot;an array of unknown bound&quot; should be changed to &quot;an
++array of unknown bound of a complete element type&quot;. Preconditions for
++some other templates (e.g., <tt>std::is_trivially_copyable</tt>,
++<tt>std::is_standard_layout</tt>, <tt>std::is_pod</tt>, and <tt>std::is_literal_type</tt>) should
++be changed similarly.</p>
++
++<p>On the other hand, some preconditions look too restrictive. For
++example, <tt>std::is_empty</tt> and <tt>std::is_polymorphic</tt> might accept any
++incomplete non&#x2011;class type.</p>
++
++<p><i>[2011-02-18: Daniel provides wording proposal]</i></p>
++
++
++<p>
++While reviewing the individual preconditions I could find three different groups of
++either too weakening or too strengthening constraints:
++</p>
++<ol>
++<li><pre>is_empty/is_polymorphic/is_abstract/has_virtual_destructor:</pre>
++
++<p>These traits can only apply for <em>non&#x2011;union class types</em>, otherwise the result must
++always be false</p>
++</li>
++
++<li><pre>is_base_of:</pre>
++
++<p>Similar to the previous bullet, but the current wording comes already near to that ideal,
++it only misses to add the <em>non&#x2011;union</em> aspect.</p>
++</li>
++
++<li><pre>is_trivial/is_trivially_copyable/is_standard_layout/is_pod/is_literal_type:</pre>
++
++<p>These traits always require that <tt>std::remove_all_extents&lt;T&gt;::type</tt> to be <tt><i>cv</i> void</tt> or
++a complete type.</p>
++</li>
++</ol>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Modify the pre-conditions of the following type traits in 20.10.4.3 [meta.unary.prop], Table 48 &mdash; Type property predicates:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 48 &mdash; Type property predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Preconditions</th>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">...</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_trivial;</tt></td>
++<td><tt>T</tt> is a trivial type (3.9)</td>
++<td><tt><ins>remove_all_extents&lt;</ins>T<ins>&gt;::type</ins></tt><br/>
++shall be a complete type<del>,</del><ins> or</ins> (possibly<br/>
++cv-qualified) <tt>void</tt><del>, or an array of<br/>
++unknown bound</del>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_trivially_copyable;</tt></td>
++<td><tt>T</tt> is a trivially copyable<br/>
++type (3.9)</td>
++<td><tt><ins>remove_all_extents&lt;</ins>T<ins>&gt;::type</ins></tt><br/>
++shall be a complete type<del>,</del><ins> or</ins> (possibly<br/>
++cv-qualified) <tt>void</tt><del>, or an array of<br/>
++unknown bound</del>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_standard_layout;</tt></td>
++<td><tt>T</tt> is a standard-layout<br/>
++type (3.9)</td>
++<td><tt><ins>remove_all_extents&lt;</ins>T<ins>&gt;::type</ins></tt><br/>
++shall be a complete type<del>,</del><ins> or</ins> (possibly<br/>
++cv-qualified) <tt>void</tt><del>, or an array of<br/>
++unknown bound</del>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_pod;</tt></td>
++<td><tt>T</tt> is a POD type (3.9)</td>
++<td><tt><ins>remove_all_extents&lt;</ins>T<ins>&gt;::type</ins></tt><br/>
++shall be a complete type<del>,</del><ins> or</ins> (possibly<br/>
++cv-qualified) <tt>void</tt><del>, or an array of<br/>
++unknown bound</del>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_literal_type;</tt></td>
++<td><tt>T</tt> is a literal type (3.9)</td>
++<td><tt><ins>remove_all_extents&lt;</ins>T<ins>&gt;::type</ins></tt><br/>
++shall be a complete type<del>,</del><ins> or</ins> (possibly<br/>
++cv-qualified) <tt>void</tt><del>, or an array of<br/>
++unknown bound</del>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_empty;</tt></td>
++<td><tt>T</tt> is a class type, but not a<br/>
++union type, with no<br/>
++non-static data members<br/>
++other than bit-fields of<br/>
++length 0, no virtual<br/>
++member functions, no<br/>
++virtual base classes, and<br/>
++no base class B for which<br/>
++<tt>is_empty&lt;B&gt;::value</tt> is<br/>
++false.</td>
++<td><del><tt>T</tt> shall be a complete type,<br/>
++(possibly cv-qualified) <tt>void</tt>, or<br/>
++an array of unknown bound</del><ins>If <tt>T</tt><br/>
++is a non&#x2011;union class type, <tt>T</tt><br/>
++shall be a complete type</ins>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_polymorphic;</tt></td>
++<td><tt>T</tt> is a polymorphic<br/>
++class (10.3)</td>
++<td><del><tt>T</tt> shall be a complete type,<br/>
++type, (possibly cv-qualified) <tt>void</tt>, or<br/>
++an array of unknown bound</del><ins>If <tt>T</tt><br/>
++is a non&#x2011;union class type, <tt>T</tt><br/>
++shall be a complete type</ins>.</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct is_abstract;</tt></td>
++<td><tt>T</tt> is an abstract<br/>
++class (10.4)</td>
++<td><del><tt>T</tt> shall be a complete type,<br/>
++type, (possibly cv-qualified) <tt>void</tt>, or<br/>
++an array of unknown bound</del><ins>If <tt>T</tt><br/>
++is a non&#x2011;union class type, <tt>T</tt><br/>
++shall be a complete type</ins>.</td>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">...</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class T&gt;<br/>
++struct has_virtual_destructor;</tt></td>
++<td><tt>T</tt> has a virtual<br/>
++destructor (12.4)</td>
++<td><del><tt>T</tt> shall be a complete type,<br/>
++(possibly cv-qualified) <tt>void</tt>, or<br/>
++an array of unknown bound</del><ins>If <tt>T</tt><br/>
++is a non&#x2011;union class type, <tt>T</tt><br/>
++shall be a complete type</ins>.</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li>
++<p>
++Modify the pre-conditions of the following type traits in 20.10.6 [meta.rel], Table 50 &mdash; Type relationship predicates:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 50 &mdash; Type relationship predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">...</td>
++</tr>
++
++<tr>
++<td><tt>template &lt;class Base, class<br/>
++Derived&gt;<br/>
++struct is_base_of;</tt></td>
++<td><tt>Base</tt> is a base class of<br/>
++<tt>Derived</tt> (10) without<br/>
++regard to cv-qualifiers<br/>
++or <tt>Base</tt> and <tt>Derived</tt><br/>
++are not unions and<br/>
++name the same class<br/>
++type without regard to<br/>
++cv-qualifiers</td>
++<td>If <tt>Base</tt> and <tt>Derived</tt> are<br/>
++<ins>non&#x2011;union</ins> class types<br/>
++and are different types<br/>
++(ignoring possible cv-qualifiers)<br/>
++then <tt>Derived</tt> shall be a complete<br/>
++type. [ <i>Note</i>: Base classes that<br/>
++are private, protected, or<br/>
++ambigious are, nonetheless, base<br/>
++classes. &mdash; <i>end note</i> ]</td>
++</tr>
++
++<tr>
++<td colspan="3" style="text-align:center;">...</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2016"></a>2016. <tt>Allocators</tt> must be no-throw <i>swappable</i></h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-11-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++During the Batavia meeting it turned out that there is a definition
++hole for types satisfying the <tt>Allocators</tt> requirements: The problem
++became obvious when it was discussed whether all <tt>swap</tt> functions
++of <tt>Containers</tt> with internal data handles can be safely tagged
++with <tt>noexcept</tt> or not. While it is correct that the implicit
++<tt>swap</tt> function of an allocator is required to be a no-throw
++operation (because move/copy-constructors and assignment operators are
++required to be no-throw functions), there are no such requirements
++for specialized <tt>swap</tt> overloads for a particular allocator.
++<p/>
++But this requirement is essential because the <tt>Containers</tt> are
++required to support <i>swappable</i> <tt>Allocators</tt>, when the value
++<tt>allocator_traits&lt;&gt;::propagate_on_container_swap</tt> evaluates
++to <tt>true</tt>.
++</p>
++<p><i>[2011-02-10 Alberto, Daniel, and Pablo collaborated on the proposed wording]</i></p>
++
++<p>
++The proposed resolution (based on N3225) attempts to solve the following problems:
++</p>
++<ol>
++<li>Table 44 &mdash; Allocator requirements, expression rows
++<tt>X::propagate_on_container_copy_assignment</tt>, <tt>X::propagate_on_container_move_assignment</tt>, and
++<tt>X::propagate_on_container_swap</tt> only describe operations, but no requirements. In fact, if and only
++if these compile-time predicates evaluate to <tt>true</tt>, the <em>additional</em> requirements
++<tt>CopyAssignable</tt>, no-throw <tt>MoveAssignable</tt>, and no-throw lvalue <tt>Swappable</tt>,
++respectively, are imposed on the allocator types.</li>
++<li>23.2.1 [container.requirements.general] p. 9 misses to refer to the correct swap conditions: The current wording does not relate to
++17.6.3.2 [swappable.requirements] as it should and omits to mention that lvalues shall be swapped. Additional there is one
++situation described twice in p. 8 and p. 9 (undefined behaviour unless <tt>a.get_allocator() == b.get_allocator()</tt>
++or <tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value == true</tt>), which should be cleaned up.</li>
++</ol>
++
++<p><i>[2011-04-08 Pablo comments]</i></p>
++
++<p>
++I'm implementing a version of list now and I actually do find it impossible to write an exception-safe assignment
++operator unless I can assume that allocator assignment does not throw. (The problem is that I use a sentinel node
++and I need to allocate a new sentinel using the new allocator without destroying the old one -- then swap the
++allocator and sentinel pointer in atomically, without risk of an exception leaving one inconsistent with the other.
++<p/>
++Please update the proposed resolution to add the nothrow requirement to copy-assignment.
++</p>
++
++<p><i>[2014-02-14 Issaquah: Move to Ready]</i></p>
++
++<p>
++Fix a couple of grammar issues related to calling <tt>swap</tt> and move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Adapt the following three rows from Table 44 &mdash; Allocator requirements:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 44 &mdash; Allocator requirements</caption>
++<tr>
++<th>
++Expression
++</th>
++
++<th>
++Return type
++</th>
++
++<th>
++Assertion/note<br/>pre-/post-condition
++</th>
++
++<th>
++Default
++</th>
++
++</tr>
++
++<tr>
++<td><tt>X::propagate_on_container_copy_assignment</tt></td>
++
++<td>Identical to or derived from <tt>true_type</tt><br/>
++or <tt>false_type</tt></td>
++
++<td><tt>true_type</tt> only if an allocator of type <tt>X</tt> should be copied<br/>
++when the client container is copy-assigned. <ins>See Note B, below.</ins></td>
++
++<td><tt>false_type</tt></td>
++</tr>
++
++<tr>
++<td><tt>X::propagate_on_container_move_assignment</tt></td>
++
++<td>Identical to or derived from <tt>true_type</tt><br/>
++or <tt>false_type</tt></td>
++
++<td><tt>true_type</tt> only if an allocator of type <tt>X</tt> should be moved<br/>
++when the client container is move-assigned. <ins>See Note B, below.</ins></td>
++
++<td><tt>false_type</tt></td>
++</tr>
++
++<tr>
++<td><tt>X::propagate_on_container_swap</tt></td>
++
++<td>Identical to or derived from <tt>true_type</tt><br/>
++or <tt>false_type</tt></td>
++
++<td><tt>true_type</tt> only if an allocator of type <tt>X</tt> should be swapped<br/>
++when the client container is swapped. <ins>See Note B, below.</ins></td>
++
++<td><tt>false_type</tt></td>
++</tr>
++
++</table>
++</blockquote>
++
++
++</li>
++
++<li>
++<p>Following 17.6.3.5 [allocator.requirements] p. 3 insert a new normative paragraph:</p>
++
++<blockquote><p>
++<ins>Note B: If <tt>X::propagate_on_container_copy_assignment::value</tt> is true, <tt>X</tt> shall
++satisfy the <tt>CopyAssignable</tt> requirements (Table 39 [copyassignable]) and the copy
++operation shall not throw exceptions. If <tt>X::propagate_on_container_move_assignment::value</tt> is
++true, <tt>X</tt> shall satisfy the <tt>MoveAssignable</tt> requirements (Table 38 [moveassignable])
++and the move operation shall not throw exceptions. If <tt>X::propagate_on_container_swap::value</tt> is
++true, lvalues of <tt>X</tt> shall be swappable (17.6.3.2 [swappable.requirements]) and the <tt>swap</tt>
++operation shall not throw exceptions.</ins>
++</p></blockquote>
++</li>
++
++<li>
++<p>Modify 23.2.1 [container.requirements.general] p. 8 and p. 9 as indicated:</p>
++
++<blockquote><p>
++8 - [..] The allocator may be replaced only via assignment or <tt>swap()</tt>. Allocator replacement is
++performed by copy assignment, move assignment, or swapping of the allocator only if
++<tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_copy_assignment::value</tt>,
++<tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment::value</tt>,
++or <tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value</tt> is true
++within the implementation of the corresponding container operation. <del>The behavior of a call to
++a container's <tt>swap</tt> function is undefined unless the objects being swapped have allocators that compare
++equal or <tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value</tt> is true</del>. In all
++container types defined in this Clause, the member <tt>get_allocator()</tt> returns a copy of the allocator
++used to construct the container or, if that allocator has been replaced, a copy of the most recent replacement.
++<p/>
++9 - The expression <tt>a.swap(b)</tt>, for containers <tt>a</tt> and <tt>b</tt> of a standard container type
++other than <tt>array</tt>, shall exchange the values of <tt>a</tt> and <tt>b</tt> without invoking any move,
++copy, or swap operations on the individual container elements. <ins>Lvalues of a</ins><del>A</del>ny <tt>Compare</tt>,
++<tt>Pred</tt>, or <tt>Hash</tt> <del>objects</del><ins>types</ins> belonging to <tt>a</tt> and <tt>b</tt> shall be swappable
++and shall be exchanged by <del>unqualified calls to non-member</del> <ins>calling</ins> <tt>swap</tt>
++<ins>as described in 17.6.3.2 [swappable.requirements]</ins>. If <tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value</tt>
++is <tt>true</tt>, then <ins>lvalues of <tt>allocator_type</tt> shall be swappable and</ins> the allocators of <tt>a</tt> and
++<tt>b</tt> shall also be exchanged <del>using an unqualified call to non-member</del><ins>by calling</ins>
++<tt>swap</tt> <ins>as described in 17.6.3.2 [swappable.requirements]</ins>. Otherwise,
++<del>they</del><ins>the allocators</ins> shall not be swapped, and the behavior is undefined unless
++<tt>a.get_allocator() == b.get_allocator()</tt>. Every iterator referring to an element in one container before
++the swap shall refer to the same element in the other container after the swap. It is unspecified whether an
++iterator with value <tt>a.end()</tt> before the swap will have value <tt>b.end()</tt> after the swap.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2017"></a>2017. <tt>std::reference_wrapper</tt> makes incorrect usage of <tt>std::result_of</tt></h3>
++<p><b>Section:</b> 20.9.4 [refwrap] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2010-11-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap">issues</a> in [refwrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>std::reference_wrapper</tt>'s function call operator uses <em>wrong</em>
++type encoding for rvalue-arguments. An rvalue-argument of type <tt>T</tt> must
++be encoded as <tt>T&amp;&amp;</tt>, not as just <tt>T</tt>.
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
++#include &lt;iostream&gt;
++#include &lt;string&gt;
++#include &lt;type_traits&gt;
++#include &lt;utility&gt;
++
++template &lt;class F, class... Types&gt;
++ typename std::result_of&lt;F (Types...)&gt;::type
++ f1(F f, Types&amp;&amp;... params)
++{
++ return f(std::forward&lt;Types...&gt;(params...));
++}
++
++template &lt;class F, class... Types&gt;
++ typename std::result_of&lt;F (Types<b>&amp;&amp;</b>...)&gt;::type
++ f2(F f, Types&amp;&amp;... params)
++{
++ return f(std::forward&lt;Types...&gt;(params...));
++}
++
++struct Functor
++{
++ template &lt;class T&gt;
++ T&amp;&amp; operator()(T&amp;&amp; t) const
++ {
++ return static_cast&lt;T&amp;&amp;&gt;(t);
++ }
++};
++
++int main()
++{
++ typedef std::string const Str;
++ std::cout &lt;&lt; f1(Functor(), Str("1")) &lt;&lt; std::endl; // (1)
++ std::cout &lt;&lt; f2(Functor(), Str("2")) &lt;&lt; std::endl; // (2)
++}
++</pre></blockquote>
++<p>
++Lets consider the function template <tt>f1</tt> (which is similar to
++<tt>std::reference_wrapper</tt>'s function call operator). In the invocation
++(1) <tt>F</tt> is deduced as '<tt>Functor</tt>' and <tt>Types</tt> is deduced as type sequence
++which consists of one type '<tt>std::string const</tt>'. After the substitution
++we have the following equivalent:
++</p>
++<blockquote><pre>
++template &lt;&gt;
++ std::result_of&lt;F (std::string const)&gt;::type
++ f1&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
++{
++ return f(std::forward&lt;const std::string&gt;(params));
++}
++</pre></blockquote>
++<p>
++The top-level <i>cv</i>-qualifier in the parameter type of '<tt>F (std::string const)</tt>' is removed, so we have
++</p>
++<blockquote><pre>
++template &lt;&gt;
++ std::result_of&lt;F (std::string)&gt;::type
++ f1&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
++{
++ return f(std::forward&lt;const std::string&gt;(params));
++}
++</pre></blockquote>
++<p>
++Let <tt>r</tt> be an rvalue of type '<tt>std::string</tt>' and <tt>cr</tt> be an rvalue of type
++'<tt>std::string const</tt>'. The expression <tt>Str("1")</tt> is <tt>cr</tt>. The corresponding
++return type for the invocation
++</p>
++<blockquote><pre>
++Functor().operator()(r)
++</pre></blockquote>
++<p>
++is '<tt>std::string &amp;&amp;</tt>'. The corresponding return type for the invocation
++</p>
++<blockquote><pre>
++Functor().operator()(cr)
++</pre></blockquote>
++<p>
++is '<tt>std::string const &amp;&amp;</tt>'.
++<p/>
++<tt>std::result_of&lt;Functor (std::string)&gt;::type</tt> is the same type as the
++corresponding return type for the invocation <tt>Functor().operator()(r)</tt>,
++i.e. it is '<tt>std::string &amp;&amp;</tt>'. As a consequence, we have wrong reference
++binding in the return statement in <tt>f1</tt>.
++<p/>
++Now lets consider the invocation (2) of the function template <tt>f2</tt>. When
++the template arguments are substituted we have the following equivalent:
++</p>
++<blockquote><pre>
++template &lt;&gt;
++ std::result_of&lt;F (std::string const &amp;&amp;)&gt;::type
++ f2&lt;Functor, std::string const&gt;(Functor f, std::string const &amp;&amp; params)
++{
++ return f(std::forward&lt;const std::string&gt;(params));
++}
++</pre></blockquote>
++<p>
++<tt>std::result_of&lt;F (std::string const &amp;&amp;)&gt;::type</tt> is the same type as
++'<tt>std::string const &amp;&amp;</tt>'. This is correct result.
++</p>
++<p><i>[
++2010-12-07 Jonathan Wakely comments and suggests a proposed resolution
++]</i></p>
++
++
++<p>
++I agree with the analysis and I think this is a defect in the
++standard, it would be a shame if it can't be fixed.
++<p/>
++In the following example one would expect <tt>f(Str("1"))</tt> and
++<tt>std::ref(f)(Str("2"))</tt> to be equivalent but the current wording makes
++the invocation through <tt>reference_wrapper</tt> ill-formed:
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
++#include &lt;string&gt;
++
++struct Functor
++{
++ template &lt;class T&gt;
++ T&amp;&amp; operator()(T&amp;&amp; t) const
++ {
++ return static_cast&lt;T&amp;&amp;&gt;(t);
++ }
++};
++
++int main()
++{
++ typedef std::string const Str;
++ Functor f;
++ f( Str("1") );
++ std::ref(f)( Str("2") ); // error
++}
++</pre></blockquote>
++
++<p><i>[
++2010-12-07 Daniel comments and refines the proposed resolution
++]</i></p>
++
++
++<p>
++There is one further defect in the usage of <tt>result_of</tt> within
++<tt>reference_wrapper</tt>'s function call operator: According to 20.9.4.4 [refwrap.invoke] p. 1
++the invokable entity of type <tt>T</tt> is provided as lvalue, but
++<tt>result_of</tt> is fed as if it were an rvalue. This does not only lead to
++potentially incorrect result types, but it will also have the effect that
++we could never use the function call operator with a function type,
++because the type encoding used in <tt>result_of</tt> would form an invalid
++function type return a function type. The following program demonstrates
++this problem:
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
++
++void foo(int) {}
++
++int main()
++{
++ std::ref(foo)(0); // error
++}
++</pre></blockquote><p>
++The correct solution is to ensure that <tt>T</tt> becomes <tt>T&amp;</tt>
++within <tt>result_of</tt>, which solves both problems at once.
++</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Change the synopsis in 20.9.4 [refwrap] paragraph 1:
++</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; class reference_wrapper
++ {
++ public :
++ [...]
++ // invocation
++ template &lt;class... ArgTypes&gt;
++ typename result_of&lt;T<ins>&amp;</ins>(ArgTypes<ins>&amp;&amp;</ins>...)&gt;::type
++ operator() (ArgTypes&amp;&amp;...) const;
++ };
++}
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Change the signature in 20.9.4.4 [refwrap.invoke] before paragraph 1
++</p>
++
++<blockquote><pre>
++template &lt;class... ArgTypes&gt;
++typename result_of&lt;T<ins>&amp;</ins>(ArgTypes<ins>&amp;&amp;</ins>... )&gt;::type
++operator()(ArgTypes&amp;&amp;... args) const;
++</pre><blockquote><p>
++1 <i>Returns</i>: <tt>INVOKE(get(), std::forward&lt;ArgTypes&gt;(args)...)</tt>. (20.8.2)
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2018"></a>2018. [CD] <tt>regex_traits::isctype</tt> Returns clause is wrong</h3>
++<p><b>Section:</b> 28.7 [re.traits] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.traits">issues</a> in [re.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses GB 10</b></p>
++
++<p>28.7 [re.traits] p. 12 says:</p>
++
++<blockquote><p>
++returns true if <tt>f</tt> bitwise or&#39;ed with the result of calling
++<tt>lookup_classname</tt> with an iterator pair that designates the character
++sequence &quot;w&quot; is not equal to <tt>0</tt> and <tt>c == '_'</tt>
++</p></blockquote>
++
++<p>
++If the bitmask value corresponding to &quot;w&quot; has a non-zero value (which
++it must do) then the bitwise or with any value is also non-zero, and
++so <tt>isctype('_', f)</tt> returns true for any <tt>f</tt>. Obviously this is wrong,
++since <tt>'_'</tt> is not in every <tt>ctype</tt> category.
++</p>
++
++<p>
++There&#39;s a similar problem with the following phrases discussing the
++&quot;blank&quot; char class.
++</p>
++
++<p><i>[2011-05-06: Jonathan Wakely comments and provides suggested wording]</i></p>
++
++
++<p>
++DR <a href="lwg-defects.html#2019">2019</a> added <tt>isblank</tt> support to <tt>&lt;locale&gt;</tt> which simplifies the
++definition of <tt>regex_traits::isctype</tt> by removing the special case for the "blank" class.
++<p/>
++My suggestion for 2018 is to add a new table replacing the lists of
++recognized names in the Remarks clause of <tt>regex_traits::lookup_classname</tt>.
++I then refer to that table in the Returns clause of <tt>regex_traits::isctype</tt>
++to expand on the "in an unspecified manner" wording which is too vague. The conversion
++can now be described using the "is set" term defined by 17.5.2.1.3 [bitmask.types] and
++the new table to convey the intented relationship between e.g.
++[[:digit:]] and <tt>ctype_base::digit</tt>, which is not actually stated in the
++FDIS.
++<p/>
++The effects of <tt>isctype</tt> can then most easily be described in code,
++given an "exposition only" function prototype to do the not-quite-so-unspecified conversion
++from <tt>char_class_type</tt> to <tt>ctype_base::mask</tt>.
++<p/>
++The core of LWG 2018 is the "bitwise or'ed" wording which gives the
++wrong result, always evaluating to true for all values of <tt>f</tt>. That is
++replaced by the condition <tt>(f&amp;x) == x</tt> where <tt>x</tt> is the result of calling
++<tt>lookup_classname</tt> with "w". I believe that's necessary, because the
++"w" class could be implemented by an internal "underscore" class i.e.
++<tt>x = _Alnum|_Underscore</tt> in which case <tt>(f&amp;x) != 0</tt> would give the wrong
++result when <tt>f==_Alnum</tt>.
++<p/>
++The proposed resolution also makes use of <tt>ctype::widen</tt> which addresses
++the problem that the current wording only talks about "w" and '_' which assumes
++<tt>charT</tt> is char. There's still room for improvement here:
++the regex grammar in 28.13 [re.grammar] says that the class names in the
++table should always be recognized, implying that e.g. U"digit" should
++be recognized by <tt>regex_traits&lt;char32_t&gt;</tt>, but the specification of
++<tt>regex_traits::lookup_classname</tt> doesn't cover that, only mentioning
++<tt>char</tt> and <tt>wchar_t</tt>. Maybe the table should not distinguish narrow and
++wide strings, but should just have one column and add wording to say
++that <tt>regex_traits</tt> widens the name as if by using <tt>use_facet&lt;ctype&lt;charT&gt;&gt;::widen()</tt>.
++<p/>
++Another possible improvement would be to allow additional
++implementation-defined extensions in <tt>isctype</tt>. An implementation is
++allowed to support additional class names in <tt>lookup_classname</tt>, e.g.
++[[:octdigit:]] for [0-7] or [[:bindigit:]] for [01], but the current
++definition of isctype provides no way to use them unless <tt>ctype_base::mask</tt>
++also supports them.
++</p>
++
++<p><i>[2011-05-10: Alberto and Daniel perform minor fixes in the P&#47;R]</i></p>
++
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Consensus that this looks to be a correct solution, and the presentation as a table is a big improvement.
++</p>
++
++<p>
++Concern that the middle section wording is a little muddled and confusing, Stefanus volunteered to reword.
++</p>
++
++<p><i>[
++2013-09 Chicago
++]</i></p>
++
++
++<p>
++Stefanus provides improved wording (replaced below)
++</p>
++
++<p><i>[
++2013-09 Chicago
++]</i></p>
++
++
++<p>
++Move as Immediate after reviewing Stefanus's revised wording, apply the new wording to the Working Paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Modify 28.7 [re.traits] p. 10 as indicated:</p>
++<blockquote><pre>
++template &lt;class ForwardIterator&gt;
++ char_class_type lookup_classname(
++ ForwardIterator first, ForwardIterator last, bool icase = false) const;
++</pre><blockquote><p>
++-9- <i>Returns</i>: an unspecified value that represents the character classification named by the character
++sequence designated by the iterator range [<tt>first</tt>,<tt>last</tt>). If the parameter <tt>icase</tt> is true then the
++returned mask identifies the character classification without regard to the case of the characters being
++matched, otherwise it does honor the case of the characters being matched.(footnote 335) The value returned shall
++be independent of the case of the characters in the character sequence. If the name is not recognized
++then returns a value that compares equal to <tt>0</tt>.
++<p/>
++-10- <i>Remarks</i>: For <tt>regex_traits&lt;char&gt;</tt>, at least the <del>names "d", "w", "s", "alnum", "alpha", "blank",
++"cntrl", "digit", "graph", "lower", "print", "punct", "space", "upper" and "xdigit"</del><ins>narrow character
++names in Table X</ins> shall be recognized. For <tt>regex_traits&lt;wchar_t&gt;</tt>, at least the <del>names L"d", L"w",
++L"s", L"alnum", L"alpha", L"blank", L"cntrl", L"digit", L"graph", L"lower", L"print", L"punct", L"space", L"upper" and
++L"xdigit"</del><ins>wide character names in Table X</ins> shall be recognized.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Modify 28.7 [re.traits] p. 12 as indicated:</p>
++<blockquote><pre>
++bool isctype(charT c, char_class_type f) const;
++</pre><blockquote><p>
++-11- <i>Effects</i>: Determines if the character <tt>c</tt> is a member of the character classification represented by <tt>f</tt>.
++<p/>
++-12- <i>Returns</i>: <del>Converts <tt>f</tt> into a value <tt>m</tt> of type <tt>std::ctype_base::mask</tt> in an
++ unspecified manner, and returns true if <tt>use_facet&lt;ctype&lt;charT&gt; &gt;(getloc()).is(m, c)</tt> is true. Otherwise
++ returns true if <tt>f</tt> bitwise or'ed with the result of calling <tt>lookup_classname</tt> with an iterator pair that
++ designates the character sequence "w" is not equal to <tt>0</tt> and <tt>c == '_'</tt>, or if <tt>f</tt> bitwise or'ed
++ with the result of calling <tt>lookup_classname</tt> with an iterator pair that designates the character sequence "blank"
++ is not equal to <tt>0</tt> and <tt>c</tt> is one of an implementation-defined subset of the characters for
++ which <tt>isspace(c, getloc())</tt> returns true, otherwise returns false.</del>
++<ins>Given an exposition-only function prototype</ins></p>
++<blockquote><pre>
++<ins style="text-decoration: none">
++ template&lt;class C&gt;
++ ctype_base::mask convert(typename regex_traits&lt;C&gt;::char_class_type f);
++</ins>
++</pre></blockquote>
++<p>
++<ins>that returns a value in which each <tt>ctype_base::mask</tt> value corresponding to a value in <tt>f</tt> named in Table <i>X</i> is set,
++then the result is determined as if by:</ins>
++</p>
++<blockquote><pre>
++<ins style="text-decoration: none">
++ctype_base::mask m = convert&lt;charT&gt;(f);
++const ctype&lt;charT&gt;&amp; ct = use_facet&lt;ctype&lt;charT&gt;&gt;(getloc());
++if (ct.is(m, c)) {
++ return true;
++} else if (c == ct.widen('_')) {
++ charT w[1] = { ct.widen('w') };
++ char_class_type x = lookup_classname(w, w+1);
++
++ return (f&amp;x) == x;
++} else {
++ return false;
++}
++</ins>
++</pre></blockquote>
++<p><ins>[<i>Example</i>:</ins></p>
++
++<blockquote><pre><ins style="text-decoration: none">
++regex_traits&lt;char&gt; t;
++string d("d");
++string u("upper");
++regex_traits&lt;char&gt;::char_class_type f;
++f = t.lookup_classname(d.begin(), d.end());
++f |= t.lookup_classname(u.begin(), u.end());
++ctype_base::mask m = convert&lt;char&gt;(f); // m == ctype_base::digit|ctype_base::upper
++</ins></pre></blockquote>
++<p><ins>&mdash; <i>end example</i>]</ins></p>
++<p><ins>[<i>Example</i>:</ins></p>
++<blockquote><pre><ins style="text-decoration: none">
++regex_traits&lt;char&gt; t;
++string w("w");
++regex_traits&lt;char&gt;::char_class_type f;
++f = t.lookup_classname(w.begin(), w.end());
++t.isctype('A', f); // returns true
++t.isctype('_', f); // returns true
++t.isctype(' ', f); // returns false
++</ins></pre></blockquote>
++<p><ins>&mdash; <i>end example</i>]</ins></p>
++</blockquote></blockquote>
++</li>
++
++<li><p>At the end of 28.7 [re.traits] add a new "Table X &mdash; Character class names and corresponding ctype masks":</p>
++
++<blockquote>
++<table border="1">
++<caption>Table X &mdash; Character class names and corresponding ctype masks</caption>
++
++<tr>
++<th>Narrow character name</th>
++<th>Wide character name</th>
++<th>Corresponding <tt>ctype_base::mask</tt> value</th>
++</tr>
++
++<tr>
++<td><tt>"alnum"</tt></td>
++<td><tt>L"alnum"</tt></td>
++<td><tt>ctype_base::alnum</tt></td>
++</tr>
++
++<tr>
++<td><tt>"alpha"</tt></td>
++<td><tt>L"alpha"</tt></td>
++<td><tt>ctype_base::alpha</tt></td>
++</tr>
++
++<tr>
++<td><tt>"blank"</tt></td>
++<td><tt>L"blank"</tt></td>
++<td><tt>ctype_base::blank</tt></td>
++</tr>
++
++<tr>
++<td><tt>"cntrl"</tt></td>
++<td><tt>L"cntrl"</tt></td>
++<td><tt>ctype_base::cntrl</tt></td>
++</tr>
++
++<tr>
++<td><tt>"digit"</tt></td>
++<td><tt>L"digit"</tt></td>
++<td><tt>ctype_base::digit</tt></td>
++</tr>
++
++<tr>
++<td><tt>"d"</tt></td>
++<td><tt>L"d"</tt></td>
++<td><tt>ctype_base::digit</tt></td>
++</tr>
++
++<tr>
++<td><tt>"graph"</tt></td>
++<td><tt>L"graph"</tt></td>
++<td><tt>ctype_base::graph</tt></td>
++</tr>
++
++<tr>
++<td><tt>"lower"</tt></td>
++<td><tt>L"lower"</tt></td>
++<td><tt>ctype_base::lower</tt></td>
++</tr>
++
++<tr>
++<td><tt>"print"</tt></td>
++<td><tt>L"print"</tt></td>
++<td><tt>ctype_base::print</tt></td>
++</tr>
++
++<tr>
++<td><tt>"punct"</tt></td>
++<td><tt>L"punct"</tt></td>
++<td><tt>ctype_base::punct</tt></td>
++</tr>
++
++<tr>
++<td><tt>"space"</tt></td>
++<td><tt>L"space"</tt></td>
++<td><tt>ctype_base::space</tt></td>
++</tr>
++
++<tr>
++<td><tt>"s"</tt></td>
++<td><tt>L"s"</tt></td>
++<td><tt>ctype_base::space</tt></td>
++</tr>
++
++<tr>
++<td><tt>"upper"</tt></td>
++<td><tt>L"upper"</tt></td>
++<td><tt>ctype_base::upper</tt></td>
++</tr>
++
++<tr>
++<td><tt>"w"</tt></td>
++<td><tt>L"w"</tt></td>
++<td><tt>ctype_base::alnum</tt></td>
++</tr>
++
++<tr>
++<td><tt>"xdigit"</tt></td>
++<td><tt>L"xdigit"</tt></td>
++<td><tt>ctype_base::xdigit</tt></td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2019"></a>2019. <tt>isblank</tt> not supported by <tt>std::locale</tt></h3>
++<p><b>Section:</b> 22.3.3.1 [classification] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2010-11-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>C99 added <tt>isblank</tt> and <tt>iswblank</tt> to <tt>&lt;locale.h&gt;</tt> but <tt>&lt;locale&gt;</tt> does not
++provide any equivalent.</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 6 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Add to 22.3.3.1 [classification] synopsis:</p>
++<blockquote><pre>
++template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);
++<ins>template &lt;class charT&gt; bool isblank (charT c, const locale&amp; loc);</ins>
++</pre></blockquote>
++
++<p>Add to 22.4.1 [category.ctype] synopsis:</p>
++
++<blockquote><pre>
++static const mask xdigit = 1 &lt;&lt; 8;
++<ins>static const mask blank = 1 &lt;&lt; 9;</ins>
++static const mask alnum = alpha | digit;
++static const mask graph = alnum | punct;
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2020"></a>2020. Time utility arithmetic <tt>constexpr</tt> functions have invalid effects</h3>
++<p><b>Section:</b> 20.12.5.5 [time.duration.nonmember] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.nonmember">issues</a> in [time.duration.nonmember].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As of issue <a href="lwg-defects.html#1171">1171</a> several time-utility functions have been marked <tt>constexpr</tt>.
++Alas this was done without adapting the corresponding return elements, which has the effect that
++none of current arithmetic functions of class template <tt>duration</tt> marked as <tt>constexpr</tt>
++can ever be <tt>constexpr</tt> functions (which makes them ill-formed, no diagnostics required as
++of recent core rules), because they invoke a non-constant expression, e.g. 20.12.5.5 [time.duration.nonmember]/2:
++</p>
++<blockquote><pre>
++template &lt;class Rep1, class Period1, class Rep2, class Period2>
++constexpr typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;{&gt;}::type
++operator+(const duration&lt;Rep1, Period1>&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++
++2 Returns: CD(lhs) += rhs.
++</pre></blockquote>
++<p>
++The real problem is, that we cannot defer to as-if rules here: The returns element
++specifies an indirect calling contract of a potentially user-defined function. This <em>cannot</em> be
++the <tt>+=</tt> assignment operator of such a user-defined type, but must be the corresponding
++immutable binary <tt>operator+</tt> (unless we require that <tt>+=</tt> shall be an immutable function
++which does not really makes sense).
++</p>
++<p><i>[2011-02-17 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++The suggested wording changes are against the working draft N3242. Additional to the normative wording
++changes some editorial fixes are suggested.
++</p>
++<ol>
++<li>
++<p>In 20.12.5.5 [time.duration.nonmember], change the following arithmetic function specifications as follows:</p>
++<blockquote><pre>
++template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
++constexpr typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;<del>{</del>&gt;<del>}</del>::type
++operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++</pre><blockquote><p>
++2 <i>Returns</i>: <del><tt>CD(lhs) += rhs</tt></del><ins><tt>CD(CD(lhs).count() + CD(rhs).count())</tt></ins>.
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
++constexpr typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;<del>{</del>&gt;<del>}</del>::type
++operator-(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++</pre><blockquote><p>
++3 <i>Returns</i>: <del><tt>CD(lhs) -= rhs</tt></del><ins><tt>CD(CD(lhs).count() - CD(rhs).count())</tt></ins>.
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
++constexpr duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
++operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
++</pre><blockquote><p>
++4 <i>Remarks</i>: This operator shall not participate in overload resolution unless <tt>Rep2</tt> is implicitly convertible
++to <tt>CR(Rep1, Rep2)</tt>.
++<p/>
++5 <i>Returns</i>: <del><tt>duration&lt;CR(Rep1, Rep2), Period&gt;(d) *= s</tt></del><ins><tt>CD(CD(d).count() * s)</tt></ins>.
++</p></blockquote></blockquote>
++
++<blockquote><p>
++<tt>[...]</tt>
++</p></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
++constexpr duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
++operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
++</pre><blockquote><p>
++8 <i>Remarks</i>: This operator shall not participate in overload resolution unless <tt>Rep2</tt> is implicitly convertible
++to <tt>CR(Rep1, Rep2)</tt> and <tt>Rep2</tt> is not an instantiation of <tt>duration</tt>.
++<p/>
++9 <i>Returns</i>: <del><tt>duration&lt;CR(Rep1, Rep2), Period&gt;(d) &#47;= s</tt></del><ins><tt>CD(CD(d).count() &#47; s)</tt></ins>.
++</p></blockquote></blockquote>
++
++<blockquote><p>
++<tt>[...]</tt>
++</p></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep1, class Period, class Rep2&gt;
++constexpr duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
++operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
++</pre><blockquote><p>
++11 <i>Remarks</i>: This operator shall not participate in overload resolution unless <tt>Rep2</tt> is implicitly convertible
++to <tt>CR(Rep1, Rep2)</tt> and <tt>Rep2</tt> is not an instantiation of <tt>duration</tt>.
++<p/>
++12 <i>Returns</i>: <del><tt>duration&lt;CR(Rep1, Rep2), Period&gt;(d) %= s</tt></del><ins><tt>CD(CD(d).count() % s)</tt></ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
++constexpr typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
++operator%(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++</pre><blockquote><p>
++13 Returns: <del><tt>common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt; &gt;::type(lhs)
++ %= rhs</tt></del><ins><tt>CD(CD(lhs).count() % CD(rhs).count())</tt></ins>.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2021"></a>2021. Further incorrect usages of <tt>result_of</tt></h3>
++<p><b>Section:</b> 20.9.10.3 [func.bind.bind], 30.6.1 [futures.overview], 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.bind.bind">issues</a> in [func.bind.bind].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Issue <a href="lwg-defects.html#2017">2017</a> points out some incorrect usages of <tt>result_of</tt> in the
++declaration of the function call operator overload of <tt>reference_wrapper</tt>,
++but there are more such specification defects:
++</p>
++<ol>
++<li>According to 20.9.10.3 [func.bind.bind] p. 3:
++<blockquote><p>
++[..] The effect of <tt>g(u1, u2, ..., uM)</tt> shall be <tt>INVOKE(fd, v1, v2, ..., vN, result_of&lt;FD cv (V1, V2, ..., VN)&gt;::type)</tt> [..]
++</p></blockquote>
++<p>
++but <tt>fd</tt> is defined as &quot;an lvalue of type <tt>FD</tt> constructed from <tt>std::forward&lt;F&gt;(f)</tt>&quot;. This means that
++the above usage must refer to <tt>result_of&lt;FD cv <strong>&amp;</strong> (V1, V2, ..., VN)&gt;</tt> instead.
++</p>
++</li>
++<li><p>
++Similar in 20.9.10.3 [func.bind.bind] p. 10 bullet 2 we have:
++</p>
++<blockquote><p>
++if the value of <tt>is_bind_expression&lt;TiD&gt;::value</tt> is true, the argument is <tt>tid(std::forward&lt;Uj&gt;(uj)...)</tt>
++and its type <tt>Vi</tt> is <tt>result_of&lt;TiD cv (Uj...)&gt;::type</tt>
++</p></blockquote>
++<p>
++Again, <tt>tid</tt> is defined as &quot;lvalue of type <tt>TiD</tt> constructed from <tt>std::forward&lt;Ti&gt;(ti)</tt>&quot;. This means that
++the above usage must refer to <tt>result_of&lt;TiD cv <strong>&amp;</strong> (Uj...)&gt;</tt> instead. We also have similar defect as in
++<a href="lwg-defects.html#2017">2017</a> in regard to the argument types, this leads us to the further corrected form
++<tt>result_of&lt;TiD cv <strong>&amp;</strong> (Uj<strong>&amp;&amp;</strong>...)&gt;</tt>. This is not the end: Since the <tt>Vi</tt>
++are similar sensitive to the argument problem, the last part must say:
++<p/>
++&quot;[..] its type <tt>Vi</tt> is <tt>result_of&lt;TiD cv <strong>&amp;</strong> (Uj<strong>&amp;&amp;</strong>...)&gt;::type <strong>&amp;&amp;</strong>&quot;</tt>
++<p/>
++(The bound arguments <tt>Vi</tt> can never be <tt>void</tt> types, therefore we don't need
++to use the more defensive <tt>std::add_rvalue_reference</tt> type trait)
++</p>
++</li>
++<li><p>The function template <tt>async</tt> is declared as follows (the other overload has the same problem):</p>
++<blockquote><pre>
++template &lt;class F, class... Args&gt;
++future&lt;typename result_of&lt;F(Args...)&gt;::type&gt;
++async(F&amp;&amp; f, Args&amp;&amp;... args);
++</pre></blockquote><p>
++This usage has the some same problems as we have found in <tt>reference_wrapper</tt> (<a href="lwg-defects.html#2017">2017</a>) and more: According to
++the specification in 30.6.8 [futures.async] the effective result type is that of the call of
++</p><blockquote><pre>
++INVOKE(decay_copy(std::forward&lt;F&gt;(f)), decay_copy(std::forward&lt;Args&gt;(args))...)
++</pre></blockquote><p>
++First, <tt>decay_copy</tt> potentially modifies the effective types to <tt>decay&lt;F&gt;::type</tt> and <tt>decay&lt;Args&gt;::type...</tt>.
++Second, the current specification is not really clear, what the value category of callable type or the arguments shall be: According
++to the second bullet of 30.6.8 [futures.async] p. 3:
++</p>
++<blockquote><p>
++Invocation of the deferred function evaluates <tt>INVOKE(g, xyz)</tt> where <tt>g</tt> is the stored value of
++<tt>decay_copy(std::forward&lt;F&gt;(f))</tt> and <tt>xyz</tt> is the stored copy of
++<tt>decay_copy(std::forward&lt;Args&gt;(args))...</tt>.
++</p></blockquote><p>
++This seems to imply that lvalues are provided in contrast to the direct call expression of 30.6.8 [futures.async] p. 2
++which implies rvalues instead. The specification needs to be clarified.
++</p>
++</li>
++</ol>
++
++<p><i>[2011-06-13: Daniel comments and refines the proposed wording changes]</i></p>
++
++
++<p>The feedback obtained following message c++std-lib-30745 and follow-ups point to the intention, that
++the implied provision of lvalues due to named variables in <tt>async</tt> should be provided as rvalues to support
++move-only types, but the functor type should be forwarded as lvalue in <tt>bind</tt>.
++<p/>
++If <tt>bind</tt> were newly invented, the value strategy could be improved, because now we have a preference of
++<i>ref</i> <tt>&amp;</tt> qualified function call operator overloads. But such a change seems to be too late now.
++User-code that needs to bind a callable object with an <i>ref</i> <tt>&amp;&amp;</tt> qualified function call
++operator (or conversion function to function pointer) needs to use a corresponding wrapper similar to <tt>reference_wrapper</tt>
++that forwards the reference as rvalue-reference instead.
++<p/>
++The wording has been adapted to honor these observations and to fit to FDIS numbering as well.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++The suggested wording changes are against the FDIS.
++</p>
++<ol>
++<li>
++<p>Change 20.9.10.3 [func.bind.bind] p. 3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class F, class... BoundArgs&gt;
++ <i>unspecified</i> bind(F&amp;&amp; f, BoundArgs&amp;&amp;... bound_args);
++</pre><blockquote><p>
++-2- <i>Requires</i>: <tt>is_constructible&lt;FD, F&gt;::value</tt> shall be true. For each <tt>Ti</tt> in <tt>BoundArgs</tt>,
++<tt>is_constructible&lt;TiD, Ti&gt;::value</tt> shall be true. <tt><i>INVOKE</i>(fd, w1, w2, ..., wN)</tt> (20.8.2) shall
++be a valid expression for some values <tt>w1</tt>, <tt>w2</tt>, ..., <tt>wN</tt>, where <tt>N == sizeof...(bound_args)</tt>.
++<p/>
++-3- <i>Returns</i>: A forwarding call wrapper <tt>g</tt> with a weak result type (20.8.2). The effect of
++<tt>g(u1, u2, ..., uM)</tt> shall be <tt>INVOKE(fd, <ins>std::forward&lt;V1&gt;(</ins>v1<ins>)</ins>,
++<ins>std::forward&lt;V2&gt;(</ins>v2<ins>)</ins>, ..., <ins>std::forward&lt;VN&gt;(</ins>vN<ins>)</ins>,
++result_of&lt;FD <i>cv</i> <ins>&amp;</ins> (V1, V2, ..., VN)&gt;::type)</tt>, where <i>cv</i> represents
++the <i>cv</i>-qualifiers of <tt>g</tt> and the values and types of the bound arguments <tt>v1</tt>,
++<tt>v2</tt>, ..., <tt>vN</tt> are determined as specified below. [&hellip;]
++</p></blockquote></blockquote>
++
++</li>
++
++<li>
++<p>Change 20.9.10.3 [func.bind.bind] p. 7 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class R, class F, class... BoundArgs&gt;
++ <i>unspecified</i> bind(F&amp;&amp; f, BoundArgs&amp;&amp;... bound_args);
++</pre><blockquote><p>
++-6- <i>Requires</i>: <tt>is_constructible&lt;FD, F&gt;::value</tt> shall be true. For each <tt>Ti</tt> in <tt>BoundArgs</tt>,
++<tt>is_constructible&lt;TiD, Ti&gt;::value</tt> shall be true. <tt><i>INVOKE</i>(fd, w1, w2, ..., wN)</tt> shall be a valid
++expression for some values <tt>w1</tt>, <tt>w2</tt>, ..., <tt>wN</tt>, where <tt>N == sizeof...(bound_args)</tt>.
++<p/>
++-7- <i>Returns</i>: A forwarding call wrapper <tt>g</tt> with a nested type <tt>result_type</tt> defined as a synonym for
++<tt>R</tt>. The effect of <tt>g(u1, u2, ..., uM)</tt> shall be <tt>INVOKE(fd, <ins>std::forward&lt;V1&gt;(</ins>v1<ins>)</ins>,
++<ins>std::forward&lt;V2&gt;(</ins>v2<ins>)</ins>, ..., <ins>std::forward&lt;VN&gt;(</ins>vN<ins>)</ins>, R)</tt>, where
++the values and types of the bound arguments <tt>v1</tt>, <tt>v2</tt>, ..., <tt>vN</tt> are determined as specified below. [&hellip;]
++</p></blockquote></blockquote>
++
++</li>
++
++<li>
++<p>Change 20.9.10.3 [func.bind.bind] p. 10 as indicated:</p>
++
++<blockquote><p>
++-10- The values of the <i>bound arguments</i> <tt>v1</tt>, <tt>v2</tt>, ..., <tt>vN</tt> and their corresponding types <tt>V1</tt>,
++<tt>V2</tt>, ..., <tt>VN</tt> depend on the types <tt>TiD</tt> derived from the call to bind and the <i>cv</i>-qualifiers
++<i>cv</i> of the call wrapper <tt>g</tt> as follows:</p>
++<ul>
++<li>if <tt>TiD</tt> is <tt>reference_wrapper&lt;T&gt;</tt>, the argument is <tt>tid.get()</tt> and its type <tt>Vi</tt>
++is <tt>T&amp;</tt>;</li>
++<li>if the value of <tt>is_bind_expression&lt;TiD&gt;::value</tt> is <tt>true</tt>, the argument is
++<tt>tid(std::forward&lt;Uj&gt;(uj)...)</tt> and its type <tt>Vi</tt> is
++<tt>result_of&lt;TiD <i>cv</i> <ins>&amp;</ins> (Uj<ins>&amp;&amp;</ins>...)&gt;::type<ins>&amp;&amp;</ins></tt>;</li>
++<li>if the value <tt>j</tt> of <tt>is_placeholder&lt;TiD&gt;::value</tt> is not zero, the argument is
++<tt>std::forward&lt;Uj&gt;(uj)</tt> and its type <tt>Vi</tt> is <tt>Uj&amp;&amp;</tt>;</li>
++<li>otherwise, the value is <tt>tid</tt> and its type <tt>Vi</tt> is <tt>TiD <i>cv</i> &amp;</tt>.</li>
++</ul>
++</blockquote>
++
++</li>
++
++<li>
++<p>
++This resolution assumes that the wording of 30.6.8 [futures.async] is intended to provide rvalues
++as arguments of <tt>INVOKE</tt>.
++</p>
++
++<p>
++Change the function signatures in header <tt>&lt;future&gt;</tt> synopsis 30.6.1 [futures.overview] p. 1
++and in 30.6.8 [futures.async] p. 1 as indicated:
++</p>
++
++<blockquote><pre>
++template &lt;class F, class... Args&gt;
++future&lt;typename result_of&lt;<ins>typename decay&lt;</ins>F<ins>&gt;::type</ins>(<ins>typename decay&lt;</ins>Args<ins>&gt;::type</ins>...)&gt;::type&gt;
++async(F&amp;&amp; f, Args&amp;&amp;... args);
++template &lt;class F, class... Args>
++future&lt;typename result_of&lt;<ins>typename decay&lt;</ins>F<ins>&gt;::type</ins>(<ins>typename decay&lt;</ins>Args<ins>&gt;::type</ins>...)&gt;::type&gt;
++async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
++</pre></blockquote>
++</li>
++
++<li>
++<p>Change 30.6.8 [futures.async] as indicated: (Remark: There is also a tiny editorial correction
++in p. 4 that completes one <tt>::</tt> scope specifier)
++</p>
++
++<blockquote><p>
++-3- <i>Effects</i>: [&hellip;]
++</p>
++<ul>
++<li>[&hellip;]</li>
++<li>if <tt>policy &amp; launch::deferred</tt> is non-zero &mdash; Stores <tt><i>DECAY_COPY</i>(std::forward&lt;F&gt;(f))</tt>
++and <tt><i>DECAY_COPY</i>(std::forward&lt;Args&gt;(args))...</tt> in the shared state. These copies of <tt>f</tt> and
++<tt>args</tt> constitute a <i>deferred function</i>. Invocation of the deferred function evaluates
++<tt><i>INVOKE</i>(<ins>std::move(</ins>g<ins>)</ins>, <ins>std::move(</ins>xyz<ins>)</ins>)</tt>
++where <tt>g</tt> is the stored value of <tt><i>DECAY_COPY</i>(std::forward&lt;F&gt;(f))</tt> and <tt>xyz</tt> is the
++stored copy of <tt><i>DECAY_COPY</i>(std::forward&lt;Args&gt;(args))...</tt>. The shared state is not made ready
++until the function has completed. The first call to a non-timed waiting function (30.6.4) on an asynchronous
++return object referring to this shared state shall invoke the deferred function in the thread that
++called the waiting function. Once evaluation of <tt><i>INVOKE</i>(<ins>std::move(</ins>g<ins>)</ins>,
++<ins>std::move(</ins>xyz<ins>)</ins>)</tt> begins, the function is no longer considered deferred. [ <i>Note</i>: If
++this policy is specified together with other policies, such as when using a <tt>policy</tt> value of
++<tt>launch::async | launch::deferred</tt>, implementations should defer invocation or the selection of
++the policy when no more concurrency can be effectively exploited. &mdash; <i>end note</i> ]</li>
++</ul>
++</blockquote>
++
++<blockquote><p>
++-4- <i>Returns</i>: an object of type
++<tt>future&lt;typename result_of&lt;<ins>typename decay&lt;</ins>F<ins>&gt;::type</ins>(<ins>typename decay&lt;</ins>Args<ins>&gt;::type</ins>...)&gt;:<ins>:</ins>type&gt;</tt>
++that refers to the associated asynchronous state created by this call to <tt>async</tt>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2022"></a>2022. <tt>reference_wrapper&lt;T&gt;::result_type</tt> is underspecified</h3>
++<p><b>Section:</b> 20.9.4 [refwrap] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#refwrap">issues</a> in [refwrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Issue <a href="lwg-defects.html#1295">1295</a> correctly removed function types and references to function types from the
++bullet 1 of 20.9.2 [func.require] p. 3 because neither function types nor function references
++satisfy the requirements for a target object which is <em>defined</em> to be an object of a callable
++type. This has the effect that the reference in 20.9.4 [refwrap] p. 2
++</p>
++<blockquote><p>
++<tt>reference_wrapper</tt> has a weak result type (20.8.2).
++</p></blockquote>
++<p>
++is insufficient as a reference to define the member type <tt>result_type</tt> when the template argument
++<tt>T</tt> is a function type.
++<p/>
++There are basically two approaches to solve the problem:
++</p>
++<ol>
++<li><p>Extend the definition of a <i>weak result type</i> in 20.9.2 [func.require] p. 3 to both
++function types and references thereof. This extension must be specified independend from the concept
++of a call wrapper, though.</p>
++</li>
++<li><p>Add one extra sentence to 20.9.4 [refwrap] p. 2 that simply defines the member type
++<tt>result_type</tt> for <tt>reference_wrapper&lt;T&gt;</tt>, when <tt>T</tt> is a function type.</p>
++</li>
++</ol>
++<p>
++I checked the current usages of <i>weak result type</i> to have a base to argue for one or the other
++approach. It turns out, that there is no further reference to this definition in regard to
++function types or references thereof. The only other reference can be found in
++20.9.10.3 [func.bind.bind] p. 3, where <tt>g</tt> is required to be a class type.
++</p>
++
++<p><i>[2011-02-23 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++The suggested wording changes are against the working draft N3242.
++</p>
++
++<ol>
++<li>
++<p>Change 20.9.4 [refwrap] p. 2 as indicated:</p>
++
++<blockquote><p>
++2 <tt>reference_wrapper<ins>&lt;T&gt;</ins></tt> has a weak result type (20.8.2). <ins>If <tt>T</tt> is a function type,
++<tt>result_type</tt> shall be a synonym for the return type of <tt>T</tt>.</ins>
++</p></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2023"></a>2023. Incorrect requirements for <tt>lock_guard</tt> and <tt>unique_lock</tt></h3>
++<p><b>Section:</b> 30.4.2.1 [thread.lock.guard], 30.4.2.2 [thread.lock.unique] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++There are two different <tt>*Lockable</tt> requirements imposed on template arguments
++of the class template <tt>lock_guard</tt> as of 30.4.2.1 [thread.lock.guard] p. 1+2:
++</p>
++<blockquote><p>
++1 [..] The supplied <tt>Mutex</tt> type shall meet the <tt>BasicLockable</tt> requirements (30.2.5.2).
++</p></blockquote>
++
++<blockquote><p>
++2 The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt> requirements (30.2.5.3).
++</p></blockquote>
++<p>
++The <tt>Lockable</tt> requirements include the availability of a member function <tt>try_lock()</tt>,
++but there is no operational semantics in the specification of <tt>lock_guard</tt> that would rely
++on such a function. It seems to me that paragraph 2 should be removed.
++<p/>
++Similarly, 30.4.2.2 [thread.lock.unique] p. 1+2 refer to exactly the same two requirements.
++In this case it seems as if the intention was that the template arguement <tt>Mutex</tt> should
++always provide the <tt>try_lock()</tt> member function, because several member functions of
++<tt>unique_lock</tt> (<tt>unique_lock(mutex_type&amp; m, try_to_lock_t)</tt> or <tt>bool try_lock()</tt>)
++take advantage of such a function without adding extra requirements for this.
++It seems that the requirement subset <tt>BasicLockable</tt> should be removed.
++<p/>
++I searched for further possible misusages of the <tt>*Lockable</tt> requirements, but could not
++find any more.
++</p>
++
++<p><i>[2011-02-23]</i></p>
++
++
++<p>Howard suggests an alternative approach in regard to <tt>unique_lock</tt>: The current
++minimum requirements on its template argument should better be reduced to <tt>BasicLockable</tt>
++instead of the current <tt>Lockable</tt>, including ammending member-wise constraints where required.
++This suggestions was supported by Anthony, Daniel, and Pablo.
++<p/>
++Daniel drafts wording that follows this separation strategy.
++</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++<blockquote class="note">
++<p>
++The suggested wording changes are against the working draft N3242.
++</p>
++
++<ol>
++<li>
++<p>Remove 30.4.2.1 [thread.lock.guard] p. 2 completely:</p>
++
++<blockquote><p>
++<del>2 The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt> requirements (30.2.5.3).</del>
++</p></blockquote>
++
++</li>
++
++<li>
++<p>Change 30.4.2.2 [thread.lock.unique] p. 1-3 as indicated. The intend is to make <tt>BasicLockable</tt>
++the fundamental requirement for <tt>unique_lock</tt>. We also update the note to reflect these changes and
++synchronize one remaining reference of 'mutex' by the proper term 'lockable object' in sync
++to the wording changes of <tt>lock_guard</tt>:</p>
++
++<blockquote><p>
++1 [..] The behavior of a program is undefined if the contained pointer <tt>pm</tt> is not null
++and the <del>mutex</del><ins>lockable object</ins> pointed to by <tt>pm</tt> does not exist for the entire remaining lifetime (3.8)
++of the <tt>unique_lock</tt> object. The supplied <tt>Mutex</tt> type shall meet the
++<tt>BasicLockable</tt> requirements (30.2.5.2). <del>[Editor's note:
++BasicLockable is redundant, since the following additional paragraph requires Lockable.]</del>
++</p></blockquote>
++
++<blockquote><p>
++<del>2 The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt> requirements (30.2.5.3).</del>
++</p></blockquote>
++
++<blockquote><p>
++3 [ <i>Note</i>: <tt>unique_lock&lt;Mutex&gt;</tt> meets the <tt><ins>Basic</ins>Lockable</tt> requirements. If
++<ins><tt>Mutex</tt> meets the <tt>Lockable</tt> requirements ([thread.req.lockable.req]), <tt>unique_lock&lt;Mutex&gt;</tt>
++also meets the <tt>Lockable</tt> requirements and if</ins> <tt>Mutex</tt> meets the <tt>TimedLockable</tt>
++requirements (30.2.5.4), <tt>unique_lock&lt;Mutex&gt;</tt> also meets the <tt>TimedLockable</tt>
++requirements. &mdash; <i>end note</i> ]
++</p></blockquote>
++
++</li>
++
++<li><p>Modify 30.4.2.2.1 [thread.lock.unique.cons] to add the now necessary member-wise
++additional constraints for <tt>Lockable</tt>:</p>
++
++<blockquote><pre>
++unique_lock(mutex_type&amp; m, try_to_lock_t) noexcept;
++</pre><blockquote><p>
++8 <i>Requires</i>: <ins>The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt> requirements ([thread.req.lockable.req]).</ins>
++If <tt>mutex_type</tt> is not a recursive mutex the calling thread does not own the mutex.
++<p/>
++9 <i>Effects</i>: Constructs an object of type <tt>unique_lock</tt> and calls <tt>m.try_lock()</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Modify 30.4.2.2.2 [thread.lock.unique.locking] to add the now necessary member-wise
++additional constraints for <tt>Lockable</tt>:</p>
++
++<blockquote><pre>
++bool try_lock();
++</pre><blockquote><p>
++<ins>? <i>Requires</i>: The supplied <tt>Mutex</tt> type shall meet the <tt>Lockable</tt> requirements ([thread.req.lockable.req]).</ins>
++<p/>
++4 <i>Effects</i>: <tt>pm-&gt;try_lock()</tt>
++</p></blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="2024"></a>2024. Inconsistent implementation requirements for <tt>atomic&lt;<i>integral</i>&gt;</tt> and <tt>atomic&lt;T*&gt;</tt></h3>
++<p><b>Section:</b> 29.5 [atomics.types.generic] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.types.generic">active issues</a> in [atomics.types.generic].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.types.generic">issues</a> in [atomics.types.generic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Paragraph 5 and 6 of 29.5 [atomics.types.generic] impose different requirements on implementations for
++specializations of the <tt>atomic</tt> class template for integral types and for pointer types:
++</p>
++<blockquote><p>
++5 The atomic integral specializations and the specialization <tt>atomic&lt;bool&gt;</tt> shall have standard layout.
++They shall each have a trivial default constructor and a trivial destructor. They shall each support aggregate
++initialization syntax.
++</p></blockquote>
++
++<blockquote><p>
++6 There are pointer partial specializations on the <tt>atomic</tt> class template. These specializations shall have
++trivial default constructors and trivial destructors.
++</p></blockquote>
++
++<p>
++It looks like an oversight to me, that for pointer specializations the requirements for standard layout and
++support for aggregate initialization syntax are omitted. In fact, this been confirmed by the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3193.htm">N3193</a> proposal author. I suggest
++to impose the same implementation requirements for pointer types as for integral types, this should not impose
++unrealistic requirements on implementations.
++</p>
++
++<p><i>[2011-02-10 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++<p>
++The suggested wording changes are against the working draft N3242.
++</p>
++
++<ol>
++<li>
++<p>Change 29.5 [atomics.types.generic] p. 6 as indicated:</p>
++
++<blockquote><p>
++6 There are pointer partial specializations on the <tt>atomic</tt> class template. These specializations shall have
++<ins>standard layout,</ins> trivial default constructors<ins>,</ins> and trivial destructors. <ins> They shall each
++support aggregate initialization syntax.</ins>
++</p></blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="2025"></a>2025. Incorrect semantics of move assignment operator of <tt>packaged_task</tt></h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2010-12-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to 30.6.9.1 [futures.task.members] p. 7 bullet 2:
++</p>
++<blockquote><pre>
++packaged_task&amp; operator=(packaged_task&amp;&amp; other);
++</pre><blockquote><p>
++7 <i>Effects</i>:<br/>
++</p>
++<ul>
++<li><p>[...]</p></li>
++<li><p><tt>packaged_task&lt;R, ArgTypes...&gt;(other).swap(*this)</tt>.</p></li>
++</ul>
++</blockquote></blockquote>
++<p>
++The argument <tt>other</tt> given to the move constructor is an lvalue and must be converted into
++an rvalue via appropriate usage of <tt>std::move</tt>.
++</p>
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++<p>
++The suggested wording changes are against the working draft N3242.
++</p>
++
++<ol>
++<li>
++<p>Change 30.6.9.1 [futures.task.members] p. 7 bullet 2 as indicated:</p>
++
++<blockquote><pre>
++packaged_task&amp; operator=(packaged_task&amp;&amp; other);
++</pre><blockquote><p>
++7 <i>Effects</i>:<br/>
++</p>
++<ul>
++<li><p>[...]</p></li>
++<li><p><tt>packaged_task(<ins>std::move(</ins>other<ins>)</ins>).swap(*this)</tt>.</p></li>
++</ul>
++</blockquote></blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="2027"></a>2027. Initialization of the stored task of a <tt>packaged_task</tt></h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2011-02-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Related with LWG issue <a href="lwg-defects.html#1514">1514</a>.
++</p>
++
++<p>
++The move constructor of <tt>packaged_task</tt> does not specify how the stored task is constructed.
++The obvious way is to move-construct it using the task stored in the argument. Moreover, the
++constructor should be provided with a throws clause similar to one used for the other constructors,
++as the move constructor of the stored task is not required to be nothrow.</p>
++
++<p>
++As for the other constructors, the terms "stores a copy of <tt>f</tt>" do not reflect the intent, which is
++to allow <tt>f</tt> to be moved when possible.
++</p>
++
++<p><i>[2011-02-25: Alberto updates wording]</i></p>
++
++
++<p><i>[2011-02-26 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>(wording written assuming LWG <a href="lwg-defects.html#1514">1514</a> is also accepted)</p>
++
++<ol>
++<li>
++<p>Change 30.6.9.1 [futures.task.members] paragraph 3:</p>
++
++<blockquote><p>
++3 <em>Effects</em>: constructs a new <tt>packaged_task</tt> object with an associated asynchronous state and <del>stores a
++copy of <tt>f</tt> as the object's stored task</del><ins>initializes the object's stored task with <tt>std::forward&lt;F&gt;(f)</tt></ins>.
++The constructors that take an <tt>Allocator</tt> argument use it to allocate memory needed to store the internal data structures.
++</p></blockquote>
++
++</li>
++
++<li>
++<p>Change 30.6.9.1 [futures.task.members] paragraph 5:</p>
++
++<blockquote><p>
++5 <em>Effects</em>: constructs a new <tt>packaged_task</tt> object and transfers ownership of <tt>other</tt>'s associated asynchronous
++state to <tt>*this</tt>, leaving <tt>other</tt> with no associated asynchronous state. <ins>Moves the stored task from <tt>other</tt>
++to <tt>*this</tt>.</ins>
++</p></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2028"></a>2028. <tt>messages_base::catalog</tt> overspecified</h3>
++<p><b>Section:</b> 22.4.7.1 [locale.messages] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 22.4.7.1 [locale.messages], <tt>messages_base::catalog</tt> is specified to be a typedef to <tt>int</tt>.
++This type is subsequently used to open, access and close catalogs.
++</p>
++
++<p>
++However, an OS may have catalog/messaging services that are indexed and managed by types other than <tt>int</tt>.
++For example <tt>POSIX</tt>, publishes the <a href="http://www.unix.org/single_unix_specification/">following messaging API</a>:
++</p>
++
++<blockquote><pre>
++typedef <em>unspecified</em> nl_catd;
++
++nl_catd catopen(const char* name , int oflag);
++char* catgets(nl_catd catd, int set_id, int msg_id, const char* s);
++int catclose(nl_catd catd);
++</pre></blockquote>
++
++<p>
++I.e., the catalog is managed with an unspecified type, not necessarily an <tt>int</tt>.
++Mac OS uses a <tt>void*</tt> for <tt>nl_catd</tt> (which is conforming to the <tt>POSIX</tt> standard).
++The current <tt>messages_base</tt> spec effectively outlaws using the built-in OS messaging service
++supplied for this very purpose!
++</p>
++
++<p><i>[2011-02-24: Chris Jefferson updates the proposed wording, changing <i>unspecified</i> to <i>unspecified signed integral type</i>]</i></p>
++
++
++<p><i>[2011-03-02: Daniel updates the proposed wording, changing <i>unspecified signed integral type</i> to
++ <i>unspecified signed integer type</i> (We don't want to allow for <tt>bool</tt> or <tt>char</tt>)]</i></p>
++
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++Consensus that this resolution is the direction we would like to see.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>Modify 22.4.7.1 [locale.messages]:</p>
++
++<blockquote><pre>
++namespace std {
++ class messages_base {
++ public:
++ typedef <del>int</del><ins><em>unspecified signed integer type</em></ins> catalog;
++ };
++ ...
++}
++</pre></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2029"></a>2029. Missing '<tt>noexcept</tt>' on <tt>basic_regex</tt> move-assignment operator</h3>
++<p><b>Section:</b> 28.8 [re.regex] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-02-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.regex">issues</a> in [re.regex].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3149.html">N3149</a> replaced
++the "<tt>Throws: nothing</tt>" clause on <tt>basic_regex::assign(basic_regex&amp;&amp;)</tt> with
++the <tt>noexcept</tt> keyword. The effects of the move-assignment operator are defined in terms of
++the <tt>assign()</tt> function, so the "<tt>Throws: nothing</tt>" applied there too, and a
++<tt>noexcept</tt>-specification should be added there too.
++</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 7 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li>
++<p>Modify the <tt>basic_regex</tt> synopsis in 28.8 [re.regex] p. 3:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class charT,
++ class traits = regex_traits&lt;charT&gt; &gt;
++ class basic_regex {
++ public:
++ ...
++ basic_regex&amp; operator=(const basic_regex&amp;);
++ basic_regex&amp; operator=(basic_regex&amp;&amp;) <ins>noexcept</ins>;
++ basic_regex&amp; operator=(const charT* ptr);
++ ...
++ };
++}
++</pre></blockquote>
++
++</li>
++
++<li>
++<p>Modify 28.8.3 [re.regex.assign] p. 2:</p>
++
++<blockquote><pre>
++basic_regex&amp; operator=(basic_regex&amp;&amp; e) <ins>noexcept</ins>;
++</pre>
++<blockquote><p>
++2 <em>Effects</em>: returns <tt>assign(std::move(e))</tt>.
++</p></blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2030"></a>2030. <tt>packaged_task::result_type</tt> should be removed</h3>
++<p><b>Section:</b> 30.6.9 [futures.task] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2010-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task">issues</a> in [futures.task].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>packaged_task::operator()</tt> always returns <tt>void</tt>, regardless of the return
++type of the wrapped task. However, <tt>packaged_task::result_type</tt> is a
++typedef to the return type of the wrapped task. This is inconsistent
++with other uses of <tt>result_type</tt> in the standard, where it matches the
++return type of <tt>operator()</tt> (e.g. <tt>function</tt>, <tt>owner_less</tt>). This is confusing.
++</p>
++
++<p>
++It also violates the TR1 <tt>result_of</tt> protocol, and thus makes
++<tt>packaged_task</tt> harder to use with anything that respects that protocol.
++</p>
++
++<p>
++Finally, it is of little use anyway.
++</p>
++
++<p><tt>packaged_task::result_type</tt> should therefore be removed.</p>
++
++<p><i>[2011-02-24 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Alter the class definition of <tt>packaged_task</tt> in 30.6.9 [futures.task] p. 2 as follows:</p>
++<blockquote><pre>
++template&lt;class R, class... ArgTypes&gt;
++class packaged_task&lt;R(ArgTypes...)&gt; {
++public:
++ <del>typedef R result_type;</del>
++ [...]
++};
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2031"></a>2031. <tt>std::future&lt;&gt;::share()</tt> only applies to rvalues</h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2011-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As specified, <tt>future&lt;&gt;::share()</tt> has the signature
++</p>
++
++<blockquote><pre>
++shared_future&lt;R&gt; share() &amp;&amp;;
++</pre></blockquote>
++
++<p>
++This means that it can only be applied to rvalues. One of the key benefits of <tt>share()</tt> is
++that it can be used with the new <tt>auto</tt> facility:
++</p>
++
++<blockquote><pre>
++std::promise&lt;<em>some_long_winded_type_name</em>&gt; some_promise;
++auto f = some_promise.get_future(); // std::future
++auto sf = std::move(f).share();
++</pre></blockquote>
++
++<p>
++<tt>share()</tt> is sufficiently explicit that the move should not be required. We should be able to write:
++</p>
++
++<blockquote><pre>
++auto sf = f.share();
++</pre></blockquote>
++
++<p><i>[2011-02-22 Reflector discussion]</i></p>
++
++<p>
++Moved to Tentatively Ready after 5 votes.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Alter the declaration of <tt>share()</tt> to remove the "&amp;&amp;" rvalue qualifier in
++30.6.6 [futures.unique_future] p. 3, and 30.6.6 [futures.unique_future] p. 11:</p>
++
++<blockquote><pre>
++shared_future&lt;R&gt; share() <del>&amp;&amp;</del>;
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2032"></a>2032. Incorrect synchronization clause of <tt>async</tt> function</h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2011-02-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Clause 30.6.8 [futures.async] has undergone significant rewording
++in Batavia. Due to co-presence of at least three different sources
++of modification there is a part where changes have overlapped
++(marked by an Editor's note), which should be reconciled. Moreover,
++I believe that a few non-overlapping sentences are now incorrect
++and should be fixed, so the problem cannot be handled editorially.
++(See c++std-lib-29667.)
++</p>
++
++<p><i>[Adopted in Madrid, 2011-03]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Edit 30.6.4 [futures.state], paragraph 3 as follows.
++</p>
++
++<blockquote>
++<p>
++An <dfn>asynchronous return object</dfn>
++is an object that reads results from an associated asynchronous state.
++A <dfn>waiting function</dfn> of an asynchronous return object
++is one that potentially blocks
++to wait for the associated asynchronous state to be made ready.
++<ins>If a waiting function can return
++before the state is made ready because of a timeout (30.2.5),
++then it is a <dfn>timed waiting function</dfn>,
++otherwise it is a <dfn>non-timed waiting function</dfn>.</ins>
++</p>
++</blockquote>
++</li>
++
++<li>
++<p>
++Edit within 30.6.8 [futures.async] paragraph 3 bullet 2 as follows.
++</p>
++
++<blockquote>
++<p>
++<i>Effects:</i>
++[...]
++</p>
++<ul><li>if <code>policy &amp; launch::deferred</code> is non-zero &mdash; [...]
++The associated asynchronous state is not made ready
++until the function has completed.
++The first call to a <ins>non-timed waiting</ins> function
++<ins>(30.6.4 [futures.state])</ins>
++<del>requiring a non-timed wait</del>
++on an asynchronous return object
++referring to <del>the</del> <ins>this</ins>
++associated asynchronous state
++<del>created by this <code>async</code> call to become ready</del>
++shall invoke the deferred function
++in the thread that called the waiting function<del>;</del><ins>.</ins>
++<del>once</del> <ins>Once</ins> evaluation of
++<code><var>INVOKE</var>(g, xyz)</code> begins,
++the function is no longer considered deferred.
++[...]
++</li></ul>
++</blockquote>
++</li>
++
++<li>
++<p>
++Edit 30.6.8 [futures.async] paragraph 5 as follows.
++</p>
++
++<blockquote>
++<p>
++<i>Synchronization:</i>
++Regardless of the provided <code>policy</code> argument,
++</p>
++<ul>
++<li>
++the invocation of <code>async</code> synchronizes with (1.10)
++the invocation of <code>f</code>.
++[<i>Note:</i>
++this statement applies even when the corresponding future object
++is moved to another thread.
++&mdash;<i>end note</i>];
++and
++</li>
++<li>
++the completion of the function <code>f</code>
++is sequenced before (1.10) the associated asynchronous state is made ready.
++[<i>Note:</i>
++<code>f</code> might not be called at all,
++so its completion might never happen.
++&mdash;<i>end note</i>]
++</li>
++</ul>
++
++<p>
++<del>If <code>policy &amp; launch::async</code> is non-zero,</del>
++<ins>If the implementation chooses the <code>launch::async</code> policy,</ins>
++</p>
++<ul>
++<li>
++a call to a waiting function on an asynchronous return object
++that shares the associated asynchronous state
++created by this <code>async</code> call
++shall block until the associated thread has completed,
++as if joined (30.3.1.5);
++</li>
++<li>
++<del>the <code>join()</code> on the created thread object</del>
++<ins>the associated thread completion</ins>
++synchronizes with (1.10)
++the return from the first function
++that successfully detects the ready status of the associated asynchronous state
++or with the return from the last function that
++releases the associated asynchronous state <del>returns</del>,
++whichever happens first.
++<del><b>[Editor's note:
++N3196 changes the following sentence as indicated.
++N3188 removes the sentence.
++Please pick one.]</b>
++If the invocation is deferred,
++the completion of the invocation of the deferred function
++synchronizes with the successful return
++from a call to a waiting function on the associated asynchronous state.</del>
++</li>
++</ul>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2033"></a>2033. Preconditions of <tt>reserve</tt>, <tt>shrink_to_fit</tt>, and <tt>resize</tt> functions</h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity], 23.3.3.3 [deque.capacity] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2011-02-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I have several questions with regard to the working paper N3225 (C++0x working draft):
++</p>
++<ol>
++<li><p>
++Where the working draft specifies preconditions for <tt>shrink_to_fit</tt>
++member function of <tt>std::vector</tt> and <tt>std::deque</tt>?
++</p></li>
++<li><p>
++Where the working draft specifies preconditions for '<tt>void reserve(size_type n)</tt>'
++member function of <tt>std::vector</tt>?
++</p></li>
++<li><p>
++Does a call to '<tt>void resize(size_type sz)</tt>' of <tt>std::vector</tt> require
++the element type to be <tt>DefaultConstructible</tt>? If yes, why such
++requirement is not listed in the <i>Requires</i> paragraph?
++</p></li>
++<li><p>
++Does a call to '<tt>void resize(size_type sz)</tt>' of <tt>std::vector</tt> require
++the element type to be <tt>MoveAssignable</tt> because the call <tt>erase(begin() + sz, end())</tt>
++mentioned in the <i>Effects</i> paragraph would require the element type to be <tt>MoveAssignable</tt>?
++</p></li>
++<li><p>
++Why <tt>CopyInsertable</tt> requirement is used for '<tt>void resize(size_type sz)</tt>' of <tt>std::vector</tt>
++instead of <tt>MoveInsertable</tt> requirement?
++</p></li>
++</ol>
++
++<p><i>[2011-06-12: Daniel comments and provides wording]</i></p>
++
++<p>According to my understanding of the mental model of vector (and to some parts for deque) the
++some requirements are missing in the standard as response to above questions:</p>
++<ol>
++<li>The preconditions of <tt>shrink_to_fit</tt> for both <tt>std::vector</tt> and <tt>std::deque</tt>
++should impose the <tt>MoveInsertable</tt> requirements. The reason for this is, that these containers
++can host move-only types. For a container type <tt>X</tt> the C++03 idiom <tt>X(*this).swap(*this)</tt>
++imposes the <tt>CopyInsertable</tt> requirements which would make the function call ill-formed,
++which looks like an unacceptable restriction to me. Assuming the committee decides to support the
++move-only case, further wording has to be added for the situation where such a move-only type could
++throw an exception, because this can leave the object in an unspecified state. This seems consistent
++with the requirements of <tt>reserve</tt>, which seems like a very similar function to me (for
++<tt>vector</tt>). And this brings us smoothly to the following bullet:
++</li>
++
++<li><p>I agree that we are currently missing to specify the preconditions of the <tt>reserve</tt> function.
++My interpretation of the mental model of this function is that it should work for move-only types, which
++seems to be supported by the wording used in 23.3.6.3 [vector.capacity] p2:
++</p>
++<blockquote><p>
++[&hellip;] If an exception is thrown other than by the move constructor of a non-CopyInsertable type,
++there are no effects.
++</p></blockquote>
++<p>
++Given this statement, the appropriate requirement is <tt>MoveInsertable</tt> into the <tt>vector</tt>.
++</p>
++</li>
++
++<li>I agree that <tt>vector::resize(size_type)</tt> misses to list the <tt>DefaultConstructible</tt>
++requirements.
++</li>
++
++<li>Unfortunately the current specification in terms of <tt>erase</tt> implies the <tt>MoveAssignable</tt>
++requirements. I don't think that this implication is intended. This function requires "append" and
++"pop-back" effects, respectively, where the former can be realized in terms of <tt>MoveInsertable</tt>
++requirements. The same fix in regard to using <tt>pop_back</tt> instead of <tt>erase</tt> is necessary
++for the two argument overload of <tt>resize</tt> as well (no <tt>MoveAssignable</tt> is required).
++</li>
++
++<li>The <tt>CopyInsertable</tt> requirement is incorrect and should be <tt>MoveInsertable</tt> instead.</li>
++</ol>
++
++<p>In addition to above mentioned items, the proposed resolution adds a linear complexity bound for
++<tt>shrink_to_fit</tt> and attempts to resolve the related issue <a href="lwg-defects.html#2066">2066</a>.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++<p>
++Note for editor: we do not normally refer to 'linear <i>time</i>' for complexity requirements, but there
++is agreement that any clean-up of such wording is editorial.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Edit 23.3.3.3 [deque.capacity] as indicated [Remark: The suggested change of p4 is
++not redundant, because <tt>CopyInsertable</tt> is not necessarily a refinement of <tt>MoveInsertable</tt>
++in contrast to the fact that <tt>CopyConstructible</tt> is a refinement of <tt>MoveConstructible</tt>]:</p>
++
++<blockquote><pre>
++void resize(size_type sz);
++</pre><blockquote><p>
++-1- <i>Effects</i>: If <tt>sz &lt;= size()</tt>, equivalent to <del><tt>erase(begin() + sz,
++end());</tt></del><ins>calling <tt>pop_back()</tt> <tt>size() - sz</tt> times</ins>. If
++<tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> value-initialized elements to the sequence.
++<p/>
++-2- Requires: <tt>T</tt> shall be <ins><tt>MoveInsertable</tt> into <tt>*this</tt> and</ins> <tt>DefaultConstructible</tt>.
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++void resize(size_type sz, const T&amp; c);
++</pre><blockquote><p>
++-3- <i>Effects</i>: <ins>If <tt>sz &lt;= size()</tt>, equivalent to calling <tt>pop_back()</tt>
++<tt>size() - sz</tt> times. If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> copies of <tt>c</tt>
++to the sequence.</ins>
++</p><blockquote><pre>
++<del>if (sz &gt; size())
++ insert(end(), sz-size(), c);
++else if (sz &lt; size())
++ erase(begin()+sz, end());
++else
++ ; <i>// do nothing</i></del>
++</pre></blockquote>
++<p>
++-4- <i>Requires</i>: <tt>T</tt> shall be <ins><tt>MoveInsertable</tt> into <tt>*this</tt> and</ins>
++<tt>CopyInsertable</tt> into <tt>*this</tt>.
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++void shrink_to_fit();
++</pre><blockquote><p>
++<ins>-?- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: Takes at most linear time in the size of the sequence.</ins>
++<p/>
++-5- <i>Remarks</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce memory use <ins>but does
++not change the size of the sequence</ins>. [ <i>Note</i>: The request is non-binding to allow latitude
++for implementation-specific optimizations. &mdash; <i>end note</i> ]
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.3.6.3 [vector.capacity] as indicated including edits that also resolve <a href="lwg-defects.html#2066">2066</a>
++[Remark: The combined listing of <tt>MoveInsertable</tt> and <tt>CopyInsertable</tt> before p12 is not redundant,
++because <tt>CopyInsertable</tt> is not necessarily a refinement of <tt>MoveInsertable</tt> in contrast to the
++fact that <tt>CopyConstructible</tt> is a refinement of <tt>MoveConstructible</tt>]:</p>
++
++<p>[&hellip;]</p>
++
++<blockquote><pre>
++void reserve(size_type n);
++</pre><blockquote><p>
++<ins>-?- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.</ins>
++<p/>
++-2- <i>Effects</i>: A directive that informs a vector of a planned change in size, so that it can manage the storage
++allocation accordingly. After <tt>reserve()</tt>, <tt>capacity()</tt> is greater or equal to the argument of reserve if
++reallocation happens; and equal to the previous value of <tt>capacity()</tt> otherwise. Reallocation happens
++at this point if and only if the current capacity is less than the argument of <tt>reserve()</tt>. If an exception
++is thrown other than by the move constructor of a non-<tt>CopyInsertable</tt> type, there are no effects.
++<p/>
++-3- <i>Complexity</i>: It does not change the size of the sequence and takes at most linear time in the size of
++the sequence.
++<p/>
++-4- <i>Throws</i>: <tt>length_error</tt> if <tt>n &gt; max_size()</tt>.[footnote 266]
++<p/>
++-5- <i>Remarks</i>: Reallocation invalidates all the references, pointers, and iterators referring to the elements
++in the sequence. It is guaranteed that no reallocation takes place during insertions that happen after
++a call to <tt>reserve()</tt> until the time when an insertion would make the size of the vector greater than
++the value of <tt>capacity()</tt>.
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++void shrink_to_fit();
++</pre><blockquote><p>
++<ins>-?- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: Takes at most linear time in the size of the sequence.</ins>
++<p/>
++-6- <i>Remarks</i>: <tt>shrink_to_fit</tt> is a non-binding request to reduce <tt>capacity()</tt> to <tt>size()</tt>.
++[ <i>Note</i>: The request is non-binding to allow latitude for implementation-specific optimizations. &mdash; <i>end note</i> ]
++<ins>If an exception is thrown other than by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt> there
++are no effects.</ins>
++</p></blockquote></blockquote>
++
++<p>[&hellip;]</p>
++
++<blockquote><pre>
++void resize(size_type sz);
++</pre><blockquote><p>
++-9- <i>Effects</i>: If <tt>sz &lt;= size()</tt>, equivalent to <del><tt>erase(begin() + sz, end());</tt></del><ins>calling
++<tt>pop_back()</tt> <tt>size() - sz</tt> times</ins>. If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt>
++value-initialized elements to the sequence.
++<p/>
++-10- <i>Requires</i>: <tt>T</tt> shall be <tt><del>Copy</del><ins>Move</ins>Insertable</tt> into <tt>*this</tt>
++<ins>and <tt>DefaultConstructible</tt></ins>.
++<p/>
++<ins>-??- <i>Remarks</i>: If an exception is thrown other than by the move constructor of a non-<tt>CopyInsertable</tt>
++<tt>T</tt> there are no effects.</ins>
++</p></blockquote></blockquote>
++
++<blockquote><pre>
++void resize(size_type sz, const T&amp; c);
++</pre><blockquote><p>
++-11- <i>Effects</i>: <ins>If <tt>sz &lt;= size()</tt>, equivalent to calling <tt>pop_back()</tt>
++<tt>size() - sz</tt> times. If <tt>size() &lt; sz</tt>, appends <tt>sz - size()</tt> copies of <tt>c</tt>
++to the sequence.</ins>
++</p><blockquote><pre>
++<del>if (sz &gt; size())
++ insert(end(), sz-size(), c);
++else if (sz &lt; size())
++ erase(begin()+sz, end());
++else
++ ; <i>// do nothing</i></del>
++</pre></blockquote><p>
++<ins>-??- <i>Requires</i>: <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt> and
++<tt>CopyInsertable</tt> into <tt>*this</tt>.</ins>
++<p/>
++-12- <i><del>Requires</del><ins>Remarks</ins></i>: If an exception is thrown other than by the move constructor of a
++non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects.
++</p></blockquote></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2034"></a>2034. Initialization of atomics is misspecified so that it doesn't preserve sequential consistency</h3>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2011-02-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++This violates the core intent of the memory model, as stated in the note in 1.10 [intro.multithread] p. 21.
++</p>
++
++<p>
++This was discovered by Mark Batty, and pointed out in their POPL 2011 paper, "Mathematizing C++ Concurrency",
++section 4, "Sequential consistency of SC atomics". The problem is quite technical, but well-explained in that paper.
++</p>
++
++<p>
++This particular issue was not understood at the time the FCD comments were generated. But it is closely related
++to a number of FCD comments. It should have arisen from
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3224.html#US171">US-171</a>, though that's not
++the actual history.
++</p>
++
++<p>This issue has been under discussion for several months in a group that included a half dozen or so of the
++most interested committee members. The P/R represents a well-considered consensus among us:</p>
++
++<p><i>[2011-03-16: Jens updates wording]</i></p>
++
++
++<blockquote class="note">
++<p>Modify 29.3 [atomics.order] p.3, so that the normative part reads:</p>
++
++<blockquote><p>
++3 There shall be a single total order <i>S</i> on all <tt>memory_order_seq_cst</tt> operations, consistent
++with the &quot;happens before&quot; order and modification orders for all affected locations, such that each
++<tt>memory_order_seq_cst</tt> operation that loads a value observes either the last
++preceding modification according to this order <i>S</i><ins>, <i>A</i> (if any)</ins>, or the result of an operation
++<ins><i>X</i></ins> that <del>is not</del><ins>does not happen before <i>A</i> and that is not</ins> <tt>memory_order_seq_cst</tt>.
++[ <i>Note</i>: Although it is not explicitly required that <i>S</i> include locks, it can always be extended
++to an order that does include lock and unlock operations, since the ordering between those is already included
++in the &quot;happens before&quot; ordering. &mdash; <i>end note</i> ]
++</p></blockquote>
++
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="2037"></a>2037. <tt>atomic</tt> free functions incorrectly specified</h3>
++<p><b>Section:</b> 29.2 [atomics.syn] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-03-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.syn">issues</a> in [atomics.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>In earlier specifications of atomics the template specialization <tt>atomic&lt;<i>integer</i>&gt;</tt>
++was derived from <tt>atomic_integer</tt> (e.g. <tt>atomic&lt;int&gt;</tt> was derived from <tt>atomic_int</tt>),
++and the working draft required free functions such as</p>
++
++<blockquote><pre>
++int atomic_load(const atomic_int*)
++</pre></blockquote>
++
++<p>for each of the <tt>atomic_integer</tt> types. This worked fine with normal function overloading.</p>
++
++<p>For the post-Batavia working draft, N3193 removed the requirement that <tt>atomic&lt;integer&gt;</tt>
++be derived from <tt>atomic_integer</tt> and replaced the free functions taking pointers to
++<tt>atomic_integer</tt> with template functions taking <tt>atomic_type*</tt>, such as</p>
++
++<blockquote><pre>
++template &lt;class T&gt; T atomic_load(const atomic_type*);
++</pre></blockquote>
++
++<p>and a code comment explaining that <tt>atomic_type</tt> can be either <tt>atomic&lt;T&gt;</tt> or a
++named base class of <tt>atomic&lt;T&gt;</tt>. The latter possibility is supposed to allow existing
++implementations based on the previous specification to continue to conform.</p>
++
++<p>From history, this allowance seems to imply that functions like <tt>atomic_load</tt> can be non-template
++free functions, as they were before. The explicit requirements do not allow this, and, by requiring that
++they be templates, make them far more complicated. As the specification is currently written, code that
++uses an implementation that uses a base class would have to provide an explicit template type:</p>
++
++<blockquote><pre>
++atomic&lt;int&gt; my_atomic_int;
++atomic_load&lt;int&gt;(&amp;my_atomic_int);
++</pre></blockquote>
++
++<p>That type argument isn't needed when <tt>atomic_type</tt> is <tt>atomic&lt;T&gt;</tt>, but cautious
++users would always provide it to make their code portable across different implementations of the
++standard library.</p>
++
++<p>One possibility for the implementor would be to do some template meta-programming to infer the type
++<tt>T</tt> when there are no function parameters of type <tt>T</tt>, but without running afoul of the
++prohibition on adding parameters with default values (17.6.5.4 [global.functions]/3).</p>
++
++<p>So the promise that implementations of the previous specification continue to conform has not been
++met. The specification of these free functions should be rewritten to support library code written to
++the previous specification or the vacuous promise should be removed.
++</p>
++
++<p><i>[2011-03-08: Lawrence comments and drafts wording:]</i></p>
++
++
++<p>One of the goals is to permit atomics code to compile under both C and C++. Adding explicit
++template arguments would defeat that goal.
++<p/>
++The intent was to permit the normal function overloads for <tt>atomic_int</tt> when <tt>atomic_int</tt>
++is distinct from <tt>atomic&lt;int&gt;</tt>. That intent was not reflected in the wording.
++</p>
++
++<blockquote class="note">
++<p>Proposed Resolution</p>
++<p>Explicitly permit free functions.</p>
++
++<ol>
++<li>
++<p>Edit within the header <tt>&lt;atomic&gt;</tt> synopsis 29.2 [atomics.syn] as follows:</p>
++
++<blockquote><pre>
++<i>// 29.6.1, general operations on atomic types</i>
++<del><i>// In the following declarations, <em>atomic_type</em> is either</i>
++<i>// </i><code>atomic&lt;T&gt;</code><i> or a named base class for</i> <code>T</code><i> from</i>
++<i>// Table 145 or inferred from</i>
++<i>// Table 146.</i></del>
++<ins><i>// In the following declarations, <em>atomic-type</em> is either</i>
++<i>// </i><code>atomic&lt;T&gt;</code><i> or a named base class for</i> <code>T</code><i> from</i>
++<i>// Table 145 or inferred from</i>
++<i>// Table 146.</i>
++<i>// If it is </i><code>atomic&lt;T&gt;</code><i>, then the declaration is a template
++// declaration prefixed with</i> <code>template &lt;class T&gt;</code></ins>
++<del>template &lt;class T&gt;</del>
++bool atomic_is_lock_free(const volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*);
++<del>template &lt;class T&gt;</del>
++bool atomic_is_lock_free(const <em><del>atomic_type</del><ins>atomic-type</ins></em>*);
++<del>template &lt;class T&gt;</del>
++void atomic_init(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++void atomic_init(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++void atomic_store(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++void atomic_store(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++void atomic_store_explicit(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T, memory_order);
++<del>template &lt;class T&gt;</del>
++void atomic_store_explicit(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T, memory_order);
++<del>template &lt;class T&gt;</del>
++T atomic_load(const volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*);
++<del>template &lt;class T&gt;</del>
++T atomic_load(const <em><del>atomic_type</del><ins>atomic-type</ins></em>*);
++<del>template &lt;class T&gt;</del>
++T atomic_load_explicit(const volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, memory_order);
++<del>template &lt;class T&gt;</del>
++T atomic_load_explicit(const <em><del>atomic_type</del><ins>atomic-type</ins></em>*, memory_order);
++<del>template &lt;class T&gt;</del>
++T atomic_exchange(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++T atomic_exchange(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T);
++<del>template &lt;class T&gt;</del>
++T atomic_exchange_explicit(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T, memory_order);
++<del>template &lt;class T&gt;</del>
++T atomic_exchange_explicit(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T, memory_order);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_weak(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_weak(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_strong(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_strong(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_weak_explicit(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T,
++ memory_order, memory_order);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_weak_explicit(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T.
++ memory_order, memory_order);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare)exchange_strong_explicit(volatile <em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T,
++ memory_order, memory_order);
++<del>template &lt;class T&gt;</del>
++bool atomic_compare_exchange_strong_explicit(<em><del>atomic_type</del><ins>atomic-type</ins></em>*, T*, T,
++ memory_order, memory_order);
++
++<i>// 29.6.2, templated operations on atomic types</i>
++<del><i>// In the following declarations, <em>atomic_type</em> is either
++// </i><code>atomic&lt;T&gt;</code><i> or a named base class for</i> <code>T</code><i> from
++// Table 145 or inferred from
++// Table 146.</i></del>
++template &lt;class T&gt;
++T atomic_fetch_add(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_add(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_add_explicit(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_add_explicit(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_sub(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_sub(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_sub_explicit(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_sub_explicit(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_and(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_and(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_and_explicit(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_and_explicit(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_or(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_or(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_or_explicit(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_or_explicit(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_xor(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_xor(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T);
++template &lt;class T&gt;
++T atomic_fetch_xor_explicit(volatile <del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++template &lt;class T&gt;
++T atomic_fetch_xor_explicit(<del><em>atomic-type</em></del><ins>atomic&lt;T&gt;</ins>*, T, memory_order);
++
++<i>// 29.6.3, arithmetic operations on atomic types</i>
++<ins><i>// In the following declarations, <em>atomic-integral</em> is either
++// </i><code>atomic&lt;T&gt;</code> <i>or a named base class for</i> <code>T</code> <i>from
++// Table 145 or inferred from
++// Table 146.
++// If it is</i> <code>atomic&lt;T&gt;</code><i>,
++// then the declaration is a template specialization declaration prefixed with
++//</i> <code>template &lt;&gt;</code></ins>
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_add(volatile <em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_add(<em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_add_explicit(volatile <em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_add_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_sub(volatile <em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_sub(<em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_sub_explicit(volatile <em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_sub_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_and(volatile <em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_and(<em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_and_explicit(volatile <em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_and_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_or(volatile <em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_or(<em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_or_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_or_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_xor(volatile <em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_xor(<em>atomic-integral</em>*, <em>integral</em>);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_xor_explicit(volatile <em>atomic-integral</em>*, <em>integral</em>, memory_order);
++<del>template &lt;&gt;</del>
++<em>integral</em> atomic_fetch_xor_explicit(<em>atomic-integral</em>*, <em>integral</em>, memory_order);
++</pre></blockquote>
++</li>
++
++<li><p>Edit 29.6.1 [atomics.types.operations.general] paragraph 1+2 as follows:</p>
++
++<blockquote><p>
++-1- The implementation shall provide the <ins>functions and</ins> function templates identified as
++&quot;general operations on atomic types&quot; in 29.2 [atomics.syn].
++<p/>
++-2- In the declarations of these <ins>functions and function</ins> templates, the name <em>atomic-type</em>
++refers to either <tt>atomic&lt;T&gt;</tt> or to a named base class for <tt>T</tt> from Table 145 or
++inferred from Table 146.
++</p>
++</blockquote>
++</li>
++
++<li><p>In 29.6.2 [atomics.types.operations.templ] delete paragraph 2:</p>
++
++<blockquote><p>
++-1- The implementation shall declare but not define the function templates identified as
++&quot;templated operations on atomic types&quot; in 29.2 [atomics.syn].
++<p/>
++<del>-2- In the declarations of these templates, the name <em>atomic-type</em> refers to either
++<tt>atomic&lt;T&gt;</tt> or to a named base class for <tt>T</tt> from Table 145 or
++inferred from Table 146.</del>
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit 29.6.3 [atomics.types.operations.arith] paragraph 1+2 as follows:</p>
++
++<blockquote><p>
++-1- The implementation shall provide the <ins>functions and</ins> function template
++specializations identified as &quot;arithmetic operations on atomic types&quot; in
++29.2 [atomics.syn].
++<p/>
++-2- In the declarations of these <ins>functions and function</ins> template specialization<ins>s</ins>,
++the name <em>integral</em> refers to an integral type and the name <em>atomic-integral</em>
++refers to either <tt>atomic&lt;</tt><em>integral</em><tt>&gt;</tt> or to a named base class for
++<em>integral</em> from Table 145 or inferred from Table 146.
++</p>
++</blockquote>
++</li>
++
++</ol>
++</blockquote>
++
++
++<p><b>Proposed resolution:</b></p><p>
++Resolved 2011-03 Madrid meeting by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3278">N3278</a>
++</p>
++
++
++
++
++<hr>
++<h3><a name="2039"></a>2039. Issues with <tt>std::reverse</tt> and <tt>std::copy_if</tt></h3>
++<p><b>Section:</b> 25.3.1 [alg.copy], 25.3.10 [alg.reverse] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nikolay Ivchenkov <b>Opened:</b> 2011-03-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#alg.copy">active issues</a> in [alg.copy].</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.copy">issues</a> in [alg.copy].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<ol>
++<li><p>In the description of <tt>std::reverse</tt></p>
++<blockquote><p>
++<i>Effects</i>: For each non-negative integer <tt>i &lt;= (last - first)/2</tt>, applies <tt>iter_swap</tt>
++to all pairs of iterators <tt>first + i</tt>, <tt>(last - i) - 1</tt>.
++</p></blockquote>
++<p>
++should be changed to
++</p><blockquote><p>
++<i>Effects</i>: For each non-negative integer <tt>i <strong>&lt;</strong> (last - first)/2</tt>, applies <tt>iter_swap</tt>
++to all pairs of iterators <tt>first + i</tt>, <tt>(last - i) - 1</tt>.
++</p></blockquote><p>
++Here <tt>i</tt> shall be strictly less than <tt>(last - first)/2</tt>.
++</p>
++</li>
++<li><p>In the description of <tt>std::copy_if</tt> <i>Returns</i> paragraph is missing.</p></li>
++</ol>
++
++<p><i>[2011-03-02: Daniel drafts wording]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Modify 25.3.10 [alg.reverse] p. 1 as indicated:</p>
++
++<blockquote><p>
++1 <i>Effects</i>: For each non-negative integer <tt>i &lt;<del>=</del> (last - first)/2</tt>, applies <tt>iter_swap</tt>
++to all pairs of iterators <tt>first + i</tt>, <tt>(last - i) - 1</tt>.
++</p></blockquote>
++</li>
++
++<li><p>Add the following <i>Returns</i> element after 25.3.1 [alg.copy] p. 9:</p>
++
++<blockquote><pre>
++template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
++OutputIterator copy_if(InputIterator first, InputIterator last,
++ OutputIterator result, Predicate pred);
++</pre><blockquote><p>
++8 <i>Requires</i>: The ranges <tt>[first,last)</tt> and <tt>[result,result + (last - first))</tt> shall not overlap.
++<p/>
++9 <i>Effects</i>: Copies all of the elements referred to by the iterator <tt>i</tt> in the range <tt>[first,last)</tt>
++for which <tt>pred(*i)</tt> is true.
++<p/>
++<ins>?? <i>Returns</i>: The end of the resulting range.</ins>
++<p/>
++10 <i>Complexity</i>: Exactly <tt>last - first</tt> applications of the corresponding predicate.
++<p/>
++11 <i>Remarks</i>: Stable.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2041"></a>2041. Stage 2 accumulate incompatibilty</h3>
++<p><b>Section:</b> 22.4.2.1.2 [facet.num.get.virtuals] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-03-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#facet.num.get.virtuals">active issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.get.virtuals">issues</a> in [facet.num.get.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><tt>num_get</tt> Stage 2 accumulation changed between C++03 and the current C++0x working draft. The sentences:</p>
++
++<blockquote><p>
++If it is not discarded, then a check is made to determine if <tt>c</tt> is allowed as the
++next character of an input field of the conversion specifier returned by stage 1.
++If so it is accumulated.
++</p></blockquote>
++
++<p>have been dropped from 22.4.2.1.2 [facet.num.get.virtuals], Stage 2, paragraph 3 that begins:</p>
++
++<blockquote><p>
++If <tt>discard</tt> is true, [&hellip;]
++</p></blockquote>
++
++<p>Consider this code:</p>
++
++<blockquote><pre>
++#include &lt;sstream&gt;
++#include &lt;iostream&gt;
++
++int main(void)
++{
++ std::istringstream s("8cz");
++ long i = 0;
++ char c;
++ s &gt;&gt; i;
++ if (!s.fail())
++ std::cout &lt;&lt; "i = " &lt;&lt; i &lt;&lt; '\n';
++ else
++ {
++ std::cout &lt;&lt; "s &gt;&gt; i failed\n";
++ s.clear();
++ }
++ s &gt;&gt; c;
++ if (!s.fail())
++ std::cout &lt;&lt; "c = " &lt;&lt; c &lt;&lt; '\n';
++ else
++ std::cout &lt;&lt; "s &gt;&gt; c failed\n";
++}
++</pre></blockquote>
++
++<p>C++0x currently prints out:</p>
++
++<blockquote><pre>
++s &gt;&gt; i failed
++c = z
++</pre></blockquote>
++
++<p>However C++03 conforming implementations will output:</p>
++
++<blockquote><pre>
++i = 8
++c = c
++</pre></blockquote>
++
++<p>I believe we need to restore C++03 compatibility.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>Add to 22.4.2.1.2 [facet.num.get.virtuals], Stage 2:</p>
++
++<blockquote><p>
++If <tt>discard</tt> is true, then if <tt>'.'</tt> has not yet been accumulated, then the position of the character
++is remembered, but the character is otherwise ignored. Otherwise, if <tt>'.'</tt> has already been
++accumulated, the character is discarded and Stage 2 terminates. <ins>If it is not discarded, then a
++check is made to determine if <tt>c</tt> is allowed as the next character of an input field of the
++conversion specifier returned by stage 1. If so it is accumulated.</ins>
++<p/>
++If the character is either discarded or accumulated then in is advanced by <tt>++in</tt> and processing
++returns to the beginning of stage 2.
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2042"></a>2042. Comparing <tt>forward_list::before_begin()</tt> to <tt>forward_list::end()</tt></h3>
++<p><b>Section:</b> 23.3.4.3 [forwardlist.iter] <b>Status:</b> <a href="lwg-active.html#C++11">C++11</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2011-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++11">C++11</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>For an object <tt>c</tt> of type <tt>forward_list&lt;X, Alloc&gt;</tt>, the iterators
++<tt>c.before_begin()</tt> and <tt>c.end()</tt> are part of the same underlying sequence,
++so the expression <tt>c.before_begin() == c.end()</tt> must be well-defined.
++But the standard says nothing about what the result of this expression
++should be. The forward iterator requirements says no dereferenceable
++iterator is equal to a non-dereferenceable iterator and that two
++dereferenceable iterators are equal if and only if they point to the
++same element. But since <tt>before_begin()</tt> and <tt>end()</tt> are both
++non-dereferenceable, neither of these rules applies.
++</p>
++
++<p>
++Many <tt>forward_list</tt> methods, such as <tt>insert_after()</tt>, have a
++precondition that the iterator passed to them must not be equal to
++<tt>end()</tt>. Thus, user code might look like the following:
++</p>
++<blockquote><pre>
++void foo(forward_list&lt;int&gt;&amp; c, forward_list&lt;int&gt;::iterator it)
++{
++ assert(it != c.end());
++ c.insert_after(it, 42);
++}
++</pre></blockquote>
++
++<p>
++Conversely, <tt>before_begin()</tt> was specifically designed to be used with
++methods like <tt>insert_after()</tt>, so if <tt>c.before_begin()</tt> is passed to
++this function the assertion must not fail.
++</p>
++
++<p><i>[2011-03-14: Daniel comments and updates the suggested wording]</i></p>
++
++
++<p>The suggested wording changes are necessary but not sufficient. Since there
++does not exist an equivalent semantic definition of <tt>cbefore_begin()</tt> as
++we have for <tt>cbegin()</tt>, this still leaves the question open whether
++the normative remark applies to <tt>cbefore_begin()</tt> as well. A simple fix
++is to define the operational semantics of <tt>cbefore_begin()</tt> in terms of
++<tt>before_begin()</tt>.</p>
++
++<p><i>[2011-03-24 Madrid meeting]</i></p>
++
++
++<p>
++General agreement that this is a serious bug.
++<p/>
++Pablo: Any objections to moving 2042 to Immediate?
++<p/>
++No objections.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>Add to the definition of <tt>forward_list::before_begin()</tt> 23.3.4.3 [forwardlist.iter]
++the following:</p>
++
++<blockquote><pre>
++iterator before_begin();
++const_iterator before_begin() const;
++const_iterator cbefore_begin() const;
++</pre><blockquote><p>
++-1- <i>Returns</i>: A non-dereferenceable iterator that, when incremented, is equal to the iterator returned by <tt>begin()</tt>.
++<p/>
++<ins>-?- <i>Effects</i>: <tt>cbefore_begin()</tt> is equivalent to <tt>const_cast&lt;forward_list const&amp;>(*this).before_begin()</tt>.</ins>
++<p/>
++<ins>-?- <i>Remarks</i>: <tt>before_begin() == end()</tt> shall equal false.</ins>
++</p></blockquote></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2044"></a>2044. No definition of "Stable" for copy algorithms</h3>
++<p><b>Section:</b> 17.6.5.7 [algorithm.stable] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2011-03-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++17.6.5.7 [algorithm.stable] specified the meaning of "stable" when applied to
++the different types of algorithms. The second bullet says:
++</p>
++<blockquote><p>
++&mdash; For the <i>remove</i> algorithms the relative order of the elements that are not removed is preserved.
++</p></blockquote>
++
++<p>
++There is no description of what "stable" means for copy algorithms, even though the term is
++applied to <tt>copy_if</tt> (and perhaps others now or in the future). Thus, <tt>copy_if</tt>
++is using the term without a precise definition.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>In 17.6.5.7 [algorithm.stable] p. 1 change as indicated:</p>
++
++<blockquote><p>
++When the requirements for an algorithm state that it is “stable” without further elaboration, it means:
++</p>
++<ul>
++<li>For the <i>sort</i> algorithms the relative order of equivalent elements is preserved.</li>
++<li>For the <i>remove</i> <ins>and <i>copy</i></ins> algorithms the relative order of the elements that are
++not removed is preserved.</li>
++<li>For the <i>merge</i> algorithms, for equivalent elements in the original two ranges, the elements from the
++first range precede the elements from the second range.</li>
++</ul>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2045"></a>2045. <tt>forward_list::merge</tt> and <tt>forward_list::splice_after</tt> with unequal allocators</h3>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2011-03-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++See also: <a href="lwg-defects.html#1215">1215</a>
++</p>
++
++<p>
++<tt>list::merge</tt> and <tt>list::splice</tt> have the requirement that the two lists being merged or
++spliced must use the same allocator. Otherwise, moving list nodes from one container to the other would
++corrupt the data structure. The same requirement is needed for <tt>forward_list::merge</tt> and
++<tt>forward_list::splice_after</tt>.
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>In 23.3.4.6 [forwardlist.ops] p. 1 change as indicated:</p>
++
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x);
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++</pre><p>
++1 - <i>Requires</i>: <tt>position</tt> is <tt>before_begin()</tt> or is a dereferenceable
++iterator in the range [<tt>begin()</tt>,<tt>end()</tt>). <ins><tt>get_allocator() == x.get_allocator()</tt>.</ins>
++<tt>&amp;x != this</tt>.
++</p></blockquote>
++
++</li>
++
++<li><p>In 23.3.4.6 [forwardlist.ops] p. 5 change as indicated:</p>
++
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x, const_iterator i);
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x, const_iterator i);
++</pre><p>
++5 - <i>Requires</i>: <tt>position</tt> is <tt>before_begin()</tt> or is a dereferenceable
++iterator in the range [<tt>begin()</tt>,<tt>end()</tt>). The iterator following <tt>i</tt> is a
++dereferenceable iterator in <tt>x</tt>. <ins><tt>get_allocator() == x.get_allocator()</tt>.</ins>
++</p></blockquote>
++
++</li>
++
++<li><p>In 23.3.4.6 [forwardlist.ops] p. 9 change as indicated:</p>
++
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x,
++ const_iterator first, const_iterator last);
++void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x,
++ const_iterator first, const_iterator last);
++</pre><p>
++9 - <i>Requires</i>: <tt>position</tt> is <tt>before_begin()</tt> or is a dereferenceable
++iterator in the range [<tt>begin()</tt>,<tt>end()</tt>). (<tt>first</tt>,<tt>last</tt>) is a valid range
++in <tt>x</tt>, and all iterators in the range (<tt>first</tt>,<tt>last</tt>) are dereferenceable.
++<tt>position</tt> is not an iterator in the range (<tt>first</tt>,<tt>last</tt>).
++<ins><tt>get_allocator() == x.get_allocator()</tt>.</ins>
++</p></blockquote>
++
++</li>
++
++<li><p>In 23.3.4.6 [forwardlist.ops] p. 18 change as indicated:</p>
++
++<blockquote><pre>
++void merge(forward_list&lt;T,Allocator&gt;&amp; x);
++void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp; x, Compare comp);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);
++</pre><p>
++18 - <i>Requires</i>: <tt>comp</tt> defines a strict weak ordering ([alg.sorting]), and <tt>*this</tt>
++and <tt>x</tt> are both sorted according to this ordering. <ins><tt>get_allocator() == x.get_allocator()</tt>.</ins>
++</p></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2047"></a>2047. Incorrect "mixed" move-assignment semantics of <tt>unique_ptr</tt></h3>
++<p><b>Section:</b> 20.8.1.2.3 [unique.ptr.single.asgn] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-04-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.asgn">issues</a> in [unique.ptr.single.asgn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The semantics described in 20.8.1.2.3 [unique.ptr.single.asgn] p. 6</p>
++<blockquote><p>
++<i>Effects</i>: Transfers ownership from <tt>u</tt> to <tt>*this</tt> as if [&hellip;] followed
++by an assignment from <tt>std::forward&lt;D&gt;(u.get_deleter())</tt>.
++</p></blockquote>
++<p>
++contradicts to the pre-conditions described in p. 4:
++</p>
++<blockquote><p>
++<i>Requires</i>: If E is not a reference type, assignment of the deleter from an rvalue of type <tt>E</tt> shall be
++well-formed and shall not throw an exception. Otherwise, <tt>E</tt> is a reference type and assignment of the
++deleter from an lvalue of type <tt>E</tt> shall be well-formed and shall not throw an exception.
++</p></blockquote>
++<p>
++Either the pre-conditions are incorrect or the semantics should be an assignment from
++<tt>std::forward&lt;<span style="color:red;font-weight:bolder">E</span>&gt;(u.get_deleter())</tt>, instead.
++</p>
++<p>It turns out that this contradiction is due to an incorrect transcription from the proposed
++resolution of <a href="lwg-defects.html#983">983</a> to the finally accepted proposal
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3073.html">n3073</a> (see
++bullet 12) as confirmed by Howard Hinnant, thus the type argument provided to <tt>std::forward</tt>
++must be fixed as indicated.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Edit 20.8.1.2.3 [unique.ptr.single.asgn] p. 6 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;
++</pre><blockquote><p>
++4 - <i>Requires</i>: If <tt>E</tt> is not a reference type, assignment of the deleter from an rvalue
++of type <tt>E</tt> shall be well-formed and shall not throw an exception. Otherwise, <tt>E</tt> is a
++reference type and assignment of the deleter from an lvalue of type <tt>E</tt> shall be well-formed and
++shall not throw an exception.
++<p/>
++5 - <i>Remarks</i>: This operator shall not participate in overload resolution unless:</p>
++<ul>
++<li><tt>unique_ptr&lt;U, E&gt;::pointer</tt> is implicitly convertible to <tt>pointer</tt> and</li>
++<li><tt>U</tt> is not an array type.</li>
++</ul>
++<p>
++6 - <i>Effects</i>: Transfers ownership from <tt>u</tt> to <tt>*this</tt> as if by calling
++<tt>reset(u.release())</tt> followed by an assignment from <tt>std::forward&lt;<del>D</del><ins>E</ins>&gt;(u.get_deleter())</tt>.
++<p/>
++7 - <i>Returns</i>: <tt>*this</tt>.
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2048"></a>2048. Unnecessary <tt>mem_fn</tt> overloads</h3>
++<p><b>Section:</b> 20.9 [function.objects], 20.9.11 [func.memfn] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-04-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>mem_fn</tt> overloads for member functions are redundant and misleading
++and should be removed from the post-C++11 WP.
++<p/>
++I believe the history of the overloads is as follows:
++<p/>
++In TR1 and in C++0x prior to the N2798 draft, <tt>mem_fn</tt> was specified by
++a single signature:
++</p>
++<blockquote><pre>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::* pm);
++</pre></blockquote>
++<p>
++and was accompanied by the remark "Implementations may implement <tt>mem_fn</tt>
++as a set of overloaded function templates." This remark predates variadic templates
++and was presumably to allow implementations to provide overloads for a limited
++number of function parameters, to meet the implementation-defined limit on numbers of
++template parameters.
++<p/>
++N2770 "Concepts for the C++0x Standard Library: Utilities" added
++separate overloads for pointers to member functions, apparently so
++that function parameters would require the <tt>CopyConstructible</tt> concept
++(those overloads first appeared in N2322.) The overloads failed to
++account for varargs member functions (i.e. those declared with an
++ellipsis in the parameter-declaration-clause) e.g.
++</p>
++<blockquote><pre>
++struct S {
++ int f(int, ...);
++};
++</pre></blockquote>
++<p>
++Syntactically such a function would be handled by the original
++<tt>mem_fn(R T::* pm)</tt> signature, the only minor drawback being that there
++would be no <tt>CopyConstructible</tt> requirement on the parameter list. (Core
++DR 547 clarifies that partial specializations can be written to match
++cv-qualified and ref-qualified functions to support the case where <tt>R T::*</tt>
++matches a pointer to member function type.)
++<p/>
++LWG issue <a href="lwg-defects.html#920">920</a> pointed out that additional overloads were missing for
++member functions with ref-qualifiers. These were not strictly
++necessary, because such functions are covered by the <tt>mem_fn(R T::* pm)</tt> signature.
++<p/>
++Concepts were removed from the draft and N3000 restored the original
++single signature and accompanying remark.
++<p/>
++LWG <a href="lwg-closed.html#1230">1230</a> was opened to strike the remark again and to add an overload
++for member functions (this overload was unnecessary for syntactic reasons and
++insufficient as it didn't handle member functions with cv-qualifiers and&#47;or
++ref-qualifiers.)
++<p/>
++<a href="lwg-defects.html#920">920</a> (and <a href="lwg-closed.html#1230">1230</a>) were resolved by restoring a full set of
++(non-concept-enabled) overloads for member functions with cv-qualifiers and ref-qualifiers,
++but as in the concept-enabled draft there were no overloads for member functions with
++an ellipsis in the parameter-declaration-clause. This is what is present in the FDIS.
++<p/>
++Following the thread beginning with message c++std-lib-30675, it is my
++understanding that all the <tt>mem_fn</tt> overloads for member functions are
++unnecessary and were only ever added to allow concept requirements.
++I'm not aware of any reason implementations cannot implement <tt>mem_fn</tt> as
++a single function template. Without concepts the overloads are
++redundant, and the absence of overloads for varargs functions can be
++interpreted to imply that varargs functions are not intended to work
++with <tt>mem_fn</tt>. Clarifying the intent by adding overloads for varargs
++functions would expand the list of 12 redundant overloads to 24, it
++would be much simpler to remove the 12 redundant overloads entirely.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Review.
++</p>
++
++<p>
++The issue and resolution appear to be correct, but there is some concern that the wording of INVOKE may be different depending on whether you pass a pointer-to-member-data or pointer-to-member-function. That might make the current wording necessary after all, and then we might need to add the missing elipsis overloads.
++</p>
++
++<p>
++There was some concern that the Remark confirming implementors had freedom to implement this as a set of overloaded functions may need to be restored if we delete the specification for these overloads.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tentatively Ready by the post-Kona issues processing subgroup.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change the <tt>&lt;functional&gt;</tt> synopsis 20.9 [function.objects] p. 2 as follows:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ // <i>[func.memfn], member function adaptors:</i>
++ template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::*);
++<del> template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...));
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) volatile);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) &amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const &amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) volatile &amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile &amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) &amp;&amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const &amp;&amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) volatile &amp;&amp;);
++ template&lt;class R, class T, class... Args&gt;
++ <i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile &amp;&amp;);</del>
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 20.9.11 [func.memfn] as follows:</p>
++
++<blockquote><pre>
++template&lt;class R, class T&gt; <i>unspecified</i> mem_fn(R T::*);
++<del>template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...));
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) volatile);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) &amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const &amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) volatile &amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile &amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) &amp;&amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const &amp;&amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) volatile &amp;&amp;);
++template&lt;class R, class T, class... Args&gt;
++<i>unspecified</i> mem_fn(R (T::*)(Args...) const volatile &amp;&amp;);</del>
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2049"></a>2049. <tt>is_destructible</tt> is underspecified</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-04-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The conditions for the type trait <tt>is_destructible</tt> to be true
++are described in Table 49 &mdash; Type property predicates:</p>
++<blockquote><p>
++For a complete type <tt>T</tt> and given<br/>
++<tt>template &lt;class U&gt;
++struct test { U u; };</tt>,<br/>
++<tt>test&lt;T&gt;::~test()</tt> is not deleted.
++</p></blockquote>
++
++<p>This specification does not say what the result would be for function
++types or for abstract types:</p>
++<ol>
++<li>For an abstract type <tt>X</tt> the instantiation <tt>test&lt;X&gt;</tt>
++is already ill-formed, so we cannot say anything about whether the destructor
++would be deleted or not.</li>
++<li>In regard to function types, there exists a special rule in the core language, 14.3.1 [temp.arg.type] p. 3,
++which excludes member functions to be declared via the type of the template parameter:
++<blockquote><p>
++If a declaration acquires a function type through a type dependent on a <i>template-parameter</i>
++and this causes a declaration that does not use the syntactic form of a function declarator
++to have function type, the program is ill-formed.
++<p/>
++[ <i>Example</i>:</p>
++<blockquote><pre>
++template&lt;class T&gt; struct A {
++ static T t;
++};
++typedef int function();
++A&lt;function&gt; a; // ill-formed: would declare A&lt;function&gt;::t
++ // as a static member function
++</pre></blockquote>
++<p>
++&mdash; <i>end example</i> ]
++</p></blockquote>
++which has the same consequence as for abstract types, namely that the corresponding
++instantiation of <tt>test</tt> is already ill-formed and we cannot say anything
++about the destructor.
++</li>
++</ol>
++<p>To solve this problem, I suggest to specify function types as trivially and nothrowing
++destructible, because above mentioned rule is very special for templates. For non-templates,
++a typedef can be used to introduce a member as member function as clarified in 8.3.5 [dcl.fct]
++p. 10.</p>
++<p>For abstract types, two different suggestions have been brought to my attention:
++Either declare them as unconditionally non-destructible or check whether the expression
++</p>
++<blockquote><pre>
++std::declval&lt;T&amp;&gt;().~T()
++</pre></blockquote>
++<p>is well-formed in an unevaluated context. The first solution is very easy to specify,
++but the second version has the advantage for providing more information to user-code. This
++information could be quite useful, if generic code is supposed to invoke the destructor
++of a reference to a base class indirectly via a delete expression, as suggested by
++Howard Hinnant:</p>
++<blockquote><pre>
++template &lt;class T&gt;
++my_pointer&lt;T&gt;::~my_pointer() noexcept(is_nothrow_destructible&lt;T&gt;::value)
++{
++ delete ptr_;
++}
++</pre></blockquote>
++<p>Additional to the <tt>is_destructible</tt> traits, its derived forms <tt>is_trivially_destructible</tt>
++and <tt>is_nothrow_destructible</tt> are similarly affected, because their wording refers to "the indicated
++destructor" and probably need to be adapted as well.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++After discussion about to to handle the exceptional cases of reference types, function types (available by defererencing a function pointer)
++and <tt>void</tt> types, Howard supplied proposed wording.
++</p>
++
++<p><i>[
++2011-08-20 Daniel comments and provides alternatives wording
++]</i></p>
++
++
++<p>
++The currently proposed wording would have the consequence that
++<em>every</em> array type is not destructible, because the pseudo-destructor
++requires a scalar type with the effect that the expression
++</p><blockquote><pre>
++std::declval&lt;T&amp;&gt;().~T()
++</pre></blockquote><p>
++is not well-formed for e.g. <tt>T</tt> equal to <tt>int[3]</tt>. The intuitive
++solution to fix this problem would be to adapt the object type case to refer to
++the expression
++</p><blockquote><pre>
++std::declval&lt;U&amp;&gt;().~U()
++</pre></blockquote><p>
++with <tt>U</tt> equal to <tt>remove_all_extents&lt;T&gt;::type</tt>, but that
++would have the effect that arrays of unknown bounds would be destructible, if
++the element type is destructible, which was not the case before (This was
++intentionally covered by the special "For a complete type T" rule in
++the FDIS).
++<p/>
++Suggestion: Use the following definition instead:
++</p>
++<blockquote><p>
++Let <tt>U</tt> be <tt>remove_all_extents&lt;T&gt;::type</tt>.<br/>
++For incomplete types and function types, <tt>is_destructible&lt;T&gt;::value</tt> is <tt>false</tt>.<br/>
++For object types, if the expression <tt>std::declval&lt;U&amp;&gt;().~U()</tt> is well-formed<br/>
++when treated as an unevaluated operand (Clause 5), then <tt>is_destructible&lt;T&gt;::value</tt><br/>
++is <tt>true</tt>, otherwise it is <tt>false</tt>.<br/>
++For reference types, <tt>is_destructible&lt;T&gt;::value</tt> is <tt>true</tt>.
++</p></blockquote>
++<p>
++This wording also harmonizes with the "unevaluated operand" phrase
++used in other places, there does not exist the definition of an
++"unevaluated context"
++<p/>
++<em>Note:</em> In the actually proposed wording this wording has been slightly reordered with the same effects.
++</p>
++
++<p><strong>Howard's (old) proposed resolution:</strong></p>
++<blockquote class="note">
++<p>
++Update 20.10.4.3 [meta.unary.prop], table 49:
++</p>
++
++<table border="1">
++<tr>
++<td><tt>template &lt;class T&gt;
++struct is_destructible;</tt></td>
++<td>
++<del>For a complete type <tt>T</tt> and given <tt>template &lt;class U&gt; struct test { U u; };</tt>, <tt>test&lt;T&gt;::~test()</tt> is not deleted.
++</del>
++<br/>
++<ins>
++For object types, if the expression: <tt>std::declval&lt;T&amp;>().~T()</tt> is well-formed in an unevaluated context then
++<tt>is_destructible&lt;T>::value</tt> is <tt>true</tt>, otherwise it is <tt>false</tt>.
++<br/>
++For <tt>void</tt> types, <tt>is_destructible&lt;T>::value</tt> is <tt>false</tt>.
++<br/>
++For reference types, <tt>is_destructible&lt;T>::value</tt> is <tt>true</tt>.
++<br/>
++For function types, <tt>is_destructible&lt;T>::value</tt> is <tt>false</tt>.
++</ins>
++</td>
++<td><tt>T</tt> shall be a complete type, (possibly cv-qualified) <tt>void</tt>, or an array of unknown bound.</td>
++</tr>
++</table>
++</blockquote>
++<p>
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tentatively Ready by the post-Kona issues processing subgroup.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Update 20.10.4.3 [meta.unary.prop], table 49:
++</p>
++
++<table border="1">
++<tr>
++<td><tt>template &lt;class T&gt;
++struct is_destructible;</tt></td>
++<td>
++<del>For a complete type <tt>T</tt> and given <tt>template &lt;class U&gt; struct test { U u; };</tt>, <tt>test&lt;T&gt;::~test()</tt> is not deleted.
++</del>
++<br/>
++<ins>
++For reference types, <tt>is_destructible&lt;T&gt;::value</tt> is <tt>true</tt>.<br/>
++For incomplete types and function types, <tt>is_destructible&lt;T&gt;::value</tt> is <tt>false</tt>.<br/>
++For object types and given <tt>U</tt> equal to <tt>remove_all_extents&lt;T&gt;::type</tt>,<br/>
++if the expression <tt>std::declval&lt;U&amp;&gt;().~U()</tt> is well-formed when treated as an<br/>
++unevaluated operand (Clause 5 [expr]), then <tt>is_destructible&lt;T&gt;::value</tt> is <tt>true</tt>,<br/>
++otherwise it is <tt>false</tt>.<br/>
++</ins>
++</td>
++<td><tt>T</tt> shall be a complete type, (possibly cv-qualified) <tt>void</tt>, or an array of unknown bound.</td>
++</tr>
++</table>
++
++
++
++
++
++
++<hr>
++<h3><a name="2050"></a>2050. Unordered associative containers do not use <tt>allocator_traits</tt> to define member types</h3>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Tom Zieberman <b>Opened:</b> 2011-04-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The unordered associative containers define their member types <tt>reference</tt>,
++<tt>const_reference</tt>, <tt>pointer</tt>, <tt>const_pointer</tt> in terms of
++their template parameter <tt>Allocator</tt> (via <tt>allocator_type</tt> typedef). As
++a consequence, only the allocator types, that provide sufficient typedefs, are usable
++as allocators for unordered associative containers, while other containers do not have
++this deficiency. In addition to that, the definitions of said typedefs are different
++from ones used in the other containers. This is counterintuitive and introduces a certain
++level of confusion. These issues can be fixed by defining <tt>pointer</tt> and
++<tt>const_pointer</tt> typedefs in terms of <tt>allocator_traits&lt;Allocator&gt;</tt>
++and by defining <tt>reference</tt> and <tt>const_reference</tt> in terms of
++<tt>value_type</tt> as is done in the other containers.
++</p>
++
++<p><i>[
++2011 Bloomington.
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to the FDIS.</p>
++
++<ul>
++<li><p>Change 23.5.4.1 [unord.map.overview] paragraph 3 as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
++ class unordered_map
++ {
++ public:
++ <i>// types</i>
++ typedef Key key_type;
++ typedef std::pair&lt;const Key, T&gt; value_type;
++ typedef T mapped_type;
++ typedef Hash hasher;
++ typedef Pred key_equal;
++ typedef Allocator allocator_type;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
++ typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
++ typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
++ typedef <i>implementation-defined</i> size_type;
++ typedef <i>implementation-defined</i> difference_type;
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.5.1 [unord.multimap.overview] paragraph 3 as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Key,
++ class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
++ class unordered_multimap
++ {
++ public:
++ <i>// types</i>
++ typedef Key key_type;
++ typedef std::pair&lt;const Key, T&gt; value_type;
++ typedef T mapped_type;
++ typedef Hash hasher;
++ typedef Pred key_equal;
++ typedef Allocator allocator_type;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
++ typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
++ typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
++ typedef <i>implementation-defined</i> size_type;
++ typedef <i>implementation-defined</i> difference_type;
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.6.1 [unord.set.overview] paragraph 3 as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Key,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;Key&gt; &gt;
++ class unordered_set
++ {
++ public:
++ <i>// types</i>
++ typedef Key key_type;
++ typedef Key value_type;
++ typedef Hash hasher;
++ typedef Pred key_equal;
++ typedef Allocator allocator_type;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
++ typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
++ typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
++ typedef <i>implementation-defined</i> size_type;
++ typedef <i>implementation-defined</i> difference_type;
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.7.1 [unord.multiset.overview] paragraph 3 as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Key,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;Key&gt; &gt;
++ class unordered_multiset
++ {
++ public:
++ <i>// types</i>
++ typedef Key key_type;
++ typedef Key value_type;
++ typedef Hash hasher;
++ typedef Pred key_equal;
++ typedef Allocator allocator_type;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::pointer pointer;
++ typedef typename <del>allocator_type</del><ins>allocator_traits&lt;Allocator&gt;</ins>::const_pointer const_pointer;
++ typedef <del>typename allocator_type::reference</del><ins>value_type&amp;</ins> reference;
++ typedef <del>typename allocator_type::const_reference</del><ins>const value_type&amp;</ins> const_reference;
++ typedef <i>implementation-defined</i> size_type;
++ typedef <i>implementation-defined</i> difference_type;
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++</ul>
++
++
++
++
++
++
++<hr>
++<h3><a name="2052"></a>2052. Mixup between <tt>mapped_type</tt> and <tt>value_type</tt> for associative containers</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Marc Glisse <b>Opened:</b> 2011-05-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++(this is basically reopening the first part of issue <a href="lwg-closed.html#2006">2006</a>, as discussed in the thread
++starting at c++std-lib-30698 )
++<p/>
++Section 23.2.4 [associative.reqmts]
++<p/>
++In Table 102, several uses of <tt>T</tt> (which means <tt>mapped_type</tt> here) should
++be <tt>value_type</tt> instead. This is almost editorial. For instance:
++</p>
++<blockquote><pre>
++a_uniq.emplace(args)
++</pre><p>
++<i>Requires</i>: <tt>T</tt> shall be <tt>EmplaceConstructible</tt> into <tt>X</tt> from args.
++<p/>
++<i>Effects</i>: Inserts a <tt>T</tt> object <tt>t</tt> constructed with
++<tt>std::forward&lt;Args&gt;(args)...</tt> if and only if there is no element in the
++container with key equivalent to the key of <tt>t</tt>. The <tt>bool</tt> component of
++the returned pair is true if and only if the insertion takes place, and the iterator component
++of the pair points to the element with key equivalent to the key of <tt>t</tt>.
++</p></blockquote>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Not even an exhaustive list of problem locations. No reason to doubt issue.
++</p>
++<p>
++Pablo agrees to provide wording.
++</p>
++
++<p><i>[
++2011-09-04 Pablo Halpern provides improved wording
++]</i></p>
++
++
++<p><i>[2014-02-15 post-Issaquah session : move to Resolved]</i></p>
++
++<p>
++AJM to replace this note with a 'Resolved By...' after tracking down the exact sequence of events, but clearly resolved in C++14 DIS.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++In both section 23.2.4 [associative.reqmts] Table 102 and 23.2.5 [unord.req], Table 103, make the following text replacements:
++</p>
++
++<table border="1">
++<tr> <td>Original text, in FDIS</td> <td>Replacement text</td> </tr>
++
++<tr>
++<td><tt>T</tt> is CopyInsertable into <tt>X</tt> and <tt>CopyAssignable</tt>.</td>
++<td><tt>value_type</tt> is <tt>CopyInsertable</tt> into <tt>X</tt>, <tt>key_type</tt> is <tt>CopyAssignable</tt>, and
++<tt>mapped_type</tt> is <tt>CopyAssignable</tt> (for containers having a <tt>mapped_type</tt>)</td>
++</tr>
++
++<tr>
++<td><tt>T</tt> is <tt>CopyInsertable</tt></td>
++<td><tt>value_type</tt> is CopyInsertable</td>
++</tr>
++
++<tr>
++<td><tt>T</tt> shall be <tt>CopyInsertable</tt></td>
++<td><tt>value_type</tt> shall be CopyInsertable</td>
++</tr>
++
++<tr>
++<td><tt>T</tt> shall be <tt>MoveInsertable</tt></td>
++<td><tt>value_type</tt> shall be MoveInsertable</td>
++</tr>
++
++<tr>
++<td><tt>T</tt> shall be <tt>EmplaceConstructible</tt></td>
++<td><tt>value_type</tt> shall be EmplaceConstructible</td>
++</tr>
++
++<tr>
++<td><tt>T</tt> object</td>
++<td><tt>value_type</tt> object</td>
++</tr>
++</table>
++
++<p><i>[
++<b>Notes to the editor</b>: The above are carefully selected
++phrases that can be used for global search-and-replace within
++the specified sections without accidentally making changes to
++correct uses <tt>T</tt>.
++]</i></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2053"></a>2053. Errors in <tt>regex</tt> bitmask types</h3>
++<p><b>Section:</b> 28.5 [re.const] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-05-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++When <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3110.html">N3110</a>
++was applied to the WP some redundant "static" keywords were added and one form of initializer
++which isn't valid for enumeration types was replaced with another form of invalid initializer.
++</p>
++
++<p><i>[
++2011 Bloomington.
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Change 28.5.1 [re.synopt] as indicated:</p>
++<blockquote><pre>
++namespace std {
++ namespace regex_constants {
++ typedef <i>T1</i> syntax_option_type;
++ <del>static </del>constexpr syntax_option_type icase = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type nosubs = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type optimize = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type collate = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type ECMAScript = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type basic = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type extended = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type awk = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type grep = <i>unspecified</i> ;
++ <del>static </del>constexpr syntax_option_type egrep = <i>unspecified</i> ;
++ }
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 28.5.2 [re.matchflag] as indicated:</p>
++<blockquote><pre>
++namespace std {
++ namespace regex_constants {
++ typedef <i>T2</i> match_flag_type;
++ <del>static </del>constexpr match_flag_type match_default<del> = 0</del><ins>{};</ins>
++ <del>static </del>constexpr match_flag_type match_not_bol = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_not_eol = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_not_bow = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_not_eow = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_any = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_not_null = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_continuous = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type match_prev_avail = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type format_default<del> = 0</del><ins>{}</ins>;
++ <del>static </del>constexpr match_flag_type format_sed = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type format_no_copy = <i>unspecified</i> ;
++ <del>static </del>constexpr match_flag_type format_first_only = <i>unspecified</i> ;
++ }
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 28.5.3 [re.err] as indicated:</p>
++<blockquote><pre>
++namespace std {
++ namespace regex_constants {
++ typedef <i>T3</i> error_type;
++ <del>static </del>constexpr error_type error_collate = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_ctype = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_escape = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_backref = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_brack = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_paren = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_brace = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_badbrace = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_range = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_space = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_badrepeat = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_complexity = <i>unspecified</i> ;
++ <del>static </del>constexpr error_type error_stack = <i>unspecified</i> ;
++ }
++}
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2054"></a>2054. <tt>time_point</tt> constructors need to be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 20.12.6 [time.point] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2011-05-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 20.12.6 [time.point], <tt>time_point::min()</tt> and <tt>time_point::max()</tt>
++are listed as <tt>constexpr</tt>. However, <tt>time_point</tt> has no <tt>constexpr</tt> constructors,
++so is not a literal type, and so these functions cannot be <tt>constexpr</tt> without adding a
++<tt>constexpr</tt> constructor for implementation purposes.
++<p/>
++Proposed resolution: Add <tt>constexpr</tt> to the constructors of <tt>time_point</tt>. The effects of
++the constructor template basically imply that the member function <tt>time_since_epoch()</tt> is
++intended to be <tt>constexpr</tt> as well.
++</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++Resolved by adopting paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3469">n3469</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Alter the class template definition in 20.12.6 [time.point] as follows:</p>
++<blockquote><pre>
++template &lt;class Clock, class Duration = typename Clock::duration&gt;
++class time_point {
++ [&hellip;]
++public:
++ <i>// 20.11.6.1, construct:</i>
++ <ins>constexpr</ins> time_point(); <i>// has value epoch</i>
++ <ins>constexpr</ins> explicit time_point(const duration&amp; d); <i>// same as time_point() + d</i>
++ template &lt;class Duration2&gt;
++ <ins>constexpr</ins> time_point(const time_point&lt;clock, Duration2&gt;&amp; t);
++
++ <i>// 20.11.6.2, observer:</i>
++ <ins>constexpr</ins> duration time_since_epoch() const;
++ [&hellip;]
++};
++</pre></blockquote>
++</li>
++
++<li><p>Alter the declarations in 20.12.6.1 [time.point.cons]:</p>
++<blockquote><pre>
++<ins>constexpr</ins> time_point();
++</pre><blockquote><p>
++-1- <i>Effects</i>: Constructs an object of type <tt>time_point</tt>, initializing <tt>d_</tt> with <tt>duration::zero()</tt>. Such a
++<tt>time_point</tt> object represents the epoch.
++</p></blockquote></blockquote>
++<blockquote><pre>
++<ins>constexpr explicit</ins> time_point(const duration&amp; d);
++</pre><blockquote><p>
++-2- <i>Effects</i>: Constructs an object of type <tt>time_point</tt>, initializing <tt>d_</tt> with <tt>d</tt>. Such a
++<tt>time_point</tt> object represents the epoch <tt>+ d</tt>.
++</p></blockquote></blockquote>
++<blockquote><pre>
++template &lt;class Duration2&gt;
++ <ins>constexpr</ins> time_point(const time_point&lt;clock, Duration2&gt;&amp; t);
++</pre><blockquote><p>
++-3- <i>Remarks</i>: This constructor shall not participate in overload resolution unless <tt>Duration2</tt> is implicitly
++convertible to <tt>duration</tt>.
++<p/>
++-4- <i>Effects</i>: Constructs an object of type <tt>time_point</tt>, initializing <tt>d_</tt> with <tt>t.time_since_epoch()</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li><p>Alter the declaration in 20.12.6.2 [time.point.observer]:</p>
++<blockquote><pre>
++<ins>constexpr</ins> duration time_since_epoch() const;
++</pre><blockquote><p>
++-1- <i>Returns</i>: d_.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2056"></a>2056. <tt>future_errc</tt> enums start with value 0 (invalid value for <tt>broken_promise</tt>)</h3>
++<p><b>Section:</b> 30.6.1 [futures.overview] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2011-05-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.overview">issues</a> in [futures.overview].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 30.6.1 [futures.overview] <tt>enum class future_errc</tt> is defined as follows:
++</p><blockquote><pre>
++enum class future_errc {
++ broken_promise,
++ future_already_retrieved,
++ promise_already_satisfied,
++ no_state
++};
++</pre></blockquote><p>
++With this declaration <tt>broken_promise</tt> has value 0, which means that
++for a <tt>future_error f</tt> with this code
++</p><blockquote><pre>
++f.code().operator bool()
++</pre></blockquote><p>
++yields false, which makes no sense. 0 has to be reserved for "no error".
++So, the enums defined here have to start with 1.
++<p/>
++Howard, Anthony, and Jonathan have no objections.
++</p>
++<p>[Discussion in Bloomington 2011-08-16]
++</p>
++<p>
++Previous resolution:
++</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>In 30.6.1 [futures.overview], header <tt>&lt;future&gt;</tt> synopsis, fix
++the declaration of <tt>future_errc</tt> as follows:</p>
++<blockquote><pre>
++namespace std {
++ enum class future_errc {
++ <del>broken_promise,</del>
++ future_already_retrieved<ins> = 1</ins>,
++ promise_already_satisfied,
++ no_state<ins>,
++ broken_promise</ins>
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++</ol>
++</blockquote>
++<p>
++Is this resolution overspecified? These seem to be all implementation-defined. How do users add new values and not conflict with established error codes?
++</p><p>
++PJP proxy says: over-specified. boo.
++</p><p>
++Other error codes: look for <tt>is_error_code_enum</tt> specializations. Only one exists <tt>io_errc</tt>
++</p><p>
++Peter: I don't see any other parts of the standard that specify error codes where we have to do something similar.
++</p><p>
++Suggest that for every place where we add an error code, the following:
++</p>
++<ol>
++ <li> no zero values
++ </li><li> all implementation defined values, so future_already_retrieved = implementation_defined
++ </li><li> values are distinct
++</li></ol>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tentatively Ready by the post-Kona issues processing subgroup.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<p>In 30.6.1 [futures.overview], header <tt>&lt;future&gt;</tt> synopsis, fix
++the declaration of <tt>future_errc</tt> as follows:</p>
++
++<blockquote><pre>
++namespace std {
++ enum class future_errc {
++ broken_promise<ins> = <var>implementation defined</var></ins>,
++ future_already_retrieved<ins> = <var>implementation defined</var></ins>,
++ promise_already_satisfied<ins> = <var>implementation defined</var></ins>,
++ no_state<ins> = <var>implementation defined</var></ins>
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++<p>In 30.6.1 [futures.overview], header <tt>&lt;future&gt;</tt> synopsis, add a paragraph after paragraph 2 as follows:</p>
++
++<ins>The enum values of <tt>future_errc</tt> are distinct and not zero.</ins>
++
++
++
++
++<hr>
++<h3><a name="2057"></a>2057. <tt>time_point + duration</tt> semantics should be made <tt>constexpr</tt> conforming</h3>
++<p><b>Section:</b> 20.12.6.5 [time.point.nonmember] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-05-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++It has been observed by LWG <a href="lwg-defects.html#2054">2054</a> that the specification of some <tt>time_point</tt> member functions
++already imply that <tt>time_point</tt> needs to be a literal type and suggests to specify the constructors
++and the member function <tt>time_since_epoch()</tt> as <tt>constexpr</tt> functions at the
++minimum necessary. Adding further <tt>constexpr</tt> specifier to other operations should
++clearly be allowed and should probably be done as well. But to allow for further <tt>constexpr</tt>
++functions in the future requires that their semantics is compatible to operations allowed in <tt>constexpr</tt>
++functions. This is already fine for all operations, except this binary plus operator:
++</p>
++<blockquote><pre>
++template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
++time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
++operator+(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++</pre><blockquote><p>
++-1- <i>Returns</i>: <tt>CT(lhs) += rhs</tt>, where <tt>CT</tt> is the type of the return value.
++</p></blockquote></blockquote>
++<p>
++for similar reasons as those mentioned in <a href="lwg-defects.html#2020">2020</a>. The semantics should be fixed to allow
++for making them <tt>constexpr</tt>. This issue should also be considered as a placeholder for a request
++to make the remaining <tt>time_point</tt> operations similarly <tt>constexpr</tt> as had been done for
++<tt>duration</tt>.
++</p>
++
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++Resolved by adopting paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3469">n3469</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>In 20.12.6.5 [time.point.nonmember], p.1 change the <i>Returns</i> element semantics as indicated:</p>
++<blockquote><pre>
++template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
++time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
++operator+(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
++</pre><blockquote><p>
++-1- <i>Returns</i>: <tt><del>CT(lhs) += rhs</del><ins>CT(lhs.time_since_epoch() + rhs)</ins></tt>, where <tt>CT</tt>
++is the type of the return value.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2058"></a>2058. <tt>valarray</tt> and <tt>begin&#47;end</tt></h3>
++<p><b>Section:</b> 26.6 [numarray] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Gabriel Dos Reis <b>Opened:</b> 2011-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#numarray">issues</a> in [numarray].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++It was just brought to my attention that the pair of functions
++<tt>begin&#47;end</tt> were added to <tt>valarray</tt> component.
++Those additions strike me as counter to the long standing agreement
++that <tt>valarray&lt;T&gt;</tt> is not yet another container. Valarray values
++are in general supposed to be treated as a whole, and as such
++has a loose specification allowing expression template techniques.
++<p/>
++The addition of these functions sound to me as making it much harder
++(or close to impossible) to effectively use expression templates
++as implementation techniques, for no clear benefits.
++<p/>
++My recommendation would be to drop <tt>begin&#47;end</tt> - or at least for the
++<tt>const valarray&lt;T&gt;&amp;</tt> version. I strongly believe those
++are defects.
++</p>
++<p><i>[This issue was discussed on the library reflector starting from c++std-lib-30761.
++Some of the key conclusions of this discussion were:]</i></p>
++
++<ol>
++<li>The <tt>begin&#47;end</tt> members were added to allow <tt>valarray</tt> to participate
++in the new range-based for-loop by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html">n2930</a>
++and not to make them container-like.</li>
++<li>It is currently underspecified when the iterator values returned from
++<tt>begin&#47;end</tt> become invalidated. To fix this, these invalidation rules need at
++least to reflect the invalidation rules of the references returned by the
++<tt>operator[]</tt> overloads of <tt>valarray</tt> (26.6.2.4 [valarray.access]).
++</li>
++<li>A further problem is that the requirements expressed in 26.6.1 [valarray.syn] p.3-5
++enforce an implementation to provide further overloads of <tt>begin&#47;end</tt>, if the
++replacement type technique is used (which was clearly part of the design of <tt>valarray</tt>).
++Providing such additional overloads would also lead to life-time problems in examples like
++<tt>begin(x + y)</tt> where <tt>x</tt> and <tt>y</tt> are expressions involving <tt>valarray</tt>
++objects. To fix this, the <tt>begin&#47;end</tt> overloads could be explicitly excluded from the
++general statements of 26.6.1 [valarray.syn] p.3-5. This would make it unspecified
++whether the expression <tt>begin(x + y)</tt> would be well-formed, portable code would
++need to write this as <tt>begin(std::valarray&lt;T&gt;(x + y))</tt>.</li>
++</ol>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++The intent of these overloads is entirely to support the new for syntax, and not to create
++new containers.
++</p>
++
++<p>
++Stefanus provides suggested wording.
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Tenatively Ready by post-meeting issues processing group, after confirmation
++from Gaby.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++In 26.6.1 [valarray.syn]&#47;4, make the following <ins>insertion</ins>:
++</p>
++
++<p>
++4 Implementations introducing such replacement types shall provide additional functions and operators as
++follows:
++</p>
++<ul>
++<li>for every function taking a <tt>const valarray&lt;T&gt;&amp;</tt> <ins>other than <tt>begin</tt> and <tt>end</tt>
++(26.6.10 [valarray.range])</ins>, identical functions taking the replacement types shall be added;
++</li>
++<li>
++for every function taking two <tt>const valarray&lt;T&gt;&amp;</tt> arguments, identical functions taking every combination
++of <tt>const valarray&lt;T&gt;&amp;</tt> and replacement types shall be added.
++</li>
++</ul>
++
++<p>
++In 26.6.10 [valarray.range], make the following <ins>insertion</ins>:
++</p>
++<p>
++1 In the <tt>begin</tt> and <tt>end</tt> function templates that follow, <i>unspecified</i>1 is a type that meets
++the requirements of a mutable random access iterator (24.2.7) whose <tt>value_type</tt> is the template parameter
++<tt>T</tt> and whose <tt>reference</tt> type is <tt>T&amp;</tt>. <i>unspecified</i>2 is a type that meets the
++requirements of a constant random access iterator (24.2.7) whose <tt>value_type</tt> is the template parameter
++<tt>T</tt> and whose <tt>reference</tt> type is <tt>const T&amp;</tt>.
++</p>
++<p><ins>
++2 The iterators returned by <tt>begin</tt> and <tt>end</tt> for an array are guaranteed to be valid until the
++member function <tt>resize(size_t, T)</tt> (26.6.2.8 [valarray.members]) is called for that array or until
++the lifetime of that array ends, whichever happens first.
++</ins></p>
++
++
++
++
++
++<hr>
++<h3><a name="2059"></a>2059. C++0x ambiguity problem with <tt>map::erase</tt></h3>
++<p><b>Section:</b> 23.4.4 [map] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2011-05-18 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#map">issues</a> in [map].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>map::erase</tt> (and several related methods) took an iterator in C++03, but take a <tt>const_iterator</tt>
++in C++0x. This breaks code where the map's <tt>key_type</tt> has a constructor which accepts an iterator
++(for example a template constructor), as the compiler cannot choose between <tt>erase(const key_type&amp;)</tt>
++and <tt>erase(const_iterator)</tt>.</p>
++<blockquote><pre>
++#include &lt;map&gt;
++
++struct X
++{
++ template&lt;typename T&gt;
++ X(T&amp;) {}
++};
++
++bool operator&lt;(const X&amp;, const X&amp;) { return false; }
++
++void erasor(std::map&lt;X,int&gt;&amp; s, X x)
++{
++ std::map&lt;X,int&gt;::iterator it = s.find(x);
++ if (it != s.end())
++ s.erase(it);
++}
++</pre></blockquote>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++This issue affects only associative container <tt>erase</tt> calls, and is not more general, as these are the
++only functions that are also overloaded on another single arguement that might cause confusion - the <tt>erase</tt>
++by key method. The complete resolution should simply restore the <tt>iterator</tt> overload in addition to the
++<tt>const_iterator</tt> overload for all eight associative containers.
++</p>
++
++<p>
++Proposed wording supplied by Alan Talbot, and moved to Review.
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved back to Open by post-meeting issues processing group.
++</p>
++<p>
++Pablo very unhappy about case of breaking code with ambiguous conversion between both iterator types.
++</p>
++<p>
++Alisdair strongly in favor of proposed resolution, this change from C++11 bit Chris in real code,
++and it took a while to track down the cause.
++</p>
++<p>
++Move to open, bring in front of a larger group
++</p>
++<p>
++Proposed wording from Jeremiah:
++
++<tt>erase(key)</tt> shall not participate in overload resolution if <tt>iterator</tt> is
++convertible to <tt>key</tt>.
++
++Note that this means making <tt>erase(key)</tt> a template-method
++</p>
++<p>
++Poll Chris to find out if he already fixed his code, or fixed his library
++</p>
++<p>
++Jeremiah - allow both overloads, but <tt>enable_if</tt> the <tt>const_iterator</tt> form as
++a template, requiring <tt>is_same</tt> to match only <tt>const_iterator</tt>.
++</p>
++<p>
++Poll PJ to see if he has already applied this fix?
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++AM: To summarize, we changed a signature and code broke. At what point do we stop and accept breakage in increasingly obscure code?
++VV: libc++ is still broken, but libstdc++ works, so they've fixed this &mdash; perhaps using this PR? [Checks] Yes, libstdc++
++uses this solution, and has a comment pointing to LWG 2059. AM: This issue hasn't been looked at since Kona. In any case, we
++already have implementation experience now.
++<p/>
++AM: I'd say let's ship it. We already have implementation experience (libstdc++ and MSVS). MC: And "tentatively ready" lets me
++try to implement this and see how it works.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Editorial note: The following things are different between 23.2.4 [associative.reqmts] p.8 and
++23.2.5 [unord.req] p.10. These should probably be reconciled.
++</p>
++<blockquote>
++<ol>
++<li>First uses the convention "denotes"; second uses the convention "is".</li>
++<li>First redundantly says: "If no such element exists, returns a.end()." in erase table entry, second does not.</li>
++</ol>
++</blockquote>
++
++<p>
++23.2.4 [associative.reqmts] Associative containers
++</p>
++<p>
++8 In Table 102, <tt>X</tt> denotes an associative container class, <tt>a</tt> denotes a value of <tt>X</tt>, <tt>a_uniq</tt>
++denotes a value of <tt>X</tt> when <tt>X</tt> supports unique keys, <tt>a_eq</tt> denotes a value of <tt>X</tt> when
++<tt>X</tt> supports multiple keys, <tt>u</tt> denotes an identifier, <tt>i</tt> and <tt>j</tt> satisfy input iterator
++requirements and refer to elements implicitly convertible to <tt>value_type</tt>, <tt>[i,j)</tt> denotes a valid range,
++<tt>p</tt> denotes a valid const iterator to <tt>a</tt>, <tt>q</tt> denotes a valid dereferenceable const iterator to <tt>a</tt>,
++<ins><tt>r</tt> denotes a valid dereferenceable iterator to a,</ins> <tt>[q1, q2)</tt> denotes a valid range of const iterators
++in <tt>a</tt>, <tt>il</tt> designates an object of type <tt>initializer_list&lt;value_type></tt>, <tt>t</tt> denotes a value of
++<tt>X::value_type</tt>, <tt>k</tt> denotes a value of <tt>X::key_type</tt> and <tt>c</tt> denotes a value of type
++<tt>X::key_compare</tt>. <tt>A</tt> denotes the storage allocator used by <tt>X</tt>, if any, or
++<tt>std::allocator&lt;X::value_type></tt> otherwise, and <tt>m</tt> denotes an allocator of a type convertible to <tt>A</tt>.
++</p>
++
++<p>
++23.2.4 [associative.reqmts] Associative containers Table 102
++</p>
++<p>
++Add row:
++</p>
++<ins>
++<table border="1">
++<tr>
++<td><tt>a.erase(r)</tt></td>
++<td><tt>iterator</tt></td>
++<td>
++erases the element pointed to by <tt>r</tt>. Returns an iterator pointing to the element immediately following <tt>r</tt>
++prior to the element being erased. If no such element exists, returns <tt>a.end()</tt>.
++</td>
++<td>amortized constant</td>
++</tr>
++</table>
++</ins>
++
++<p>
++23.2.5 [unord.req] Unordered associative containers</p>
++<p>
++10 In table 103: <tt>X</tt> is an unordered associative container class, <tt>a</tt> is an object of type <tt>X</tt>,
++<tt>b</tt> is a possibly const object of type <tt>X</tt>, <tt>a_uniq</tt> is an object of type <tt>X</tt> when
++<tt>X</tt> supports unique keys, <tt>a_eq</tt> is an object of type <tt>X</tt> when <tt>X</tt> supports equivalent keys,
++<tt>i</tt> and <tt>j</tt> are input iterators that refer to <tt>value_type</tt>, <tt>[i, j)</tt> is a valid range,
++<tt>p</tt> and <tt>q2</tt> are valid const iterators to <tt>a</tt>, <tt>q</tt> and <tt>q1</tt> are valid dereferenceable
++const iterators to <tt>a</tt>, <ins><tt>r</tt> is a valid dereferenceable iterator to a,</ins> <tt>[q1,q2)</tt> is a
++valid range in <tt>a</tt>, <tt>il</tt> designates an object of type <tt>initializer_list&lt;value_type></tt>,
++<tt>t</tt> is a value of type <tt>X::value_type</tt>, <tt>k</tt> is a value of type <tt>key_type</tt>, <tt>hf</tt> is a
++possibly const value of type <tt>hasher</tt>, <tt>eq</tt> is a possibly const value of type <tt>key_equal</tt>,
++<tt>n</tt> is a value of type <tt>size_type</tt>, and <tt>z</tt> is a value of type <tt>float</tt>.
++</p>
++
++<p>
++23.2.5 [unord.req] Unordered associative containers Table 103
++</p>
++<p>
++Add row:
++</p>
++<ins>
++<table border="1">
++<tr>
++<td><tt>a.erase(r)</tt></td>
++<td><tt>iterator</tt></td>
++<td>
++Erases the element pointed to by <tt>r</tt>. Returns the iterator immediately following <tt>r</tt> prior to the erasure.
++</td>
++<td>Average case O(1), worst case O(<tt>a.size()</tt>).</td>
++</tr>
++</table>
++</ins>
++
++<p>
++23.4.4.1 [map.overview] Class template map overview p. 2
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.4.5.1 [multimap.overview] Class template multimap overview p. 2
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.4.6.1 [set.overview] Class template set overview p. 2
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.4.7.1 [multiset.overview] Class template multiset overview
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.5.4.1 [unord.map.overview] Class template unordered_map overview p. 3
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.5.5.1 [unord.multimap.overview] Class template unordered_multimap overview p. 3
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++23.5.6.1 [unord.set.overview] Class template unordered_set overview p. 3
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++
++<p>
++23.5.7.1 [unord.multiset.overview] Class template unordered_multiset overview p. 3
++</p>
++<pre>
++<ins>iterator erase(iterator position);</ins>
++iterator erase(const_iterator position);
++size_type erase(const key_type&amp; x);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++
++<p>
++C.2.13 [diff.cpp03.containers] C.2.12 Clause 23: containers library
++</p>
++<p>
++23.2.3, 23.2.4
++</p>
++<p>
++Change: Signature changes: from iterator to const_iterator parameters
++</p>
++<p>
++Rationale: Overspecification. Effects: The signatures of the following member functions changed from
++taking an iterator to taking a const_iterator:
++</p>
++<ul>
++<li>insert(iter, val) for vector, deque, list, set, multiset, map, multimap</li>
++<li>insert(pos, beg, end) for vector, deque, list, forward_list</li>
++<li><del>erase(iter) for set, multiset, map, multimap</del></li>
++<li>erase(begin, end) for set, multiset, map, multimap</li>
++<li>all forms of list::splice</li>
++<li>all forms of list::merge</li>
++</ul>
++<p>
++Valid C++ 2003 code that uses these functions may fail to compile with this International Standard.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2061"></a>2061. <tt>make_move_iterator</tt> and arrays</h3>
++<p><b>Section:</b> 24.3 [iterator.synopsis], 24.5.3 [move.iterators] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marc Glisse <b>Opened:</b> 2011-05-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.synopsis">issues</a> in [iterator.synopsis].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The standard library always passes template iterators by value and never by reference,
++which has the nice effect that an array decays to a pointer. There is one exception:
++<tt>make_move_iterator</tt>.
++</p>
++<blockquote><pre>
++#include &lt;iterator&gt;
++int main(){
++ int a[]={1,2,3,4};
++ std::make_move_iterator(a+4);
++ std::make_move_iterator(a); // fails here
++}
++</pre></blockquote>
++
++<p><i>[
++2011 Bloomington.
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the header <tt>&lt;iterator&gt;</tt> synopsis in 24.3 [iterator.synopsis]:</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ template &lt;class Iterator&gt;
++ move_iterator&lt;Iterator&gt; make_move_iterator(<del>const Iterator&amp;</del><ins>Iterator</ins> i);
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify the class template <tt>move_iterator</tt> synopsis in 24.5.3.1 [move.iterator]:</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ template &lt;class Iterator&gt;
++ move_iterator&lt;Iterator&gt; make_move_iterator(<del>const Iterator&amp;</del><ins>Iterator</ins> i);
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify 24.5.3.3.14 [move.iter.nonmember]:</p>
++<blockquote><pre>
++template &lt;class Iterator&gt;
++move_iterator&lt;Iterator&gt; make_move_iterator(<del>const Iterator&amp;</del><ins>Iterator</ins> i);
++</pre><blockquote><p>
++-3- <i>Returns</i>: <tt>move_iterator&lt;Iterator&gt;(i)</tt>.
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2063"></a>2063. Contradictory requirements for string move assignment</h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-05-29 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++21.4.1 [string.require]&#47;p4 says that <tt>basic_string</tt> is an "allocator-aware"
++container and behaves as described in 23.2.1 [container.requirements.general].
++<p/>
++23.2.1 [container.requirements.general] describes move assignment in p7 and Table 99.
++<p/>
++If <tt>allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment::value</tt>
++is false, and if the allocators stored in the lhs and rhs sides are not equal, then move
++assigning a string has the same semantics as copy assigning a string as far as resources are
++concerned (resources can not be transferred). And in this event, the lhs may have to acquire
++resources to gain sufficient capacity to store a copy of the rhs.
++<p/>
++However 21.4.2 [string.cons]&#47;p22 says:
++</p><blockquote><pre>
++basic_string&lt;charT,traits,Allocator&gt;&amp;
++operator=(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; str) noexcept;
++</pre><blockquote><p>
++<i>Effects</i>: If <tt>*this</tt> and <tt>str</tt> are not the same object, modifies <tt>*this</tt>
++as shown in Table 71. [<i>Note</i>: A valid implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]
++</p></blockquote></blockquote><p>
++These two specifications for <tt>basic_string::operator=(basic_string&amp;&amp;)</tt> are in conflict with
++each other. It is not possible to implement a <tt>basic_string</tt> which satisfies both requirements.
++<p/>
++Additionally assign from an rvalue <tt>basic_string</tt> is defined as:
++</p><blockquote><pre>
++basic_string&amp; assign(basic_string&amp;&amp; str) noexcept;
++</pre><blockquote><p>
++<i>Effects</i>: The function replaces the string controlled by <tt>*this</tt> with a string of length
++<tt>str.size()</tt> whose elements are a copy of the string controlled by <tt>str</tt>. [ <i>Note</i>: A valid
++implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]
++</p></blockquote></blockquote><p>
++It seems contradictory that this member can be sensitive to <tt>propagate_on_container_swap</tt> instead
++of <tt>propagate_on_container_move_assignment</tt>. Indeed, there is a very subtle chance for undefined
++behavior here: If the implementation implements this in terms of <tt>swap</tt>, and if
++<tt>propagate_on_container_swap</tt> is false, and if the two allocators are unequal, the behavior
++is undefined, and will likely lead to memory corruption. That's a lot to go wrong under a member
++named "assign".
++</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++Alisdair: Can this be conditional <tt>noexcept</tt>?
++</p>
++<p>
++Pablo: We said we were not going to put in many conditional <tt>noexcept</tt>s. Problem is not allocator, but non-normative definition. It says swap is a valid operation which it is not.
++</p>
++<p>
++Dave: Move assignment is not a critical method.
++</p>
++<p>
++Alisdair: Was confusing assignment and construction.
++</p>
++<p>
++Dave: Move construction is critical for efficiency.
++</p>
++<p>
++Kyle: Is it possible to test for <tt>noexcept</tt>.
++</p>
++<p>
++Alisdair: Yes, query the <tt>noexcept</tt> operator.
++</p>
++<p>
++Alisdair: Agreed there is a problem that we cannot unconditionally mark these operations as <tt>noexcept</tt>.
++</p>
++<p>
++Pablo: How come swap is not defined in alloc
++</p>
++<p>
++Alisdair: It is in utility.
++</p>
++<p>
++Pablo: Swap has a conditional <tt>noexcept</tt>. Is no throw move constructable, is no throw move assignable.
++</p>
++<p>
++Pablo: Not critical for strings or containers.
++</p>
++<p>
++Kyle: Why?
++</p>
++<p>
++Pablo: They do not use the default swap.
++</p>
++<p>
++Dave: Important for deduction in other types.
++</p>
++<p>
++Alisdair: Would change the policy we adopted during FDIS mode.
++</p>
++<p>
++Pablo: Keep it simple and get some vendor experience.
++</p>
++<p>
++Alisdair: Is this wording correct? Concerned with bullet 2.
++</p>
++<p>
++Pablo: Where does it reference containers section.
++</p>
++<p>
++Alisdair: String is a container.
++</p>
++<p>
++Alisdair: We should not remove redundancy piecemeal.
++</p>
++<p>
++Pablo: I agree. This is a deviation from rest of string. Missing forward reference to containers section.
++</p>
++<p>
++Pablo: To fix section 2. Only the note needs to be removed. The rest needs to be a forward reference to containers.
++</p>
++<p>
++Alisdair: That is a new issue.
++</p>
++<p>
++Pablo: Not really. Talking about adding one sentence, saying that basic string is a container.
++</p>
++<p>
++Dave: That is not just a forward reference, it is a semantic change.
++</p>
++<p>
++PJ: We intended to make it look like a container, but it did not satisfy all the requirements.
++</p>
++<p>
++Pablo: Clause 1 is correct. Clause 2 is removing note and <tt>noexcept</tt> (do not remove the rest). Clause 3 is correct.
++</p>
++<p>
++Alisdair: Not sure data() is correct (in clause 2).
++</p>
++<p>
++Conclusion: Move to open, Alisdair and Pablo volunteered to provide wording
++</p>
++
++<p><i>[
++originally proposed wording:
++]</i></p>
++
++
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the class template <tt>basic_string</tt> synopsis in 21.4 [basic.string]:</p>
++<blockquote><pre>
++namespace std {
++ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
++ class Allocator = allocator&lt;charT&gt; &gt;
++ class basic_string {
++ public:
++ [&hellip;]
++ basic_string&amp; operator=(basic_string&amp;&amp; str) <del>noexcept</del>;
++ [&hellip;]
++ basic_string&amp; assign(basic_string&amp;&amp; str) <del>noexcept</del>;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Remove the definition of the <tt>basic_string</tt> move assignment operator from 21.4.2 [string.cons]
++entirely, including Table 71 &mdash; <tt>operator=(const basic_string&lt;charT, traits, Allocator&gt;&amp;&amp;)</tt>.
++This is consistent with how we define move assignment for the containers in Clause 23:</p>
++<blockquote><pre>
++<del>basic_string&lt;charT,traits,Allocator&gt;&amp;
++operator=(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; str) noexcept;</del>
++</pre><blockquote><p>
++<del>-22- <i>Effects</i>: If <tt>*this</tt> and <tt>str</tt> are not the same object, modifies <tt>*this</tt> as shown
++in Table 71. [ <i>Note</i>: A valid implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]</del>
++<p/>
++<del>-23- If <tt>*this</tt> and <tt>str</tt> are the same object, the member has no effect.</del>
++<p/>
++<del>-24- <i>Returns</i>: <tt>*this</tt></del>
++</p></blockquote></blockquote>
++<blockquote>
++<table border="1">
++<caption><del>Table 71 &mdash; <tt>operator=(const basic_string&lt;charT, traits, Allocator&gt;&amp;&amp;)</tt></del></caption>
++
++<tr>
++<th><del>Element</del></th>
++<th><del>Value</del></th>
++</tr>
++
++<tr>
++<td><del><tt>data()</tt></del></td>
++<td><del>points at the array whose first element was pointed
++at by <tt>str.data()</tt></del></td>
++</tr>
++
++<tr>
++<td><del><tt>size()</tt></del></td>
++<td><del>previous value of <tt>str.size()</tt></del></td>
++</tr>
++
++<tr>
++<td><del><tt>capacity()</tt></del></td>
++<td><del>a value at least as large as <tt>size()</tt></del></td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>Modify the paragraphs prior to 21.4.6.3 [string::assign] p.3 as indicated (The
++first insertion recommends a separate paragraph number for the indicated paragraph):</p>
++<blockquote><pre>
++basic_string&amp; assign(basic_string&amp;&amp; str) <del>noexcept</del>;
++</pre><blockquote><p>
++<ins>-?-</ins> <i>Effects</i>: <ins>Equivalent to <tt>*this = std::move(str)</tt>.</ins>
++<del>The function replaces the string controlled by <tt>*this</tt> with a string of length
++<tt>str.size()</tt> whose elements are a copy of the string controlled by <tt>str</tt>.
++[ <i>Note</i>: A valid implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]</del>
++<p/>
++-3- <i>Returns</i>: <tt>*this</tt>
++</p></blockquote></blockquote>
++
++</li>
++</ol>
++
++<p><i>[
++2012-08-11 Joe Gottman observes:
++]</i></p>
++
++
++<blockquote>
++<p>
++One of the effects of <tt>basic_string</tt>'s move-assignment operator (21.4.2 [string.cons], Table 71) is
++</p>
++<blockquote>
++
++<table border="1">
++
++<tr>
++<th>Element</th>
++<th>Value</th>
++</tr>
++
++<tr>
++<td><tt>data()</tt></td>
++<td>points at the array whose first element was pointed at by <tt>str.data()</tt></td>
++</tr>
++
++</table>
++
++</blockquote>
++<p>
++If a string implementation uses the small-string optimization and the input string <tt>str</tt> is small enough
++to make use of it, this effect is impossible to achieve. To use the small string optimization, a string has to
++be implemented using something like
++</p>
++<blockquote><pre>
++union
++{
++ char buffer[SMALL_STRING_SIZE];
++ char *pdata;
++};
++</pre></blockquote>
++<p>
++When the string is small enough to fit inside <tt>buffer</tt>, the <tt>data()</tt> member function returns
++<tt>static_cast&lt;const char *&gt;(buffer)</tt>, and since <tt>buffer</tt> is an array variable, there
++is no way to implement move so that the moved-to string's <tt>buffer</tt> member variable is equal to
++<tt>this->buffer</tt>.
++<p/>
++Resolution proposal:
++<p/>
++Change Table 71 to read:
++</p>
++<blockquote>
++
++<table border="1">
++
++<tr>
++<th>Element</th>
++<th>Value</th>
++</tr>
++
++<tr>
++<td><tt>data()</tt></td>
++<td>points at the array <del>whose first element was pointed at by <tt>str.data()</tt></del>
++<ins>that contains the same characters in the same order as <tt>str.data()</tt> contained before
++<tt>operator=()</tt> was called</ins></td>
++</tr>
++
++</table>
++
++</blockquote>
++<blockquote>
++</blockquote>
++</blockquote>
++
++<p><i>[2015-05-07, Lenexa]</i></p>
++
++<p>
++Howard suggests improved wording
++<p/>
++Move to Immediate
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<ol>
++<li><p>Modify the class template <tt>basic_string</tt> synopsis in 21.4 [basic.string]:</p>
++<blockquote><pre>
++namespace std {
++ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
++ class Allocator = allocator&lt;charT&gt; &gt;
++ class basic_string {
++ public:
++ [&hellip;]
++ basic_string&amp; assign(basic_string&amp;&amp; str) noexcept<ins>(
++ allocator_traits&lt;Allocator&gt;::propagate_on_container_move_assignment::value ||
++ allocator_traits&lt;Allocator&gt;::is_always_equal::value)</ins>;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.2 [string.cons]/p21-23:</p>
++<blockquote><pre>
++basic_string&amp;
++operator=(basic_string&amp;&amp; str) noexcept(
++ allocator_traits&lt;Allocator&gt;::propagate_on_container_move_assignment::value ||
++ allocator_traits&lt;Allocator&gt;::is_always_equal::value);
++</pre><blockquote><p>
++-21- <i>Effects</i>: <del>If <tt>*this</tt> and <tt>str</tt> are not the same object, modifies <tt>*this</tt> as shown
++in Table 71. [ <i>Note</i>: A valid implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]</del>
++<ins>Move assigns as a sequence container ([container.requirements]), except that iterators, pointers and references may be invalidated.</ins>
++<p/>
++<del>-22- If <tt>*this</tt> and <tt>str</tt> are the same object, the member has no effect.</del>
++<p/>
++-23- <i>Returns</i>: <tt>*this</tt>
++</p></blockquote></blockquote>
++<blockquote>
++<table border="1">
++<caption><del>Table 71 &mdash; <tt>operator=(basic_string&amp;&amp;)</tt> effects</del></caption>
++
++<tr>
++<th><del>Element</del></th>
++<th><del>Value</del></th>
++</tr>
++
++<tr>
++<td><del><tt>data()</tt></del></td>
++<td><del>points at the array whose first element was pointed
++at by <tt>str.data()</tt></del></td>
++</tr>
++
++<tr>
++<td><del><tt>size()</tt></del></td>
++<td><del>previous value of <tt>str.size()</tt></del></td>
++</tr>
++
++<tr>
++<td><del><tt>capacity()</tt></del></td>
++<td><del>a value at least as large as <tt>size()</tt></del></td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>Modify the paragraphs prior to 21.4.6.3 [string::assign] p.3 as indicated</p>
++<blockquote><pre>
++basic_string&amp; assign(basic_string&amp;&amp; str) noexcept<ins>(
++ allocator_traits&lt;Allocator&gt;::propagate_on_container_move_assignment::value ||
++ allocator_traits&lt;Allocator&gt;::is_always_equal::value)</ins>;
++</pre><blockquote><p>
++-3- <i>Effects</i>: <ins>Equivalent to <tt>*this = std::move(str)</tt>.</ins>
++<del>The function replaces the string controlled by <tt>*this</tt> with a string of length
++<tt>str.size()</tt> whose elements are a copy of the string controlled by <tt>str</tt>.
++[ <i>Note</i>: A valid implementation is <tt>swap(str)</tt>. &mdash; <i>end note</i> ]</del>
++<p/>
++-4- <i>Returns</i>: <tt>*this</tt>
++</p></blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2064"></a>2064. More <tt>noexcept</tt> issues in <tt>basic_string</tt></h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-05-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The following inconsistencies regarding <tt>noexcept</tt> for <tt>basic_string</tt> are noted.
++<p/>
++Member swap is not marked <tt>noexcept</tt>:
++</p><blockquote><pre>
++void swap(basic_string&amp; str);
++</pre></blockquote><p>
++But the global swap is marked <tt>noexcept</tt>:
++</p><blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <span style="color:#C80000;font-weight:bolder">noexcept</span>;
++</pre></blockquote><p>
++But only in the definition, not in the synopsis.
++<p/>
++All comparison operators are marked <tt>noexcept</tt> in their definitions, but not in the synopsis.
++<p/>
++The compare function that takes a pointer:
++</p><blockquote><pre>
++int compare(const charT *s) const;
++</pre></blockquote><p>
++is not marked <tt>noexcept</tt>. But some of the comparison functions which are marked <tt>noexcept</tt>
++(only in their definition) are specified to call the throwing compare operator:
++</p><blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <span style="color:#C80000;font-weight:bolder">noexcept</span>;
++</pre><blockquote><p>
++<i>Returns</i>: <tt>lhs.compare(rhs) == 0</tt>.
++</p></blockquote></blockquote>
++<p>
++All functions with a narrow contract should not be declared as <tt>noexcept</tt> according to
++the guidelines presented in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3279.pdf">n3279</a>.
++Among these narrow contract functions are the <tt>swap</tt> functions (23.2.1 [container.requirements.general] p. 8)
++and functions with non-<tt>NULL</tt> <tt>const charT*</tt> parameters.
++</p>
++<p><i>[2011-06-08 Daniel provides wording]</i></p>
++
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS. Both move-assignment operator and the moving <tt>assign</tt>
++function are not touched by this issue, because they are handled separately by issue <a href="lwg-defects.html#2063">2063</a>.</p>
++<ol>
++<li><p>Modify the header <tt>&lt;string&gt;</tt> synopsis in 21.3 [string.classes] as
++indicated (Rationale: Adding <tt>noexcept</tt> to these specific overloads is in sync with
++applying the same rule to specific overloads of the member functions <tt>find</tt>, <tt>compare</tt>, etc.
++This approach deviates from that taken in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3279.pdf">n3279</a>,
++but seems more consistent given similar application for comparable member functions):</p>
++
++<blockquote><pre>
++#include &lt;initializer_list&gt;
++
++namespace std {
++
++ [&hellip;]
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator&lt;(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator&gt;(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++ template&lt;class charT, class traits, class Allocator&gt;
++ bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <ins>noexcept</ins>;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Modify the class template <tt>basic_string</tt> synopsis in 21.4 [basic.string] as
++indicated (Remark 1: The <tt>noexcept</tt> at the move-constructor is fine, because even for a
++small-object optimization there is no problem here, because <tt>basic_string::value_type</tt>
++is required to be a non-array POD as of 21.1 [strings.general] p1, Remark 2: This
++proposal removes the <tt>noexcept</tt> at single character overloads of <tt>find</tt>, <tt>rfind</tt>,
++etc. because they are defined in terms of potentially allocating functions. It seems like
++an additional issue to me to change the semantics in terms of non-allocating functions and
++adding <tt>noexcept</tt> instead):</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
++ class Allocator = allocator&lt;charT&gt; &gt;
++ class basic_string {
++ public:
++ [&hellip;]
++ <i>// [string.ops], string operations:</i>
++ [&hellip;]
++ size_type find (charT c, size_type pos = 0) const <del>noexcept</del>;
++ [&hellip;]
++ size_type rfind(charT c, size_type pos = npos) const <del>noexcept</del>;
++ [&hellip;]
++ size_type find_first_of(charT c, size_type pos = 0) const <del>noexcept</del>;
++ [&hellip;]
++ size_type find_last_of (charT c, size_type pos = npos) const <del>noexcept</del>;
++ [&hellip;]
++ size_type find_first_not_of(charT c, size_type pos = 0) const <del>noexcept</del>;
++ [&hellip;]
++ size_type find_last_not_of (charT c, size_type pos = npos) const <del>noexcept</del>;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.2 [string::find] before p5 and before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type find(const charT* s, size_type pos = 0) const <del>noexcept</del>;
++[&hellip;]
++size_type find(charT c, size_type pos = 0) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>find(basic_string&lt;charT,traits,Allocator&gt;(1,c), pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.3 [string::rfind] before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type rfind(charT c, size_type pos = npos) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>rfind(basic_string&lt;charT,traits,Allocator&gt;(1,c),pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.4 [string::find.first.of] before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type find_first_of(charT c, size_type pos = 0) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>find_first_of(basic_string&lt;charT,traits,Allocator&gt;(1,c), pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.5 [string::find.last.of] before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type find_last_of(charT c, size_type pos = npos) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>find_last_of(basic_string&lt;charT,traits,Allocator&gt;(1,c),pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.6 [string::find.first.not.of] before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type find_first_not_of(charT c, size_type pos = 0) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>find_first_not_of(basic_string(1, c), pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.7.7 [string::find.last.not.of] before p7 as indicated:</p>
++
++<blockquote><pre>
++size_type find_last_not_of(charT c, size_type pos = npos) const <del>noexcept</del>;
++</pre><blockquote><p>
++-7- <i>Returns</i>: <tt>find_last_not_of(basic_string(1, c), pos)</tt>.
++</p></blockquote></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.2 [string::operator==] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator==(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.3 [string::op!=] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator!=(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.4 [string::op&lt;] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&lt;(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&lt;(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.5 [string::op&gt;] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&gt;(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&gt;(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.6 [string::op&lt;=] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&lt;=(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.7 [string::op&gt;=] before p2+p3 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&gt;=(const charT* lhs,
++ const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++
++[&hellip;]
++
++template&lt;class charT, class traits, class Allocator&gt;
++bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ const charT* rhs) <del>noexcept</del>;
++</pre></blockquote>
++
++</li>
++
++<li><p>Modify 21.4.8.8 [string.special] as indicated (Remark: The change of
++the semantics guarantees as of 17.5.1.4 [structure.specifications] p4 that
++the "Throws: Nothing" element of member swap is implied):</p>
++
++<blockquote><pre>
++template&lt;class charT, class traits, class Allocator&gt;
++ void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
++ basic_string&lt;charT,traits,Allocator&gt;&amp; rhs) <del>noexcept</del>;
++</pre><blockquote><p>
++-1- Effects: <ins>Equivalent to</ins> <tt>lhs.swap(rhs);</tt>
++</p></blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2065"></a>2065. Minimal allocator interface</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-06-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The example in 17.6.3.5 [allocator.requirements] says <tt>SimpleAllocator</tt> satisfies
++the requirements of Table 28 &mdash; Allocator requirements, but it doesn't support comparison
++for equality&#47;inequality.
++</p>
++
++<p><i>[Bloomington, 2011]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the example in 17.6.3.5 [allocator.requirements] p5 as indicated:</p>
++<blockquote><p>
++-5- [&hellip;]
++<p/>
++[ <i>Example</i>: the following is an allocator class template supporting the minimal interface
++that satisfies the requirements of Table 28:
++</p><blockquote><pre>
++template &lt;class Tp&gt;
++struct SimpleAllocator {
++ typedef Tp value_type;
++ SimpleAllocator(<i>ctor args</i>);
++ template &lt;class T&gt; SimpleAllocator(const SimpleAllocator&lt;T&gt;&amp; other);
++ Tp *allocate(std::size_t n);
++ void deallocate(Tp *p, std::size_t n);
++};
++
++<ins>template &lt;class T, class U&gt;
++bool operator==(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);
++template &lt;class T, class U&gt;
++bool operator!=(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);</ins>
++</pre></blockquote><p>
++&mdash; <i>end example</i> ]
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2066"></a>2066. Missing specification of <tt>vector::resize(size_type)</tt></h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Rani Sharoni <b>Opened:</b> 2011-03-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In C++1x (N3090) there are two version of <tt>vector::resize</tt> &mdash; 23.3.6.3 [vector.capacity]:
++</p>
++<blockquote><pre>
++void resize(size_type sz);
++void resize(size_type sz, const T&amp; c);
++</pre></blockquote>
++<p>
++The text in 23.3.6.3 [vector.capacity]&#47;12 only mentions "no effects on throw" for the
++two args version of resize:
++</p><blockquote><p>
++<i>Requires</i>: If an exception is thrown other than by the move constructor
++of a non-<tt>CopyConstructible</tt> <tt>T</tt> there are no effects.
++</p></blockquote><p>
++This seems like unintentional oversight since <tt>resize(size)</tt> is
++semantically the same as <tt>resize(size, T())</tt>.
++Additionally, the C++03 standard only specify single version of resize
++with default for the second argument - 23.2.4:
++</p>
++<blockquote><pre>
++void resize(size_type sz, T c = T());
++</pre></blockquote>
++<p>
++Therefore not requiring same guarantees for both version of resize is
++in fact a regression.
++</p>
++
++<p><i>[2011-06-12: Daniel comments]</i></p>
++
++
++<p>The proposed resolution for issue <a href="lwg-defects.html#2033">2033</a> should solve this issue as well.</p>
++
++<p><i>[
++2011 Bloomington
++]</i></p>
++
++
++<p>
++This issue will be resolved by issue <a href="lwg-defects.html#2033">2033</a>, and closed when this issue is applied.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Resolved by adopting the resolution in issue <a href="lwg-defects.html#2033">2033</a> at this meeting.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>Apply the proposed resolution of issue <a href="lwg-defects.html#2033">2033</a></p>
++
++
++
++
++
++<hr>
++<h3><a name="2067"></a>2067. <tt>packaged_task</tt> should have deleted copy c'tor with const parameter</h3>
++<p><b>Section:</b> 30.6.9 [futures.task] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task">issues</a> in [futures.task].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Class template <tt>packaged_task</tt> is a move-only type with the following form of the
++deleted copy operations:
++</p>
++<blockquote><pre>
++packaged_task(packaged_task&amp;) = delete;
++packaged_task&amp; operator=(packaged_task&amp;) = delete;
++</pre></blockquote>
++<p>
++Note that the argument types are non-const. This does not look like a typo to me,
++this form seems to exist from the very first proposing paper on
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2276.html">N2276</a>.
++Using either of form of the copy-constructor did not make much difference before the
++introduction of defaulted special member functions, but it makes now an observable
++difference. This was brought to my attention by a question on a German C++ newsgroup
++where the question was raised why the following code does not compile on a recent
++gcc:
++</p>
++<blockquote><pre>
++#include &lt;utility&gt;
++#include &lt;future&gt;
++#include &lt;iostream&gt;
++#include &lt;thread&gt;
++
++int main(){
++ std::packaged_task&lt;void()&gt; someTask([]{ std::cout &lt;&lt; std::this_thread::get_id() &lt;&lt; std::endl; });
++ std::thread someThread(std::move(someTask)); // <span style="color:#C80000">Error here</span>
++ // Remainder omitted
++}
++</pre></blockquote>
++<p>
++It turned out that the error was produced by the instantiation of some return type
++of <tt>std::bind</tt> which used a defaulted copy-constructor, which leads to a
++const declaration conflict with [class.copy] p8.
++<p/>
++Some aspects of this problem are possibly core-language related, but I consider it
++more than a service to programmers, if the library would declare the usual form of
++the copy operations (i.e. those with const first parameter type) as deleted for
++<tt>packaged_task</tt> to prevent such problems.
++<p/>
++A similar problem exists for class template <tt>basic_ostream</tt> in 27.7.3.1 [ostream]:
++</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
++ class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {
++ [&hellip;]
++
++ // 27.7.3.3 Assign/swap
++ basic_ostream&amp; operator=(basic_ostream&amp; rhs) = delete;
++ basic_ostream&amp; operator=(const basic_ostream&amp;&amp; rhs);
++ void swap(basic_ostream&amp; rhs);
++};
++</pre></blockquote>
++<p>
++albeit this could be considered as an editorial swap of copy and move
++assignment operator, I suggest to fix this as part of this issue as well.
++</p>
++
++<p><i>[
++2011 Bloomington.
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++<ol>
++<li><p>Modify the class template <tt>basic_ostream</tt> synopsis in 27.7.3.1 [ostream]
++as indicated (Note: The prototype signature of the move assignment operator in 27.7.3.3 [ostream.assign]
++is fine):</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
++ class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {
++ [&hellip;]
++
++ // 27.7.3.3 Assign/swap
++ basic_ostream&amp; operator=(<ins>const</ins> basic_ostream&amp; rhs) = delete;
++ basic_ostream&amp; operator=(<del>const</del> basic_ostream&amp;&amp; rhs);
++ void swap(basic_ostream&amp; rhs);
++};
++</pre></blockquote>
++</li>
++
++<li><p>Modify the class template <tt>packaged_task</tt> synopsis in 30.6.9 [futures.task] p2
++as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class&gt; class packaged_task; <i>// undefined</i>
++
++ template&lt;class R, class... ArgTypes&gt;
++ class packaged_task&lt;R(ArgTypes...)&gt; {
++ public:
++ [&hellip;]
++
++ <i>// no copy</i>
++ packaged_task(<ins>const</ins> packaged_task&amp;) = delete;
++ packaged_task&amp; operator=(<ins>const</ins> packaged_task&amp;) = delete;
++
++ [&hellip;]
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2069"></a>2069. Inconsistent exception spec for <tt>basic_string</tt> move constructor</h3>
++<p><b>Section:</b> 21.4.2 [string.cons] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2011-07-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.cons">issues</a> in [string.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Sub-clause 21.4.2 [string.cons] contains these constructors in paragraphs 2 and 3:
++</p>
++<blockquote><pre>
++basic_string(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
++basic_string(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; str) noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- <i>Throws</i>: The second form throws nothing if the allocator's move constructor throws nothing.
++</p></blockquote></blockquote>
++<p>
++How can it <i>ever</i> throw anything if it is marked <tt>noexcept</tt>?
++</p>
++<p><i>[2011-07-11: Daniel comments and suggests wording changes]</i></p>
++
++<p>
++Further, according to paragraph 18 of the same sub-clause:
++</p>
++<blockquote><pre>
++basic_string(const basic_string&amp; str, const Allocator&amp; alloc);
++basic_string(basic_string&amp;&amp; str, const Allocator&amp; alloc);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-18- <i>Throws</i>: The second form throws nothing if <tt>alloc == str.get_allocator()</tt>
++unless the copy constructor for <tt>Allocator</tt> throws.
++</p>
++</blockquote></blockquote>
++<p>
++The constraint &quot;unless the copy constructor for <tt>Allocator</tt> throws&quot;
++is redundant, because according to Table 28 &mdash; Allocator requirements, the expressions
++</p>
++<blockquote><pre>
++X a1(a);
++X a(b);
++</pre></blockquote>
++<p>
++impose the requirement: &quot;Shall not exit via an exception&quot;.
++</p>
++
++<p><i>[
++2011 Bloomington.
++]</i></p>
++
++
++<p>
++Move to Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change 21.4.2 [string.cons] p3 as indicated (This move constructor has a wide
++contract and is therefore safely marked as <tt>noexcept</tt>):</p>
++
++<blockquote><pre>
++basic_string(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
++basic_string(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; str) noexcept;
++</pre><blockquote>
++<p>
++-2- <i>Effects</i>: Constructs an object of class <tt>basic_string</tt> as indicated in Table 64.
++In the second form, <tt>str</tt> is left in a valid state with an unspecified value.
++<p/>
++<del>-3- <i>Throws</i>: The second form throws nothing if the allocator's move constructor throws nothing.</del>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 21.4.2 [string.cons] p18 as indicated (This move-like constructor may throw,
++if the allocators don't compare equal, but not because of a potentially throwing allocator
++copy constructor, only because the allocation attempt may fail and throw an exception):</p>
++
++<blockquote><pre>
++basic_string(const basic_string&amp; str, const Allocator&amp; alloc);
++basic_string(basic_string&amp;&amp; str, const Allocator&amp; alloc);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-18- <i>Throws</i>: The second form throws nothing if <tt>alloc == str.get_allocator()</tt>
++<del>unless the copy constructor for <tt>Allocator</tt> throws</del>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2071"></a>2071. <tt>std::valarray</tt> move-assignment</h3>
++<p><b>Section:</b> 26.6.2.3 [valarray.assign] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Paolo Carlini <b>Opened:</b> 2011-05-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#valarray.assign">issues</a> in [valarray.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Yesterday I noticed that the language we have in the FDIS about <tt>std::valarray</tt> move assignment
++is inconsistent with the resolution of LWG 675. Indeed, we guarantee constant complexity (vs linear
++complexity). We also want it to be noexcept, that is more subtle, but again it's at variance with all
++the containers.
++<p/>
++Also, even if we suppose that LWG <a href="lwg-defects.html#675">675</a> applies only to the containers proper, I don't think the current
++"as if by calling resize(v.size())" is internally consistent with the noexcept requirement.
++<p/>
++So, what do we really want for <tt>std::valarray</tt>? Shall we maybe just strike or fix the as-if, consider it
++some sort of pasto from the copy-assignment text, thus keep the noexcept and constant complexity requirements
++(essentially the whole operation would boild down to a swap of POD data members). Or LWG <a href="lwg-defects.html#675">675</a> should be
++explicitly extended to <tt>std::valarray</tt> too? In that case both noexcept and constant complexity
++would go, I think, and the operation would boil down to the moral equivalent of <tt>clear()</tt> (which
++doesn't really exist in this case) + <tt>swap</tt>?
++</p>
++
++<p>
++Howard: I agree the current wording is incorrect. The complexity should be linear in <tt>size()</tt> (not
++<tt>v.size()</tt>) because the first thing this operator needs to do is <tt>resize(0)</tt> (or <tt>clear()</tt>
++as you put it).
++<p/>
++I think we can keep the <tt>noexcept</tt>.
++<p/>
++As for proper wording, here's a first suggestion:
++</p><blockquote><p>
++<i>Effects</i>: <tt>*this</tt> obtains the value of <tt>v</tt>. The value of <tt>v</tt> after the assignment
++is not specified.
++<p/>
++<i>Complexity</i>: linear.
++</p></blockquote><p>
++</p>
++
++<p>
++See also reflector discussion starting with c++std-lib-30690.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++<p>
++Some discussion on the types supported by <tt>valarray</tt> concludes that the wording is
++trying to say something similar to the core wording for trivial types, but significantly
++predates it, and does allow for types with non-trivial destructors. Howard notes that
++the only reason for linear complexity, rather than constant, is to support types with
++non-trivial destructors.
++</p>
++<p>
++AJM suggests replacing the word 'value' with 'state', but straw poll prefers moving
++forward with the current wording, 5 to 2.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>In 26.6.2.3 [valarray.assign] update as follows:</p>
++
++<blockquote><pre>
++valarray&lt;T&gt;&amp; operator=(valarray&lt;T&gt;&amp;&amp; v) noexcept;
++</pre><blockquote><p>
++3 <i>Effects</i>: <tt>*this</tt> obtains the value of <tt>v</tt>. <del>If the length of <tt>v</tt>
++is not equal to the length of <tt>*this</tt>, resizes <tt>*this</tt> to make the two arrays the
++same length, as if by calling <tt>resize(v.size())</tt>, before performing the assignment.</del><ins>The
++value of <tt>v</tt> after the assignment is not specified.</ins>
++<p/>
++4 <i>Complexity</i>: <del>Constant</del><ins>Linear</ins>.
++</p></blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2074"></a>2074. Off by one error in <tt>std::reverse_copy</tt></h3>
++<p><b>Section:</b> 25.3.10 [alg.reverse] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Peter Miller <b>Opened:</b> 2011-08-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.reverse">issues</a> in [alg.reverse].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The output of the program below should be:
++</p>
++<blockquote><pre>
++"three two one null \n"
++</pre></blockquote>
++<p>
++But when <tt>std::reverse_copy</tt> is implemented as described in N3291 25.3.10 [alg.reverse]
++it's:
++</p>
++<blockquote><pre>
++"null three two one \n"
++</pre></blockquote>
++<p>
++because there's an off by one error in 25.3.10 [alg.reverse]&#47;4; the definition should read:
++</p>
++<blockquote><pre>
++*(result + (last - first) <span style="color:#C80000;font-weight:bold">- 1</span> - i) = *(first + i)
++</pre></blockquote>
++<p>
++Test program:
++</p>
++<blockquote><pre>
++#include &lt;algorithm&gt;
++#include &lt;iostream&gt;
++
++template &lt;typename BiIterator, typename OutIterator&gt;
++auto
++reverse_copy_as_described_in_N3291(
++ BiIterator first, BiIterator last, OutIterator result )
++-&gt; OutIterator
++{
++ // 25.3.10&#47;4 [alg.reverse]:
++ // "...such that for any non-negative integer i &lt; (last - first)..."
++ for ( unsigned i = 0; i &lt; ( last - first ); ++i )
++ // "...the following assignment takes place:"
++ *(result + (last - first) - i) = *(first + i);
++
++ // 25.3.10&#47;6
++ return result + (last - first);
++}
++
++int main()
++{
++ using std::begin;
++ using std::end;
++ using std::cout;
++
++ static const char*const in[3] { "one", "two", "three" };
++ const char* out[4] { "null", "null", "null", "null" };
++
++ reverse_copy_as_described_in_N3291( begin( in ), end( in ), out );
++
++ for ( auto s : out )
++ cout &lt;&lt; s &lt;&lt; ' ';
++
++ cout &lt;&lt; std::endl;
++
++ return 0;
++}
++</pre></blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>
++Change 25.3.10 [alg.reverse] p4 as follows:
++</p>
++<blockquote><pre>
++template&lt;class BidirectionalIterator, class OutputIterator&gt;
++ OutputIterator
++ reverse_copy(BidirectionalIterator first,
++ BidirectionalIterator last, OutputIterator result);
++</pre><blockquote><p>
++-4- <i>Effects</i>: Copies the range [<tt>first,last</tt>) to the range [<tt>result,result+(last-first)</tt>)
++such that for any non-negative integer <tt>i &lt; (last - first)</tt> the following assignment takes place:
++<tt>*(result + (last - first) <ins>- 1</ins> - i) = *(first + i)</tt>.
++<p/>
++-5- <i>Requires</i>: The ranges [<tt>first,last</tt>) and [<tt>result,result+(last-first)</tt>) shall not overlap.
++<p/>
++-6- <i>Returns</i>: <tt>result + (last - first)</tt>.
++<p/>
++-7- <i>Complexity</i>: Exactly <tt>last - first</tt> assignments.
++</p></blockquote></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2075"></a>2075. Progress guarantees, lock-free property, and scheduling assumptions</h3>
++<p><b>Section:</b> 1.10 [intro.multithread], 29.4 [atomics.lockfree], 29.6.5 [atomics.types.operations.req] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Torvald Riegel <b>Opened:</b> 2011-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 1.10 [intro.multithread] p2:
++</p>
++<blockquote><p>
++"Implementations should ensure that all unblocked threads eventually make progress."
++</p></blockquote>
++<ul>
++<li>If taken literally, this cannot be achieved with lock-free atomics in
++ general because they only guarantee that some thread makes progress
++ (i.e., minimal progress, whereas 1.10 [intro.multithread] p2 seems to
++ require maximal progress).
++</li>
++<li>What does it mean precisely to "make progress"? Does "unblocked
++ threads" exclude live-locked threads (if so, lock-free atomics would
++ be sufficient I suppose)?
++</li>
++<li><p>Which assumptions can an implementation make about the thread
++ scheduling? This is relevant for how implementations implement
++ compare-exchange with load-linked &#47; store conditional (LL-SC), and
++ atomic read-modifiy-write operations with load...compare-exchange-weak
++ loops.
++</p>
++<ul>
++<li>Do threads run long enough without being descheduled (e.g.,
++ OS timeslices are long enough, interrupt frequency is not too
++ high, etc.)?
++</li>
++<li>Or is this implementation-defined, and the sentence is just about
++ stating that the progress guarantees will not hold on, for example,
++ systems with unfair scheduling or thread priorities?
++</li>
++</ul>
++</li>
++</ul>
++
++<p>
++29.4 [atomics.lockfree] p2 declares the lock-free property for a
++particular object. However, "lock-free" is never defined, and in discussions
++that I had with committee members it seemed as if the standard's lock-free would be
++different from what lock-free means in other communities (eg, research,
++text books on concurrent programming, etc.).
++</p>
++<ul>
++<li>Originally, lock-freedom for an object requires minimal progress (ie,
++ some thread makes progress, but other threads might never do) without
++ any assumptions about the scheduling (threads could be stopped
++ executing (so it is "nonblocking"), and threads are not guaranteed to
++ execute in isolation, even for very small intervals of cycles).
++</li>
++<li>In contrast, obstruction-freedom, another nonblocking progress
++ condition, guarantees progress for all threads that eventually get
++ executed long enough in isolation (ie, without interference by other
++ threads).
++</li>
++<li>Simple load...compare-exchange-weak loops (or LL-SC loops) to
++ implement atomic read-modify-write operations can be just
++ obstruction-free but not lock-free because they can livelock
++ (depending on the hardware's LL-SC implementation, though). However,
++ they effectively guarantee the same as lock-free iff threads will
++ eventually run in isolation for long enough (that can be an assumption
++ about the OS scheduler), or if the implementation adds this (e.g.,
++ probabilistically by employing randomized exponential back-off when
++ contention is detected, in all operations that can create contention).
++</li>
++<li>Does the particular object has to be lock-free, or is it only required
++ that threads make progress irrespective on which object? Again
++ considering compare-exchange-weak or LL-SC here, what happens if the
++ compare-exchange object shares a cacheline with an integer counter
++ object that is constantly updated by other threads? The
++ compare-exchange-weak can always fail, so the object would not be
++ lock-free. However, if we consider progress to be overall progress for
++ threads, it would be lock-free because other threads succeed updating
++ the integer counter. I would have assumed the lock-free property is
++ strictly about the atomic object, but in discussions with committee
++ members it seemed as if progress for any object could be the intended
++ guarantee.
++</li>
++</ul>
++
++<p>
++Following 29.6.5 [atomics.types.operations.req] p7 <tt>is_lock_free()</tt>
++returns "true if the object is lock-free". What is returned if the object is only
++sometimes lock-free?
++</p>
++
++<p>
++Basically, I would like to see clarifications for the progress
++guarantees so that users know what they can expect from implementations
++(and what they cannot expect!), and to give implementors a clearer
++understanding of which user expectations they have to implement.
++</p>
++<ol>
++<li><p>Elaborate on the intentions of the progress guarantee in
++1.10 [intro.multithread] p2. As I don't know about your intentions,
++it's hard to suggest a resolution.
++</p>
++<ul>
++<li>Is it for straightforward, non-synchronizing code only?</li>
++<li>Is it for blocking code only? (Is "unblocked" more than blocked on
++ external I/O or on deadlocks?)
++</li>
++<li>What does it mean to "make progress"?</li>
++<li>Is this meant to only waive any progress guarantees if there are
++ thread priorities?
++</li>
++<li>Can an implementation make any assumptions about thread scheduling?
++</li>
++</ul>
++</li>
++<li><p>Define the lock-free property. The definition should probably include
++the following points:
++</p>
++<ul>
++<li>Is it just nonblocking, or what is the distinction to just being nonblocking?</li>
++<li>Does it make any assumptions about the scheduler?</li>
++<li>What are the progress guarantees, minimal or maximal (some or all threads finish eventually).</li>
++<li>Is progress guaranteed for all operations on the particular object, or
++ do operations on other objects also count as "making progress"?
++</li>
++</ul>
++</li>
++<li>Add a note explaining that compare-exchange-weak is not necessarily
++lock-free (but is nonblocking)? Or is it indeed intended to be lock-free
++(only allowed to fail spuriously but guaranteed to not fail eventually)?
++Implementing the latter might be a challenge on LL-SC machines or lead
++to space overheads I suppose, see the cacheline sharing example above.
++</li>
++</ol>
++
++<p><i>[2011-12-01: Hans comments]</i></p>
++
++
++<p>
++1.10 [intro.multithread] p2 was an intentional compromise, and it was understood at the
++time that it was not a precise statement. The wording was introduced by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3209.htm">N3209</a>, which
++discusses some of the issues. There were additional reflector discussions.
++<p/>
++This is somewhat separable from the question of what lock-free means, which is probably a more
++promising question to focus on.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++General direction: lock-free means obstruction-free. Leave the current "should" recommendation
++for progress. It would take a lot of effort to try to do better.
++</p>
++
++
++<p><i>[2012, Portland: move to Open]</i></p>
++
++<p>
++The current wording of 1.10 [intro.multithread] p2 doesn't really say very much.
++As far as we can tell the term <i>lock-free</i> is nowhere defined in the standard.
++</p>
++<p>
++James: we would prefer a different way to phrase it.
++</p>
++<p>
++Hans: the research literature includes the term <i>abstraction-free</i> which might be a better fit.
++</p>
++<p>
++Detlef: does Posix define a meaning for blocking (or locking) that we could use?
++</p>
++<p>
++Hans: things like compare-exchange-strong can wait indefinitely.
++</p>
++<p>
++Niklas: what about spin-locks -- still making no progress.
++</p>
++<p>
++Hans: suspect we can only give guidance, at best. The lock-free meaning from the theoretical commmunity (forard progress will be made) is probably too strong here.
++</p>
++<p>
++Atrur: what about livelocks?
++</p>
++<p>
++Hans: each atomic <i>modification</i> completes, even if the whole thing is blocked.
++</p>
++<p>
++Moved to open.
++</p>
++
++<p><i>[2013-11-06: Jason Hearne-McGuiness comments]</i></p>
++
++
++<p>
++Related to this issue, the wording in 29.4 [atomics.lockfree] p2,
++</p>
++<blockquote><p>
++In any given program execution, the result of the lock-free query
++shall be consistent for all pointers of the same type.
++</p></blockquote>
++<p>
++should be made clearer, because the object-specific (non-static) nature of the <tt>is_lock_free()</tt> functions
++from 29.5 [atomics.types.generic] and 29.6 [atomics.types.operations] imply that for different
++instances of pointers of the same type the returned value could be different.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p><i>[2014-02-16 Issaquah: Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3927.html">n3927</a>]</i></p>
++
++
++
++
++
++
++
++<hr>
++<h3><a name="2076"></a>2076. Bad <tt>CopyConstructible</tt> requirement in set constructors</h3>
++<p><b>Section:</b> 23.4.6.2 [set.cons] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jens Maurer <b>Opened:</b> 2011-08-20 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++23.4.6.2 [set.cons] paragraph 4 says:
++</p>
++
++<blockquote><p>
++<i>Requires</i>: If the iterator's dereference operator returns an lvalue or a non-const rvalue,
++then <tt>Key</tt> shall be <tt>CopyConstructible</tt>.
++</p></blockquote>
++
++<p>
++I'm confused why a "non-const rvalue" for the return value of the iterator
++would require <tt>CopyConstructible</tt>; isn't that exactly the situation
++when you'd want to apply the move constructor?
++<p/>
++The corresponding requirement for <tt>multimap</tt> seems better in that regard
++([multimap.cons] paragraph 3):
++</p>
++<blockquote><p>
++Requires: If the iterator's dereference operator returns an lvalue or a const rvalue
++<tt>pair&lt;key_type, mapped_type&gt;</tt>, then both <tt>key_type</tt> and mapped_type
++shall be <tt>CopyConstructible</tt>.
++</p></blockquote>
++<p>
++Obviously, if I have a const rvalue, I can't apply the move constructor (which will
++likely attempt modify its argument).
++<p/>
++Dave Abrahams:
++<p/>
++I think you are right.
++Proposed resolution: drop "non-" from 23.4.6.2 [set.cons] paragraph 3.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++The wording is in this area will be affected by Pablo's paper being adopted at this meeting.
++Wait for that paper to be applied before visiting this issue - deliberately leave in New
++status until the next meeting.
++</p>
++
++<p><strong>Proposed resolution from Kona 2012:</strong></p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<p>
++Change 23.4.6.2 [set.cons] p3 as follows:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ set(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
++</pre><blockquote><p>
++-3- Effects: Constructs an empty set using the specified comparison object and allocator, and inserts
++elements from the range [<tt>first,last</tt>).
++<p/>
++-4- <i>Requires</i>: If the iterator's dereference operator returns an lvalue or a <del>non-</del>const rvalue,
++then <tt>Key</tt> shall be <tt>CopyConstructible</tt>.
++<p/>
++-5- <i>Complexity</i>: Linear in <tt>N</tt> if the range [<tt>first,last</tt>) is already sorted using
++<tt>comp</tt> and otherwise <tt>N logN</tt>, where <tt>N</tt> is <tt>last - first</tt>.
++</p></blockquote></blockquote>
++</blockquote>
++
++<p><i>[2014-05-18, Daniel comments]</i></p>
++
++<p>
++According to Pablo, the current P/R correctly incorporates the changes from his paper (which was adopted in Kona)
++</p>
++
++<p><i>[2014-06-10, STL comments and suggests better wording]</i></p>
++
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1858.html">N1858</a> was voted into WP
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2284.pdf">N2284</a> but was
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2283.html">"(reworded)"</a>, introducing the "non-const" damage.
++<p/>
++N1858 wanted to add this for map:
++</p>
++<blockquote><p>
++<i>Requires</i>: Does not require <tt>CopyConstructible</tt> of either <tt>key_type</tt> or <tt>mapped_type</tt> if the dereferenced
++<tt>InputIterator</tt> returns a non-const rvalue <tt>pair&lt;key_type, mapped_type&gt;</tt>. Otherwise <tt>CopyConstructible</tt>
++is required for both <tt>key_type</tt> and <tt>mapped_type</tt>.
++</p></blockquote>
++<p>
++And this for set:
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>Key</tt> must be <tt>CopyConstructible</tt> only if the dereferenced <tt>InputIterator</tt> returns an lvalue
++or const rvalue.
++</p></blockquote>
++<p>
++(And similarly for multi.)
++<p/>
++This was reworded to N2284 23.3.1.1 [map.cons]/3 and N2284 23.3.3.1 [set.cons]/4, and it slightly changed over the years into
++N3936 23.4.4.2 [map.cons]/3 and N3936 23.4.6.2 [set.cons]/4.
++<p/>
++In 2005/2007, this was the best known way to say "hey, we should try to move this stuff", as the fine-grained element requirements
++were taking shape.
++<p/>
++Then in 2010, <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3173.pdf">N3173</a> was
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3226.html">voted</a> into WP
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3225.pdf">N3225</a>, adding the definition of
++<tt>EmplaceConstructible</tt> and modifying the container requirements tables to make the range constructors require
++<tt>EmplaceConstructible</tt>.
++<p/>
++After looking at this history and double-checking our implementation (where <tt>map</tt>/<tt>set</tt> range construction goes through
++emplacement, with absolutely no special-casing for <tt>map</tt>'s pairs), I am convinced that N3173 superseded N1858 here.
++(Range-<tt>insert()</tt> and the unordered containers are unaffected.)
++</p>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to the N3936.</p>
++
++<p>
++Change 23.4.6.2 [set.cons] p4 as follows:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ set(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
++</pre><blockquote><p>
++-3- Effects: Constructs an empty <tt>set</tt> using the specified comparison object and allocator, and inserts
++elements from the range [<tt>first,last</tt>).
++<p/>
++-4- <i>Requires</i>: If the iterator's indirection operator returns an lvalue or a <del>non-</del>const rvalue,
++then <tt>Key</tt> shall be <tt>CopyInsertible</tt> into <tt>*this</tt>.
++<p/>
++-5- <i>Complexity</i>: Linear in <tt>N</tt> if the range [<tt>first,last</tt>) is already sorted using
++<tt>comp</tt> and otherwise <tt>N logN</tt>, where <tt>N</tt> is <tt>last - first</tt>.
++</p></blockquote></blockquote>
++</blockquote>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++GR: Do requirements supersede rather than compose [container requirements and per-function requirements]? AM: Yes, they supersede.
++<p/>
++AM: This looks good. Ready? Agreement.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the N4296.</p>
++
++<ol>
++<li><p>
++Remove 23.4.4.2 [map.cons] p3:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ map(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires</i>: If the iterator's indirection operator returns an lvalue or a <tt>const</tt> rvalue
++<tt>pair&lt;key_type, mapped_type&gt;</tt>, then both <tt>key_type</tt> and <tt>mapped_type</tt> shall be
++<tt>CopyInsertible</tt> into <tt>*this</tt>.</del>
++<p/>
++[&hellip;]
++</p></blockquote></blockquote>
++</li>
++
++<li><p>
++Remove 23.4.5.2 [multimap.cons] p3:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ multimap(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(),
++ const Allocator&amp; = Allocator());
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires</i>: If the iterator's indirection operator returns an lvalue or a <tt>const</tt> rvalue
++<tt>pair&lt;key_type, mapped_type&gt;</tt>, then both <tt>key_type</tt> and <tt>mapped_type</tt> shall be
++<tt>CopyInsertible</tt> into <tt>*this</tt>.</del>
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>
++Remove 23.4.6.2 [set.cons] p4:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ set(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-4- <i>Requires</i>: If the iterator's indirection operator returns an lvalue or a non-<tt>const</tt> rvalue, then
++<tt>Key</tt> shall be <tt>CopyInsertible</tt> into <tt>*this</tt>.</del>
++</p></blockquote></blockquote>
++</li>
++
++<li><p>
++Remove 23.4.7.2 [multiset.cons] p3:
++</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++ multiset(InputIterator first, InputIterator last,
++ const Compare&amp; comp = Compare(),
++ const Allocator&amp; = Allocator());
++</pre><blockquote>
++<p>
++<del>-3- <i>Requires</i>: If the iterator's indirection operator returns an lvalue or a <tt>const</tt> rvalue, then
++<tt>Key</tt> shall be <tt>CopyInsertible</tt> into <tt>*this</tt>.</del>
++<p/>
++[&hellip;]
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2078"></a>2078. Throw specification of <tt>async()</tt> incomplete</h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2011-08-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The current throw specification of <tt>async()</tt> does state:
++</p>
++<blockquote><p>
++-6- <i>Throws</i>: <tt>system_error</tt> if policy is <tt>launch::async</tt> and
++the implementation is unable to start a new thread.
++</p></blockquote>
++<p>
++First it seems not clear whether this only applies if policy equals
++<tt>launch::async</tt> of if the <tt>async</tt> launch mode flag is set
++(if <tt>policy|launch::async!=0</tt>)
++<p/>
++In the discussion Lawrence Crowl also wrote:
++</p>
++<blockquote><p>
++ More generally, I think what we want to say is that if the
++ implementation cannot successfully execute on one of the policies
++ allowed, then it must choose another. The principle would apply
++ to implementation-defined policies as well.
++</p></blockquote>
++
++<p>
++Peter Sommerlad:
++</p>
++<blockquote><p>
++Should not throw. That was the intent. "is async" meat exactly.
++</p></blockquote>
++
++<p><i>[2012, Portland: move to Tentatively NAD Editorial]</i></p>
++
++<p>
++If no launch policy, it is undefined behavior.
++</p>
++<p>
++Agree with Lawrence, should try all the allowed policies. We will rephrase so that
++the policy argument should be <tt>lauch::async</tt>. Current wording seems good enough.
++</p>
++<p>
++We believe this choice of policy statement is really an editorial issue.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++If all the implementors read it and can't get it right - it is not editorial. Nico to provide wording
++</p>
++<p>
++No objections to revised wording, so moved to Immediate.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 30.6.8 [futures.async] p6, p7 as indicated:</p>
++
++<blockquote>
++<p>
++-6- <i>Throws:</i> <tt>system_error</tt> if <tt>policy</tt> <del>is</del> <ins><tt>==</tt></ins> <tt>launch::async</tt>
++and the implementation is unable to start a new thread.
++</p>
++<p>
++-7- <i>Error conditions:</i>
++</p>
++<ul>
++<li><p> <tt>resource_unavailable_try_again</tt> &mdash; if <tt>policy</tt> <del>is</del> <ins><tt>==</tt></ins> <tt>launch::async</tt>
++and the system is unable to start a new thread.</p>
++</li>
++</ul>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2080"></a>2080. Specify when <tt>once_flag</tt> becomes invalid</h3>
++<p><b>Section:</b> 30.4.4 [thread.once] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2011-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In function <tt>call_once</tt> 30.4.4.2 [thread.once.callonce]
++paragraph 4 and 5 specify for <tt>call_once()</tt>:
++</p>
++
++<blockquote>
++<p>
++<i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception]),
++or any exception thrown by <tt>func</tt>.
++<p/>
++<i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>invalid_argument</tt> &mdash; if the <tt>once_flag</tt> object is no longer valid.</li>
++</ul>
++</blockquote>
++
++<p>
++However, nowhere in 30.4.4 [thread.once] is specified, when a once-flag becomes invalid.
++<p/>
++As far as I know this happens if the flag is used for different functions. So we either have to have
++to insert a sentence&#47;paragraph in
++</p>
++<blockquote><p>
++30.4.4.2 Function call_once [thread.once.callonce]
++</p></blockquote>
++<p>
++or
++</p>
++<blockquote><p>
++30.4.4 Call once [thread.once]
++</p></blockquote>
++<p>
++explaining when a <tt>once_flag</tt> becomes invalidated or we should state as error condition something like:
++</p>
++
++<ul>
++<li><tt>invalid_argument</tt> &mdash; if the <tt>func</tt> used in combination with the <tt>once_flag</tt> is different
++from a previously passed <tt>func</tt> for the same <tt>once_flag</tt>
++</li>
++</ul>
++
++<p>
++Anthony Williams:
++</p>
++<blockquote>
++<p>
++A <tt>once_flag</tt> is invalidated if you destroy it (e.g. it is an automatic object, or heap
++allocated and deleted, etc.)
++<p/>
++If the library can detect that this is the case then it will throw this exception. If it cannot
++detect such a case then it will never be thrown.
++</p>
++</blockquote>
++
++<p>
++Jonathan Wakely:
++</p>
++<blockquote>
++<p>
++I have also wondered how that error can happen in C++, where the type
++system will reject a non-callable type being passed to <tt>call_once()</tt> and
++should prevent a <tt>once_flag</tt> being used after its destructor runs.
++<p/>
++If a <tt>once_flag</tt> is used after its destructor runs then it is indeed
++undefined behaviour, so implementations are already free to throw any
++exception (or set fire to a printer) without the standard saying so.
++<p/>
++My assumption was that it's an artefact of basing the API on pthreads,
++which says:
++</p>
++<blockquote>
++<p>
++The <tt>pthread_once()</tt> function may fail if:
++<p/>
++<tt>[EINVAL]</tt> If either <tt>once_control</tt> or <tt>init_routine</tt> is invalid.
++</p>
++</blockquote>
++</blockquote>
++
++<p>
++Pete Becker:
++</p>
++<blockquote><p>
++Yes, probably. We had to clean up several UNIXisms that were in the original design.
++</p></blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Remove error conditions, move to Review.
++</p>
++
++<p><i>[2012, Portland: move to Tentatively Ready]</i></p>
++
++<p>
++Concurrency move to Ready, pending LWG review.
++</p>
++
++<p>
++LWG did not have time to perform the final review in Portland, so moving to
++<i>tentatively</i> ready to reflect the Concurrency belief that the issue is
++ready, but could use a final inspection from library wordsmiths.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3337.</p>
++
++<ol>
++<li><p>Change 30.4.4.2 [thread.once.callonce] as indicated:</p>
++<blockquote><pre>
++template&lt;class Callable, class ...Args&gt;
++void call_once(once_flag&amp; flag, Callable&amp;&amp; func, Args&amp;&amp;... args);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-4- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2), or any exception thrown by <tt>func</tt>.
++<p/>
++<del>-5- Error conditions:</del>
++</p>
++<ul>
++<li><del><tt>invalid_argument</tt> &mdash; if the <tt>once_flag</tt> object is no longer valid.</del></li>
++</ul>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2081"></a>2081. <tt>Allocator</tt> requirements should include <tt>CopyConstructible</tt></h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++As discussed in c++std-lib-31054 and c++std-lib-31059, the <tt>Allocator</tt>
++requirements implicitly require <tt>CopyConstructible</tt> because
++<tt>a.select_on_container_copy_construction()</tt> and
++<tt>container.get_allocator()</tt> both return a copy by value, but the
++requirement is not stated explicitly anywhere.
++<p/>
++In order to clarify that allocators cannot have 'explicit' copy
++constructors, the requirements should include <tt>CopyConstructible</tt>.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change Table 28 &mdash; Allocator requirements in 17.6.3.5 [allocator.requirements]:</p>
++
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
++<tr>
++<td>
++<tt>X a1(a);<br/>
++<ins>X a1 = a;</ins></tt>
++</td>
++<td>
++</td>
++<td>
++Shall not exit via an exception.<br/>
++post: <tt>a1 == a</tt>
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X a1(move(a));<br/>
++<ins>X a1 = move(a);</ins></tt>
++</td>
++<td>
++</td>
++<td>
++Shall not exit via an exception.<br/>
++post: <tt>a1</tt> equals the prior value<br/>
++of <tt>a</tt>.
++</td>
++<td>
++</td>
++</tr>
++</table>
++
++</li>
++
++<li><p>Change 17.6.3.5 [allocator.requirements] paragraph 4:</p>
++
++<blockquote><p>
++<ins>An allocator type <tt>X</tt> shall satisfy the requirements of <tt>CopyConstructible</tt>
++(17.6.3.1 [utility.arg.requirements]).</ins> The <tt>X::pointer</tt>, <tt>X::const_pointer</tt>,
++<tt>X::void_pointer</tt>, and <tt>X::const_void_pointer</tt> types shall satisfy the requirements of
++<tt>NullablePointer</tt> (17.6.3.3 [nullablepointer.requirements]). No constructor, comparison
++operator, copy operation, move operation, or swap operation on these types shall exit via an
++exception. <tt>X::pointer</tt> and <tt>X::const_pointer</tt> shall also satisfy the requirements
++for a random access iterator (24.2 [iterator.requirements]).
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2083"></a>2083. const-qualification on <tt>weak_ptr::owner_before</tt></h3>
++<p><b>Section:</b> 20.8.2.3 [util.smartptr.weak], 20.8.2.3.5 [util.smartptr.weak.obs] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ai Azuma <b>Opened:</b> 2011-09-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.weak">issues</a> in [util.smartptr.weak].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Is there any reason why <tt>weak_ptr::owner_before</tt> member function templates are not const-qualified?
++</p>
++
++<p>
++Daniel Kr&uuml;gler:
++</p>
++<blockquote><p>
++I don't think so. To the contrary, without these to be const member function templates, the
++semantics of the specializations <tt>owner_less&lt;weak_ptr&lt;T&gt;&gt;</tt> and
++<tt>owner_less&lt;shared_ptr&lt;T&gt;&gt;</tt> described in 20.8.2.4 [util.smartptr.ownerless]
++is unclear.
++<p/>
++It is amusing to note that this miss has remain undetected from the accepted paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2637.pdf">n2637</a>
++on. For the suggested wording changes see below.
++</p></blockquote>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change the class template <tt>weak_ptr</tt> synopsis in 20.8.2.3 [util.smartptr.weak]
++as indicated:</p>
++<blockquote><pre>
++namespace std {
++ template&lt;class T&gt; class weak_ptr {
++ public:
++ typedef T element_type;
++ [&hellip;]
++ template&lt;class U&gt; bool owner_before(shared_ptr&lt;U&gt; const&amp; b) <ins>const</ins>;
++ template&lt;class U&gt; bool owner_before(weak_ptr&lt;U&gt; const&amp; b) <ins>const</ins>;
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++<li><p>Change the prototypes in 20.8.2.3.5 [util.smartptr.weak.obs] before p6 as indicated:</p>
++<blockquote><pre>
++template&lt;class U&gt; bool owner_before(shared_ptr&lt;U&gt; const&amp; b) <ins>const</ins>;
++template&lt;class U&gt; bool owner_before(weak_ptr&lt;U&gt; const&amp; b) <ins>const</ins>;
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2085"></a>2085. Wrong description of effect 1 of <tt>basic_istream::ignore</tt></h3>
++<p><b>Section:</b> 27.7.2.3 [istream.unformatted] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Krzysztof Zelechowski <b>Opened:</b> 2011-09-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#istream.unformatted">active issues</a> in [istream.unformatted].</p>
++<p><b>View all other</b> <a href="lwg-index.html#istream.unformatted">issues</a> in [istream.unformatted].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++27.7.2.3 [istream.unformatted] in N3242 currently has the following to say about the
++semantics of <tt>basic_istream::ignore</tt>:
++</p>
++
++<blockquote><p>
++[..]. Characters are extracted until any of the following occurs:
++</p>
++<ul>
++<li>if <tt>n != numeric_limits&lt;streamsize&gt;::max()</tt> (18.3.2), <tt>n</tt> characters are extracted
++</li>
++</ul>
++</blockquote>
++
++<p>
++This statement, apart from being slightly ungrammatical, indicates that if
++(<tt>n == numeric_limits&lt;streamsize&gt;::max()</tt>), the method returns without
++extracting any characters.
++<p/>
++The description intends to describe the observable behaviour of an
++implementation in terms of logical assertions. Logical assertions are not
++"bullets" that can be "entered" but need not; they are predicates that can
++evaluate to true or false.
++<p/>
++The description contains two predicates, either of them causes extraction to
++terminate. In the incriminated case, the first predicate is evaluates to
++true because its premise is false, therefore no characters will be
++extracted.
++<p/>
++The intended semantics would be described by the following statement:
++</p>
++
++<blockquote><p>
++[..]. Characters are extracted until any of the following occurs:
++</p>
++<ul>
++<li><tt>(n != numeric_limits&lt;streamsize&gt;::max())</tt> (18.3.2) and (<tt>n</tt>) characters
++have been extracted so far.
++</li>
++</ul>
++</blockquote>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Resolution: Ready.
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 27.7.2.3 [istream.unformatted] p25 as indicated:</p>
++
++<blockquote><pre>
++basic_istream&lt;charT,traits&gt;&amp;
++ ignore(streamsize n = 1, int_type delim = traits::eof());
++</pre><blockquote><p>
++-25- <i>Effects</i>: Behaves as an unformatted input function (as described in 27.7.2.3 [istream.unformatted], paragraph 1). After
++constructing a <tt>sentry</tt> object, extracts characters and discards them. Characters are extracted until
++any of the following occurs:
++</p>
++<ul>
++<li><del>if</del> <tt>n != numeric_limits&lt;streamsize&gt;::max()</tt> (18.3.2.1 [limits.numeric])<del>,</del><ins>and</ins>
++<tt>n</tt> characters <del>are</del><ins>have been</ins> extracted <ins>so far</ins>
++</li>
++<li>end-of-file occurs on the input sequence (in which case the function calls <tt>setstate(eofbit)</tt>,
++which may throw <tt>ios_base::failure</tt> (27.5.5.4 [iostate.flags]));
++</li>
++<li><tt>traits::eq_int_type(traits::to_int_type(c), delim)</tt> for the next available input character <tt>c</tt>
++(in which case <tt>c</tt> is extracted).
++</li>
++</ul>
++</blockquote></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2086"></a>2086. Overly generic type support for math functions</h3>
++<p><b>Section:</b> 26.8 [c.math] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.math">active issues</a> in [c.math].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.math">issues</a> in [c.math].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++26.8 [c.math] ends with a description of a rule set for "sufficient overloads"
++in p11:
++</p>
++
++<blockquote>
++<p>Moreover, there shall be additional overloads sufficient to ensure:</p>
++<ol>
++<li>
++If any argument corresponding to a <tt>double</tt> parameter has type <tt>long double</tt>, then all arguments
++corresponding to <tt>double</tt> parameters are effectively cast to <tt>long double</tt>.
++</li>
++<li>
++Otherwise, if any argument corresponding to a <tt>double</tt> parameter has type <tt>double</tt> or an integer type,
++then all arguments corresponding to <tt>double</tt> parameters are effectively cast to <tt>double</tt>.
++</li>
++<li>
++Otherwise, all arguments corresponding to <tt>double</tt> parameters are effectively cast to <tt>float</tt>.
++</li>
++</ol>
++</blockquote>
++
++<p>
++My impression is that this rule set is probably more generic as intended, my assumption is that it is written
++to mimic the C99&#47;C1x rule set in 7.25 p2+3 in the "C++" way:
++</p>
++
++<blockquote>
++<p>
++-2- Of the <tt>&lt;math.h&gt;</tt> and <tt>&lt;complex.h&gt;</tt> functions without an
++<tt>f</tt> (<tt>float</tt>) or <tt>l</tt> (<tt>long double</tt>) suffix, several have
++one or more parameters whose corresponding real type is <tt>double</tt>. For each such
++function, except <tt>modf</tt>, there is a corresponding type-generic macro. (footnote 313)
++The parameters whose corresponding real type is <tt>double</tt> in the function
++synopsis are generic parameters. Use of the macro invokes a function whose
++corresponding real type and type domain are determined by the arguments for the generic
++parameters. (footnote 314)
++<p/>
++-3- Use of the macro invokes a function whose generic parameters have the corresponding
++real type determined as follows:
++</p>
++<ul>
++<li>
++First, if any argument for generic parameters has type <tt>long double</tt>, the type
++determined is <tt>long double</tt>.
++</li>
++<li>
++Otherwise, if any argument for generic parameters has type <tt>double</tt> or is of integer
++type, the type determined is <tt>double</tt>.
++</li>
++<li>
++Otherwise, the type determined is <tt>float</tt>.
++</li>
++</ul>
++</blockquote>
++
++<p>
++where footnote 314 clarifies the intent:
++</p>
++
++<blockquote>
++<p>
++If the type of the argument is not compatible with the type of the parameter for the selected function,
++the behavior is undefined.
++</p>
++</blockquote>
++
++<p>
++The combination of the usage of the unspecific term "cast" with otherwise no further constraints
++(note that C constraints the valid set to types that C++ describes as arithmetic types, but see below
++for one important difference) has the effect that it requires the following examples to be well-formed
++and well-defined:
++</p>
++
++<blockquote><pre>
++#include &lt;cmath&gt;
++
++enum class Ec { };
++
++struct S { explicit operator long double(); };
++
++void test(Ec e, S s) {
++ std::sqrt(e); // OK, behaves like std::sqrt((float) e);
++ std::sqrt(s); // OK, behaves like std::sqrt((float) s);
++}
++</pre></blockquote>
++<p>
++GCC 4.7 does not accept any of these examples.
++<p/>
++I found another example where the C++ rule differs from the C set,
++but in this case I'm not so sure, which direction C++ should follow.
++The difference is located in the fact, that in C enumerated types are
++<em>integer types</em> as described in 6.2.5 p17 (see e.g. n1569 or n1256):
++<p/>
++"The type char, the signed and unsigned integer types, and
++the enumerated types are collectively called integer types. The
++integer and real floating types are collectively called real types."
++<p/>
++This indicates that in C the following code
++</p>
++<blockquote><pre>
++#include &lt;math.h&gt;
++
++enum E { e };
++
++void test(void) {
++ sqrt(e); // OK, behaves like sqrt((double) e);
++}
++</pre></blockquote>
++<p>
++seems to be well-defined and <tt>e</tt> is cast to <tt>double</tt>, but in C++
++referring to
++</p>
++<blockquote><pre>
++#include &lt;cmath&gt;
++
++enum E { e };
++
++void test() {
++ std::sqrt(e); // OK, behaves like sqrt((float) e);
++}
++</pre></blockquote>
++
++<p>
++is also well-defined (because of our lack of constraints) but we
++must skip bullet 2 (because E is not an integer type) and effectively
++cast <tt>e</tt> to <tt>float</tt>. Accepting this, we would introduce
++a silent, but observable runtime difference for C and C++.
++<p/>
++GCC 4.7 does not accept this example, but causes an ambiguity
++error among the three floating point overloads of sqrt.
++<p/>
++My current suggestion to fix these problems would be to constrain the
++valid argument types of these functions to arithmetic types.
++</p>
++
++<blockquote><p>
++Howard provided wording to solve the issue.
++</p></blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Moved to Ready. The proposed wording reflects both original intent from
++TR1, and current implementations.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 26.8 [c.math] p11 as indicated:</p>
++
++<blockquote>
++<p>Moreover, there shall be additional overloads sufficient to ensure:</p>
++<ol>
++<li>
++If any <ins>arithmetic</ins> argument corresponding to a <tt>double</tt> parameter has
++type <tt>long double</tt>, then all <ins>arithmetic</ins> arguments corresponding to
++<tt>double</tt> parameters are effectively cast to <tt>long double</tt>.
++</li>
++<li>
++Otherwise, if any <ins>arithmetic</ins> argument corresponding to a <tt>double</tt>
++parameter has type <tt>double</tt> or an integer type, then all <ins>arithmetic</ins>
++arguments corresponding to <tt>double</tt> parameters are effectively cast to <tt>double</tt>.
++</li>
++<li>
++Otherwise, all <ins>arithmetic</ins> arguments corresponding to <tt>double</tt> parameters
++<del>are effectively cast to</del><ins>have type</ins> <tt>float</tt>.
++</li>
++</ol>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2087"></a>2087. <tt>iostream_category()</tt> and <tt>noexcept</tt></h3>
++<p><b>Section:</b> 27.5 [iostreams.base] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2011-09-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iostreams.base">issues</a> in [iostreams.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In <tt>&lt;system_error&gt;</tt> we have:
++</p>
++
++<blockquote><pre>
++const error_category&amp; generic_category() noexcept;
++const error_category&amp; system_category() noexcept;
++</pre></blockquote>
++
++<p>
++In <tt>&lt;future&gt;</tt> we have:
++</p>
++
++<blockquote><pre>
++const error_category&amp; future_category() noexcept;
++</pre></blockquote>
++
++<p>
++But in <tt>&lt;ios&gt;</tt> we have:
++</p>
++
++<blockquote><pre>
++const error_category&amp; iostream_category();
++</pre></blockquote>
++
++<p>
++Is there any reason that <tt>iostream_category()</tt> is not declared with
++<tt>noexcept</tt> or is this an oversight?
++</p>
++
++<p>
++Daniel:
++<p/>
++This looks like an oversight to me. We made the above
++mentioned changes as part of noexcept-ifying the thread
++library but <tt>iostream_category()</tt> was skipped, so it seems
++to be forgotten. There should be no reason, why it cannot
++be <tt>noexcept</tt>. When doing so, we should also make these functions
++<tt>noexcept</tt> (similar to corresponding overloads):
++</p>
++<blockquote><pre>
++error_code make_error_code(io_errc e);
++error_condition make_error_condition(io_errc e);
++</pre></blockquote>
++
++<p>
++Suggested wording provided by Daniel.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Unanimous.
++<p/>
++Resolution: move to tentatively ready.
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol><li>
++<p>Change 27.5.1 [iostreams.base.overview], header <tt>&lt;ios&gt;</tt> synopsis
++as indicated:
++</p>
++<blockquote><pre>
++#include &lt;iosfwd&gt;
++namespace std {
++ [&hellip;]
++ error_code make_error_code(io_errc e) <ins>noexcept</ins>;
++ error_condition make_error_condition(io_errc e) <ins>noexcept</ins>;
++ const error_category&amp; iostream_category() <ins>noexcept</ins>;
++}
++</pre></blockquote>
++
++</li>
++<li>
++<p>Change the prototype declarations in 27.5.6.5 [error.reporting] as indicated:
++</p>
++<blockquote><pre>
++error_code make_error_code(io_errc e) <ins>noexcept</ins>;
++</pre></blockquote><blockquote>
++<p>
++-1- <i>Returns</i>: <tt>error_code(static_cast&lt;int&gt;(e), iostream_category())</tt>.
++</p>
++</blockquote><blockquote><pre>
++error_condition make_error_condition(io_errc e) <ins>noexcept</ins>;
++</pre></blockquote><blockquote>
++<p>
++-2- <i>Returns</i>: <tt>error_condition(static_cast&lt;int&gt;(e), iostream_category())</tt>.
++</p>
++</blockquote><blockquote><pre>
++const error_category&amp; iostream_category() <ins>noexcept</ins>;
++</pre></blockquote><blockquote>
++<p>
++-3- <i>Returns</i>: A reference to an object of a type derived from class <tt>error_category</tt>.
++<p/>
++-4- The object’s <tt>default_error_condition</tt> and <tt>equivalent</tt> virtual functions shall behave as specified
++for the class <tt>error_category</tt>. The object’s <tt>name</tt> virtual function shall return a pointer to the string
++<tt>"iostream"</tt>.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2091"></a>2091. Misplaced effect in <tt>m.try_lock_for()</tt></h3>
++<p><b>Section:</b> 30.4.1.3 [thread.timedmutex.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-10-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.timedmutex.requirements">issues</a> in [thread.timedmutex.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.4.1.3 [thread.timedmutex.requirements]&#47;4 says, in part,
++</p><blockquote><p>
++"<i>Requires</i>: If the tick period of [the argument] is not exactly
++convertible &hellip; [it] shall be rounded up &hellip;"
++</p></blockquote>
++<p>
++This doesn't belong in the requires clause. It's an effect. It belongs in paragraph 5.
++Nitpickingly, this would be a technical change: as written it imposes an obligation on
++the caller, while moving it imposes an obligation on the callee. Although that's certainly
++not what was intended.
++<p/>
++Peter Dimov comments:
++<p/>
++Not to mention that it should round down, not up. :-)
++<p/>
++Incidentally, I see that the wrong <tt>try_lock</tt> requirement that the caller shall not own
++the mutex has entered the standard, after all. Oh well. Let's hope that the real world
++continues to ignore it.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Remove the offending sentence from the requirements clause. Do <em>not</em> add it back
++anywhere else. The implementation already must have license to wake up late, so the
++rounding is invisible.
++<p/>
++Move to Review.
++</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++Concurrency move to Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3337.</p>
++
++<ol>
++<li><p>Change 30.4.1.3 [thread.timedmutex.requirements]&#47;4 as indicated:</p>
++
++<blockquote><p>
++-3- The expression <tt>m.try_lock_for(rel_time)</tt> shall be well-formed and have the following semantics:
++<p/>
++-4- <i>Requires</i>: <del>If the tick period of <tt>rel_time</tt> is not exactly convertible to the native tick period, the
++duration shall be rounded up to the nearest native tick period.</del> If <tt>m</tt> is of type <tt>std::timed_mutex</tt>,
++the calling thread does not own the mutex.
++</p></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2092"></a>2092. Vague Wording for <tt>condition_variable_any</tt></h3>
++<p><b>Section:</b> 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-10-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvarany">issues</a> in [thread.condition.condvarany].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.5.2 [thread.condition.condvarany]&#47;4 says, in part, that
++<tt>condition_variable_any()</tt> throws an exception
++"if any native handle type manipulated is not available".
++<p/>
++I don't know what that means. Is this intended to say something different
++from the analogous words for <tt>condition_variable()</tt> [30.5.1 [thread.condition.condvar]&#47;4],
++"if some non-memory resource limitation prevents initialization"? If not,
++it should be worded the same way.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Copy the corresponding wording from the <tt>condition_variable</tt> constructor in 30.5.1 [thread.condition.condvar] p4.
++<p/>
++Move to Review.
++</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++Concurrency move to Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3337.</p>
++
++<ol>
++<li><p>Change 30.4.1.3 [thread.timedmutex.requirements]&#47;4 as indicated:</p>
++
++<blockquote><pre>
++condition_variable_any();
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-4- <i>Error conditions</i>:
++</p>
++<ul>
++<li><tt>resource_unavailable_try_again</tt> &mdash; <del>if any native handle type manipulated is not available</del>
++<ins>if some non-memory resource limitation prevents initialization</ins>.</li>
++<li><tt>operation_not_permitted</tt> &mdash; if the thread does not have the privilege to perform the operation.</li>
++</ul>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2093"></a>2093. Throws clause of <tt>condition_variable::wait</tt> with predicate</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2011-10-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++the Throws: clause of <tt>condition_variable::wait&#47;wait_xxx</tt> functions that
++take a predicate argument is:
++</p>
++<blockquote><p>
++<i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception]).
++</p></blockquote>
++<p>
++If executing the predicate throws an exception, I would expect such exception to propagate unchanged
++to the caller, but the throws clause seems to indicate that it gets mutated into a system_error. T
++hat's because of 17.5.1.4 [structure.specifications]&#47;4:
++<p/>
++"If F’s semantics contains a Throws:, Postconditions:, or Complexity: element, then that supersedes
++any occurrences of that element in the code sequence."
++<p/>
++Is my interpretation correct? Does it match the intent?
++<p/>
++Daniel comments:
++<p/>
++I don't think that this interpretation is entirely correct, the wording does not say that
++<tt>std::system_error</tt> or a derived class must be thrown, it simply is underspecified
++in this regard (The extreme interpretation is that the behaviour would be undefined, but
++that would be too far reaching I think). We have better wording for this in
++30.4.4.2 [thread.once.callonce] p4, where it says:
++<p/>
++"<i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception]),
++or any exception thrown by <tt>func</tt>."
++<p/>
++or in 30.3.2 [thread.thread.this] p6&#47;p9:
++<p/>
++"<i>Throws</i>: Nothing if <tt>Clock</tt> satisfies the <tt>TrivialClock</tt> requirements
++(20.12.3 [time.clock.req]) and operations of <tt>Duration</tt> do not throw exceptions.
++[ <i>Note</i>: instantiations of time point types and clocks supplied by the implementation
++as specified in 20.12.7 [time.clock] do not throw exceptions. &mdash; <i>end note</i> ]"
++<p/>
++So, the here discussed Throws elements should add lines along the lines of
++<p/>
++"Any exception thrown by operations of <tt>pred</tt>."
++<p/>
++and similar wording for time-related operations:
++<p/>
++"Any exception thrown by operations of <tt>Duration</tt>",
++<p/>
++"Any exception thrown by operations of <tt>chrono::duration&lt;Rep, Period&gt;</tt>"
++</p>
++
++<p><i>[2011-11-28: Ganesh comments and suggests wording]</i></p>
++
++
++<p>
++As for the discussion about the exception thrown by the manipulation of time-related objects,
++I believe the argument applies to all functions declared in 30 [thread]. Therefore,
++instead of adding wording to each member, I would simply move those requirements from
++30.3.2 [thread.thread.this] p6&#47;p9 to a new paragraph in 30.2.4 [thread.req.timing].
++<p/>
++As for 30.5.2 [thread.condition.condvarany], the member functions <tt>wait()</tt> and
++<tt>wait_until()</tt> are described only in terms of the Effects: clause (so strictly speaking,
++they need no changes), however, <tt>wait_for()</tt> is described with a full set of clauses
++including Throws: and Error conditions:. Either we should add those clauses to <tt>wait&#47;wait_until</tt>
++with changes similar to the one above, or remove paragraphs 29 to 34 entirely. By the way,
++even paragraph 26 could be removed IMHO.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++We like the idea behind the proposed resolution.
++<p/>
++Modify the first addition to read instead: "Functions that specify a timeout, will throw if an operation
++on a clock, time point, or time duration throws an exception."
++<p/>
++In the note near the bottom change "even if the timeout has already expired" to "or if the timeout has
++already expired". (This is independent, but the original doesn't seem to make sense.)
++<p/>
++Move to Review.
++</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++Concurrency move to Ready with slightly ammended wording.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3337.</p>
++
++<ol>
++<li><p>Add a new paragraph at the end of 30.2.4 [thread.req.timing]:</p>
++
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-6- The resolution of timing provided by an implementation depends on both operating system and hardware.
++The finest resolution provided by an implementation is called the <i>native resolution</i>.
++<p/>
++-7- Implementation-provided clocks that are used for these functions shall meet the <tt>TrivialClock</tt>
++requirements (20.12.3 [time.clock.req]).
++<p/>
++
++<ins>-?- Functions that specify a timeout, will throw if, during the execution of this function,
++a clock, time point, or time duration throws an exception. [ <i>Note</i>: instantiations of clock,
++time point and duration types supplied by the implementation as specified in 20.12.7 [time.clock]
++do not throw exceptions. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote>
++</li>
++
++
++<li><p>Change 30.3.2 [thread.thread.this] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++ void sleep_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);;
++</pre><blockquote>
++<p>
++-4- <i>Effects</i>: Blocks the calling thread for the absolute timeout (30.2.4 [thread.req.timing]) specified by <tt>abs_time</tt>.
++<p/>
++-5- <i>Synchronization</i>: None.
++<p/>
++-6- <i>Throws</i>: <ins>timeout-related exceptions (30.2.4 [thread.req.timing]).</ins><del>Nothing if
++<tt>Clock</tt> satisfies the <tt>TrivialClock</tt> requirements (20.12.3 [time.clock.req]) and
++operations of <tt>Duration</tt> do not throw exceptions. [ <i>Note</i>: instantiations of time point types
++and clocks supplied by the implementation as specified in 20.12.7 [time.clock] do not throw
++exceptions. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++ void sleep_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);;
++</pre><blockquote>
++<p>
++-7- <i>Effects</i>: Blocks the calling thread for the relative timeout (30.2.4 [thread.req.timing]) specified by <tt>rel_time</tt>.
++<p/>
++-8- <i>Synchronization</i>: None.
++<p/>
++-9- <i>Throws</i>: <ins>timeout-related exceptions (30.2.4 [thread.req.timing]).</ins><del>Nothing
++if operations of <tt>chrono::duration&lt;Rep, Period&gt;</tt> do not throw exceptions.
++[ <i>Note</i>: instantiations of time point types and clocks supplied by the implementation
++as specified in 20.12.7 [time.clock] do not throw exceptions. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Change 30.4.1.3 [thread.timedmutex.requirements] as indicated:</p>
++
++<p>
++-3- The expression <tt>m.try_lock_for(rel_time)</tt> shall be well-formed and have the following semantics:
++<p/>
++[&hellip;]
++<p/>
++-5- <i>Effects</i>: The function attempts to obtain ownership of the mutex within the relative timeout (30.2.4 [thread.req.timing])
++specified by <tt>rel_time</tt>. If the time specified by <tt>rel_time</tt> is less than or equal to <tt>rel_time.zero()</tt>, the
++function attempts to obtain ownership without blocking (as if by calling <tt>try_lock()</tt>). The function
++shall return within the timeout specified by <tt>rel_time</tt> only if it has obtained ownership of the mutex
++object. [<i>Note</i>: As with <tt>try_lock()</tt>, there is no guarantee that ownership will be obtained if the lock
++is available, but implementations are expected to make a strong effort to do so. &mdash; <i>end note</i>]
++<p/>
++[&hellip;]
++<p/>
++-8- <i>Synchronization</i>: If <tt>try_lock_for()</tt> returns <tt>true</tt>, prior <tt>unlock()</tt> operations on the same object
++<i>synchronize with</i> (1.10 [intro.multithread]) this operation.
++<p/>
++-9- <i>Throws</i>: <ins>timeout-related exceptions (30.2.4 [thread.req.timing]).</ins><del>Nothing</del>.
++<p/>
++-10- The expression <tt>m.try_lock_until(abs_time)</tt> shall be well-formed and have the following semantics:
++<p/>
++[&hellip;]
++<p/>
++-12- <i>Effects</i>: The function attempts to obtain ownership of the mutex. If <tt>abs_time</tt> has already passed, the
++function attempts to obtain ownership without blocking (as if by calling <tt>try_lock()</tt>). The function
++shall return before the absolute timeout (30.2.4 [thread.req.timing]) specified by <tt>abs_time</tt> only
++if it has obtained ownership of the mutex object. [<i>Note</i>: As with <tt>try_lock()</tt>, there is no guarantee
++that ownership will be obtained if the lock is available, but implementations are expected to make a strong effort
++to do so. &mdash; <i>end note</i>]
++<p/>
++[&hellip;]
++<p/>
++-15- <i>Synchronization</i>: If <tt>try_lock_until()</tt> returns true, prior <tt>unlock()</tt> operations on the same object
++<i>synchronize with</i> (1.10 [intro.multithread]) this operation.
++<p/>
++-16- <i>Throws</i>: <ins>timeout-related exceptions (30.2.4 [thread.req.timing]).</ins><del>Nothing</del>.
++</p>
++</li>
++
++<li><p>Change 30.5.1 [thread.condition.condvar] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class Predicate&gt;
++ void wait(unique_lock&lt;mutex&gt;&amp; lock, Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-15- <i>Effects</i>: <ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++while (!pred())
++ wait(lock);
++</pre></blockquote>
++<p>
++[&hellip;]
++<p/>
++-17- <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2 [thread.req.exception])<ins>,
++timeout-related exceptions (30.2.4 [thread.req.timing]), or any exception thrown by <tt>pred</tt></ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++ cv_status wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-23- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception])
++<ins>or timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++ cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-26- <i>Effects</i>: <del>as if</del><ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++return wait_until(lock, chrono::steady_clock::now() + rel_time);
++</pre></blockquote>
++<p>
++[&hellip;]
++<p/>
++-29- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception])
++<ins>or timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Clock, class Duration, class Predicate&gt;
++ bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
++ Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-32- <i>Effects</i>: <ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++while (!pred())
++ if (wait_until(lock, abs_time) == cv_status::timeout)
++ return pred();
++return true;
++</pre></blockquote>
++<p>
++<del>-33- <i>Returns</i>: <tt>pred()</tt></del>
++<p/>
++[&hellip;]
++<p/>
++-36- <i>Throws</i>: <tt>std::system_error</tt> when an exception is required (30.2.2 [thread.req.exception])<ins>,
++timeout-related exceptions (30.2.4 [thread.req.timing]), or any exception thrown by <tt>pred</tt></ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Rep, class Period, class Predicate&gt;
++ bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
++ Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-39- <i>Effects</i>: <del>as if</del><ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
++</pre></blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-42- <i>Returns</i>: <tt>pred()</tt></del>
++<p/>
++[&hellip;]
++<p/>
++-44- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception])<ins>,
++timeout-related exceptions (30.2.4 [thread.req.timing]), or any exception thrown by <tt>pred</tt></ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Change 30.5.2 [thread.condition.condvarany] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class Lock, class Predicate&gt;
++ void wait(Lock&amp; lock, Predicate pred);
++</pre><blockquote>
++<p>
++-14- <i>Effects</i>: <ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++while (!pred())
++ wait(lock);
++</pre></blockquote>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Lock, class Clock, class Duration&gt;
++ cv_status wait_until(Lock&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-18- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception])
++<ins>or any timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period&gt;
++ cv_status wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-20- <i>Effects</i>: <del>as if</del><ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++return wait_until(lock, chrono::steady_clock::now() + rel_time);
++</pre></blockquote>
++<p>
++[&hellip;]
++<p/>
++-23- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception])
++<ins>or any timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Lock, class Clock, class Duration, class Predicate&gt;
++ bool wait_until(Lock&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time, Predicate pred);
++</pre><blockquote>
++<p>
++-25- <i>Effects</i>: <ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++while (!pred())
++ if (wait_until(lock, abs_time) == cv_status::timeout)
++ return pred();
++return true;
++</pre></blockquote>
++<p>
++-26- <del><i>Returns</i>: <tt>pred()</tt></del><ins>[<i>Note</i>: There is no blocking if <tt>pred()</tt> is initially <tt>true</tt>,
++or if the timeout has already expired. &mdash; <i>end note</i>]</ins>
++<p/>
++-27- [<i>Note</i>: The returned value indicates whether the predicate evaluates to <tt>true</tt> regardless of whether the
++timeout was triggered. <i>end note</i>]
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class Lock, class Rep, class Period, class Predicate&gt;
++ bool wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time, Predicate pred);
++</pre><blockquote>
++<p>
++-28- <i>Effects</i>: <del>as if</del><ins>Equivalent to:</ins>
++</p>
++<blockquote><pre>
++return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
++</pre></blockquote>
++<p>
++<del>-29- [<i>Note</i>: There is no blocking if <tt>pred()</tt> is initially <tt>true</tt>,
++even if the timeout has already expired. &mdash; <i>end note</i>]</del>
++<del>-30- <i>Postcondition</i>: <tt>lock</tt> is locked by the calling thread.</del>
++<p/>
++<del>-31- <i>Returns</i>: <tt>pred()</tt></del>
++<p/>
++<del>-32- [<i>Note</i>: The returned value indicates whether the predicate evaluates to <tt>true</tt>
++regardless of whether the timeout was triggered. &mdash; <i>end note</i>]</del>
++<p/>
++<del>-33- <i>Throws</i>: <tt>system_error</tt> when an exception is required (30.2.2 [thread.req.exception]).</del>
++<p/>
++<del>-34- <i>Error conditions</i>:</del>
++</p>
++<ul>
++<li><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></li>
++</ul>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2094"></a>2094. <tt>duration</tt> conversion overflow shouldn't participate in overload resolution</h3>
++<p><b>Section:</b> 20.12.5.1 [time.duration.cons] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Vicente J. Botet Escriba <b>Opened:</b> 2011-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#time.duration.cons">issues</a> in [time.duration.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++20.12.5.1 [time.duration.cons] says:
++</p>
++<blockquote><pre>
++template &lt;class Rep2, class Period2&gt;
++ constexpr duration(const duration&lt;Rep2, Period2&gt;&amp; d);
++</pre><blockquote>
++<p>
++<i>Remarks</i>: This constructor shall not participate in overload resolution unless
++<tt>treat_as_floating_point&lt;rep&gt;::value</tt> is <tt>true</tt> or both
++<tt>ratio_divide&lt;Period2, period&gt;::den</tt> is <tt>1</tt> and <tt>treat_as_floating_point&lt;Rep2&gt;::value</tt>
++is <tt>false</tt>.
++</p></blockquote></blockquote>
++<p>
++The evaluation of <tt>ratio_divide&lt;Period2, period&gt;::den</tt> could make
++<tt>ratio_divide&lt;Period2, period&gt;::num</tt> overflow.
++<p/>
++This occur for example when we try to create a millisecond (<tt>period</tt>=<tt>ratio&lt;1,1000&gt;</tt>)
++from an exa-second (<tt>Period2</tt>=<tt>ratio&lt;10<sup>18</sup>&gt;</tt>).
++<p/>
++<tt>ratio_divide&lt;ratio&lt;10<sup>18</sup>&gt;, ratio&lt;1,1000&gt;&gt;::num</tt> is
++<tt>10<sup>21</sup></tt> which overflows which makes the compiler error.
++<p/>
++If the function <tt>f</tt> is overloaded with milliseconds and seconds
++</p>
++<blockquote><pre>
++void f(milliseconds);
++void f(seconds);
++</pre></blockquote>
++<p>
++The following fails to compile.
++</p>
++<blockquote><pre>
++duration&lt;int,exa&gt; r(1);
++f(r);
++</pre></blockquote>
++<p>
++While the conversion to seconds work, the conversion to milliseconds make the program fail at compile time.
++In my opinion, this program should be well formed and the constructor from <tt>duration&lt;int,exa&gt;</tt>
++to milliseconds shouldn't participate in overload resolution as the result can not be represented.
++<p/>
++I think the wording of the standard can be improved so no misinterpretations are possible by adding that
++"no overflow is induced by the conversion".
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Review.
++</p>
++<p>Pete: The wording is not right.</p>
++<p>Howard: Will implement this to be sure it works.</p>
++<p>Jeffrey: If ratio needs a new hook, should it be exposed to users for their own uses?</p>
++<p>Pete: No.</p>
++
++<p>
++Move to Review,
++Howard to implement in a way that mere mortals can understand.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change the following paragraphs of 20.12.5.1 [time.duration.cons] p4 indicated:</p>
++
++<blockquote><pre>
++template &lt;class Rep2, class Period2&gt;
++ constexpr duration(const duration&lt;Rep2, Period2&gt;&amp; d);
++</pre><blockquote>
++<p>
++<i>Remarks</i>: This constructor shall not participate in overload resolution unless <ins>no
++overflow is induced in the conversion and</ins> <tt>treat_as_floating_point&lt;rep&gt;::value</tt>
++is <tt>true</tt> or both <tt>ratio_divide&lt;Period2, period&gt;::den</tt> is <tt>1</tt> and
++<tt>treat_as_floating_point&lt;Rep2&gt;::value</tt> is <tt>false</tt>. [ <i>Note</i>: This
++requirement prevents implicit truncation error when converting between integral-based duration
++types. Such a construction could easily lead to confusion about the value of the
++duration. &mdash; <i>end note</i> ]
++</p></blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2096"></a>2096. Incorrect constraints of <tt>future::get</tt> in regard to <tt>MoveAssignable</tt></h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.6.6 [futures.unique_future] paragraph 15 says the following:
++</p>
++<blockquote><pre>
++R future::get();
++</pre></blockquote>
++<p>
++&hellip;
++<p/>
++-15- <i>Returns</i>:
++</p>
++<ul>
++<li>
++<p><tt>future::get()</tt> returns the value stored in the object’s shared state. If the type of the value is
++<tt>MoveAssignable</tt> the returned value is moved, otherwise it is copied.
++<p/>
++&hellip;
++</p>
++</li>
++</ul>
++<p>
++There are some problems with the description:
++<p/>
++"If the type of the value is <tt>MoveAssignable</tt> the returned value is moved, otherwise it is copied."
++</p>
++<ol>
++<li>It seems to impose unrealistic constraints on implementations, because how could an implementor
++recognize whether a user-defined type satisfies the semantics of <tt>MoveAssignable</tt>? This should be
++based solely on a pure expression-based requirement, if this is an requirement for implementations.
++</li>
++<li>
++Reducing <tt>MoveAssignable</tt> to the plain expression part <tt>std::is_move_assignable</tt>
++would solvs (1), but raises another question, namely why a <em>move-assignment</em> should be relevant
++for a function return based on the value stored in the future state? We would better fall back to
++<tt>std::is_move_constructible</tt> instead.
++</li>
++<li><p>The last criticism I have is about the part
++<p/>
++"the returned value is moved, otherwise it is copied"
++<p/>
++because an implementation won't be able to recognize what the user-defined type
++will do during an expression that is prepared by the implementation. I think the
++wording is intended to <em>allow</em> a move by seeding with an rvalue expression via
++<tt>std::move</tt> (or equivalent), else the result will be an effective
++copy construction.
++</p>
++</li>
++</ol>
++
++<p><i>[2011-11-28 Moved to Tentatively Ready after 5 positive votes on c++std-lib.]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 30.6.6 [futures.unique_future] paragraph 15 as indicated:</p>
++
++<blockquote><pre>
++R future::get();
++</pre></blockquote>
++<p>
++&hellip;
++<p/>
++-15- <i>Returns</i>:
++</p>
++<ul>
++<li>
++<p><tt>future::get()</tt> returns the value <ins><tt>v</tt></ins> stored in the object’s shared
++state <ins>as <tt>std::move(v)</tt></ins>. <del>If the type of the value is <tt>MoveAssignable</tt>
++the returned value is moved, otherwise it is copied.</del>
++<p/>
++&hellip;
++</p>
++</li>
++</ul>
++
++
++
++
++
++
++<hr>
++<h3><a name="2097"></a>2097. <tt>packaged_task</tt> constructors should be constrained</h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-11-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++With the proposed resolution of <a href="lwg-defects.html#2067">2067</a>, this no longer selects the
++copy constructor:
++</p>
++<blockquote><pre>
++std::packaged_task&lt;void()&gt; p1;
++std::packaged_task&lt;void()&gt; p2(p1);
++</pre></blockquote>
++<p>
++Instead this constructor is a better match:
++</p>
++<blockquote><pre>
++template &lt;class F&gt;
++ explicit packaged_task(F&amp;&amp; f);
++</pre></blockquote>
++<p>
++This attempts to package a <tt>packaged_task</tt>, which internally tries to
++copy <tt>p2</tt>, which fails because the copy constructor is deleted. For at
++least one implementation the resulting error message is much less
++helpful than the expected "cannot call deleted function" because it
++happens after instantiating several more templates rather than in the
++context where the constructor is called.
++<p/>
++I believe the solution is to constrain to the template constructors so
++the template argument <tt>F</tt> cannot be deduced as (possibly <i>cv</i>)
++<tt>packaged_task&amp;</tt> or <tt>packaged_task</tt>. It could be argued
++this constraint is already implied because <tt>packaged_task</tt> is not
++copyable and the template constructors require that "invoking a copy of <tt>f</tt>
++shall behave the same as invoking <tt>f</tt>".
++<p/>
++Daniel points out that the variadic constructor of <tt>std::thread</tt>
++described in 30.3.1.2 [thread.thread.constr] has a similar problem and
++suggests a similar wording change, which has been integrated below.
++<p/>
++An alternative is to declare <tt>thread(thread&amp;)</tt> and
++<tt>packaged_task(packaged_task&amp;)</tt> as deleted.
++</p>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++This issue appears to be more about library specification than technical
++concurrency issues, so should be handled in LWG.
++</p>
++
++
++<p><i>[2013, Chicago]</i></p>
++
++<p>
++Move to Immediate resolution.
++</p>
++<p>
++Howard volunteered existing implementation experience with the first change, and saw no issue that the second would
++introduce any new issue.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Insert a new Remarks element to 30.3.1.2 [thread.thread.constr] around p3 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class F, class ...Args&gt; explicit thread(F&amp;&amp; f, Args&amp;&amp;... args);
++</pre></blockquote>
++<p>
++-3- <i>Requires</i>: <tt>F</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall satisfy the <tt>MoveConstructible</tt>
++requirements. <tt><i>INVOKE</i>(<i>DECAY_COPY</i> ( std::forward&lt;F&gt;(f)), <i>DECAY_COPY</i> (std::forward&lt;Args&gt;(args))...)</tt>
++(20.8.2) shall be a valid expression.
++<p/>
++<ins>-?- <i>Remarks</i>: This constructor shall not participate in overload resolution if <tt>decay&lt;F&gt;::type</tt>
++is the same type as <tt>std::thread</tt>.</ins>
++</p>
++</li>
++
++<li><p>Insert a new Remarks element to 30.6.9.1 [futures.task.members] around p2 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class F&gt;
++ packaged_task(F&amp;&amp; f);
++template &lt;class F, class Allocator&gt;
++ explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++</pre></blockquote>
++<p>
++-2- <i>Requires</i>: <tt><i>INVOKE</i>(f, t1, t2, ..., tN, R)</tt>, where <tt>t1, t2, ..., tN</tt> are values of the corresponding
++types in <tt>ArgTypes...</tt>, shall be a valid expression. Invoking a copy of <tt>f</tt> shall behave the same as invoking <tt>f</tt>.
++<p/>
++<ins>-?- <i>Remarks</i>: These constructors shall not participate in overload resolution if <tt>decay&lt;F&gt;::type</tt>
++is the same type as <tt>std::packaged_task&lt;R(ArgTypes...)&gt;</tt>.</ins>
++</p>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2098"></a>2098. Minor Inconsistency between <tt>promise::set_value</tt> and <tt>promise::set_value_at_thread_exit</tt></h3>
++<p><b>Section:</b> 30.6.5 [futures.promise] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2011-11-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#futures.promise">active issues</a> in [futures.promise].</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.promise">issues</a> in [futures.promise].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.6.5 [futures.promise]&#47;16 says that <tt>promise::set_value(const R&amp;)</tt> throws any exceptions
++thrown by <tt>R</tt>'s copy constructor, and that <tt>promise_set_value(R&amp;&amp;)</tt> throws any exceptions
++thrown by <tt>R</tt>'s move constructor.
++<p/>
++30.6.5 [futures.promise]&#47;22 is the Throws: clause for <tt>promise::set_value_at_thread_exit</tt>. It
++has no corresponding requirements, only that these functions throw "<tt>future_error</tt> if an error condition
++occurs."
++<p/>
++Daniel suggests wording to fix this: The approach is a bit more ambitious and also attempts to fix wording glitches
++of 30.6.5 [futures.promise]&#47;16, because it would be beyond acceptable efforts of implementations to
++determine whether a constructor call of a user-defined type will indeed call a copy constructor or move constructor
++(in the first case it might be a template constructor, in the second case it might also be a copy-constructor,
++if the type has no move constructor).
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++Moved to Review by the concurrency working group, with no further comments.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change 30.6.5 [futures.promise]&#47;16 as indicated:</p>
++<blockquote><pre>
++void promise::set_value(const R&amp; r);
++void promise::set_value(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value(R&amp; r);
++void promise&lt;void&gt;::set_value();
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-16- <i>Throws</i>:
++</p>
++<ul>
++<li><tt>future_error</tt> if its shared state already has a stored value or exception, or</li>
++<li>for the first version, any exception thrown by the <del>copy constructor
++of</del><ins>constructor selected to copy an object of</ins> <tt>R</tt>, or</li>
++<li>for the second version, any exception thrown by the <del>move constructor
++of</del><ins>constructor selected to move an object of</ins> <tt>R</tt>.</li>
++</ul>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 30.6.5 [futures.promise]&#47;22 as indicated:</p>
++<blockquote><pre>
++void promise::set_value_at_thread_exit(const R&amp; r);
++void promise::set_value_at_thread_exit(R&amp;&amp; r);
++void promise&lt;R&amp;&gt;::set_value_at_thread_exit(R&amp; r);
++void promise&lt;void&gt;::set_value_at_thread_exit();
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-16- <i>Throws</i>: <del><tt>future_error</tt> if an error condition occurs.</del>
++</p>
++<ul>
++<li><ins><tt>future_error</tt> if its shared state already has a stored value or exception, or</ins></li>
++<li><ins>for the first version, any exception thrown by the constructor selected to copy an object of <tt>R</tt>, or</ins></li>
++<li><ins>for the second version, any exception thrown by the constructor selected to move an object of <tt>R</tt>.</ins></li>
++</ul>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2099"></a>2099. Unnecessary constraints of <tt>va_start()</tt> usage</h3>
++<p><b>Section:</b> 18.10 [support.runtime] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-11-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#support.runtime">active issues</a> in [support.runtime].</p>
++<p><b>View all other</b> <a href="lwg-index.html#support.runtime">issues</a> in [support.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In 18.10 [support.runtime] p3 we find (emphasis mine):
++</p>
++<blockquote><p>
++The restrictions that ISO C places on the second parameter to the <tt>va_start()</tt> macro in header <tt>&lt;stdarg.h&gt;</tt>
++are different in this International Standard. The parameter <tt>parmN</tt> is the identifier of the rightmost parameter
++in the variable parameter list of the function definition (the one just before the ...).227 <em>If the parameter
++<tt>parmN</tt> is <strong>declared</strong> with a <strong>function</strong>, <strong>array</strong></em>, or reference type,
++or with a type that is not compatible with the type that results when passing an argument for which there is no parameter,
++the behavior is undefined.
++</p></blockquote>
++
++<p>
++It seems astonishing that the constraints on function types and array types imposes these
++on the <strong>declared</strong> parameter <tt>parmN</tt>, not to the adjusted one (which would
++not require this extra wording, because that is implicit). This seems to say that a function
++definition of the form (Thanks to Johannes Schaub for this example)
++</p>
++<blockquote><pre>
++#include &lt;stdarg.h&gt;
++
++void f(char const paramN[], ...) {
++ va_list ap;
++ va_start(ap, paramN);
++ va_end(ap);
++}
++</pre></blockquote>
++<p>
++would produce undefined behaviour when used.
++<p/>
++Similar wording exists in C99 and in the most recent C11 draft in 7.16.1.4 p4
++<p/>
++In my opinion the constraints in regard to array types and function types are
++unnecessary and should be relaxed. Are there really implementations out in the
++wild that would (according to my understanding incorrectly) provide the declared and
++not the adjusted type of <tt>paramN</tt> as deduced type to <tt>va_start()</tt>?
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 18.10 [support.runtime] p3 as indicated:</p>
++<blockquote><p>
++The restrictions that ISO C places on the second parameter to the <tt>va_start()</tt> macro in header <tt>&lt;stdarg.h&gt;</tt>
++are different in this International Standard. The parameter <tt>parmN</tt> is the identifier of the rightmost parameter
++in the variable parameter list of the function definition (the one just before the ...).227 If the parameter
++<tt>parmN</tt> is <del>declared with</del><ins>of</ins> a <del>function, array, or</del> reference type, or
++<del>with</del><ins>of</ins> a type that is not compatible with the type that results when passing an argument for
++which there is no parameter, the behavior is undefined.
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2100"></a>2100. timed waiting functions cannot timeout if <tt>launch::async</tt> policy used</h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-11-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.6.8 [futures.async] p5 says
++</p>
++
++<blockquote>
++<p>
++If the implementation chooses the <tt>launch::async</tt> policy,
++</p>
++<ul><li>a call to a waiting function on an asynchronous return object that shares the
++shared state created by this <tt>async</tt> call shall block until the associated thread has
++completed, as if joined (30.3.1.5 [thread.thread.member]);</li>
++</ul>
++</blockquote>
++
++<p>
++That should say a non-timed waiting function, otherwise, calling a timed waiting function
++can block indefinitely waiting for the associated thread to complete, rather than timing
++out after the specified time.
++<p/>
++Since <tt>std::thread</tt> does not provide a <tt>timed_join()</tt> function (nor does
++Pthreads, making it impossible on many platforms) there is no way for a timed waiting
++function to try to join but return early due to timeout, therefore timed waiting
++functions either cannot guarantee to timeout or cannot be used to meet the requirement
++to block until the thread is joined. In order to allow timed waiting functions to
++timeout the requirement should only apply to non-timed waiting functions.
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++Detlef: Do we actually need this fix &mdash; is it detectable?
++</p>
++<p>
++Yes &mdash; you will never get a timeout. Should we strike the whole paragraph?
++</p>
++<p>
++Hans: issue with thread local destruction.
++</p>
++<p>
++Niklas: I have a strong expectation that a timed wait will respect the timeout
++</p>
++<p>
++<em>agreed</em>
++</p>
++<p>
++Detlef: we want a timed wait that does not time out to return like a non-timed wait; but is this implementable?
++</p>
++<p>
++Pablo: Could we simply append ", or else time out"
++</p>
++<p>
++Detlef: the time out on the shared state needs implementing anyway, even if the underlying O/S does not support a timed join.
++</p>
++<p>
++Hans: the net effect is the timeout does not cover the thread local destruction... ah, I see what you're doing
++</p>
++<p>
++Detlef: happy with Pablo's proposal
++</p>
++<p>
++Wording proposed is to append after the word "joined" add ", or else time out"
++</p>
++<p>
++Moved to review with this wording.
++</p>
++
++<p><i>[2013, Bristol]</i></p>
++
++
++<p>
++"Non-timed" made the new wording redundant and the result overly weak. Remove it.
++<p/>
++Attempted to move to add this to the working paper (Concurrency motion 2) without the addition of "non-timed".
++Motion was withdrawn after Jonathan Wakely expressed implementability concerns.
++</p>
++
++<p><i>[2013-09, Chicago]</i></p>
++
++<p>
++Discussion of interaction with the absence of a Posix timed join.
++<p/>
++Jonathan Wakely withdrew his objection, so moved to Immediate.
++<p/>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to the FDIS.]</i></p>
++
++
++<p>Change 30.6.8 [futures.async] p5 as indicated:</p>
++
++<blockquote>
++<p>
++If the implementation chooses the <tt>launch::async</tt> policy,
++</p>
++<ul><li>a call to a waiting function on an asynchronous return object
++that shares the shared state created by this <tt>async</tt> call shall block until the
++associated thread has completed, as if joined<ins>, or else time out</ins>
++(30.3.1.5 [thread.thread.member]);</li>
++</ul>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2102"></a>2102. Why is <tt>std::launch</tt> an implementation-defined type?</h3>
++<p><b>Section:</b> 30.6.1 [futures.overview] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-11-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.overview">issues</a> in [futures.overview].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++30.6.1 [futures.overview] says <tt>std::launch</tt> is an
++implementation-defined bitmask type, which would usually mean the
++implementation can choose whether to define an enumeration type, or a
++<tt>bitset</tt>, or an integer type. But in the case of <tt>std::launch</tt> it's
++required to be a scoped enumeration type,
++</p>
++<blockquote><pre>
++enum class launch : <i>unspecified</i> {
++ async = <i>unspecified</i>,
++ deferred = <i>unspecified</i>,
++ <i>implementation-defined</i>
++};
++</pre></blockquote>
++<p>
++so what is implementation-defined about it, and what is an implementation
++supposed to document about its choice?
++</p>
++
++<p><i>[2011-12-02 Moved to Tentatively Ready after 6 positive votes on c++std-lib.]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 30.6.1 [futures.overview] paragraph 2 as indicated:</p>
++
++<blockquote><p>
++The enum type <tt>launch</tt> is <del>an implementation-defined</del><ins>a</ins> bitmask type
++(17.5.2.1.3 [bitmask.types]) with <tt>launch::async</tt> and <tt>launch::deferred</tt>
++denoting individual bits. [ <i>Note</i>: Implementations can provide bitmasks to specify restrictions
++on task interaction by functions launched by <tt>async()</tt> applicable to a corresponding subset of
++available launch policies. Implementations can extend the behavior of the first overload of <tt>async()</tt> by
++adding their extensions to the launch policy under the “as if” rule. &mdash; <i>end note</i> ]
++</p></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2103"></a>2103. <tt>std::allocator_traits&lt;std::allocator&lt;T&gt;&gt;::propagate_on_container_move_assignment</tt></h3>
++<p><b>Section:</b> 20.7.9 [default.allocator] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ai Azuma <b>Opened:</b> 2011-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#default.allocator">issues</a> in [default.allocator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++&quot;<tt>std::allocator_traits&lt;std::allocator&lt;T&gt;&gt;::propagate_on_container_move_assignment::value</tt>&quot;
++is specified as &quot;false&quot;, according to (20.7.9 [default.allocator]) and (20.7.8.1 [allocator.traits.types]).
++However, according to (23.2.1 [container.requirements.general]), this specification leads to the unneeded requirements
++(<tt>MoveInsertable</tt> and <tt>MoveAssignable</tt> of the value type) on the move assignment operator of containers
++with the default allocator.
++<p/>
++Proposed resolution:
++<p/>
++Either of the following two changes;
++</p>
++<ol>
++<li>
++adding the nested typedef like
++&quot;<tt>typedef std::true_type propagate_on_container_move_assignment;</tt>&quot;
++in the definition of <tt>std::allocator</tt> class template,
++</li>
++<li>
++adding the explicit partial specialization of
++&quot;<tt>std::allocator_traits</tt>&quot; class template for &quot;<tt>std::allocator</tt>&quot;
++class template, in which &quot;<tt>propagate_on_container_move_assignment</tt>&quot;
++nested typedef is specified as &quot;<tt>std::true_type</tt>&quot;.
++</li>
++</ol>
++<p>
++Pablo prefers the first resolution.
++</p>
++
++<p><i>[2011-12-02: Pablo comments]</i></p>
++
++
++<p>
++This issue has potentially some overlap with <a href="lwg-defects.html#2108">2108</a>. Should the trait <tt>always_compare_equal</tt>
++been added, this issue's resolution should be improved based on that.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 20.7.9 [default.allocator], the class template <tt>allocator</tt> synopsis as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; class allocator;
++
++ <i>// specialize for <tt>void</tt>:</i>
++ template &lt;&gt; class allocator&lt;void&gt; {
++ public:
++ typedef void* pointer;
++ typedef const void* const_pointer;
++ <i>// reference-to-<tt>void</tt> members are impossible.</i>
++ typedef void value_type;
++ template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
++ };
++
++ template &lt;class T&gt; class allocator {
++ public:
++ typedef size_t size_type;
++ typedef ptrdiff_t difference_type;
++ typedef T* pointer;
++ typedef const T* const_pointer;
++ typedef T&amp; reference;
++ typedef const T&amp; const_reference;
++ typedef T value_type;
++ template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
++ <ins>typedef true_type propagate_on_container_move_assignment;</ins>
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2104"></a>2104. <tt>unique_lock</tt> move-assignment should not be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 30.4.2.2 [thread.lock.unique] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Anthony Williams <b>Opened:</b> 2011-11-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++I just noticed that the <tt>unique_lock</tt> move-assignment operator is declared <tt>noexcept</tt>. This
++function may call <tt>unlock()</tt> on the wrapped mutex, which may throw.
++<p/>
++Suggested change: remove the <tt>noexcept</tt> specification from <tt>unique_lock::operator=(unique_lock&amp;&amp;)</tt>
++in 30.4.2.2 [thread.lock.unique] and 30.4.2.2.1 [thread.lock.unique.cons].
++<p/>
++Daniel:
++<p/>
++I think the situation is actually a bit more complex as it initially looks.
++<p/>
++First, the effects of the move-assignment operator are (emphasize mine):
++</p>
++<blockquote><p>
++<i>Effects</i>: <strong>If</strong> <tt>owns</tt> calls <tt>pm->unlock()</tt>.
++</p></blockquote>
++<p>
++Now according to the <tt>BasicLockable</tt> requirements:
++</p>
++<blockquote><p>
++<tt>m.unlock()</tt>
++<p/>
++3 <i>Requires</i>: The current execution agent shall hold a lock on <tt>m</tt>.
++<p/>
++4 <i>Effects</i>: Releases a lock on <tt>m</tt> held by the current execution agent.
++<p/>
++<i>Throws</i>: Nothing.
++</p></blockquote>
++<p>
++This shows that unlock itself is a function with narrow contract and for
++this reasons no unlock function of a mutex or lock itself does have a noexcept
++specifier according to our mental model.
++<p/>
++Now the move-assignment operator <strong>attempts</strong> to satisfy these
++requirement of the function and calls it only when it assumes that the conditions
++are ok, so from the view-point of the caller of the move-assignment operator it
++looks as if the move-assignment operator would in total a function with a
++wide contract.
++<p/>
++The problem with this analysis so far is, that it depends on the assumed
++correctness of the state "owns".
++<p/>
++Looking at the construction or state-changing functions, there do exist several
++ones that depend on caller-code satisfying the requirements and there is one
++guy, who looks most suspicious:
++</p>
++<blockquote><p>
++<tt>unique_lock(mutex_type&amp; m, adopt_lock_t);</tt>
++<p/>
++11 <i>Requires</i>: The calling thread own the mutex.<br/>
++[&hellip;]<br/>
++13 <i>Postconditions</i>: <tt>pm == &amp;m</tt> and <tt>owns == true</tt>.<br/>
++</p></blockquote>
++<p>
++because this function does not even call <tt>lock()</tt> (which may, but is not
++required to throw an exception if the calling thread does already own the mutex).
++So we have in fact still a move-assignment operator that might throw an exception,
++if the mutex was either constructed or used (call of lock) incorrectly.
++<p/>
++The correct fix seems to me to also add a "<i>Throws</i>: Nothing" element to
++the move-assignment operator, because using it correctly shall not throw an
++exception.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate after SG1 review]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li>
++<p>Change 30.4.2.2 [thread.lock.unique], class template <tt>unique_lock</tt> synopsis as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Mutex&gt;
++ class unique_lock {
++ public:
++ typedef Mutex mutex_type;
++ [&hellip;]
++ unique_lock(unique_lock&amp;&amp; u) noexcept;
++ unique_lock&amp; operator=(unique_lock&amp;&amp; u) <del>noexcept</del>;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li>
++<p>Change 30.4.2.2.1 [thread.lock.unique.cons] around p22 as indicated:</p>
++
++<blockquote><pre>
++unique_lock&amp; operator=(unique_lock&amp;&amp; u) <del>noexcept</del>;
++</pre><blockquote>
++<p>
++-22- <i>Effects</i>: If <tt>owns</tt> calls <tt>pm->unlock()</tt>.
++<p/>
++-23- <i>Postconditions</i>: <tt>pm == u_p.pm</tt> and <tt>owns == u_p.owns</tt> (where <tt>u_p</tt>
++is the state of <tt>u</tt> just prior to this construction), <tt>u.pm == 0</tt> and <tt>u.owns == false</tt>.
++<p/>
++-24- [<i>Note</i>: With a recursive mutex it is possible for both <tt>*this</tt> and <tt>u</tt> to own
++the same mutex before the assignment. In this case, <tt>*this</tt> will own the mutex after the assignment
++and <tt>u</tt> will not. &mdash; <i>end note</i>]
++</p>
++<ins>-??- <i>Throws</i>: Nothing.</ins>
++<p/>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2105"></a>2105. Inconsistent requirements on <tt>const_iterator</tt>'s <tt>value_type</tt></h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2011-11-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In the FDIS, Table 96 specifies <tt>X::const_iterator</tt> as a "constant iterator type
++whose value type is <tt>T</tt>". However, Table 97 specifies <tt>X::const_reverse_iterator</tt>
++as an "iterator type whose value type is <tt>const T</tt>" and which is defined as
++<tt>reverse_iterator&lt;const_iterator&gt;</tt>. But <tt>reverse_iterator::value_type</tt> is
++just "<tt>typename iterator_traits&lt;Iterator&gt;::value_type</tt>" 24.5.1.1 [reverse.iterator],
++so <tt>const_iterator</tt> and <tt>const_reverse_iterator</tt> must have the same <tt>value_type</tt>.
++</p>
++<p>
++The resolution to issue <a href="lwg-defects.html#322">322</a> implies that
++<tt>const_reverse_iterator</tt> should change.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change Table 97 &mdash; "Reversible container requirements" as indicated</p>
++
++<table border="1">
++<caption>Table 97 &mdash; Reversible container requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td>
++<tt>X::reverse_-<br/>
++iterator</tt>
++</td>
++<td>
++iterator type whose value type<br/>
++is <tt>T</tt>
++</td>
++<td>
++<tt>reverse_iterator&lt;iterator&gt;</tt>
++</td>
++<td>
++compile time
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X::const_-<br/>
++reverse_-<br/>
++iterator</tt>
++</td>
++<td>
++<ins>constant</ins> iterator type whose value type<br/>
++is <tt><del>const</del> T</tt>
++</td>
++<td>
++<tt>reverse_iterator&lt;const_iterator&gt;</tt>
++</td>
++<td>
++compile time
++</td>
++</tr>
++</table>
++
++
++
++
++
++
++
++<hr>
++<h3><a name="2106"></a>2106. <tt>move_iterator</tt> wrapping iterators returning prvalues</h3>
++<p><b>Section:</b> 24.5.3 [move.iterators] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Dave Abrahams <b>Opened:</b> 2011-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#move.iterators">issues</a> in [move.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Shouldn't <tt>move_iterator</tt> be specialized so that if the iterator it wraps
++returns a prvalue when dereferenced, the <tt>move_iterator</tt> also returns by
++value? Otherwise, it creates a dangling reference.
++<p/>
++Howard: I believe just changing <tt>move_iterator&lt;I&gt;::reference</tt> would do.
++A direction might be testing on <tt>is_reference&lt;iterator_traits&lt;I&gt;::reference&gt;</tt>,
++or <tt>is_reference&lt;decltype(*declval&lt;I&gt;())&gt;</tt>.
++<p/>
++Daniel: I would prefer to use a consistent style among the iterator adaptors, so I
++suggest to keep with the <tt>iterator_traits</tt> typedefs if possible.
++</p>
++<blockquote><pre>
++using reference = typename conditional&lt;
++ is_reference&lt;typename iterator_traits&lt;Iterator&gt;::reference&gt;::value,
++ value_type&amp;&amp;,
++ value_type
++&gt;::type;
++</pre></blockquote>
++<p>
++We might also want to ensure that if <tt>Iterator</tt>'s <tt>reference</tt> type <em>is</em>
++a reference, the referent is equal to <tt>value_type</tt> (after removal of <i>cv</i>-qualifiers).
++In <em>general</em> we have no such guarantee.
++<p/>
++Marc: In the default case where we don't return <tt>value_type&amp;&amp;</tt>, should we use
++<tt>value_type</tt> or should we keep the <tt>reference</tt> type of the wrapped iterator?
++<p/>
++Daniel: This suggestion looks appealing at first, but the problem here is that using this typedef
++can make it impossible for <tt>move_iterator</tt> to satisfy its contract, which means returning
++an rvalue of the value type (Currently it says rvalue-reference, but this must be fixed as of
++this issue anyway). I think that user-code can reasonably expect that when it has constructed
++an object <tt>m</tt> of <tt>move_iterator&lt;It&gt;</tt>, where <tt>It</tt> is a valid
++mutable iterator type, the expression
++</p>
++<blockquote><pre>
++<span style="color:#C80000;font-weight:bold">It::value_type&amp;&amp; rv = *m;</span>
++</pre></blockquote>
++<p>
++is well-formed.
++<p/>
++Let's set <tt>R</tt> equal to <tt>iterator_traits&lt;Iterator&gt;::reference</tt>
++in the following. We can discuss the following situations:
++</p>
++<ol><li><tt>R</tt> is a reference type: We can only return the corresponding xvalue of <tt>R</tt>,
++if <tt>value_type</tt> is reference-related to the referent type, else this is presumably no
++forward iterator and we cannot say much about it, except that it must be convertible to
++<tt>value_type</tt>, so it better should return a prvalue.</li>
++<li><tt>R</tt> is not a reference type: In this case we can rely on a conversion to
++<tt>value_type</tt> again, but not much more. Assume we would return <tt>R</tt> directly,
++this might turn out to have a conversion to an lvalue-reference type of the value type (for
++example). If that is the case, this would indirectly violate the contract of
++<tt>move_iterator</tt>.</li>
++</ol>
++<p>
++In regard to the first scenario I suggest that implementations are simply required to
++check that <tt>V2 = remove_cv&lt;remove_reference&lt;R&gt;::type&gt;::type</tt> is equal
++to the value type <tt>V1</tt> as a criterion to return this reference as an xvalue, in all other
++cases it should return the value type directly as prvalue.
++<p/>
++The additional advantage of this strategy is, that we always ensure that <tt>reference</tt> has
++the correct <i>cv</i>-qualification, if <tt>R</tt> is a real reference.
++<p/>
++It is possible to improve this a bit by indeed supporting reference-related types,
++this would require to test <tt>is_same&lt;V1, V2&gt;::value || is_base_of&lt;V1, V2&gt;::value</tt>
++instead. I'm unsure whether (a) this additional effort is worth it and (b) a strict reading of
++the forward iterator requirements seems not to allow to return a reference-related type (Whether
++this is a defect or not is another question).
++</p>
++
++<p><i>[2011-12-05: Marc Glisse comments and splits into two resolution alternatives]</i></p>
++
++
++<p>
++I guess I am looking at the speed of:
++</p>
++<blockquote><pre>
++value_type x;
++x = *m;
++</pre></blockquote>
++<p>
++(copy construction would likely trigger copy elision and thus be neutral)
++
++instead of the validity of:
++</p>
++<blockquote><pre>
++value_type&amp;&amp; x = *m;
++</pre></blockquote>
++<p>
++In this sense, Daniels earlier proposition that ignored <tt>value_type</tt> and just did
++<tt>switch_lvalue_ref_to_rvalue_ref&lt;reference&gt;</tt> was easier to understand (and it didn't
++require thinking about reference related types).
++<p/>
++The currently proposed resolution has been split into two alternatives.
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Review.
++</p>
++<p>
++Alisdair: This only applies to input iterators, so keep that in mind when thinking about this.
++</p>
++<p>
++STL: I see what B is doing, but not A.
++</p>
++<p>
++Howard: I agree.
++</p>
++<p>
++Alisdair: Should we use <tt>add_rvalue_reference</tt>?
++</p>
++<p>
++STL: No, we do not want reference collapsing.
++</p>
++<p>
++STL: Re A, messing with the CV qualification scares me.
++</p>
++<p>
++Alisdair: Agree. That would break my intent.
++</p>
++<p>
++STL: Actually I don't think it's actually wrong, but I still don't see what it's doing.
++</p>
++<p>
++Alisdair: A is picking the value type, B is picking the proxy type.
++</p>
++<p>
++Howard: I like returning the proxy type.
++</p>
++<p>
++STL: Returning a reference (B) seems right, because the requirements say "reference".
++I suspect that B works correctly if you have a move iterator wrapping a move iterator
++wrapping a thing. I think that A would mess up the type in the middle.
++</p>
++<p>
++Considerable discussion about which version is correct, checking various examples.
++</p>
++<p>
++STL: Still think B is right. Still don't understand A. In A we are losing the proxyness.
++</p>
++<p>
++Howard: Agree 100%. We don't want to lose the proxy. If it's const, so be it.
++</p>
++<p>
++STL: B is also understandable by mortals.
++</p>
++<p>
++Howard: Remove to review, keep A but move it out of the proposed resolution area
++(but keep it for rational).
++</p>
++<p>
++Alisdair: Adding an explanatory note might be a good idea, if someone wants to write one.
++</p>
++<p>
++Walter: Concerned about losing the word "reference" in p.1.
++</p>
++<p>
++Howard: <tt>move_iterator</tt> will return an xvalue or a prvalue, both of which are rvalues.
++</p>
++
++<p><i>[Proposed resolution A, rejected in preference to the currently proposed resolution (B)
++
++<ol>
++<li><p>Change 24.5.3 [move.iterators] p1 as indicated:</p>
++
++<blockquote><p>
++Class template <tt>move_iterator</tt> is an iterator adaptor with the same behavior as the underlying iterator
++except that its dereference operator implicitly converts the value returned by the underlying iterator's
++dereference operator to an rvalue <del>reference</del><ins>of the value type</ins>. Some generic algorithms
++can be called with move iterators to replace copying with moving.
++</p></blockquote>
++</li>
++
++<li><p>Change 24.5.3.1 [move.iterator], class template <tt>move_iterator</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Iterator&gt;
++ class move_iterator {
++ public:
++ typedef Iterator iterator_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
++ typedef Iterator pointer;
++ typedef typename iterator_traits&lt;Iterator&gt;::value_type value_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::iterator_category iterator_category;
++ typedef <del>value_type&amp;&amp;</del><ins><i>see below</i></ins> reference;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++
++</li>
++
++<li><p>Immediately following the class template <tt>move_iterator</tt> synopsis in
++24.5.3.1 [move.iterator] insert a new paragraph as indicated:</p>
++
++<blockquote><p>
++<ins>-?- Let <tt><i>R</i></tt> be <tt>iterator_traits&lt;Iterator&gt;::reference</tt> and
++let <tt><i>V</i></tt> be <tt>iterator_traits&lt;Iterator&gt;::value_type</tt>. If
++<tt>is_reference&lt;<i>R</i>&gt;::value</tt> is <tt>true</tt> and if
++<tt>remove_cv&lt;remove_reference&lt;<i>R</i>&gt;::type&gt;::type</tt> is the same type as <tt><i>V</i></tt>,
++the template instantiation <tt>move_iterator&lt;Iterator&gt;</tt> shall define the nested type
++named <tt>reference</tt> as a synonym for <tt>remove_reference&lt;<i>R</i>&gt;::type&amp;&amp;</tt>,
++otherwise as a synonym for <tt><i>V</i></tt>.</ins>
++</p></blockquote>
++</li>
++</ol>
++
++]</i></p>
++
++
++<p><i>[2012, Portland: Move to Tentatively Ready]</i></p>
++
++<p>
++AJM wonders if the implied trait might be useful elsewhere, and worth adding to type traits as a
++transformation type trait.
++</p>
++
++<p>
++Suspicion that the Range SG might find such a trait useful, but wait until there is clear additional
++use of such a trait before standardizing.
++</p>
++
++<p>
++Minor wording tweak to use <tt>add_rvalue_reference</tt> rather than manually adding the <tt>&amp;&amp;</tt>,
++then move to Tentatively Ready.
++</p>
++
++<p><i>[2013-01-09 Howard Hinnant comments]</i></p>
++
++
++<p>
++I believe the P/R for LWG 2106 is incorrect (item 3). The way it currently reads, <tt>move_iterator&lt;I&gt;::reference</tt>
++is <em>always</em> an lvalue reference. I.e. if <tt>R</tt> is an lvalue reference type, then reference becomes
++<tt>add_rvalue_reference&lt;R&gt;::type</tt> which is just <tt>R</tt>. And if <tt>R</tt> is not a reference type,
++then reference becomes <tt>R</tt> (which is also just <tt>R</tt> ;-)).
++</p>
++
++<p>
++I believe the correct wording is what was there previously:
++</p>
++
++<p>
++-?- Let <tt>R</tt> be <tt>iterator_traits&lt;Iterator&gt;::reference</tt>. If <tt>is_reference&lt;R&gt;::value</tt>
++is true, the template instantiation <tt>move_iterator&lt;Iterator&gt;</tt> shall define the nested type named
++<tt>reference</tt> as a synonym for <tt>remove_reference&lt;R&gt;::type&amp;&amp;</tt>, otherwise as a synonym for
++<tt>R</tt>.
++</p>
++
++<p>
++Additionally Marc Glisse points out that <tt>move_iterator&lt;I&gt;::operator*()</tt> should return
++<tt>static_cast&lt;reference&gt;(*current)</tt>, not <tt>std::move(*current)</tt>.
++</p>
++
++<p>
++Previous resolution:
++</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change 24.5.3 [move.iterators] p1 as indicated:</p>
++
++<blockquote><p>
++Class template <tt>move_iterator</tt> is an iterator adaptor with the same behavior as the underlying iterator
++except that its dereference operator implicitly converts the value returned by the underlying iterator's
++dereference operator to an rvalue <del>reference</del>. Some generic algorithms
++can be called with move iterators to replace copying with moving.
++</p></blockquote>
++</li>
++
++<li><p>Change 24.5.3.1 [move.iterator], class template <tt>move_iterator</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Iterator&gt;
++ class move_iterator {
++ public:
++ typedef Iterator iterator_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
++ typedef Iterator pointer;
++ typedef typename iterator_traits&lt;Iterator&gt;::value_type value_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::iterator_category iterator_category;
++ typedef <del>value_type&amp;&amp;</del><ins><i>see below</i></ins> reference;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++
++</li>
++
++<li><p>Immediately following the class template <tt>move_iterator</tt> synopsis in
++24.5.3.1 [move.iterator] insert a new paragraph as indicated:</p>
++
++<blockquote><p>
++<ins>-?- Let <tt><i>R</i></tt> be <tt>iterator_traits&lt;Iterator&gt;::reference</tt>. If
++<tt>is_reference&lt;<i>R</i>&gt;::value</tt> is <tt>true</tt>, the template instantiation
++<tt>move_iterator&lt;Iterator&gt;</tt> shall define the nested type named <tt>reference</tt>
++as a synonym for <tt>add_rvalue_reference&lt;<i>R</i>&gt;::type</tt>, otherwise as a synonym
++for <tt><i>R</i></tt>.</ins>
++</p></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-05-19, Daniel comments]</i></p>
++
++<p>
++The term <em>instantiation</em> has been changed to <em>specialization</em> in the newly added paragraph as
++suggested by STL and much preferred by myself.
++</p>
++
++<p><i>[2014-05-19 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on five votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 24.5.3 [move.iterators] p1 as indicated:</p>
++
++<blockquote><p>
++Class template <tt>move_iterator</tt> is an iterator adaptor with the same behavior as the underlying iterator
++except that its indirection operator implicitly converts the value returned by the underlying iterator's
++indirection operator to an rvalue <del>reference</del>. Some generic algorithms
++can be called with move iterators to replace copying with moving.
++</p></blockquote>
++</li>
++
++<li><p>Change 24.5.3.1 [move.iterator], class template <tt>move_iterator</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Iterator&gt;
++ class move_iterator {
++ public:
++ typedef Iterator iterator_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
++ typedef Iterator pointer;
++ typedef typename iterator_traits&lt;Iterator&gt;::value_type value_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::iterator_category iterator_category;
++ typedef <del>value_type&amp;&amp;</del><ins><i>see below</i></ins> reference;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++
++</li>
++
++<li><p>Immediately following the class template <tt>move_iterator</tt> synopsis in
++24.5.3.1 [move.iterator] insert a new paragraph as indicated:</p>
++
++<blockquote><p>
++<ins>-?- Let <tt><i>R</i></tt> be <tt>iterator_traits&lt;Iterator&gt;::reference</tt>. If
++<tt>is_reference&lt;<i>R</i>&gt;::value</tt> is <tt>true</tt>, the template specialization
++<tt>move_iterator&lt;Iterator&gt;</tt> shall define the nested type named <tt>reference</tt>
++as a synonym for <tt>remove_reference&lt;<i>R</i>&gt;::type&amp;&amp;</tt>, otherwise as a synonym
++for <tt><i>R</i></tt>.</ins>
++</p></blockquote>
++</li>
++
++<li><p>Edit 24.5.3.3.4 [move.iter.op.star] p1 as indicated:</p>
++<blockquote><pre>
++reference operator*() const;
++</pre><blockquote>
++<p>
++-1- <i>Returns</i>: <tt><del>std::move</del><ins>static_cast&lt;reference&gt;</ins>(*current)</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2108"></a>2108. No way to identify allocator types that always compare equal</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2011-12-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Whether two allocator objects compare equal affects the complexity of
++container copy and move assignments and also the possibility of an
++exception being thrown by container move assignments. The latter point
++means container move assignment cannot be <tt>noexcept</tt> when
++<tt>propagate_on_container_move_assignment</tt> (POCMA) is false for the
++allocator because there is no way to detect at compile-time if two
++allocators will compare equal. LWG <a href="lwg-defects.html#2013">2013</a> means this affects all
++containers using <tt>std::allocator</tt>, but even if that is resolved, this
++affects all stateless allocators which do not explicitly define POCMA
++to <tt>true_type</tt>.
++<p/>
++One solution would be to add an "always_compare_equal" trait to
++<tt>allocator_traits</tt>, but that would be duplicating information that is
++already defined by the type's equality operator if that operator
++always returns true. Requiring users to write <tt>operator==</tt> that simply
++returns true and also explicitly override a trait to repeat the same
++information would be unfortunate and risk user errors that allow the
++trait and actual <tt>operator==</tt> to disagree.
++<p/>
++Dave Abrahams suggested a better solution in message c++std-lib-31532,
++namely to allow <tt>operator==</tt> to return <tt>true_type</tt>, which is convertible
++to <tt>bool</tt> but also detectable at compile-time. Adopting this as the
++recommended way to identify allocator types that always compare equal
++only requires a slight relaxation of the allocator requirements so
++that <tt>operator==</tt> is not required to return <tt>bool</tt> exactly.
++<p/>
++The allocator requirements do not make it clear that it is well-defined
++to compare non-const values, that should be corrected too.
++<p/>
++In message c++std-lib-31615 Pablo Halpern suggested an <tt>always_compare_equal</tt>
++trait that could still be defined, but with a sensible default value rather
++than requiring users to override it, and using that to set sensible values for
++other allocator traits:
++</p>
++<blockquote><p>
++Do we still need <tt>always_compare_equal</tt> if we can have an <tt>operator==</tt>
++that returns <tt>true_type</tt>? What would its default value be? <tt>is_empty&lt;A&gt;
++|| is_convertible&lt;decltype(a == a), true_type&gt;::value</tt>, perhaps? One
++benefit I see to such a definition is that stateless C++03 allocators
++that don't use the <tt>true_type</tt> idiom will still benefit from the new
++trait.
++<p/>
++[&hellip;]
++<p/>
++One point that I want to ensure doesn't get lost is that if we adopt some sort of
++<tt>always_compare_equal</tt>-like trait, then <tt>propagate_on_container_swap</tt>
++and <tt>propagate_on_container_move_assignment</tt> should default to
++<tt>always_compare_equal</tt>. Doing this will eliminate unnecessary requirements
++on the container element type, as per [LWG <a href="lwg-defects.html#2103">2103</a>].
++</p></blockquote>
++<p>
++Optionally, <tt>operator==</tt> for <tt>std::allocator</tt> could be made to return
++<tt>true_type</tt>, however if LWG <a href="lwg-defects.html#2103">2103</a> is adopted that is less important.
++<p/>
++Alberto Ganesh Barbati: Suggest either <tt>always_compare_equal</tt>,
++<tt>all_objects_(are_)equivalent</tt>, or <tt>all_objects_compare_equal</tt>.
++</p>
++
++<p><i>[2014-11-07 Urbana]</i></p>
++
++<p>
++Resolved by N4258
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li><p>Change Table 27 &mdash; "Descriptive variable definitions" in 17.6.3.5 [allocator.requirements]:</p>
++
++<table border="1">
++<caption>Table 27 &mdash; Descriptive variable definitions</caption>
++<tr>
++<th>Variable</th>
++<th>Definition</th>
++</tr>
++
++<tr>
++<td>
++<tt>a3<ins>, a4</ins></tt>
++</td>
++<td>
++<del>an rvalue of</del><ins>values of (possibly <tt>const</tt>)</ins> type <tt>X</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>b</tt>
++</td>
++<td>
++a value of <ins>(possibly <tt>const</tt>)</ins> type <tt>Y</tt>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>Change Table 28 &mdash; "Allocator requirements" in 17.6.3.5 [allocator.requirements]:</p>
++
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
++
++<tr>
++<td>
++<tt><del>a1 == a2</del><ins>a3 == a4</ins></tt>
++</td>
++<td>
++<ins>convertible to</ins> <tt>bool</tt>
++</td>
++<td>
++returns true only if storage<br/>
++allocated from each can be<br/>
++deallocated via the other.<br/>
++<tt>operator==</tt> shall be reflexive,<br/>
++symmetric, and transitive, and<br/>
++shall not exit via an exception.
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt><del>a1 != a2</del><ins>a3 != a4</ins></tt>
++</td>
++<td>
++<ins>convertible to</ins> <tt>bool</tt>
++</td>
++<td>
++same as <tt><del>!(a1 == a2)</del><ins>!(a3 == a4)</ins></tt>
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a<ins>3</ins> == b</tt>
++</td>
++<td>
++<ins>convertible to</ins> <tt>bool</tt>
++</td>
++<td>
++same as <tt>a<ins>3</ins> ==<br/>
++Y::rebind&lt;T&gt;::other(b)</tt>
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a<ins>3</ins> != b</tt>
++</td>
++<td>
++<ins>convertible to</ins> <tt>bool</tt>
++</td>
++<td>
++same as <tt>!(a<ins>3</ins> == b)</tt>
++</td>
++<td>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.select_on_-<br/>
++container_copy_-<br/>
++construction()</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++Typically returns either <tt>a</tt> or<br/>
++<tt>X()</tt>
++</td>
++<td>
++<tt>return a;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X::always_compares_equal</tt></ins>
++</td>
++<td>
++<ins>Identical to or derived<br/>
++from <tt>true_type</tt> or<br/>
++<tt>false_type</tt></ins>
++</td>
++<td>
++<ins><tt>true_type</tt> if the expression <tt>x1 == x2</tt> is<br/>
++guaranteed to be <tt>true</tt> for any two (possibly<br/>
++<tt>const</tt>) values <tt>x1, x2</tt> of type <tt>X</tt>, when<br/>
++implicitly converted to <tt>bool</tt>. See Note B, below.</ins>
++</td>
++<td>
++<ins><tt>true_type</tt>, if <tt>is_empty&lt;X&gt;::value</tt> is <tt>true</tt> or if<br/>
++<tt>decltype(declval&lt;const X&amp;&gt;() == declval&lt;const X&amp;&gt;())</tt><br/>
++is convertible to <tt>true_type</tt>, otherwise <tt>false_type</tt>.</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>[&hellip;]</tt>
++</td>
++</tr>
++
++</table>
++<p>
++Note A: [&hellip;]
++<p/>
++<ins>Note B: If <tt>X::always_compares_equal::value</tt> or <tt>XX::always_compares_equal::value</tt> evaluate
++to <tt>true</tt> and an expression equivalent to <tt>x1 == x2</tt> or <tt>x1 != x2</tt> for any two values
++<tt>x1, x2</tt> of type <tt>X</tt> evaluates to <tt>false</tt> or <tt>true</tt>, respectively, the behaviour
++is undefined.</ins>
++</p>
++
++</li>
++
++<li><p>Change class template <tt>allocator_traits</tt> synopsis, 20.7.8 [allocator.traits] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class Alloc&gt; struct allocator_traits {
++ typedef Alloc allocator_type;
++ [&hellip;]
++ <ins>typedef <i>see below</i> always_compares_equal;</ins>
++ typedef <i>see below</i> propagate_on_container_copy_assignment;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Insert the following between 20.7.8.1 [allocator.traits.types] p6 and p7 as indicated:</p>
++
++<blockquote><pre>
++<ins>typedef <i>see below</i> always_compares_equal;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Type</i>: <tt>Alloc::always_compares_equal</tt> if such a type exists; otherwise,
++<tt>true_type</tt> if <tt>is_empty&lt;Alloc&gt;::value</tt> is <tt>true</tt> or if
++<tt>decltype(declval&lt;const Alloc&amp;&gt;() == declval&lt;const Alloc&amp;&gt;())</tt>
++is convertible to <tt>true_type</tt>; otherwise, <tt>false_type</tt>
++.</ins>
++</p>
++</blockquote></blockquote>
++<blockquote><pre>
++typedef <i>see below</i> propagate_on_container_copy_assignment;
++</pre><blockquote>
++<p>
++-7- <i>Type</i>: <tt>Alloc::propagate_on_container_copy_assignment</tt> if such a type exits,
++otherwise <tt>false_type</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change class template <tt>allocator</tt> synopsis, 20.7.9 [default.allocator] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; class allocator;
++
++ <i>// specialize for <tt>void</tt>:</i>
++ template &lt;&gt; class allocator&lt;void&gt; {
++ public:
++ typedef void* pointer;
++ typedef const void* const_pointer;
++ <i>// reference-to-<tt>void</tt> members are impossible.</i>
++ typedef void value_type;
++ template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
++ };
++
++ template &lt;class T&gt; class allocator {
++ public:
++ typedef size_t size_type;
++ typedef ptrdiff_t difference_type;
++ typedef T* pointer;
++ typedef const T* const_pointer;
++ typedef T&amp; reference;
++ typedef const T&amp; const_reference;
++ typedef T value_type;
++ template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
++ <ins>typedef true_type always_compares_equal;</ins>
++
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2109"></a>2109. Incorrect requirements for <tt>hash</tt> specializations</h3>
++<p><b>Section:</b> 19.5.5 [syserr.hash], 20.8.2.7 [util.smartptr.hash], 20.9.13 [unord.hash], 20.14.1 [type.index.synopsis], 21.6 [basic.string.hash], 23.3.7 [vector.bool], 30.3.1.1 [thread.thread.id] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-12-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++20.8.2.7 [util.smartptr.hash] p2 is specified as follows:
++</p>
++
++<blockquote><p>
++<i>Requires</i>: the template specializations shall meet the requirements of class template
++<tt>hash</tt> (20.8.12).
++</p></blockquote>
++
++<p>
++The problem here is the usage of a <i>Requires</i> element, which is actually a pre-condition
++that a <em>user</em> of a component has to satisfy. But the intent of this wording is actually
++to be a requirement on implementations. The <i>Requires</i> element should be removed here and
++the wording should be improved to say what it was intended for.
++<p/>
++We have similar situations in basically all other places where the specification of library-provided
++<tt>hash</tt> specializations is defined. Usually, the <i>Requires</i> element is incorrect. In the
++special case of <tt>hash&lt;unique_ptr&lt;T, D&gt;&gt;</tt> the implementation depends on
++the behaviour of <tt>hash</tt> specializations, that could be user-provided. In this case
++the specification needs to separate the requirements on these specializations and those
++that are imposed on the implementation.
++</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Update wording and move to Review.
++</p>
++<p>
++Believe a simpler formulation is to simply string the term <i>Requires:</i> and leave the
++current wording intact, rather than strike the whole clause and replace it.
++</p>
++
++<p><i>[Originally proposed wording for reference
++<ol>
++<li><p>Change 19.5.5 [syserr.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;error_code&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;system_error&gt;</tt> provides a definition for a specialization of the
++template <tt>hash&lt;error_code&gt;</tt>. The requirements for the members of
++this specialization are given in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.6.3 [bitset.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;bitset&gt;</tt> provides a definition for a partial specialization of the
++<tt>hash</tt> class template for specializations of class template <tt>bitset&lt;N&gt;</tt>.
++The requirements for the members of instantiations of this specialization are given
++in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.8.2.7 [util.smartptr.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class T, class D&gt; struct hash&lt;unique_ptr&lt;T, D&gt; &gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;memory&gt;</tt> provides a definition for a partial specialization of the
++<tt>hash</tt> class template for specializations of class template <tt>unique_ptr&lt;T, D&gt;</tt>.
++The requirements for the members of instantiations of this specialization are given
++in sub-clause 20.9.13 [unord.hash]</ins>. For an object <tt>p</tt> of type
++<tt>UP</tt>, where <tt>UP</tt> is <tt>unique_ptr&lt;T, D&gt;</tt>,
++<tt>hash&lt;UP&gt;()(p)</tt> shall evaluate to the same value as
++<tt>hash&lt;typename UP::pointer&gt;()(p.get())</tt>. <del>The specialization
++<tt>hash&lt;typename UP::pointer&gt;</tt> shall be well-formed.</del>
++<p/>
++<ins>-?- <i>Requires</i>: The specialization <tt>hash&lt;typename UP::pointer&gt;</tt>
++shall be well-formed and well-defined [<i>Note:</i> the general requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]) are implied &mdash;
++<i>end note</i>].</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt; &gt;;
++</pre><blockquote>
++<p>
++-2- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;memory&gt;</tt> provides a definition for a partial specialization of the
++<tt>hash</tt> class template for specializations of class template <tt>shared_ptr&lt;T&gt;</tt>.
++The requirements for the members of instantiations of this specialization are given
++in sub-clause 20.9.13 [unord.hash]</ins>. For an object <tt>p</tt> of type
++<tt>shared_ptr&lt;T&gt;</tt>, <tt>hash&lt;shared_ptr&lt;T&gt; &gt;()(p)</tt>
++shall evaluate to the same value as <tt>hash&lt;T*&gt;()(p.get())</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.9.13 [unord.hash] p2 as indicated: [<i>Comment</i>: For unknown
++reasons the extended integer types are not mentioned here, which looks like an oversight to
++me and makes also the wording more complicated. See <a href="lwg-active.html#2119">2119</a> for this part
++of the problem. &mdash; <i>end comment</i>]</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;bool&gt;;
++template &lt;&gt; struct hash&lt;char&gt;;
++[&hellip;]
++template &lt;&gt; struct hash&lt;long double&gt;;
++template &lt;class T&gt; struct hash&lt;T*&gt;;
++</pre><blockquote>
++<p>
++-2- <del><i>Requires</i>: the template specializations shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;functional&gt;</tt> provides definitions for specializations of the
++<tt>hash</tt> class template for each <i>cv</i>-unqualified arithmetic type except
++for the extended integer types. This header also provides a definition for a partial
++specialization of the <tt>hash</tt> class template for any pointer type. The
++requirements for the members of these specializations are given in sub-clause
++20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.14.4 [type.index.hash] p1 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;type_index&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;typeindex&gt;</tt> provides a definition for a specialization of the
++template <tt>hash&lt;type_index&gt;</tt>. The requirements for the members
++of this specialization are given in sub-clause 20.9.13 [unord.hash]</ins>. For
++an object <tt>index</tt> of type <tt>type_index</tt>, <tt>hash&lt;type_index&gt;()(index)</tt>
++shall evaluate to the same result as <tt>index.hash_code()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 21.6 [basic.string.hash] p1 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;string&gt;;
++template &lt;&gt; struct hash&lt;u16string&gt;;
++template &lt;&gt; struct hash&lt;u32string&gt;;
++template &lt;&gt; struct hash&lt;wstring&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: the template specializations shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;string&gt;</tt> provides definitions for specializations of the
++<tt>hash</tt> class template for the types <tt>string</tt>, <tt>u16string</tt>,
++<tt>u32string</tt>, and <tt>wstring</tt>. The requirements for the members
++of these specializations are given in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 23.3.7 [vector.bool] p7 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt; &gt;;
++</pre><blockquote>
++<p>
++-7- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;vector&gt;</tt> provides a definition for a partial specialization of the
++<tt>hash</tt> class template for specializations of class template <tt>vector&lt;bool, Allocator&gt;</tt>.
++The requirements for the members of instantiations of this specialization are given
++in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 30.3.1.1 [thread.thread.id] p14 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;thread::id&gt;;
++</pre><blockquote>
++<p>
++-14- <del><i>Requires</i>: the template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash])</del><ins>The header
++<tt>&lt;thread&gt;</tt> provides a definition for a specialization of the
++template <tt>hash&lt;thread::id&gt;</tt>. The requirements for the members of this
++specialization are given in sub-clause 20.9.13 [unord.hash]</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++]</i></p>
++
++
++<p><i>[2012, Portland: Move to Tentatively Ready]</i></p>
++
++<p>
++No further wording issues, so move to Tentatively Ready (post meeting issues processing).
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Change 19.5.5 [syserr.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;error_code&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash].
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.6.3 [bitset.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]).
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.8.2.7 [util.smartptr.hash] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class T, class D&gt; struct hash&lt;unique_ptr&lt;T, D&gt; &gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]). For an object <tt>p</tt> of type
++<tt>UP</tt>, where <tt>UP</tt> is <tt>unique_ptr&lt;T, D&gt;</tt>,
++<tt>hash&lt;UP&gt;()(p)</tt> shall evaluate to the same value as
++<tt>hash&lt;typename UP::pointer&gt;()(p.get())</tt>. <del>The specialization
++<tt>hash&lt;typename UP::pointer&gt;</tt> shall be well-formed.</del>
++<p/>
++<ins>-?- <i>Requires</i>: The specialization <tt>hash&lt;typename UP::pointer&gt;</tt>
++shall be well-formed and well-defined, and shall meet the requirements of class template
++<tt>hash</tt> (20.9.13 [unord.hash]).</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt; &gt;;
++</pre><blockquote>
++<p>
++-2- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]). For an object <tt>p</tt> of type
++<tt>shared_ptr&lt;T&gt;</tt>, <tt>hash&lt;shared_ptr&lt;T&gt; &gt;()(p)</tt>
++shall evaluate to the same value as <tt>hash&lt;T*&gt;()(p.get())</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.9.13 [unord.hash] p2 as indicated: [<i>Comment</i>: For unknown
++reasons the extended integer types are not mentioned here, which looks like an oversight to
++me and makes also the wording more complicated. See <a href="lwg-active.html#2119">2119</a> for this part
++of the problem. &mdash; <i>end comment</i>]</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;bool&gt;;
++template &lt;&gt; struct hash&lt;char&gt;;
++[&hellip;]
++template &lt;&gt; struct hash&lt;long double&gt;;
++template &lt;class T&gt; struct hash&lt;T*&gt;;
++</pre><blockquote>
++<p>
++-2- <del><i>Requires</i>: t</del><ins>T</ins>he template specializations shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]).
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 20.14.4 [type.index.hash] p1 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;type_index&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]). For
++an object <tt>index</tt> of type <tt>type_index</tt>, <tt>hash&lt;type_index&gt;()(index)</tt>
++shall evaluate to the same result as <tt>index.hash_code()</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 21.6 [basic.string.hash] p1 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;string&gt;;
++template &lt;&gt; struct hash&lt;u16string&gt;;
++template &lt;&gt; struct hash&lt;u32string&gt;;
++template &lt;&gt; struct hash&lt;wstring&gt;;
++</pre><blockquote>
++<p>
++-1- <del><i>Requires</i>: t</del><ins>T</ins>he template specializations shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]).
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 23.3.7 [vector.bool] p7 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt; &gt;;
++</pre><blockquote>
++<p>
++-7- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]).
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 30.3.1.1 [thread.thread.id] p14 as indicated:</p>
++
++<blockquote><pre>
++template &lt;&gt; struct hash&lt;thread::id&gt;;
++</pre><blockquote>
++<p>
++-14- <del><i>Requires</i>: t</del><ins>T</ins>he template specialization shall meet the requirements
++of class template <tt>hash</tt> (20.9.13 [unord.hash]).
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2110"></a>2110. <tt>remove</tt> can't swap but note says it might</h3>
++<p><b>Section:</b> 25.3.8 [alg.remove] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2011-12-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.remove">issues</a> in [alg.remove].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++25.3.8 [alg.remove]&#47;p1 says:
++</p>
++
++<blockquote><p>
++1 <i>Requires</i>: The type of <tt>*first</tt> shall satisfy the <tt>MoveAssignable</tt> requirements (Table 22).
++</p></blockquote>
++
++<p>
++This means that <tt>remove</tt>&#47;<tt>remove_if</tt> can only use move assignment to permute the sequence. But then
++25.3.8 [alg.remove]&#47;p6 (non-normatively) contradicts p1:
++</p>
++
++<blockquote><p>
++6 <i>Note</i>: each element in the range <tt>[ret,last)</tt>, where <tt>ret</tt> is the returned value, has a valid
++but unspecified state, because the algorithms can eliminate elements by swapping with or moving from elements that
++were originally in that range.
++</p></blockquote>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++<p>
++Alisdair notes we could extend permission to use <tt>swap</tt> if it is available, but there
++is no interest. Accept the proposed resolution as written.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 25.3.8 [alg.remove] as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator, class T&gt;
++ ForwardIterator remove(ForwardIterator first, ForwardIterator last,
++ const T&amp; value);
++
++template&lt;class ForwardIterator, class Predicate&gt;
++ ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
++ Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-6-<i>Note</i>: each element in the range <tt>[ret,last)</tt>, where <tt>ret</tt> is the
++returned value, has a valid but unspecified state, because the algorithms can eliminate
++elements by <del>swapping with or</del> moving from elements that were originally in that range.
++</p>
++</blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2112"></a>2112. User-defined classes that cannot be derived from</h3>
++<p><b>Section:</b> 17.6.5 [conforming], 20.7.8 [allocator.traits], 20.13.1 [allocator.adaptor.syn] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2011-11-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#conforming">issues</a> in [conforming].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++It is a very established technique for implementations to derive internally from user-defined class types that are
++used to customize some library component, e.g. deleters and allocators are typical candidates. The advantage of this
++approach is to possibly take advantage of the empty-base-class optimization (EBCO).
++<p/>
++Whether or whether not libraries did take advantage of such a detail didn't much matter in C++03. Even though there
++did exist a portable idiom to prevent that a class type could be derived from, this idiom has never reached great
++popularity: The <a href="http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Final_Class">technique</a> required
++to introduce a virtual base class and it did not really prevent the derivation, but only any construction of
++such a type. Further, such types are not <em>empty</em> as defined by the <tt>std::is_empty</tt> trait, so
++could easily be detected by implementations from TR1 on.
++<p/>
++With the new C++11 feature of final classes and final member functions it is now very easy to define an empty,
++but not derivable from class type. From the point of the user it is quite natural to use this feature for
++types that he or she did not foresee to be derivable from.
++<p/>
++On the other hand, most library implementations (including third-party libraries) often take advantage of EBCO
++applied to user-defined types used to instantiate library templates internally. As the time of submitting this
++issue the following program failed to compile on all tested library implementations:
++</p>
++<blockquote><pre>
++#include &lt;memory&gt;
++
++struct Noop <span style="color:#C80000;font-weight:bold">final</span> {
++ template&lt;class Ptr&gt;
++ void operator()(Ptr) const {}
++};
++
++std::unique_ptr&lt;int, Noop&gt; up;
++</pre></blockquote>
++<p>
++In addition, many <tt>std::tuple</tt> implementations with empty, final classes as element types failed as well,
++due to a popular inheritance-based implementation technique. EBCO has also a long tradition to be
++used in library containers to efficiently store potentially stateless, empty allocators.
++<p/>
++It seems that both user and library did the best they could: None of the affected types did impose explicit
++requirements on the corresponding user-defined types to be derivable from (This capability was not part of
++the required operations), and libraries did apply EBCO whereever possible to the convenience of the customer.
++<p/>
++Nonetheless given the existence of non-derivable-from class types in C++11, libraries have to cope with
++failing derivations. How should that problem be solved?
++<p/>
++It would certainly be possible to add weazel wording to the allocator requirements similar to what we had
++in C++03, but restricted to derivation-from requirements. I consider this as the bad solution, because it
++would add new requirements that never had existed before in this explicit form onto types like allocators.
++<p/>
++Existing libraries presumably will need internal traits like <tt>__is_final</tt> or <tt>__is_derivable</tt>
++to make EBCO possible in the current form but excluding non-derivable class types. As of this writing this
++seems to happen already. Problem is that without a <tt>std::is_derivable</tt> trait, third-party libraries
++have no portable means to do the same thing as standard library implementations. This should be a good
++reason to make such a trait public available soon, but seems not essential to have now. Further, this issue
++should also be considered as a chance to recognice that EBCO has always been a very special corner case
++(There exist parallels to the previously existing odd core language rule that did make the interplay
++between <tt>std::auto_ptr</tt> and <tt>std::auto_ptr_ref</tt> possible) and that it would be better to
++provide explicit means for space-efficient storage, not necessarily restricted to inheritance relations,
++e.g. by marking data members with a special attribute.
++<p/>
++At least two descriptions in the current standard should be fixed now for better clarification:
++</p>
++<ol>
++<li><p>As mentioned by Ganesh, 20.7.8 [allocator.traits] p1 currently contains a (non-normative) note
++"Thus, it is always possible to create a derived class from an allocator." which should be removed.
++</p>
++</li>
++<li><p>As pointed out by Howard, the specification of <tt>scoped_allocator_adaptor</tt> as of
++20.13.1 [allocator.adaptor.syn] already requires derivation from <tt>OuterAlloc</tt>, but
++only implies indirectly the same for the inner allocators due to the <em>exposition-only</em>
++description of member <tt>inner</tt>. This indirect implication should be normatively required for
++all participating allocators.
++</p></li>
++</ol>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++What we really need is a type trait to indicate if a type can be derived from. Howard reports
++Clang and libc++ have had success with this approach.
++</p>
++<p>
++Howard to provide wording, and AJM to alert Core that we may be wanting to add a new trait
++that requires compiler support.
++</p>
++
++<p><i>[2014-02, Issaquah: Howard and Daniel comment and provide wording]</i></p>
++
++
++<p>
++Several existing C++11 compilers do already provide an internal <tt>__is_final</tt> intrinsic (e.g. clang and gcc) and therefore
++we believe that this is evidence enough that this feature is implementable today.
++<p/>
++We believe that both a simple and clear definition of the <tt>is_final</tt> query should result in a true outcome
++if and only if the current existing language definition holds that a complete class type (either union or non-union)
++has been marked with the <i>class-virt-specifier</i> <code>final</code> &mdash; nothing more.
++<p/>
++The following guidelines lead to the design decision and the wording choice given below:
++<p/>
++It has been expressed several times that a high-level trait such as "<tt>is_derivable</tt>" would be preferred and
++would be more useful for non-experts. One problem with that request is that it is astonishingly hard to find a common denominator
++for what the <em>precise</em> definition of this trait should be, especially regarding corner-cases. Another example of getting very
++differing points of view is to ask a bunch of C++ experts what the best definition of the <tt>is_empty</tt> trait
++should be (which can be considered as a kind of higher-level trait).
++<p/>
++Once we have a fundamental trait like <tt>is_final</tt> available, we can easily define higher-level traits in the future
++on top of this by a proper logical combination of the low-level traits.
++<p/>
++A critical question is whether providing such a low-level compile-time introspection might be considered as disadvantageous,
++because it could constrain the freedom of existing implementations even further and whether a high-level trait would solve
++this dilemma. We assert that since C++11 the static introspection capabilities are already very large and we believe that
++making the presence or absence of the <tt>final</tt> keyword testable does not make the current situation worse.
++<p/>
++Below code example demonstrates the intention and the implementability of this feature:
++</p>
++<blockquote><pre>
++#include &lt;type_traits&gt;
++
++namespace std
++{
++
++template &lt;class T&gt;
++struct is_final
++ : public integral_constant&lt;bool, __is_final(T)&gt;
++{};
++
++} // std
++
++// test it
++
++union FinalUnion <span style="color:#009900;font-weight:bolder">final</span> { };
++
++union NonFinalUnion { };
++
++class FinalClass <span style="color:#009900;font-weight:bolder">final</span> { };
++
++struct NonFinalClass { };
++
++class Incomplete;
++
++int main()
++{
++ using std::is_final;
++ static_assert( is_final&lt;const volatile FinalUnion&gt;{}, "");
++ static_assert(!is_final&lt;FinalUnion[]&gt;{}, "");
++ static_assert(!is_final&lt;FinalUnion[1]&gt;{}, "");
++ static_assert(!is_final&lt;NonFinalUnion>{}, "");
++ static_assert( is_final&lt;FinalClass&gt;{}, "");
++ static_assert(!is_final&lt;FinalClass&amp;&gt;{}, "");
++ static_assert(!is_final&lt;FinalClass*&gt;{}, "");
++ static_assert(!is_final&lt;NonFinalClass&gt;{}, "");
++ static_assert(!is_final&lt;void&gt;{}, "");
++ static_assert(!is_final&lt;int&gt;{}, "");
++ static_assert(!is_final&lt;Incomplete&gt;{}, ""); // <span style="color:#C80000;font-weight:bolder">error incomplete type 'Incomplete' used in type trait expression</span>
++}
++</pre></blockquote>
++
++<p><i>[2014-02-14, Issaquah: Move to Immediate]</i></p>
++
++<p>
++This is an important issue, that we really want to solve for C++14.
++</p>
++
++<p>
++Move to Immediate after polling LEWG, and then the NB heads of delegation.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Change 20.10.2 [meta.type.synop], header <tt>&lt;type_traits&gt;</tt> synopsis, as indicated</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 20.10.4.3, type properties:</i>
++ [&hellip;]
++ template &lt;class T&gt; struct is_empty;
++ template &lt;class T&gt; struct is_polymorphic;
++ template &lt;class T&gt; struct is_abstract;
++ <ins>template &lt;class T&gt; struct is_final;</ins>
++
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 20.10.4.3 [meta.unary.prop], Table 49 &mdash; Type property predicates, as indicated</p>
++
++<table border="1">
++<caption>Table 49 &mdash; Type property predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Preconditions</th>
++</tr>
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_abstract;</tt>
++</td>
++<td>
++[&hellip;]
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_final;</tt></ins>
++</td>
++<td>
++<ins><code>T</code> is a class type marked with the <i>class-virt-specifier</i> <code>final</code> (9 [class]).<br/>
++[<i>Note:</i> A union is a class type that can be marked with <code>final</code>. &mdash; <i>end note</i>]</ins>
++</td>
++<td>
++<ins>If <tt>T</tt> is a class type, <tt>T</tt> shall be a complete type</ins>
++</td>
++</tr>
++
++</table>
++
++</li>
++
++<li><p>After 20.10.4.3 [meta.unary.prop] p5 add one further example as indicated:</p>
++
++<blockquote><p>
++<ins>[<i>Example</i>:</ins>
++</p>
++<blockquote><pre>
++<ins><i>// Given:</i>
++struct P final { };
++union U1 { };
++union U2 final { };
++
++<i>// the following assertions hold:</i>
++static_assert(!is_final&lt;int&gt;::value, "Error!");
++static_assert( is_final&lt;P&gt;::value, "Error!");
++static_assert(!is_final&lt;U1&gt;::value, "Error!");
++static_assert( is_final&lt;U2&gt;::value, "Error!");</ins>
++</pre></blockquote>
++<p>
++<ins>&mdash; <i>end example</i>]</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2118"></a>2118. [CD] <tt>unique_ptr</tt> for array does not support <i>cv</i> qualification conversion of actual argument</h3>
++<p><b>Section:</b> 20.8.1.3 [unique.ptr.runtime] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Alf P. Steinbach <b>Opened:</b> 2011-12-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.runtime">issues</a> in [unique.ptr.runtime].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p><b>Addresses US 16</b></p>
++
++<p>
++N3290 20.8.1.3.1 [unique.ptr.runtime.ctor] "<tt>unique_ptr</tt> constructors":
++</p>
++<blockquote><p>
++These constructors behave the same as in the primary template except that they do not accept pointer types
++which are convertible to <tt>pointer</tt>. [<i>Note:</i> One implementation technique is to create private
++templated overloads of these members. &mdash; <i>end note</i>]
++</p></blockquote>
++<p>
++This language excludes even <tt>pointer</tt> itself as type for the actual argument.
++<p/>
++But of more practical concern is that both Visual C++ 10.0 and MinGW g++ 4.1.1 reject the code below, where
++only an implicit <i>cv</i> qualification is needed, which <i>cv</i> qualification is supported by the non-array
++version:
++</p>
++<blockquote><pre>
++#include &lt;memory&gt;
++using namespace std;
++
++struct T {};
++
++T* foo() { return new T; }
++T const* bar() { return foo(); }
++
++int main()
++{
++ unique_ptr&lt; T const &gt; p1( bar() ); // OK
++ unique_ptr&lt; T const [] &gt; a1( bar() ); // OK
++
++ unique_ptr&lt; T const &gt; p2( foo() ); // OK
++ unique_ptr&lt; T const [] &gt; a2( foo() ); // <span style="color:#C80000;font-weight:bold">? this is line #15</span>
++}
++</pre></blockquote>
++<p>
++The <em>intent</em> seems to be clearly specified in 20.8.1.3 [unique.ptr.runtime]&#47;1 second bullet:
++</p>
++<blockquote><p>
++&mdash; Pointers to types derived from <tt>T</tt> are rejected by the constructors, and by <tt>reset</tt>.
++</p></blockquote>
++
++<p>
++But the following language in 20.8.1.3.1 [unique.ptr.runtime.ctor] then rejects far too much...
++<p/>
++Proposed new wording of N3290 20.8.1.3.1 [unique.ptr.runtime.ctor] "<tt>unique_ptr</tt> constructors":
++</p>
++<blockquote><p>
++These constructors behave the same as in the primary template except that actual argument pointers <tt>p</tt>
++to types derived from <tt>T</tt> are rejected by the constructors. [<i>Note:</i> One implementation technique
++is to create private templated overloads of these members. &mdash; <i>end note</i>]
++</p></blockquote>
++<p>
++This will possibly capture the intent better, and avoid the inconsistency between the non-array and array
++versions of <tt>unique_ptr</tt>, by using nearly the exact same phrasing as for the paragraph explaining
++the intent.
++</p>
++
++<p><i>[2012-08-25 Geoffrey Romer comments in <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32978">c++std-lib-32978</a>]</i></p>
++
++
++<ol>
++<li><p>
++The current P/R seems to intend to support at least two different implementation techniques &mdash; additional
++unusable templates that catch forbidden arguments or replacing existing constructors by templates that
++ensure ill-formed code inside the template body, when the requirements are not met. It seems unclear whether
++the current wording allows the second approach, though. It should be considered to allow both strategies or
++if that is not possible the note should be clearer.
++</p></li>
++
++<li><p>
++The very same problem exists for the <tt>reset</tt> member function, but even worse, because the current
++specification is more than clear that the deleted <tt>reset</tt> function will catch all cases not equal to
++<tt>pointer</tt>. It seems confusing at best to have different policies for the constructor and for the <tt>reset</tt>
++function. In this case, the question in regard to implementation freedom mentioned above is even more important.
++</p></li>
++
++<li><p>
++It's awkward to refer to "the constructors" twice in the same sentence; I suggest revising the sentence as
++"...except that they do not accept argument pointers <tt>p</tt> to types derived from <tt>T</tt>"
++</p></li>
++</ol>
++
++<p><i>[2012-12-20: Geoffrey Romer comments and provides a revised resolution]</i></p>
++
++
++<p>
++The array specialization of <tt>unique_ptr</tt> differs from the primary template in several ways,
++including the following:
++</p>
++<ul>
++<li><p>
++<tt>unique_ptr&lt;T[], D&gt;</tt> cannot be constructed from a plain pointer whose type is not
++exactly <tt>unique_ptr&lt;T[], D&gt;::pointer</tt> or <tt>nullptr_t</tt>.
++</p></li>
++<li><p>
++<tt>unique_ptr&lt;T[], D&gt;</tt> cannot be constructed from a <tt>unique_ptr&lt;U[], E&gt;&amp;&amp;</tt>
++unless <tt>U</tt> is exactly <tt>T</tt> and <tt>E</tt> is exactly <tt>D</tt>.
++</p></li>
++<li><p>
++<tt>unique_ptr&lt;T[], D&gt;</tt> cannot be moveassigned from a <tt>unique_ptr&lt;U[], E&gt;&amp;&amp;</tt>
++unless <tt>U</tt> is exactly <tt>T</tt> and <tt>E</tt> is exactly <tt>D</tt>.
++</p></li>
++<li><p>
++<tt>unique_ptr&lt;T[], D&gt;::reset</tt> cannot take an argument whose type is not exactly
++<tt>unique_ptr&lt;T[], D&gt;::pointer</tt> or <tt>nullptr_t</tt>.
++</p></li>
++<li><p>
++<tt>default_delete&lt;T[]&gt;</tt> cannot be constructed from a <tt>default_delete&lt;U[]&gt;</tt> unless
++<tt>U</tt> is exactly <tt>T</tt>.
++</p></li>
++<li><p>
++<tt>default_delete&lt;T[]&gt;::operator()</tt> cannot be called on a pointer whose type is not
++exactly <tt>T*</tt>.
++</p></li>
++</ul>
++<p>
++The common intent of all these restrictions appears to be to disallow implicit conversions from
++pointer-to-derived-class to pointer-to-base-class in contexts where the pointer is known to point
++to an array, because such conversions are inherently unsafe; deleting or subscripting the result
++of such a conversion leads to undefined behavior (see also CWG 1504). However, these restrictions
++have the effect of disallowing all implicit conversions in those contexts, including most notably
++cv-qualification, but also user-defined conversions, and possibly others. This PR narrows all those
++restrictions, to disallow only unsafe pointer-to-derived to pointer-to-base conversions, while
++allowing all others.
++<p/>
++I removed the nebulous language stating that certain functions "will not accept" certain arguments.
++Instead I use explicitly deleted template functions, which participate in overload resolution only
++for pointer-to-derived to pointer-to-base conversions. This is more consistent with the existing
++text and easier to express correctly than an approach based on declaring certain types of calls to
++be ill-formed, but may produce inferior compiler diagnostics.
++<p/>
++Wherever possible, this PR defines the semantics of template specializations in terms of their
++differences from the primary template. This improves clarity and minimizes the risk of
++unintended differences (e.g. LWG <a href="lwg-defects.html#2169">2169</a>, which this PR also fixes). This PR also makes it
++explicit that the specialization inherits the description of all members, not just member functions,
++from the primary template and, in passing, clarifies the default definition of pointer in the
++specialization.
++<p/>
++This resolution only disallows pointer-to-derived to pointer-to-base conversions between
++ordinary pointer types; if user-defined pointer types provide comparable conversions, it is their
++responsibility to ensure they are safe. This is consistent with C++'s general preference for
++expressive power over safety, and for assuming the user knows what they're doing;
++furthermore, enforcing such a restriction on user-defined types appears to be impractical without
++cooperation from the user.
++<p/>
++The "base class without regard to cv-qualifiers" language is intended to parallel the specification
++of <tt>std::is_base_of</tt>.
++<p/>
++Jonathan Wakely has a working implementation of this PR patched into libstdc++.
++</p>
++
++<p>
++Previous resolution:
++</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<p>Change 20.8.1.3.1 [unique.ptr.runtime.ctor] as indicated:</p>
++
++<blockquote><pre>
++explicit unique_ptr(pointer p) noexcept;
++unique_ptr(pointer p, <i>see below</i> d) noexcept;
++unique_ptr(pointer p, <i>see below</i> d) noexcept;
++</pre>
++<blockquote><p>
++These constructors behave the same as in the primary template except that <del>they do not accept pointer
++types which are convertible to <tt>pointer</tt></del><ins>argument pointers <tt>p</tt> to types derived
++from <tt>T</tt> are rejected by the constructors</ins>. [<i>Note:</i> One implementation technique is to
++create private templated overloads of these members. &mdash; <i>end note</i>]
++</p></blockquote></blockquote>
++</blockquote>
++
++<p><i>[2014-02, Issaquah]</i></p>
++
++<p>
++GR: want to prevent unsafe conversions. Standard is inconsistent how it does this. for <tt>reset()</tt> has deleted function
++template capturing everything except the known-safe cases. Other functions use SFINAE. Main reason this is hard is that
++<tt>unique_ptr</tt> supports fancy pointers. Have to figure out how to handle them and what requirements to put on them.
++Requirements are minimal, not even required to work with <tt>pointer_traits</tt>.
++<p/>
++STL surprised <tt>pointer_traits</tt> doesn't work
++<p/>
++GR: ways to get fancy pointers to work is to delegate responsibility for preventing unsafe conversions to the fancy pointers themselves.
++Howard doesn't like that, he wants even fancy pointers to be prevented from doing unsafe conversions in <tt>unique_ptr</tt> contexts.
++<p/>
++AM: Howard says <tt>unique_ptr</tt> was meant to be very very safe under all conditions, this open a hole in that. Howard wants to
++eke forward and support more, but not if we open any holes in type safety.
++<p/>
++GR: do we need to be typesafe even for fancy types with incorrect <tt>pointer_traits</tt>?
++<p/>
++AM: that would mean it's only unsafe for people who lie by providing a broken specialization of <tt>pointer_traits</tt>
++<p/>
++GR: probably can't continue with ambiguity between using SFINAE and ill-formedness. Would appreciate guidance on direction used for that.
++<p/>
++STL: difference is observable in convertibility using type traits.
++<p/>
++STL: for <tt>reset()</tt> which doesn't affect convertibility ill-formed allows <tt>static_assert</tt>, better diagnostic.
++For assignment it's detectable and has traits, constraining them is better.
++<p/>
++EN: I strongly prefer constraints than <tt>static_asserts</tt>
++<p/>
++STL: if we could rely on <tt>pointer_traits</tt> that might be good. Alternatively could we add more machinery to deleter?
++make deleter say conversions are allowed, otherwise we lock down all conversions. basically want to know if converting <tt>U</tt> to
++<tt>T</tt> is safe.
++</p>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3485.</p>
++<ol>
++<li><p>Revise 20.8.1.1.3 [unique.ptr.dltr.dflt1] as follows</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class T&gt; struct default_delete&lt;T[]&gt; {
++ constexpr default_delete() noexcept = default;
++ <ins>template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp;) noexcept;</ins>
++ void operator()(T*) const;
++ template &lt;class U&gt; void operator()(U*) const = delete;
++ };
++}
++</pre></blockquote>
++<p>
++<ins>-?- Descriptions are provided below only for member functions that have behavior different from the
++primary template.</ins>
++</p>
++<blockquote>
++<pre>
++<ins>template &lt;class U&gt; default_delete(const default_delete&lt;U&gt;&amp;) noexcept;</ins>
++</pre>
++<blockquote><p>
++<ins>-?- This constructor behaves the same as in the primary template except that it shall not participate
++in overload resolution unless:</ins>
++</p>
++<ul>
++<li><p>
++<ins><tt>U</tt> is an array type, and</ins>
++</p></li>
++<li><p>
++<ins><tt>V*</tt> is implicitly convertible to <tt>T*</tt>, and</ins>
++</p></li>
++<li><p>
++<ins><tt>T</tt> is not a base class of <tt>V</tt> (without regard to <i>cv</i>-qualifiers),</ins>
++</p></li>
++</ul>
++<p>
++<ins>where <tt>V</tt> is the array element type of <tt>U</tt>.</ins>
++</p>
++</blockquote>
++
++<blockquote><pre>
++void operator()(T* ptr) const;
++</pre><blockquote>
++<p>
++-1- <i>Effects</i>: calls <tt>delete[]</tt> on <tt>ptr</tt>.
++<p/>
++-2- <i>Remarks</i>: If <tt>T</tt> is an incomplete type, the program is ill-formed.
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++<ins>template &lt;class U&gt; void operator()(U*) const = delete;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Remarks</i>: This function shall not participate in overload resolution unless <tt>T</tt> is a base
++class of <tt>U</tt> (without regard to <i>cv</i>-qualifiers).</ins>
++</p>
++</blockquote></blockquote>
++
++</blockquote>
++</li>
++
++<li><p>Revise 20.8.1.2 [unique.ptr.single]/3 as follows:</p>
++<blockquote><p>
++If the type <tt>remove_reference&lt;D&gt;::type::pointer</tt> exists, then <tt>unique_ptr&lt;T, D&gt;::pointer</tt>
++shall be a synonym for <tt>remove_reference&lt;D&gt;::type::pointer</tt>. Otherwise <tt>unique_ptr&lt;T, D&gt;::pointer</tt>
++shall be a synonym for <tt><del>T</del><ins>element_type</ins>*</tt>. The type <tt>unique_ptr&lt;T, D&gt;::pointer</tt>
++shall satisfy the requirements of <tt>NullablePointer</tt> (17.6.3.3 [nullablepointer.requirements]).
++</p></blockquote>
++</li>
++
++<li><p>Revise 20.8.1.3 [unique.ptr.runtime] as follows:</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt; {
++ public:
++ typedef <i>see below</i> pointer;
++ typedef T element_type;
++ typedef D deleter_type;
++
++ <i>// 20.7.1.3.1, constructors</i>
++ constexpr unique_ptr() noexcept;
++ explicit unique_ptr(pointer p) noexcept;
++ <ins>template &lt;class U&gt; explicit unique_ptr(U* p) = delete;</ins>
++ unique_ptr(pointer p, <i>see below</i> d) noexcept;
++ <ins>template &lt;class U&gt; unique_ptr(U* p, <i>see below</i> d) = delete;</ins>
++ unique_ptr(pointer p, <i>see below</i> d) noexcept;
++ <ins>template &lt;class U&gt; unique_ptr(U* p, <i>see below</i> d) = delete;</ins>
++ unique_ptr(unique_ptr&amp;&amp; u) noexcept;
++ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
++ <ins>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;</ins>
++
++ <i>// destructor</i>
++ ~unique_ptr();
++
++ <i>// assignment</i>
++ unique_ptr&amp; operator=(unique_ptr&amp;&amp; u) noexcept;
++ <ins>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;</ins>
++ unique_ptr&amp; operator=(nullptr_t) noexcept;
++
++ <i>// 20.7.1.3.2, observers</i>
++ T&amp; operator[](size_t i) const;
++ pointer get() const noexcept;
++ deleter_type&amp; get_deleter() noexcept;
++ const deleter_type&amp; get_deleter() const noexcept;
++ explicit operator bool() const noexcept;
++
++ <i>// 20.7.1.3.3 modifiers</i>
++ pointer release() noexcept;
++ void reset(pointer p = pointer()) noexcept;
++ <del>void reset(nullptr_t) noexcept;</del>
++ template &lt;class U&gt; void reset(U<ins>*</ins>) = delete;
++ void swap(unique_ptr&amp; u) noexcept;
++
++ <i>// disable copy from lvalue</i>
++ unique_ptr(const unique_ptr&amp;) = delete;
++ unique_ptr&amp; operator=(const unique_ptr&amp;) = delete;
++ };
++}
++</pre></blockquote>
++<blockquote><p>
++-1- A specialization for array types is provided with a slightly altered interface.
++</p>
++<ul>
++<li><p>
++Conversions <del>between different types of <tt>unique_ptr&lt;T[], D&gt;</tt></del><ins>from
++<tt>unique_ptr&lt;Derived[]&gt;</tt> to <tt>unique_ptr&lt;Base[]&gt;</tt>, where <tt>Base</tt> is a
++base class of <tt>Derived</tt>, from <tt>auto_ptr</tt>,</ins> or to or from the non-array forms of
++<tt>unique_ptr</tt> produce an ill-formed program.
++</p></li>
++<li><p>
++Pointers to types derived from <tt>T</tt> are rejected by the constructors, and by <tt>reset</tt>.
++</p></li>
++<li><p>
++The observers <tt>operator*</tt> and <tt>operator-&gt;</tt> are not provided.
++</p></li>
++<li><p>
++The indexing observer <tt>operator[]</tt> is provided.
++</p></li>
++<li><p>
++The default deleter will call <tt>delete[]</tt>.
++</p></li>
++</ul>
++<p>
++-2- Descriptions are provided below only for <del>member functions that have behavior
++different</del><ins>members that differ</ins> from the primary template.
++<p/>
++-3- The template argument <tt>T</tt> shall be a complete type.
++</p>
++</blockquote>
++</li>
++
++<li><p>Revise 20.8.1.3.1 [unique.ptr.runtime.ctor] as follows:</p>
++<blockquote>
++<pre>
++<del>explicit unique_ptr(pointer p) noexcept;
++unique_ptr(pointer p, <i>see below</i> d) noexcept;
++unique_ptr(pointer p, <i>see below</i> d) noexcept;</del>
++<ins>template &lt;class U&gt; explicit unique_ptr(U* p) = delete;</ins>
++<ins>template &lt;class U&gt; unique_ptr(U* p, <i>see below</i> d) = delete;</ins>
++<ins>template &lt;class U&gt; unique_ptr(U* p, <i>see below</i> d) = delete;</ins>
++</pre><blockquote><p>
++<del>These constructors behave the same as in the primary template except that they do not accept pointer
++types which are convertible to pointer. [<i>Note</i>: One implementation technique is to create private
++templated overloads of these members. &mdash; <i>end note</i>]</del><ins>These constructors shall not
++participate in overload resolution unless:</ins></p>
++<ul>
++<li><p><ins><tt>pointer</tt> is a pointer type, and</ins></p></li>
++<li><p><ins><tt>U*</tt> is implicitly convertible to <tt>pointer</tt>, and</ins></p></li>
++<li><p><ins><tt>T</tt> is a base class of <tt>U</tt> (without regard to <i>cv</i>-qualifiers).</ins></p></li>
++</ul>
++<p><ins>The type of <tt>d</tt> is determined as in the corresponding non-deleted constructors.</ins></p>
++</blockquote>
++<pre>
++<ins>template &lt;class U, class E&gt; unique_ptr(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;</ins>
++</pre><blockquote><p>
++<ins>-?- This constructor behaves the same as in the primary template, except that it shall not participate
++in overload resolution unless:</ins>
++</p>
++<ul>
++<li><p><ins><tt>unique_ptr&lt;U, E&gt;::pointer</tt> is implicitly convertible to <tt>pointer</tt>, and</ins></p></li>
++<li><p><ins><tt>U</tt> is an array type, and</ins></p></li>
++<li><p><ins>either <tt>D</tt> is a reference type and <tt>E</tt> is the same type as <tt>D</tt>, or <tt>D</tt>
++is not a reference type and <tt>E</tt> is implicitly convertible to <tt>D</tt>, and</ins></p></li>
++<li><p><ins>either at least one of <tt>pointer</tt> and <tt>unique_ptr&lt;U, E&gt;::pointer</tt> is not a
++pointer type, or <tt>T</tt> is not a base class of the array element type of <tt>U</tt> (without regard to
++<i>cv</i>-qualifiers).</ins></p></li>
++</ul>
++</blockquote></blockquote>
++</li>
++
++<li><p>Insert a new sub-clause following 20.8.1.3.1 [unique.ptr.runtime.ctor] as follows:</p>
++
++<p><ins>?? <tt>unique_ptr</tt> assignment [unique.ptr.runtime.asgn]</ins></p>
++
++<blockquote>
++<pre>
++<ins>template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;</ins>
++</pre><blockquote><p>
++<ins>-?- This operator behaves the same as in the primary template, except that it shall not participate in
++overload resolution unless:</ins></p>
++<ul>
++<li><p><ins><tt>unique_ptr&lt;U, E&gt;::pointer</tt> is implicitly convertible to <tt>pointer</tt>, and</ins></p></li>
++<li><p><ins><tt>U</tt> is an array type, and</ins></p></li>
++<li><p><ins>either <tt>D</tt> is a reference type and <tt>E</tt> is the same type as <tt>D</tt>, or <tt>D</tt>
++is not a reference type and <tt>E</tt> is implicitly convertible to <tt>D</tt>, and</ins></p></li>
++<li><p><ins>either at least one of <tt>pointer</tt> and <tt>unique_ptr&lt;U, E&gt;::pointer</tt> is not a
++pointer type, or <tt>T</tt> is not a base class of the array element type of <tt>U</tt> (without regard to
++<i>cv</i>-qualifiers).</ins></p></li>
++</ul>
++</blockquote></blockquote>
++</li>
++
++<li><p>Revise 20.8.1.3.4 [unique.ptr.runtime.modifiers] as follows:</p>
++
++<blockquote>
++<pre>
++<del>void reset(pointer p = pointer()) noexcept;
++void reset(nullptr_t p) noexcept;</del>
++<ins>template &lt;class U&gt; void reset(U*) = delete;</ins>
++</pre><blockquote><p>
++<del>-1- <i>Effects</i>: If <tt>get() == nullptr</tt> there are no effects. Otherwise <tt>get_deleter()(get())</tt>.</del>
++<p/>
++<del>-2- <i>Postcondition</i>: <tt>get() == p</tt>.</del>
++<p/>
++<ins>-?- This function shall not participate in overload resolution unless:</ins>
++</p>
++<ul>
++<li><p><ins><tt>pointer</tt> is a pointer type, and</ins></p></li>
++<li><p><ins><tt>U*</tt> is implicitly convertible to <tt>pointer</tt>, and</ins></p></li>
++<li><p><ins><tt>T</tt> is a base class of <tt>U</tt> (without regard to <i>cv</i>-qualifiers).</ins></p></li>
++</ul>
++
++</blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-06 Rapperswil]</i></p>
++
++<p>
++Discussion of N4042 and general agreement that this paper resolves the substance of this issue and should be adopted with
++minor edits. Geoffrey Romer will provide an updated paper.
++</p>
++
++<p><i>[2014-06 post-Rapperswil]</i></p>
++
++<p>
++As described in N4089.
++</p>
++
++<p><i>[2014-11-07 Urbana]</i></p>
++
++<p>
++Resolved by
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089.pdf">N4089</a>
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++See proposed wording in N4089.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2120"></a>2120. What should <tt>async</tt> do if neither '<tt>async</tt>' nor '<tt>deferred</tt>' is set in policy?</h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-01-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Implementations already disagree, one returns an invalid future with
++no shared state, one chooses <tt>policy == async</tt> and one chooses <tt>policy ==
++deferred</tt>, see c++std-lib-30839, c++std-lib-30840 and c++std-lib-30844.
++It's not clear if returning an invalid future is allowed by the current wording.
++</p>
++<p>
++If the intention is to allow an empty future to be returned, then
++30.6.8 [futures.async] p3 and p4 should be adjusted to clarify that a
++shared state might not be created and an invalid future might be returned.
++</p>
++<p>
++If the intention is that a valid future is always returned, p3 should
++say something about the case where none of the conditions applies.
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++We could make it undefined if no launch policy is defined.
++</p>
++<p>
++Hans: If no launch policy is specified the behaviour is undefined
++</p>
++<p>
++Artur: or implementation defined?
++</p>
++<p>
++Hans: no: we don't want people to do this
++</p>
++<p><i>[Proposed wording]</i></p>
++
++<p>
++This wording is relative to N3376
++</p>
++<p>
++Add a third bullet to the end of the list in 30.6.8p3
++</p>
++<blockquote>
++"if no valid launch policy is provided the behaviour is undefined"
++</blockquote>
++<p>
++Moved to review
++</p>
++
++<p><i>[2013-04-19, Bristol]</i></p>
++
++
++<p>Detlef provides new wording</p>
++
++<p>Previous wording:</p>
++
++<blockquote class="note">
++<p><i>[This wording is relative to N3376]</i></p>
++
++<p>
++Add a third bullet to the end of the list in 30.6.8 [futures.async]p3
++</p>
++<blockquote>
++<ins>&ndash; if no valid launch policy is provided the behaviour is undefined</ins>
++</blockquote>
++</blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++If no policy is given, it should be undefined, so moved to Immediate.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to N3485]</i></p>
++
++<p>
++Add a third bullet to the end of the list in 30.6.8 [futures.async]p3
++</p>
++<blockquote>
++<ins>&ndash; If no value is set in the launch policy, or a value is set that is
++neither specified in this International Standard or by the implementation, the behaviour
++is undefined.</ins>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2122"></a>2122. <tt>merge()</tt> stability for lists versus forward lists</h3>
++<p><b>Section:</b> 23.3.5.5 [list.ops], 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2012-01-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#list.ops">issues</a> in [list.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>forward_list::merge()</tt> is specified in 23.3.4.6 [forwardlist.ops], p19 as follows:
++</p>
++<blockquote><p>
++This operation shall be stable: for equivalent elements in the two lists,
++the elements from <tt>*this</tt> shall always precede the elements from <tt>x</tt>.
++</p></blockquote>
++<p>
++But <tt>list::merge()</tt> is only specified in 23.3.5.5 [list.ops], p24 as follows:
++</p>
++<blockquote><p>
++<i>Remarks</i>: Stable.
++</p></blockquote>
++<p>
++Note that in general we define "stable" only for algorithms (see 17.3 [defns.stable] and
++17.6.5.7 [algorithm.stable]) so for member function we should explain it everywhere we use it.
++<p/>
++Thus for lists we have to add:
++</p>
++<blockquote><p>
++Stable: for equivalent elements in the two lists, the elements from the list always precede the elements
++from the argument list.
++</p></blockquote>
++<p>
++This, BTW, was the specification we had with C++03.
++<p/>
++In addition, I wonder whether we also have some guarantees regarding stability saying that the order
++of equivalent elements of each list merged remains stable (which would be my interpretation of just
++saying "stable", BTW).
++<p/>
++Thus, I'd expect that for equivalent elements we guarantee that
++</p>
++<ul>
++ <li> we first have all element of <tt>*this</tt> (in the same order as on entry)</li>
++ <li> and then all elements of the passed argument (in the same order as on entry).</li>
++</ul>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Open.
++</p>
++<p>
++STL says we need to fix up 17.6.5.7 to be stronger, and then the remarks for merge should
++just say "Remarks: Stable (see 17.6.5.7)"
++</p>
++<p>
++Assigned to STL for word-smithing.
++</p>
++
++<p><i>[
++2013-04-14 STL provides rationale and improved wording
++]</i></p>
++
++
++<p>Step 1: Centralize all specifications of stability to 17.6.5.7 [algorithm.stable].</p>
++<p>Step 2: 17.3 [defns.stable] and 17.6.5.7 [algorithm.stable] talk about "algorithms", without mentioning
++"container member functions". There's almost no potential for confusion here, but there's a simple way to increase clarity
++without increasing verbosity: make the container member functions explicitly cite 17.6.5.7 [algorithm.stable]. For
++consistency, we can also update the non-member functions.</p>
++<p>Step 3: Fix the "so obvious, we forgot to say it" bug in 17.6.5.7 [algorithm.stable]: a "stable" merge of equivalent
++elements A B C D and W X Y Z produces A B C D W X Y Z, never D C B A X W Z Y.</p>
++<p>Step 3.1: Say "(preserving their original order)" to be consistent with "the relative order [...] is preserved" in
++17.6.5.7 [algorithm.stable]'s other bullet points.</p>
++<p>Step 4: Copy part of <tt>list::merge()</tt>'s wording to <tt>forward_list::merge()</tt>, in order to properly connect
++with 17.6.5.7 [algorithm.stable]'s "first range" and "second range".</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Original wording saved here:</p>
++<blockquote class="note">
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li>
++<p>Change 23.3.5.5 [list.ops] as indicated:</p>
++
++<blockquote><pre>
++void merge(list&lt;T,Allocator&gt;&amp; x);
++void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
++template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);
++template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-24- <i>Remarks</i>: <del>Stable</del><ins>This operation shall be stable: for equivalent elements
++in the two lists, the elements from <tt>*this</tt> shall always precede the elements from <tt>x</tt>
++and the order of equivalent elements of <tt>*this</tt> and <tt>x</tt> remains stable</ins>. If
++<tt>(&amp;x != this)</tt> the range <tt>[x.begin(), x.end())</tt>
++is empty after the merge. No elements are copied by this operation. The behavior is undefined if
++<tt>this-&gt;get_allocator() != x.get_allocator()</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 23.3.4.6 [forwardlist.ops] as indicated:</p>
++
++<blockquote><pre>
++void merge(forward_list&lt;T,Allocator&gt;&amp; x);
++void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp; x, Compare comp);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-19- <i>Effects</i>: Merges <tt>x</tt> into <tt>*this</tt>. This operation shall be stable: for
++equivalent elements in the two lists, the elements from <tt>*this</tt> shall always precede the
++elements from <tt>x</tt> <ins>and the order of equivalent elements of <tt>*this</tt> and <tt>x</tt>
++remains stable</ins>. <tt>x</tt> is empty after the merge. If an exception is thrown other
++than by a comparison there are no effects. Pointers and references to the moved elements of <tt>x</tt>
++now refer to those same elements but as members of <tt>*this</tt>. Iterators referring
++to the moved elements will continue to refer to their elements, but they now behave as iterators into
++<tt>*this</tt>, not into <tt>x</tt>.
++</p></blockquote></blockquote>
++</li>
++</ol>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the N3485.</p>
++
++<ol>
++<li><p>Change 17.6.5.7 [algorithm.stable]/1 as indicated:</p>
++<blockquote><p>
++When the requirements for an algorithm state that it is “stable” without further elaboration, it means:
++<p/>
++[&hellip;]
++</p>
++<ul>
++<li>For the <em>merge</em> algorithms, for equivalent elements in the original two ranges, the elements from the
++first range <ins>(preserving their original order)</ins> precede the elements from the second range <ins>(preserving
++their original order)</ins>.</li>
++</ul>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.4.6 [forwardlist.ops] as indicated:</p>
++<blockquote>
++<pre>
++void remove(const T&amp; value);
++template &lt;class Predicate&gt; void remove_if(Predicate pred);
++</pre>
++<blockquote>
++<p>
++-12- <i>Effects</i>: Erases all the elements in the list referred by a list iterator <tt>i</tt> for which the following conditions
++hold: <tt>*i == value</tt> (for <tt>remove()</tt>), <tt>pred(*i)</tt> is true (for <tt>remove_if()</tt>). <del>This operation shall be
++stable: the relative order of the elements that are not removed is the same as their relative order in the original
++list.</del> Invalidates only the iterators and references to the erased elements.
++<p/>
++-13- <i>Throws</i>: Nothing unless an exception is thrown by the equality comparison or the predicate.
++<p/>
++<ins>-??- <i>Remarks</i>: Stable (17.6.5.7 [algorithm.stable]).</ins>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++void merge(forward_list&amp; x);
++void merge(forward_list&amp;&amp; x);
++template &lt;class Compare&gt; void merge(forward_list&amp; x, Compare comp)
++template &lt;class Compare&gt; void merge(forward_list&amp;&amp; x, Compare comp)
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-19- <i>Effects</i>: Merges <del><tt>x</tt> into <tt>*this</tt></del><ins>the two sorted ranges <tt>[begin(), end())</tt>
++and <tt>[x.begin(), x.end())</tt></ins>. <del>This operation shall be stable: for equivalent
++elements in the two lists, the elements from <tt>*this</tt> shall always precede the elements from <tt>x</tt>.</del>
++<tt>x</tt> is empty after the merge. If an exception is thrown other than by a comparison there are no effects. Pointers and
++references to the moved elements of <tt>x</tt> now refer to those same elements but as members of <tt>*this</tt>.
++Iterators referring to the moved elements will continue to refer to their elements, but they now behave as iterators into
++<tt>*this</tt>, not into <tt>x</tt>.
++<p/>
++-20- <i>Remarks</i>: <ins>Stable (17.6.5.7 [algorithm.stable]).</ins> The behavior is undefined if
++<tt>this-&gt;get_allocator() != x.get_allocator()</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++void sort();
++template &lt;class Compare&gt; void sort(Compare comp);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-23- <i>Effects</i>: Sorts the list according to the <tt>operator&lt;</tt> or the <tt>comp</tt> function object. <del>This
++operation shall be stable: the relative order of the equivalent elements is preserved.</del> If an exception is thrown the order
++of the elements in <tt>*this</tt> is unspecified. Does not affect the validity of iterators and references.
++<p/>
++<ins>-??- <i>Remarks</i>: Stable (17.6.5.7 [algorithm.stable]).</ins>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.5.5 [list.ops] as indicated:</p>
++<blockquote>
++<pre>
++void remove(const T&amp; value);
++template &lt;class Predicate&gt; void remove_if(Predicate pred);
++</pre>
++<blockquote>
++<p>
++[&hellip;]<p/>
++-17- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++<p/>
++[&hellip;]</p>
++</blockquote>
++
++<pre>
++void merge(list&amp; x);
++void merge(list&amp;&amp; x);
++template &lt;class Compare&gt; void merge(list&amp; x, Compare comp)
++template &lt;class Compare&gt; void merge(list&amp;&amp; x, Compare comp)
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-24- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>. [&hellip;]
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++void sort();
++template &lt;class Compare&gt; void sort(Compare comp);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-30- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 25.3.1 [alg.copy]/12 as indicated:</p>
++<blockquote>
++<pre>
++template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
++OutputIterator
++copy_if(InputIterator first, InputIterator last,
++ OutputIterator result, Predicate pred);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-12- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 25.3.8 [alg.remove] as indicated:</p>
++<blockquote>
++<pre>
++template&lt;class ForwardIterator, class T&gt;
++ForwardIterator
++remove(ForwardIterator first, ForwardIterator last, const T&amp; value);
++template&lt;class ForwardIterator, class Predicate&gt;
++ForwardIterator
++remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-4- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++template&lt;class InputIterator, class OutputIterator, class T&gt;
++OutputIterator
++remove_copy(InputIterator first, InputIterator last,
++ OutputIterator result, const T&amp; value);
++template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
++OutputIterator
++remove_copy_if(InputIterator first, InputIterator last,
++ OutputIterator result, Predicate pred);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-11- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 25.4.1.2 [stable.sort]/4 as indicated:</p>
++<blockquote>
++<pre>
++template&lt;class RandomAccessIterator&gt;
++void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
++template&lt;class RandomAccessIterator, class Compare&gt;
++void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
++Compare comp);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-4- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 25.4.4 [alg.merge] as indicated:</p>
++<blockquote>
++<pre>
++template&lt;class InputIterator1, class InputIterator2,
++ class OutputIterator&gt;
++OutputIterator
++merge(InputIterator1 first1, InputIterator1 last1,
++ InputIterator2 first2, InputIterator2 last2,
++ OutputIterator result);
++template&lt;class InputIterator1, class InputIterator2,
++ class OutputIterator, class Compare&gt;
++OutputIterator
++merge(InputIterator1 first1, InputIterator1 last1,
++ InputIterator2 first2, InputIterator2 last2,
++ OutputIterator result, Compare comp);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-5- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++
++<pre>
++template&lt;class BidirectionalIterator&gt;
++void inplace_merge(BidirectionalIterator first,
++ BidirectionalIterator middle,
++ BidirectionalIterator last);
++template&lt;class BidirectionalIterator, class Compare&gt;
++void inplace_merge(BidirectionalIterator first,
++ BidirectionalIterator middle,
++ BidirectionalIterator last, Compare comp);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-9- <i>Remarks</i>: Stable <ins>(17.6.5.7 [algorithm.stable])</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2123"></a>2123. <tt>merge()</tt> allocator requirements for lists versus forward lists</h3>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2012-01-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Sub-clause 23.3.5.5 [list.ops], p24 states for lists:
++</p>
++<blockquote><p>
++The behavior is undefined if <tt>this-&gt;get_allocator() != x.get_allocator()</tt>.
++</p></blockquote>
++<p>
++But there is nothing like that for forward lists in 23.3.4.6 [forwardlist.ops],
++although I would expect the same undefined behavior there.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++Move to Ready.
++</p>
++
++<p><i>[2012, Portland: applied to WP]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to the FDIS.</p>
++
++<ol>
++<li>
++<p>Add a new paragraph after 23.3.4.6 [forwardlist.ops] p19 as indicated:</p>
++
++<blockquote><pre>
++void merge(forward_list&lt;T,Allocator&gt;&amp; x);
++void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp; x, Compare comp);
++template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-19- <i>Effects</i>: [&hellip;]
++<p/>
++<ins>-?- <i>Remarks</i>: The behavior is undefined if <tt>this-&gt;get_allocator() != x.get_allocator()</tt>.</ins>
++</p></blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2128"></a>2128. Absence of global functions <tt>cbegin&#47;cend</tt></h3>
++<p><b>Section:</b> 24.3 [iterator.synopsis], 24.7 [iterator.range] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Dmitry Polukhin <b>Opened:</b> 2012-01-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.synopsis">issues</a> in [iterator.synopsis].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++All standard containers support <tt>cbegin&#47;cend</tt> member functions but corresponding global functions are
++missing. Proposed resolution it to add global <tt>cbegin&#47;cend</tt> functions by analogy with global <tt>begin&#47;end</tt>
++functions. This addition will unify things for users.
++</p>
++
++<p><i>[2012, Kona]</i></p>
++
++
++<p>STL: Range-based for loops do not use global <tt>begin</tt>/<tt>end</tt> (anymore).</p>
++<p>Alisdair: We will have to make sure these will be available through many headers.</p>
++<p>STL: Do this, including <tt>r</tt> and <tt>cr</tt>. This won't add any additional work.</p>
++<p>Matt: Users will find it strange if these are not all available.</p>
++<p>Alisdair: Should we have these available everywhere begin/end are available?</p>
++<p>Marshall: Yes. Not any extra work.</p>
++<p>Howard: Adding all of these means we need all of <tt>&lt;iterator></tt>.</p>
++<p>STL: We already need it all.</p>
++<p>Matt: We have to be careful what we are requiring if we include the <tt>r</tt> versions.</p>
++<p>Jeffrey: If we include <tt>r</tt>, should they adapt if the container does not define reverse iteration?</p>
++<p>STL: No. No special behavior. Should fail to compile. Up to user to add the reverse code--it's easy.</p>
++<p>Howard: Anyway it will SFINAE out.</p>
++<p>Alisdair: Error messages due to SFINAE are harder to understand than simple failure to compile.</p>
++<p>STL: Agrees that SFINAE makes error messages much worse.</p>
++
++<p>
++Action: STL to provide additional wording for the <tt>r</tt> variants.
++Move to Review once that wording is availalbe.
++</p>
++
++<p><i>[
++2013-04-14 STL provides rationale and improved wording
++]</i></p>
++
++
++<p>Step 1: Implement <tt>std::cbegin/cend()</tt> by calling <tt>std::begin/end()</tt>. This has numerous advantages:</p>
++<ul>
++<li>It automatically works with arrays, which is the whole point of these non-member functions.</li>
++<li>It works with C++98/03-era user containers, written before <tt>cbegin/cend()</tt> members were invented.</li>
++<li>It works with <tt>initializer_list</tt>, which is extremely minimal and lacks <tt>cbegin/cend()</tt> members.</li>
++<li>23.2.1 [container.requirements.general] guarantees that this is equivalent to calling cbegin/cend() members.</li>
++</ul>
++<p>Step 2: Like <tt>std::begin/end()</tt>, implement <tt>std::rbegin/rend()</tt> by calling <tt>c.rbegin/rend()</tt>.
++Note that C++98/03 had the <tt>Reversible Container Requirements</tt>.</p>
++<p>Step 3: Also like <tt>std::begin/end()</tt>, provide overloads of <tt>std::rbegin/rend()</tt> for arrays.</p>
++<p>Step 4: Provide overloads of <tt>std::rbegin/rend()</tt> for <tt>initializer_list</tt>, because it lacks
++<tt>rbegin/rend()</tt> members. These overloads follow 18.9.3 [support.initlist.range]'s signatures. Note that
++because these overloads return <tt>reverse_iterator</tt>, they aren't being specified in <tt>&lt;initializer_list&gt;</tt>.</p>
++<p>Step 5: Like Step 1, implement <tt>std::crbegin/crend()</tt> by calling <tt>std::rbegin/rend()</tt>.</p>
++
++<p>Original wording saved here:</p>
++<blockquote class="note">
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf">N3337</a>.</p>
++
++<ol>
++<li><p>In 24.3 [iterator.synopsis], header iterator synopsis, add the following declarations:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 24.6.5, range access:</i>
++ template &lt;class C&gt; auto begin(C&amp; c) -> decltype(c.begin());
++ template &lt;class C&gt; auto begin(const C&amp; c) -> decltype(c.begin());
++ template &lt;class C&gt; auto end(C&amp; c) -> decltype(c.end());
++ template &lt;class C&gt; auto end(const C&amp; c) -> decltype(c.end());
++ <ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -> decltype(c.cbegin());</ins>
++ <ins>template &lt;class C&gt; auto cend(const C&amp; c) -> decltype(c.cend());</ins>
++ template &lt;class T, size_t N&gt; T* begin(T (&amp;array)[N]);
++ template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
++ <ins>template &lt;class T, size_t N&gt; const T* cbegin(T (&amp;array)[N]);</ins>
++ <ins>template &lt;class T, size_t N&gt; const T* cend(T (&amp;array)[N]);</ins>
++}
++</pre></blockquote>
++</li>
++
++<li><p>In 24.7 [iterator.range] after p5 add the following series of paragraphs:</p>
++
++<blockquote>
++<pre>
++<ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -> decltype(c.cbegin());</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>c.cbegin()</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto cend(const C&amp; c) -> decltype(c.cend());</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>c.cend()</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class T, size_t N&gt; const T* cbegin(T (&amp;array)[N]);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>array</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class T, size_t N&gt; const T* cend(T (&amp;array)[N]);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>array + N</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>
++
++<ol>
++<li><p>In 24.3 [iterator.synopsis], header iterator synopsis, add the following declarations:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 24.6.5, range access:</i>
++ template &lt;class C&gt; auto begin(C&amp; c) -> decltype(c.begin());
++ template &lt;class C&gt; auto begin(const C&amp; c) -> decltype(c.begin());
++ template &lt;class C&gt; auto end(C&amp; c) -> decltype(c.end());
++ template &lt;class C&gt; auto end(const C&amp; c) -> decltype(c.end());
++ template &lt;class T, size_t N&gt; T* begin(T (&amp;array)[N]);
++ template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
++ <ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -> decltype(std::begin(c));</ins>
++ <ins>template &lt;class C&gt; auto cend(const C&amp; c) -> decltype(std::end(c));</ins>
++ <ins>template &lt;class C&gt; auto rbegin(C&amp; c) -> decltype(c.rbegin());</ins>
++ <ins>template &lt;class C&gt; auto rbegin(const C&amp; c) -> decltype(c.rbegin());</ins>
++ <ins>template &lt;class C&gt; auto rend(C&amp; c) -> decltype(c.rend());</ins>
++ <ins>template &lt;class C&gt; auto rend(const C&amp; c) -> decltype(c.rend());</ins>
++ <ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rbegin(T (&amp;array)[N]);</ins>
++ <ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rend(T (&amp;array)[N]);</ins>
++ <ins>template &lt;class E> reverse_iterator&lt;const E*&gt; rbegin(initializer_list&lt;E&gt; il);</ins>
++ <ins>template &lt;class E> reverse_iterator&lt;const E*&gt; rend(initializer_list&lt;E&gt; il);</ins>
++ <ins>template &lt;class C&gt; auto crbegin(const C&amp; c) -> decltype(std::rbegin(c));</ins>
++ <ins>template &lt;class C&gt; auto crend(const C&amp; c) -> decltype(std::rend(c));</ins>
++}
++</pre></blockquote>
++</li>
++
++<li><p>At the end of 24.7 [iterator.range], add:</p>
++
++<blockquote>
++<pre>
++<ins>template &lt;class C&gt; auto cbegin(const C&amp; c) -> decltype(std::begin(c));</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>std::begin(c)</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto cend(const C&amp; c) -> decltype(std::end(c));</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>std::end(c)</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto rbegin(C&amp; c) -> decltype(c.rbegin());</ins>
++<ins>template &lt;class C&gt; auto rbegin(const C&amp; c) -> decltype(c.rbegin());</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>c.rbegin()</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto rend(C&amp; c) -> decltype(c.rend());</ins>
++<ins>template &lt;class C&gt; auto rend(const C&amp; c) -> decltype(c.rend());</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>c.rend()</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rbegin(T (&amp;array)[N]);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;T*&gt;(array + N)</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class T, size_t N&gt; reverse_iterator&lt;T*&gt; rend(T (&amp;array)[N]);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;T*&gt;(array)</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class E> reverse_iterator&lt;const E*&gt; rbegin(initializer_list&lt;E&gt; il);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;const E*&gt;(il.end())</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class E> reverse_iterator&lt;const E*&gt; rend(initializer_list&lt;E&gt; il);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>reverse_iterator&lt;const E*&gt;(il.begin())</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto crbegin(const C&amp; c) -> decltype(std::rbegin(c));</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>std::rbegin(c)</tt>.</ins>
++</p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class C&gt; auto crend(const C&amp; c) -> decltype(std::rend(c));</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: <tt>std::rend(c)</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2129"></a>2129. User specializations of <tt>std::initializer_list</tt></h3>
++<p><b>Section:</b> 17.6.4.2.1 [namespace.std], 18.9 [support.initlist] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2012-01-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#namespace.std">issues</a> in [namespace.std].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Since the implementation is intended to magically synthesize instances of <tt>std::initializer_list</tt>
++(rather than by a constructor call, for instance), user specializations of this type can't generally be
++made to work. I can't find any wording which makes such specializations ill-formed, though, which leads
++me to suspect that they're technically legal under the provisions of 17.6.4.2.1 [namespace.std] p1.</p>
++
++
++<p><i>[2012, Kona]</i></p>
++
++<p>
++This sounds correct, but we need wording for a resolution.
++</p>
++<p>
++Marshall Clow volunteers to produce wording.
++</p>
++
++<p><i>[2014-02-19, Jonathan Wakely provides proposed wording]</i></p>
++
++
++<p><i>[2014-03-27, Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Add new new paragraph below 18.9 [support.initlist] p2:</p>
++
++<blockquote>
++<p>
++-2- An object of type <tt>initializer_list&lt;E&gt;</tt> provides access to an array of objects of type <tt>const E</tt>. [&hellip;]
++<p/>
++<ins>-?- If an explicit specialization or partial specialization of <tt>initializer_list</tt> is declared, the program is ill-formed.</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2130"></a>2130. Missing ordering constraints</h3>
++<p><b>Section:</b> 29.3 [atomics.order] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Mark Batty <b>Opened:</b> 2012-02-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#atomics.order">active issues</a> in [atomics.order].</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.order">issues</a> in [atomics.order].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>C11 issue 407</b></p>
++
++<p>
++It seems that both C11 and C++11 are missing the following two derivatives of this
++rule:
++</p>
++<blockquote><p>
++ For atomic modifications <tt>A</tt> and <tt>B</tt> of an atomic object <tt>M</tt>, if there is
++ a <tt>memory_order_seq_cst</tt> fence <tt>X</tt> such that <tt>A</tt> is sequenced before <tt>X</tt>,
++ and <tt>X</tt> precedes <tt>B</tt> in <tt>S</tt>, then <tt>B</tt> occurs later than <tt>A</tt> in the
++ modification order of <tt>M</tt>.
++</p></blockquote>
++<blockquote><p>
++ For atomic modifications <tt>A</tt> and <tt>B</tt> of an atomic object <tt>M</tt>, if there is
++ a <tt>memory_order_seq_cst</tt> fence <tt>Y</tt> such that <tt>Y</tt> is sequenced before <tt>B</tt>,
++ and <tt>A</tt> precedes <tt>Y</tt> in <tt>S</tt>, then <tt>B</tt> occurs later than <tt>A</tt> in the
++ modification order of <tt>M</tt>.
++</p></blockquote>
++<p>
++Above wording has been suggested for the Technical Corrigendum of C11 via issue 407, details can be found
++<a href="http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1584.pdf">here</a>.
++</p>
++
++<p><i>[2012-03-19: Daniel proposes a slightly condensed form to reduce wording duplications]</i></p>
++
++
++<p><i>[2012-03-20: Hans comments]</i></p>
++
++<p>
++The usage of the term <em>atomic operations</em> in 29.3 [atomics.order] p7 is actually
++incorrect and should better be replaced by <em>atomic modifications</em> as used in the C11
++407 wording.
++<p/>
++There seems to be a similar wording incorrectness used in 1.10 [intro.multithread] p17
++which should be corrected as well.
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++Olivier: does the fence really participate in the modifications?
++</p>
++<p>
++Hans: S is the total set of <em>all</em> sequentially consistent operations,
++ and sequentially consistent fences are in S.
++</p>
++<p>
++Olivier: this sort of combination of a pair of half-open rules seems to imply the
++ write must make it to main memory
++</p>
++<p>
++But not all implementations treat a fence as a memory operation; cannot observe the half-open rule.
++</p>
++<p>
++Hans: not sure this is actually prevented here. You could defer until the next load.
++ What the wording doesn't quite show is that the third bullet in the new wording
++ is already in the standard.
++</p>
++<p>
++Hans: it is the interaction between fences on one side and other memory modifications
++ on the other that is being defined here.
++</p>
++<p>
++Pablo: S is not directly observable; it is a hypothetic ordering.
++</p>
++<p>
++Moved to review
++</p>
++<p>
++Hans: to alert C liaison
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p><em>[Drafting note: The project editor is kindly asked to consider to replace in 1.10 [intro.multithread] p17
++the phrase <em>"before an operation <i>B</i> on <i>M</i>"</em> by <em>"before a modification <i>B</i> of <i>M</i>"</em>.]</em></p>
++</li>
++<li><p>Change 29.3 [atomics.order] paragraph 7 as indicated: <em>[Drafting note: Note that the
++wording change intentionally does also replace the term <em>atomic operation</em> by <em>atomic modification</em>]</em>
++</p>
++
++<p>
++-7- <del>For atomic operations <i>A</i> and <i>B</i> on an atomic object <i>M</i>, if there are
++<tt>memory_order_seq_cst</tt> fences <i>X</i> and <i>Y</i> such that <i>A</i> is sequenced before <i>X</i>,
++<i>Y</i> is sequenced before <i>B</i>, and <i>X</i> precedes <i>Y</i> in <i>S</i>, then <i>B</i>
++occurs later than <i>A</i> in the modification order of <i>M</i>.</del>
++<ins>For atomic modifications <i>A</i> and <i>B</i> of an atomic object <i>M</i>, <i>B</i> occurs
++later than <i>A</i> in the modification order of <i>M</i> if:</ins>
++<ul>
++<li><ins>there is a <tt>memory_order_seq_cst</tt> fence <i>X</i> such that <i>A</i> is sequenced before <i>X</i>,
++and <i>X</i> precedes <i>B</i> in <i>S</i>, or</ins>
++</li>
++<li><ins>there is a <tt>memory_order_seq_cst</tt> fence <i>Y</i> such that <i>Y</i> is sequenced before <i>B</i>,
++and <i>A</i> precedes <i>Y</i> in <i>S</i>, or</ins>
++</li>
++<li><ins>there are <tt>memory_order_seq_cst</tt> fences <i>X</i> and <i>Y</i> such that <i>A</i> is sequenced
++before <i>X</i>, <i>Y</i> is sequenced before <i>B</i>, and <i>X</i> precedes <i>Y</i> in <i>S</i>.</ins>
++</li>
++</ul>
++<p/>
++-8- [ <i>Note</i>: <tt>memory_order_seq_cst</tt> ensures sequential consistency only for a program that is free of data races
++and uses exclusively <tt>memory_order_seq_cst</tt> operations. Any use of weaker ordering will invalidate this
++guarantee unless extreme care is used. In particular, <tt>memory_order_seq_cst</tt> fences ensure a total order
++only for the fences themselves. Fences cannot, in general, be used to restore sequential consistency for atomic
++operations with weaker ordering specifications. &mdash; <i>end note</i> ]
++</p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2132"></a>2132. <tt>std::function</tt> ambiguity</h3>
++<p><b>Section:</b> 20.9.12.2.1 [func.wrap.func.con] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ville Voutilainen <b>Opened:</b> 2012-02-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func.con">issues</a> in [func.wrap.func.con].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider the following:
++</p>
++<blockquote><pre>
++#include &lt;functional&gt;
++
++void f(std::function&lt;void()&gt;) {}
++void f(std::function&lt;void(int)&gt;) {}
++
++int main() {
++ f([]{});
++ f([](int){});
++}
++</pre></blockquote>
++<p>
++The calls to <tt>f</tt> in <tt>main</tt> are ambiguous. Apparently because the
++conversion sequences to <tt>std::function</tt> from the lambdas are identical.
++The standard specifies that the function object given to <tt>std::function</tt>
++"shall be <em>Callable</em> (20.8.11.2) for argument types <tt>ArgTypes</tt> and
++return type <tt>R</tt>." It doesn't say that if this is not the case, the
++constructor isn't part of the overload set.
++<p/>
++Daniel: During the preparation of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3123.html">N3123</a>
++it turned out that there are no longer reasons to refer to <em>INVOKE</em> as a
++conceptually entity alone, its real implementation as a function template <tt>invoke</tt>
++is possible but was deferred for a later point in time. Defining a type trait for
++the <em>Callable</em> requirement would also be possible, so there seem to be no technical
++reasons why the template constructor of <tt>std::function</tt> should not be
++constrained. The below suggested wording does this without introducing a special
++trait for this. This corresponds to the way that has been used to specify the
++<tt>result_of</tt> trait. Note that the definition of the <em>Callable</em>
++requirement is perfectly suitable for this, because it is a pure syntactically
++based requirement and can be directly transformed into a constrained template.
++<p/>
++The suggested resolution also applies such wording to the "perfectly forwarding"
++assignment operator
++</p>
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(F&amp;&amp;);
++</pre></blockquote>
++<p>
++The positive side-effect of this is that it automatically implements a solution to
++a problem similar to that mentioned in issue <a href="lwg-defects.html#1234">1234</a>.
++<p/>
++It would be possible to apply similar constraints to the member signatures
++</p>
++<blockquote><pre>
++template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt;);
++
++template&lt;class F, class A&gt; void assign(F&amp;&amp;, const A&amp;);
++</pre></blockquote>
++<p>
++as well. At this point there does not seem to be a pestering reason to do so.
++</p>
++
++<p><i>[2012-10 Portland: Move to Review]</i></p>
++
++<p>
++STL: This is a real issue, but does not like a resolution relying on a SFINAEable metafunction
++that is not specified and available to the users.
++</p>
++
++<p>
++<tt>packaged_task</tt> has the same issue.
++</p>
++
++<p>
++STL strongly wants to see an <tt>is_callable</tt> type trait to clarify the proposed wording.
++</p>
++
++<p>
++Jeremiah concerned about holding up what appears to be a correct resolution for a hypothetical
++better one later - the issue is real.
++</p>
++
++<p>
++Why must <tt>f</tt> by CopyConstructible? Surely MoveConstructible would be sufficient?
++</p>
++
++<p>
++Answer: because <tt>function</tt> is CopyConstructible, and the bound functor is type-erased
++so must support all the properties of <tt>function</tt> itself.
++</p>
++
++<p>
++Replace various applications of <tt>declval</tt> in the proposed resolution with simply using
++the passed functor object, <tt>f</tt>.
++</p>
++
++<p>
++Alisdair to apply similar changes to <tt>packaged_task</tt>.
++</p>
++
++<p><i>[2012-11-09, Vicente J. Botet Escriba provides another example]</i></p>
++
++
++<p>
++Consider the following:
++</p>
++<blockquote><pre>
++class AThreadWrapper {
++public:
++ explicit operator std::thread();
++ ...
++};
++std::thread th = std::thread(AThreadWrapper); // call to conversion operator intended
++</pre></blockquote>
++<p>
++The call to the conversion operator is overloaded with the thread constructor. But thread constructor requirement
++makes it fail as <tt>AThreadWrapper</tt> is not a Callable and the compiler tries to instantiate the thread
++constructor and fails.
++</p>
++
++<p><i>[2014-02-14 Issaquah meeting: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change the following paragraphs in 20.9.12.2.1 [func.wrap.func.con]:
++[<em>Editorial comment</em>: The removal of the seemingly additional no-throw
++requirements of copy constructor and destructor of <tt>A</tt> is recommended,
++because they are already part of the Allocator requirements. Similar clean-up
++has been suggested by <a href="lwg-active.html#2070">2070</a> &mdash; <em>end comment</em>]</p>
++
++<blockquote>
++<pre>
++template&lt;class F> function(F f);
++template&lt;class F, class A&gt; function(allocator_arg_t, const A&amp; a, F f);
++</pre>
++<blockquote>
++<p>
++-7- <i>Requires</i>: <tt>F</tt> shall be <tt>CopyConstructible</tt>. <del><tt>f</tt> shall be Callable
++(20.9.12.2 [func.wrap.func]) for argument types <tt>ArgTypes</tt> and return type <tt>R</tt>.
++The copy constructor and destructor of <tt>A</tt> shall not throw exceptions.</del>
++<p/>
++<ins>-?- <i>Remarks</i>: These constructors shall not participate in overload resolution unless
++<tt>f</tt> is Callable (20.9.12.2 [func.wrap.func]) for argument types
++<tt>ArgTypes...</tt> and return type <tt>R</tt>.</ins>
++</p>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<pre>
++template&lt;class F> function&amp; operator=(F&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++-18- <i>Effects</i>: <tt>function(std::forward&lt;F&gt;(f)).swap(*this);</tt>
++<p/>
++-19- <i>Returns</i>: <tt>*this</tt>
++<p/>
++<ins>-?- <i>Remarks</i>: This assignment operator shall not participate in overload resolution unless
++<tt>declval&lt;typename decay&lt;F&gt;::type&amp;&gt;()</tt> is Callable (20.9.12.2 [func.wrap.func])
++for argument types <tt>ArgTypes...</tt> and return type <tt>R</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2135"></a>2135. Unclear requirement for exceptions thrown in <tt>condition_variable::wait()</tt></h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar], 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>condition_varible::wait()</tt> (and, presumably, <tt>condition_variable_any::wait()</tt>, although
++I haven't looked at it) says that it calls <tt>lock.unlock()</tt>, and if <tt>condition_variable::wait()</tt>
++exits by an exception it calls <tt>lock.lock()</tt> on the way out. But if the initial call to
++<tt>lock.unlock()</tt> threw an exception, does it make sense to call <tt>lock.lock()</tt>? We simply
++don't know the state of that lock object, and it's probably better not to touch it.
++<p/>
++That aside, once the <tt>wait()</tt> call has been unblocked, it calls <tt>lock.lock()</tt>. If <tt>lock.lock()</tt>
++throws an exception, what happens? The requirement is:
++</p>
++<blockquote><p>
++If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function scope.
++</p></blockquote>
++<p>
++That can be read in two different ways. One way is as if it said "<tt>lock.lock()</tt> shall have been called …",
++i.e. the original, failed, call to <tt>lock.lock()</tt> is all that's required. But a more natural reading is
++that wait has to call <tt>lock.lock()</tt> again, even though it already failed.
++<p/>
++I think this wording suffers from being too general. There are two possible exception sources: the initial call
++to <tt>lock.unlock()</tt> and the final call to <tt>lock.lock()</tt>. Each one should have its own requirement.
++Lumping them together muddles things.
++</p>
++
++<p><i>[2012, Portland: move to Open]</i></p>
++
++<p>
++Pablo: <tt>unlock</tt> failing is easy -- the call leaves it locked.
++ The second case, trying to <tt>lock</tt> fails -- what can you do?
++ This is an odd state as we <em>had</em> it locked before was called wait.
++ Maybe we should call <tt>terminate</tt> as we cannot meet the post-conditions.
++ We could throw a different exception.
++</p>
++<p>
++Hans: calling <tt>terminate</tt> makes sense as we're likely to call it soon anyway
++ and at least we have some context.
++</p>
++<p>
++Detlef: what kind of locks might be being used?
++</p>
++<p>
++Pablo: condition variables are 'our' locks so this is less of a problem.
++ <tt>condition_variable_any</tt> might be more problematic.
++</p>
++<p>
++The general direction is to call <tt>terminate</tt> if the lock cannot be reacquired.
++</p>
++<p>
++Pablo: Can we change the wording to 'leaves the mutex locked' ?
++</p>
++<p>
++Hans: so if the <tt>unlock</tt> throws we simply propagate the exception.
++</p>
++<p>
++Move the issue to open and add some formal wording at a later time.
++</p>
++
++<p><i>[2013-09 Chicago: Resolved]</i></p>
++
++
++<p>
++Detlef improves wording. Daniel suggests to introduce a <i>Remarks</i> element for the special
++"If the function fails to meet the postcondition..." wording and applies this to the proposed
++wording.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 30.5.1 [thread.condition.condvar] as indicated:</p>
++
++<blockquote><pre>
++void wait(unique_lock&lt;mutex&gt;&amp; lock);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-10- <i>Effects:</i>
++</p>
++<ul>
++<li><p>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.</p></li>
++<li><p>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock), then returns.</p></li>
++<li><p>The function will unblock when signaled by a call to <tt>notify_one()</tt> or a call to <tt>notify_all()</tt>,
++or spuriously.</p></li>
++<li><p><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
++scope.</del></p></li>
++</ul>
++<p>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-11- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++-12- <i>Throws:</i> <ins>Nothing</ins><del><tt>system_error</tt> when an exception is required (30.2.2)</del>.
++<p/>
++<del>-13- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Predicate&gt;
++void wait(unique_lock&lt;mutex&gt;&amp; lock, Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-16- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++-17- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2),</del> timeout-related exceptions
++(30.2.4)<del>,</del> or any exception thrown by <tt>pred</tt>.
++<p/>
++<del>-18- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Clock, class Duration&gt;
++ cv_status wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-20- <i>Effects:</i>
++</p>
++<ul>
++<li><p>[&hellip;]</p></li>
++<li><p>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
++<del>scope</del>.</p></li>
++</ul>
++<p>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-21- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++[&hellip;]
++<p/>
++-23- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2) or</del> timeout-related
++exceptions (30.2.4).
++<p/>
++<del>-24- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Rep, class Period&gt;
++ cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-28- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++[&hellip;]
++<p/>
++-29- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2) or</del> timeout-related
++exceptions (30.2.4).
++<p/>
++<del>-30- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Clock, class Duration, class Predicate&gt;
++ bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
++ Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-33- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++[&hellip;]
++<p/>
++-35- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2),</del> timeout-related exceptions
++(30.2.4)<del>,</del> or any exception thrown by <tt>pred</tt>.
++<p/>
++<del>-36- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Rep, class Period, class Predicate&gt;
++ bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
++ const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
++ Predicate pred);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-40- <i>Postcondition:</i> <tt>lock.owns_lock()</tt> is true and <tt>lock.mutex()</tt> is locked by the calling
++thread.
++<p/>
++[&hellip;]
++<p/>
++-42- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2),</del> timeout-related exceptions
++(30.2.4)<del>,</del> or any exception thrown by <tt>pred</tt>.
++<p/>
++<del>-43- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++</blockquote>
++
++</li>
++
++<li><p>Edit 30.5.2 [thread.condition.condvarany] as indicated:</p>
++
++<blockquote><pre>
++template&lt;class Lock&gt;
++void wait(Lock&amp; lock);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-10- <i>Effects:</i>
++</p>
++<ul>
++<li><p>Atomically calls <tt>lock.unlock()</tt> and blocks on <tt>*this</tt>.</p></li>
++<li><p>When unblocked, calls <tt>lock.lock()</tt> (possibly blocking on the lock) and returns.</p></li>
++<li><p>The function will unblock when signaled by a call to <tt>notify_one()</tt>, a call to <tt>notify_all()</tt>,
++or spuriously.</p></li>
++<li><p><del>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
++scope.</del></p></li>
++</ul>
++<p>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-11- <i>Postcondition:</i> <tt>lock</tt> is locked by the calling thread.
++<p/>
++-12- <i>Throws:</i> <ins>Nothing</ins><del><tt>system_error</tt> when an exception is required (30.2.2)</del>.
++<p/>
++<del>-13- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++
++</blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Lock, class Clock, class Duration&gt;
++ cv_status wait_until(Lock&amp; lock, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-15- <i>Effects:</i>
++</p>
++<ul>
++<li><p>[&hellip;]</p></li>
++<li><p>If the function exits via an exception, <tt>lock.lock()</tt> shall be called prior to exiting the function
++<del>scope</del>.</p></li>
++</ul>
++<p>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-16- <i>Postcondition:</i> <tt>lock</tt> is locked by the calling thread.
++<p/>
++[&hellip;]
++<p/>
++-18- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2) or</del> timeout-related
++exceptions (30.2.4).
++<p/>
++<del>-19- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++<blockquote>
++<pre>
++template &lt;class Lock, class Rep, class Period&gt;
++ cv_status wait_for(Lock&amp; lock, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<ins>-?- <i>Remarks:</i> If the function fails to meet the postcondition, <tt>std::terminate()</tt> shall be called
++(15.5.1 [except.terminate]). [<i>Note:</i> This can happen if the re-locking of the mutex throws an
++exception. &mdash; <i>end note</i>]</ins>
++<p/>
++-22- <i>Postcondition:</i> <tt>lock</tt> is locked by the calling thread.
++<p/>
++[&hellip;]
++<p/>
++-23- <i>Throws:</i> <del><tt>system_error</tt> when an exception is required (30.2.2) or</del> timeout-related
++exceptions (30.2.4).
++<p/>
++<del>-24- <i>Error conditions:</i></del>
++</p>
++<ul>
++<li><p><del>equivalent error condition from <tt>lock.lock()</tt> or <tt>lock.unlock()</tt>.</del></p></li>
++</ul>
++</blockquote></blockquote>
++
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2138"></a>2138. <tt>atomic_flag::clear</tt> should not accept <tt>memory_order_consume</tt></h3>
++<p><b>Section:</b> 29.7 [atomics.flag] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ben Viglietta <b>Opened:</b> 2012-03-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.flag">issues</a> in [atomics.flag].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.pdf">N3376</a> 29.7 [atomics.flag]&#47;7 says
++this about <tt>atomic_flag::clear</tt>:
++</p>
++<blockquote><p>
++<i>Requires</i>: The <tt>order</tt> argument shall not be <tt>memory_order_acquire</tt> or <tt>memory_order_acq_rel</tt>.
++</p></blockquote>
++<p>
++In addition, <tt>memory_order_consume</tt> should be disallowed, since it doesn't meaningfully apply to store operations.
++It's already disallowed on the analogous <tt>atomic&lt;T&gt;::store</tt>. The proposed updated text would be:
++</p>
++<blockquote><p>
++<i>Requires</i>: The <tt>order</tt> argument shall not be <ins><tt>memory_order_consume</tt>,</ins>
++<tt>memory_order_acquire</tt><ins>,</ins> or <tt>memory_order_acq_rel</tt>.
++</p></blockquote>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++Hans: this is a clear oversight.
++</p>
++<p>
++Moved to review
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to N3376.]</i></p>
++
++
++<blockquote><pre>
++void atomic_flag_clear(volatile atomic_flag *object) noexcept;
++void atomic_flag_clear(atomic_flag *object) noexcept;
++void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order) noexcept;
++void atomic_flag_clear_explicit(atomic_flag *object, memory_order order) noexcept;
++void atomic_flag::clear(memory_order order = memory_order_seq_cst) volatile noexcept;
++void atomic_flag::clear(memory_order order = memory_order_seq_cst) noexcept;
++</pre><blockquote>
++<p>
++-7- <i>Requires</i>: The <tt>order</tt> argument shall not be <ins><tt>memory_order_consume</tt>,</ins>
++<tt>memory_order_acquire</tt><ins>,</ins> or <tt>memory_order_acq_rel</tt>.
++<p/>
++-8- <i>Effects</i>: Atomically sets the value pointed to by <tt>object</tt> or by <tt>this</tt> to false. Memory is affected
++according to the value of <tt>order</tt>.
++</p>
++</blockquote>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2140"></a>2140. Meaning of <tt>notify_all_at_thread_exit</tt> synchronization requirement?</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-03-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>notify_all_at_thread_exit</tt> has the following synchronization requirement:
++</p>
++<blockquote><p>
++<i>Synchronization</i>: The call to <tt>notify_all_at_thread_exit</tt> and the completion of the destructors
++for all the current thread's variables of thread storage duration <em>synchronize with</em> (1.10 [intro.multithread])
++calls to functions waiting on <tt>cond</tt>.
++</p></blockquote>
++<p>
++The functions waiting on <tt>cond</tt> have already been called, otherwise they wouldn't be waiting. So how can a subsequent
++call to <tt>notify_all_at_thread_exit</tt> synchronize with them?
++<p/>
++Also, "synchronizes with" is a relationship between library calls (1.10 [intro.multithread]&#47;8), so it's not
++meaningful for completion of destructors for non-library objects. Presumably the intention wasn't so make library
++destructors special here.
++</p>
++
++<p><i>[2012-03-09 Jeffrey Yasskin comments:]</i></p>
++
++
++<p>
++I think the text should say that "<tt>notify_all_at_thread_exit</tt> and destructor calls are sequenced before
++the <tt>lk.unlock()</tt>", and leave it at that, unless there's a funny implementation I haven't thought of.
++</p>
++
++<p><i>[2012-03-19 Hans Boehm comments:]</i></p>
++
++
++<p>
++I think the synchronization clause should just be replaced with (modulo wording tweaks):
++<p/>
++"The implied <tt>lk.unlock()</tt> call is sequenced after the destruction of all objects with thread storage duration
++associated with the current thread."
++<p/>
++as Jeffrey suggested.
++<p/>
++To use this correctly, the notifying thread has to essentially acquire the lock, set a variable indicating it's done,
++call <tt>notify_all_at_thread_exit()</tt>, while the waiting thread acquires the lock, and repeatedly waits on the
++cv until the variable is set, and then releases the lock. That ensures that we have the proper synchronizes with
++relationship as a result of the lock.
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++The <tt>lk.unlock()</tt> refers back to the wording the previous paragraph.
++</p>
++<p>
++Moved to review
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol><li><p>Modify 30.5 [thread.condition] p8 as indicated:</p>
++
++<blockquote>
++<pre>
++void notify_all_at_thread_exit(condition_variable&amp; cond, unique_lock&lt;mutex&gt; lk);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-8- <i>Synchronization</i>: <del>The call to <tt>notify_all_at_thread_exit</tt> and the completion of the destructors for
++all the current thread's variables of thread storage duration synchronize with (1.10 [intro.multithread])
++calls to functions waiting on <tt>cond</tt></del> <ins>The implied <tt>lk.unlock()</tt> call is sequenced after the
++destruction of all objects with thread storage duration associated with the current thread</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2141"></a>2141. <tt>common_type</tt> trait produces reference types</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Doug Gregor <b>Opened:</b> 2012-03-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The type computation of the <tt>common_type</tt> type trait is defined as
++</p>
++<blockquote><pre>
++template &lt;class T, class U&gt;
++ struct common_type&lt;T, U&gt; {
++ typedef decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;()) type;
++ };
++</pre></blockquote>
++<p>
++This means that <tt>common_type&lt;int, int&gt;::type</tt> is <tt>int&amp;&amp;</tt>, because
++</p>
++<ul>
++<li><tt>declval&lt;int&gt;()</tt> returns <tt>int&amp;&amp;</tt></li>
++<li>The conditional operator returns an xvalue when its second and third operands have the same type
++and are both xvalues (5.16 [expr.cond] p4)</li>
++<li><tt>decltype</tt> returns <tt>T&amp;&amp;</tt> when its expression is an xvalue (7.1.6.2 [dcl.type.simple] p4)</li>
++</ul>
++<p>
++Users of <tt>common_type</tt> do not expect to get a reference type as the result; the expectation is that
++<tt>common_type</tt> will return a non-reference type to which all of the types can be converted.
++<p/>
++Daniel: In addition to that it should be noted that without such a fix the definition of <tt>std::unique_ptr</tt>'s
++<tt>operator&lt;</tt> in 20.8.1.5 [unique.ptr.special] (around p4) is also broken: In the most typical case
++(with default deleter), the determination of the common pointer type <em>CT</em> will instantiate
++<tt>std::less&lt;<em>CT</em>&gt;</tt> which can now be <tt>std::less&lt;T*&amp;&amp;&gt;</tt>, which will
++<em>not</em> be the specialization of pointer types that guarantess a total order.
++<p/>
++Given the historic constext of <tt>common_type</tt> original specification, the proper resolution to me
++seems to be using <tt>std::decay</tt> instead of <tt>std::remove_reference</tt>:
++</p>
++<blockquote><pre>
++template &lt;class T, class U&gt;
++struct common_type&lt;T, U&gt; {
++ typedef <ins>typename decay&lt;</ins>decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())<ins>&gt;::type</ins> type;
++};
++</pre></blockquote>
++<p>
++At that time rvalues had no identity in this construct and rvalues of non-class types have no cv-qualification.
++With this change we would ensure that
++</p>
++<blockquote><pre>
++common_type&lt;int, int&gt;::type == common_type&lt;const int, const int&gt;::type == int
++</pre></blockquote>
++<p>
++Note that this harmonizes with the corresponding heterogenous case, which has already the exact same effect:
++</p>
++<blockquote><pre>
++common_type&lt;int, long&gt;::type == common_type&lt;const int, const long&gt;::type == long
++</pre></blockquote>
++
++<p><i>[2012-10-11 Daniel comments]</i></p>
++
++<p>
++While testing the effects of applying the proposed resolution I noticed that this will have the effect that the unary
++form of <tt>common_type</tt>, like
++</p>
++<blockquote><pre>
++common_type&lt;int&gt;
++</pre></blockquote>
++<p>
++is not symmetric to the n-ary form (n &gt; 1). This is unfortunate, because this difference comes especially to effect when
++<tt>common_type</tt> is used with variadic templates. As an example consider the following <tt>make_array</tt> template:
++</p>
++<blockquote><pre>
++#include &lt;array>
++#include &lt;type_traits>
++#include &lt;utility>
++
++template&lt;class... Args&gt;
++std::array&lt;typename std::common_type&lt;Args...&gt;::type, sizeof...(Args)&gt;
++make_array(Args&amp;&amp;... args)
++{
++ typedef typename std::common_type&lt;Args...&gt;::type CT;
++ return std::array&lt;CT, sizeof...(Args)&gt;{static_cast&lt;CT&gt;(std::forward&lt;Args&gt;(args))...};
++}
++
++int main()
++{
++ auto a1 = make_array(0); // OK: std::array&lt;int, 1&gt;
++ auto a2 = make_array(0, 1.2); // OK: std::array&lt;double, 2&gt;
++ auto a3 = make_array(5, true, 3.1415f, 'c'); // OK: std::array&lt;float, 4&gt;
++
++ int i = 0;
++ auto a1b = make_array(i); // <span style="color:#C80000;font-weight:bold">Error, attempt to form std::array&lt;int&amp;, 1&gt;</span>
++
++ auto a2b = make_array(i, 1.2); // OK: std::array&lt;double, 2&gt;
++ auto a2c = make_array(i, 0); // OK: std::array&lt;int, 2&gt;
++}
++</pre></blockquote>
++<p>
++The error for <tt>a1b</tt> <em>only</em> happens in the unary case and it is easy that it remains unnoticed
++during tests. You cannot explain that reasonably to the user here.
++<p/>
++Of-course it is possible to fix that in this example by applying <tt>std::decay</tt> to the result of the
++<tt>std::common_type</tt> deduction. But if this is necessary here, I wonder why it should also be applied to
++the binary case, where it gives the wrong illusion of a complete type decay? The other way around: Why is
++<tt>std::decay</tt> not also applied to the unary case as well?
++<p/>
++This problem is not completely new and was already observed for the original <tt>std::common_type</tt> specification.
++At this time the <tt>decltype</tt> rules had a similar asymmetric effect when comparing
++</p>
++<blockquote><p>
++<tt>std::common_type&lt;const int, const int&gt;::type</tt> (equal to '<tt>int</tt>' at this time)
++</p></blockquote>
++<p>
++with:
++</p>
++<blockquote><p>
++<tt>std::common_type&lt;const int&gt;::type</tt> (equal to '<tt>const int</tt>')
++</p></blockquote>
++<p>
++and I wondered whether the unary form shouldn't also perform the same "decay" as the n-ary form.
++<p/>
++This problem makes me think that the current resolution proposal might not be ideal and I expect
++differences in implementations (for those who consider to apply this proposed resolution already). I
++see at least three reasonable options:
++</p>
++<ol>
++<li><p>Accept the current wording suggestion for LWG 2141 as it is and explain that to users.</p></li>
++<li><p>Keep <tt>std::common_type</tt> as currently specified in the Standard and tell users to use
++<tt>std::decay</tt> where needed. Also fix other places in the library, e.g. the comparison
++functions of <tt>std::unique_ptr</tt> or a most of the time library functions.</p></li>
++<li><p>Apply <tt>std::decay</tt> also in the unary specialization of <tt>std::common_type</tt> with
++the effect that <tt>std::common_type&lt;const int&amp;&gt;::type</tt> returns <tt>int</tt>.</p></li>
++</ol>
++
++<p><i>[2012-10-11 Marc Glisse comments]</i></p>
++
++<p>
++If we are going with decay everywhere, I wonder whether we should also decay in the 2-argument version <em>before</em>
++and not only <em>after</em>. So if I specialize <tt>common_type&lt;mytype, double&gt;</tt>,
++<tt>common_type&lt;const mytype, volatile double&amp;&gt;</tt> would automatically work.
++</p>
++
++<p><i>[2012-10-11 Daniel provides wording for bullet 3 of his list:]</i></p>
++
++
++<ol style="list-style-type:upper-alpha">
++<li><p>Change 20.10.7.6 [meta.trans.other] p3 as indicated:</p>
++<blockquote><pre>
++template &lt;class T&gt;
++struct common_type&lt;T&gt; {
++ typedef <ins>typename decay&lt;</ins>T<ins>&gt;::type</ins> type;
++};
++
++template &lt;class T, class U&gt;
++struct common_type&lt;T, U&gt; {
++ typedef <ins>typename decay&lt;</ins>decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())<ins>&gt;::type</ins> type;
++};
++</pre></blockquote>
++</li>
++</ol>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++Want to carefully consider the effect of <tt>decay</tt> vs. <tt>remove_reference</tt> with respect
++to constness before adopting, although this proposed resolution stands for review in Bristol.
++</p>
++
++<p><i>[2013-04-18, Bristol meeting]</i></p>
++
++
++<p>Previous wording:</p>
++
++<blockquote class="note">
++<p>This wording is relative to N3376.</p>
++
++<ol><li><p>In 20.10.7.6 [meta.trans.other] p3, change the <tt>common_type</tt> definition to</p>
++<blockquote><pre>
++template &lt;class T, class U&gt;
++struct common_type&lt;T, U&gt; {
++ typedef <ins>typename decay&lt;</ins>decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())<ins>&gt;::type</ins> type;
++};
++</pre></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Move to Ready</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Change 20.10.7.6 [meta.trans.other] p3 as indicated:</p>
++<blockquote><pre>
++template &lt;class T&gt;
++struct common_type&lt;T&gt; {
++ typedef <ins>typename decay&lt;</ins>T<ins>&gt;::type</ins> type;
++};
++
++template &lt;class T, class U&gt;
++struct common_type&lt;T, U&gt; {
++ typedef <ins>typename decay&lt;</ins>decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())<ins>&gt;::type</ins> type;
++};
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2142"></a>2142. <tt>packaged_task::operator()</tt> synchronization too broad?</h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-03-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 30.6.9.1 [futures.task.members] p.18:
++</p>
++<blockquote><p>
++[A] successful call to [<tt>packaged_task::</tt>]<tt>operator()</tt> <em>synchronizes with</em>
++a call to any member function of a <tt>future</tt> or <tt>shared_future</tt> object that shares
++the shared state of <tt>*this</tt>.
++</p></blockquote>
++<p>
++This requires that the call to <tt>operator()</tt> synchronizes with calls to <tt>future::wait_for</tt>,
++<tt>future::wait_until</tt>, <tt>shared_future::wait_for</tt>, and <tt>shared_future::wait_until</tt>,
++even when these functions return because of a timeout.
++</p>
++
++<p><i>[2012, Portland: move to Open]</i></p>
++
++<p>
++If it said "a successful return from" (or "a return from" to cover exceptions) the problem would be more obvious.
++</p>
++<p>
++Detlef: will ask Anthony Williams to draft some wording.
++</p>
++<p>
++Moved to open (Anthony drafted to draft)
++</p>
++
++<p><i>[2013-09, Chicago: move to Ready]</i></p>
++
++
++<p>
++Anthony's conclusion is that the offending paragraph is not needed. Already included in the statement
++that the state is made ready.
++<p/>
++Recommendation: Remove 30.6.9.1 [futures.task.members] p18 (the synchronization clause). Redundant because of
++30.6.4 [futures.state] p9.
++</p>
++<p>
++Moved to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Remove 30.6.9.1 [futures.task.members] p18 as indicated:</p>
++
++<blockquote><pre>
++void operator()(ArgTypes... args);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-18- <i>Synchronization:</i> a successful call to <tt>operator()</tt> synchronizes with (1.10) a call to any member function
++of a <tt>future</tt> or <tt>shared_future</tt> object that shares the shared state of <tt>*this</tt>. The completion of
++the invocation of the stored task and the storage of the result (whether normal or exceptional) into
++the shared state synchronizes with (1.10) the successful return from any member function that detects
++that the state is set to ready. [<i>Note:</i> <tt>operator()</tt> synchronizes and serializes with other functions
++through the shared state. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2143"></a>2143. <tt>ios_base::xalloc</tt> should be thread-safe</h3>
++<p><b>Section:</b> 27.5.3 [ios.base] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2012-03-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ios.base">issues</a> in [ios.base].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The static function <tt>ios_base::xalloc()</tt> could be called from multiple threads and is not covered by
++17.6.4.10 [res.on.objects] and 17.6.5.9 [res.on.data.races]. Adding a thread-safety requirement
++should not impose a significant burden on implementations, as the function can be easily implemented with
++hopefully lock-free atomics.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Unanimous.
++<p/>
++Resolution: move tentatively ready. (Inform Bill about this issue.)
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>In 27.5.3.5 [ios.base.storage] add a new paragraph after paragraph 1:</p>
++
++<blockquote><pre>
++static int xalloc();
++</pre><blockquote>
++<p>
++-1- <i>Returns</i>: <tt>index ++</tt>.
++<p/>
++<ins>-?- <i>Remarks</i>: Concurrent access to this function by multiple threads shall not result in a data
++race (1.10 [intro.multithread]).</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2144"></a>2144. Missing <tt>noexcept</tt> specification in <tt>type_index</tt></h3>
++<p><b>Section:</b> 20.14 [type.index] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-03-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#type.index">issues</a> in [type.index].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The class type <tt>type_index</tt> is a thin wrapper of <tt>type_info</tt> to
++adapt it as a valid associative container element. Similar to <tt>type_info</tt>,
++all member functions have an effective <tt>noexcept(true)</tt> specification, with the
++exception of <tt>hash_code()</tt> and <tt>name()</tt>. The actual effects of these
++functions is a direct call to <tt>type_info</tt>'s <tt>hash_code()</tt> and <tt>name</tt>
++function, but according to 18.7 [support.rtti] these are both <tt>noexcept</tt>
++functions, so there is no reason for not declaring them as <tt>noexcept</tt>, too. In fact,
++one of the suggested changes of the original proposing paper
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2530.html">N2530</a>
++specifically was to ensure that <tt>type_info</tt> would get a <tt>hash_code()</tt>
++function that guarantees not to throw exceptions (during that time the <tt>hash</tt>
++requirements did not allow to exit with an exception). From this we can conclude that
++<tt>type_index::hash_code()</tt> was intended to be nothrow.
++<p/>
++It seems both consistent and technically simply to require these functions to be <tt>noexcept</tt>.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Modify the class <tt>type_index</tt> synopsis, 20.14.2 [type.index.overview] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ class type_index {
++ public:
++ type_index(const type_info&amp; rhs) noexcept;
++ bool operator==(const type_index&amp; rhs) const noexcept;
++ bool operator!=(const type_index&amp; rhs) const noexcept;
++ bool operator&lt; (const type_index&amp; rhs) const noexcept;
++ bool operator&lt;= (const type_index&amp; rhs) const noexcept;
++ bool operator&gt; (const type_index&amp; rhs) const noexcept;
++ bool operator&gt;= (const type_index&amp; rhs) const noexcept;
++ size_t hash_code() const <ins>noexcept</ins>;
++ const char* name() const <ins>noexcept</ins>;
++ private:
++ const type_info* target; <i>// exposition only</i>
++ <i>// Note that the use of a pointer here, rather than a reference,</i>
++ <i>// means that the default copy&#47;move constructor and assignment</i>
++ <i>// operators will be provided and work as expected.</i>
++ };
++}
++</pre></blockquote>
++</li>
++</ol>
++
++<ol>
++<li><p>Modify the prototype definitions in 20.14.3 [type.index.members] as indicated:</p>
++
++<blockquote><pre>
++size_t hash_code() const <ins>noexcept</ins>;
++</pre><blockquote>
++<p>
++-8- <i>Returns</i>: <tt>target->hash_code()</tt>
++</p>
++</blockquote>
++<pre>
++const char* name() const <ins>noexcept</ins>;
++</pre><blockquote>
++<p>
++-9- <i>Returns</i>: <tt>target->name()</tt>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2145"></a>2145. <tt>error_category</tt> default constructor</h3>
++<p><b>Section:</b> 19.5.1 [syserr.errcat] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2012-03-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#syserr.errcat">issues</a> in [syserr.errcat].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Should <tt>error_category</tt> have a default constructor?
++<p/>
++If you look at the synopsis in 19.5.1.1 [syserr.errcat.overview], it appears the answer is no. There
++is no default constructor declared and there is another constructor declared (which should inhibit a default
++constructor).
++<p/>
++However in paragraph 1 of the same section, descriptive text says:
++</p>
++<blockquote><p>
++Classes may be derived from <tt>error_category</tt> to support categories of errors in addition to those
++defined in this International Standard.
++</p></blockquote>
++<p>
++How shall classes derived from <tt>error_category</tt> construct their base?
++<p/>
++Jonathan Wakely: In <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2066.html">N2066</a>
++<tt>error_category</tt> was default-constructible. That is still the case in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2241.html">N2241</a>, because no other
++constructor is declared. Then later <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2422.htm">N2422</a>
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2422.htm#Issue6">issue 6</a>) declares
++the copy constructor as deleted, but doesn't add a default constructor, causing it to be no longer
++default-constructible. That looks like an oversight to me, and I think there should be a public default
++constructor.
++<p/>
++Daniel: A default-constructor indeed should be provided to allow user-derived classes as described by the
++standard. I suggest this one to be both <tt>noexcept</tt> and <tt>constexpr</tt>. The latter allows
++user-derived non-abstract classes to take advantage of the special <em>constant initialization</em> rule
++of 3.6.2 [basic.start.init] p2 b2 for objects with static (or thread) storage duration in namespace
++scope. Note that a <tt>constexpr</tt> constructor is feasible here, even though there exists a non-trivial
++destructor and even though <tt>error_category</tt> is not a literal type (see <tt>std::mutex</tt> for a similar
++design choice).
++<p/>
++In addition to that the proposed resolution fixes another minor glitch: According to 17.5.2.2 [functions.within.classes]
++virtual destructors require a semantics description.
++<p/>
++Alberto Ganesh Barbati: I would suggest to remove <tt>=default</tt> from the constructor instead.
++Please consider that defaulting a constructor or destructor may actually define them as deleted under certain
++conditions (see 12.1 [class.ctor]&#47;5 and 12.4 [class.dtor]&#47;5). Removing <tt>=default</tt>
++is easier than providing wording to ensures that such conditions do not occur.
++</p>
++
++<p><i>[2012-10 Portland: move to Ready]</i></p>
++
++<p>
++The issue is real and the resolution looks good.
++</p>
++
++<p>
++Are there similar issues elsewhere in this clause?
++</p>
++
++<p>
++Potential to add <tt>constexpr</tt> to more constructors, but clearly a separable issue.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Modify the class <tt>error_category</tt> synopsis, 19.5.1.1 [syserr.errcat.overview] as indicated:
++<em>[Drafting note: According to the general
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3279.pdf"><tt>noexcept</tt> library guidelines</a>
++destructors should not have any explicit exception specification. This destructor was overlooked during the paper
++analysis &mdash; end note]</em>
++</p>
++
++<blockquote><pre>
++namespace std {
++ class error_category {
++ public:
++ <ins>constexpr error_category() noexcept;</ins>
++ virtual ~error_category() <del>noexcept</del>;
++ error_category(const error_category&amp;) = delete;
++ error_category&amp; operator=(const error_category&amp;) = delete;
++ virtual const char* name() const noexcept = 0;
++ virtual error_condition default_error_condition(int ev) const noexcept;
++ virtual bool equivalent(int code, const error_condition&amp; condition) const noexcept;
++ virtual bool equivalent(const error_code&amp; code, int condition) const noexcept;
++ virtual string message(int ev) const = 0;
++ bool operator==(const error_category&amp; rhs) const noexcept;
++ bool operator!=(const error_category&amp; rhs) const noexcept;
++ bool operator&lt;(const error_category&amp; rhs) const noexcept;
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Before 19.5.1.2 [syserr.errcat.virtuals] p1 insert a new prototype description as indicated:</p>
++
++<blockquote><pre>
++<ins>virtual ~error_category();</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Effects</i>: Destroys an object of class <tt>error_category</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++
++<li><p>Before 19.5.1.3 [syserr.errcat.nonvirtuals] p1 insert a new prototype description as indicated:</p>
++
++<blockquote><pre>
++<ins>constexpr error_category() noexcept;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Effects</i>: Constructs an object of class <tt>error_category</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2147"></a>2147. Unclear hint type in <tt>Allocator</tt>'s <tt>allocate</tt> function</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-03-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to Table 28 &mdash; "Allocator requirements", the expression
++</p>
++<blockquote><pre>
++a.allocate(n, u)
++</pre></blockquote>
++<p>
++expects as second argument a value <tt>u</tt> that is described in Table 27 as:
++</p>
++<blockquote><p>
++a value of type <tt>YY::const_pointer</tt> obtained by calling <tt>YY::allocate</tt>, or else <tt>nullptr</tt>.
++</p></blockquote>
++<p>
++This description leaves it open, whether or whether not a value of type <tt>YY::const_void_pointer</tt> is
++valid or not. The corresponding wording in C++03 is nearly the same, but in C++03 there did not exist the concept of
++a general <tt>void_pointer</tt> for allocators. There is some evidence for support of void pointers because
++the general <tt>allocator_traits</tt> template declares
++</p>
++<blockquote><pre>
++static pointer allocate(Alloc&amp; a, size_type n, const_void_pointer hint);
++</pre></blockquote>
++<p>
++and the corresponding function for <tt>std::allocator&lt;T&gt;</tt> is declared as:
++</p>
++<blockquote><pre>
++pointer allocate(size_type, allocator&lt;void&gt;::const_pointer hint = 0);
++</pre></blockquote>
++<p>
++As an additional minor wording glitch (especially when comparing with the <tt>NullablePointer</tt> requirements imposed on
++<tt>const_pointer</tt> and <tt>const_void_pointer</tt>), the wording seems to exclude lvalues of type
++<tt>std::nullptr_t</tt>, which looks like an unwanted artifact to me.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Ready
++]</i></p>
++
++
++<p>
++No strong feeling that this is a big issue, but consensus that the proposed resolution is strictly
++better than the current wording, so move to Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change Table 27 &mdash; "Descriptive variable definitions" in 17.6.3.5 [allocator.requirements]:</p>
++
++<table border="1">
++<caption>Table 27 &mdash; Descriptive variable definitions</caption>
++<tr>
++<th>Variable</th>
++<th>Definition</th>
++</tr>
++
++<tr>
++<td>
++<tt>u</tt>
++</td>
++<td>
++a value of type <del><tt>YY::const_pointer</tt> obtained by calling <tt>YY::allocate</tt>, or else
++<tt>nullptr</tt></del><ins><tt>XX::const_void_pointer</tt> obtained by conversion from a result
++value of <tt>YY::allocate</tt>, or else a value of type (possibly const) <tt>std::nullptr_t</tt></ins>.
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2148"></a>2148. Hashing enums should be supported directly by <tt>std::hash</tt></h3>
++<p><b>Section:</b> 20.9.13 [unord.hash] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ville Voutilainen <b>Opened:</b> 2012-04-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.hash">active issues</a> in [unord.hash].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.hash">issues</a> in [unord.hash].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3333.html">paper</a>
++proposes various hashing improvements. What it doesn't mention is hashing of
++enums; enums are integral types, and users expect them to have built-in hashing
++support, rather than having to convert enums to ints for uses with
++unordered containers and other uses of hashes. Daniel Kr&uuml;gler explains in c++std-lib-32412
++that this is not achievable with a SFINAEd hash specialization because it would require
++a partial specialization with a type parameter and a non-type parameter with a
++default argument, which is currently not allowed, and hence the fixes in N3333 should be
++adopted instead.
++</p>
++
++<p><i>[2012-10 Portland: Move to Open]</i></p>
++
++<p>
++We agree this is a real issue that should be resolved, by specifying such a hash.
++</p>
++
++<p>
++It is not clear that we should specify this as calling hash on the <tt>underlying_type</tt>,
++or whether that is overspecification and we merely require that the hash be supplied.
++</p>
++
++<p>
++STL already has shipped an implementation, and is keen to provide wording.
++</p>
++
++<p><i>[
++2013-04-14 STL provides rationale and improved wording
++]</i></p>
++
++
++<p>Rationale:</p>
++<p>This can be achieved by inserting a very small tweak to the Standardese. We merely have to require that <tt>hash&lt;Key&gt;</tt>
++be valid when <tt>Key</tt> is an "enumeration type" (which includes both scoped and unscoped enums). This permits, but does
++not require, <tt>hash&lt;Enum&gt;</tt> to behave identically to <tt>hash&lt;underlying_type&lt;Enum&gt;::type&gt;</tt>, following
++existing precedent &mdash; note that when <tt>unsigned int</tt> and <tt>unsigned long</tt> are the same size,
++<tt>hash&lt;unsigned int&gt;</tt> is permitted-but-not-required to behave identically to <tt>hash&lt;unsigned long&gt;</tt>.
++<p/>
++This proposed resolution doesn't specify anything else about the primary template, allowing implementations to do
++whatever they want for non-enums: <tt>static_assert</tt> nicely, explode horribly at compiletime or runtime, etc.
++<p/>
++While we're in the neighborhood, this proposed resolution contains an editorial fix. The 20.9 [function.objects]
++synopsis says "base template", which doesn't appear anywhere else in the Standard, and could confuse users into
++thinking that they need to derive from it. The proper phrase is "primary template".
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>
++
++<ol>
++<li><p>In 20.9 [function.objects], header functional synopsis, edit as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ <i>// 20.8.12, hash function <del>base</del><ins>primary</ins> template:</i>
++ template &lt;class T&gt; struct hash;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li><p>In 20.9.13 [unord.hash]/1 edit as indicated:</p>
++
++<blockquote><p>
++-1- The unordered associative containers defined in 23.5 [unord] use specializations of the class template
++<tt>hash</tt> as the default <tt>hash</tt> function. For all object types <tt>Key</tt> for which there exists a
++specialization <tt>hash&lt;Key&gt;</tt><ins>, and for all enumeration types (7.2 [dcl.enum]) Key</ins>,
++the instantiation <tt>hash&lt;Key&gt;</tt> shall: [&hellip;]
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2149"></a>2149. Concerns about 20.8/5</h3>
++<p><b>Section:</b> 20.9 [function.objects] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Scott Meyers <b>Opened:</b> 2012-02-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#function.objects">issues</a> in [function.objects].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++20.9 [function.objects] p5 says:
++</p>
++<blockquote><p>
++To enable adaptors and other components to manipulate function objects that take one or two arguments
++it is required that the function objects correspondingly provide typedefs <tt>argument_type</tt> and
++<tt>result_type</tt> for function objects that take one argument and <tt>first_argument_type</tt>,
++<tt>second_argument_type</tt>, and <tt>result_type</tt> for function objects that take two arguments.
++</p></blockquote>
++<p>
++I have two concerns about this paragraph. First, the wording appears to prescribe a requirement for all
++function objects in valid C++ programs, but it seems unlikely that that is the intent. As such, the scope
++of the requirement is unclear. For example, there is no mention of these typedefs in the specification for
++closures (5.1.2), and Daniel Kr&uuml;gler has explained in the thread at
++<a href="http://tinyurl.com/856plkn">http://tinyurl.com/856plkn</a> that conforming implementations can
++detect the difference between closures with and without these typedefs. (Neither gcc 4.6 nor VC10 appear
++to define typedefs such as <tt>result_type</tt> for closure types. I have not tested other compilers.)
++<p/>
++Second, the requirement appears to be unimplementable in some cases, notably for function objects returned
++from <tt>std::bind</tt>, as Howard Hinnant explains in the thread at <a href="http://tinyurl.com/6q5bos4">http://tinyurl.com/6q5bos4</a>.
++<p/>
++From what I can tell, the standard already defines which adaptability typedefs must be provided by various
++kinds of function objects in the specifications for those objects. Examples include the function objects
++specified in 20.9.4 [refwrap]-20.9.9 [negators]. I therefore suggest that
++20.9 [function.objects]&#47;5 simply be removed from the standard. I don't think it adds anything
++except opportunities for confusion.
++</p>
++
++<p><i>[2012-10 Portland: Move to Open]</i></p>
++
++<p>
++This wording caused confusion earlier in the week when reviewing Stefan's paper on <tt>greater&lt;></tt>.
++</p>
++
++<p>
++This phrasing sounds normative, but is actually descriptive but uses unfortunate wording.
++</p>
++
++<p>
++The main reason this wording exists is to document the protocol required to support the legacy binders
++in Annex D.
++</p>
++
++<p>
++Stefan points out that <tt>unary_negate</tt> and <tt>binary_negate</tt> have not been deprecated and rely
++on this. He plans a paper to remove this dependency.
++</p>
++
++<p>
++Consensus that this wording is inadequate, confusing, and probably should be removed. However, that
++leaves a big hole in the specification for the legacy binders, that needs filling.
++</p>
++
++<p>
++While not opposed to striking this paragraph, we will need the additional wording to fix the openning
++hole before this issue can move forward.
++</p>
++
++<p><i>[
++2013-04-14 STL provides rationale
++]</i></p>
++
++
++<p>Rationale:</p>
++
++<p>I've concluded that Scott's original proposed resolution was correct and complete. There are two sides to this
++story: the producers and the consumers of these typedefs.</p>
++
++<p><em>Producers</em>: As Scott noted, the Standard clearly documents which function objects must provide these
++typedefs. Some function objects must provide them unconditionally (e.g. <tt>plus&lt;T&gt;</tt> (for <tt>T != void</tt>),
++20.9.5 [arithmetic.operations]/1), some conditionally (e.g. <tt>reference_wrapper&lt;T&gt;</tt>,
++20.9.4 [refwrap]/2-4), and some don't have to provide them at all (e.g. lambdas, 5.1.2 [expr.prim.lambda]).
++These requirements are clear, so we shouldn't change them or even add informative notes. Furthermore, because these
++typedefs aren't needed in the C++11 world with <tt>decltype</tt>/perfect forwarding/etc., we shouldn't add more
++requirements to provide them.</p>
++
++<p><em>Consumers</em>: This is what we were concerned about at Portland. However, the consumers also clearly document
++their requirements in the existing text. For example, <tt>reference_wrapper&lt;T&gt;</tt> is also a conditional consumer,
++and 20.9.4 [refwrap] explains what typedefs it's looking for. We were especially concerned about the old negators
++and the deprecated binders, but they're okay too. 20.9.9 [negators] clearly says that
++<tt>unary_negate&lt;Predicate&gt;</tt> requires <tt>Predicate::argument_type</tt> to be a type, and
++<tt>binary_negate&lt;Predicate&gt;</tt> requires <tt>Predicate::first_argument_type</tt> and <tt>Predicate::second_argument_type</tt>
++to be types. (<tt>unary_negate</tt>/<tt>binary_negate</tt> provide <tt>result_type</tt> but they don't consume it.)
++X [depr.lib.binders] behaves the same way with <tt>Fn::first_argument_type</tt>, <tt>Fn::second_argument_type</tt>,
++and <tt>Fn::result_type</tt>. No additional wording is necessary.</p>
++
++<p>A careful reading of 20.9 [function.objects]/5 reveals that it wasn't talking about anything beyond the mere
++existence of the mentioned typedefs &mdash; for example, it didn't mention that the function object's return type should be
++<tt>result_type</tt>, or even convertible to <tt>result_type</tt>. As the producers and consumers are certainly talking about
++the existence of the typedefs (in addition to clearly implying semantic requirements), we lose nothing by deleting the
++unnecessary paragraph.</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Previous wording:</p>
++
++<blockquote class="note">
++<p>Remove 20.9 [function.objects] p5:</p>
++
++<blockquote><p><del>
++To enable adaptors and other components to manipulate function objects that take one or two arguments
++it is required that the function objects correspondingly provide typedefs <tt>argument_type</tt> and
++<tt>result_type</tt> for function objects that take one argument and <tt>first_argument_type</tt>,
++<tt>second_argument_type</tt>, and <tt>result_type</tt> for function objects that take two arguments.
++</del></p></blockquote>
++</blockquote>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf">N3485</a>.</p>
++
++<p>Edit 20.9 [function.objects] p5:</p>
++
++<blockquote><p>
++<ins>[<i>Note:</i></ins>To enable adaptors and other components to manipulate function objects that take one or two arguments
++<del>it is required that the function objects</del><ins>many of the function objects in this clause</ins> correspondingly provide
++typedefs <tt>argument_type</tt> and <tt>result_type</tt> for function objects that take one argument and <tt>first_argument_type</tt>,
++<tt>second_argument_type</tt>, and <tt>result_type</tt> for function objects that take two arguments.<ins>&mdash; <i>end note</i>]</ins>
++</p></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2150"></a>2150. Unclear specification of <tt>find_end</tt></h3>
++<p><b>Section:</b> 25.2.6 [alg.find.end] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Andrew Koenig <b>Opened:</b> 2012-03-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++25.2.6 [alg.find.end] describes the behavior of find_end as returning:
++</p>
++<blockquote><p>
++The last iterator <tt>i</tt> in the range <tt>[first1,last1 - (last2 - first2))</tt> such that for any
++nonnegative integer <tt>n &lt; (last2 - first2)</tt>, the following corresponding conditions hold:
++<tt>*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false</tt>.
++</p></blockquote>
++<p>
++Does "for any" here mean "for every" or "there exists a"? I think it means the former, but it could be
++interpreted either way.
++<p/>
++Daniel: The same problem exists for the following specifications from Clause 25 [algorithms]:
++</p>
++<ol>
++<li>25.2.13 [alg.search] p2 and p6</li>
++<li>25.3.10 [alg.reverse] p4</li>
++<li>25.3.13 [alg.partitions] p5 and p9</li>
++<li>25.4 [alg.sorting] p5</li>
++<li>25.4.2 [alg.nth.element] p1</li>
++<li>25.4.3.1 [lower.bound] p2</li>
++<li>25.4.3.2 [upper.bound] p2</li>
++<li>25.4.7 [alg.min.max] p21 and p23</li>
++</ol>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Unanimous agreement on the wording.
++<p/>
++Resolution: move to tentatively ready
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li>
++<p>Change 25.2.6 [alg.find.end] p2 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++ForwardIterator1
++find_end(ForwardIterator1 first1, ForwardIterator1 last1,
++ ForwardIterator2 first2, ForwardIterator2 last2);
++template&lt;class ForwardIterator1, class ForwardIterator2,
++ class BinaryPredicate&gt;
++ForwardIterator1
++find_end(ForwardIterator1 first1, ForwardIterator1 last1,
++ ForwardIterator2 first2, ForwardIterator2 last2,
++ BinaryPredicate pred);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-2- <i>Returns</i>: The last iterator <tt>i</tt> in the range <tt>[first1,last1 - (last2 - first2))</tt> such
++that for <del>any</del><ins>every</ins> nonnegative integer <tt>n &lt; (last2 - first2)</tt>, the following
++corresponding conditions hold: <tt>*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false</tt>.
++Returns <tt>last1</tt> if <tt>[first2,last2)</tt> is empty or if no such iterator is found.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.2.13 [alg.search] p2 and p6 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator1, class ForwardIterator2&gt;
++ForwardIterator1
++search(ForwardIterator1 first1, ForwardIterator1 last1,
++ ForwardIterator2 first2, ForwardIterator2 last2);
++template&lt;class ForwardIterator1, class ForwardIterator2,
++ class BinaryPredicate&gt;
++ForwardIterator1
++search(ForwardIterator1 first1, ForwardIterator1 last1,
++ ForwardIterator2 first2, ForwardIterator2 last2,
++ BinaryPredicate pred);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-2- <i>Returns</i>: The first iterator <tt>i</tt> in the range <tt>[first1,last1 - (last2-first2))</tt>
++such that for <del>any</del><ins>every</ins> nonnegative integer <tt>n</tt> less than <tt>last2 - first2</tt>
++the following corresponding conditions hold: <tt>*(i + n) == *(first2 + n), pred(*(i + n), *(first2 + n)) != false</tt>.
++Returns <tt>first1</tt> if <tt>[first2,last2)</tt> is empty, otherwise returns <tt>last1</tt> if no such iterator
++is found.
++</p></blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template&lt;class ForwardIterator, class Size, class T&gt;
++ForwardIterator
++search_n(ForwardIterator first, ForwardIterator last, Size count,
++ const T&amp; value);
++template&lt;class ForwardIterator, class Size, class T,
++ class BinaryPredicate&gt;
++ForwardIterator
++search_n(ForwardIterator first, ForwardIterator last, Size count,
++ const T&amp; value, BinaryPredicate pred);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-6- <i>Returns</i>: The first iterator <tt>i</tt> in the range <tt>[first,last-count)</tt> such that
++for <del>any</del><ins>every</ins> non-negative integer <tt>n</tt> less than <tt>count</tt> the following
++corresponding conditions hold: <tt>*(i + n) == value, pred(*(i + n),value) != false</tt>. Returns <tt>last</tt>
++if no such iterator is found.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.3.10 [alg.reverse] p4 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class BidirectionalIterator, class OutputIterator&gt;
++OutputIterator
++reverse_copy(BidirectionalIterator first,
++ BidirectionalIterator last, OutputIterator result);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-4- <i>Effects</i>: Copies the range <tt>[first,last)</tt> to the range <tt>[result,result+(last-first))</tt>
++such that for <del>any</del><ins>every</ins> non-negative integer <tt>i &lt; (last - first)</tt> the following
++assignment takes place: <tt>*(result + (last - first) - i) = *(first + i)</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.3.13 [alg.partitions] p5 and p9 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator, class Predicate&gt;
++ForwardIterator
++partition(ForwardIterator first,
++ ForwardIterator last, Predicate pred);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-5- <i>Returns</i>: An iterator <tt>i</tt> such that for <del>any</del><ins>every</ins> iterator <tt>j</tt>
++in the range <tt>[first,i) pred(*j) != false</tt>, and for <del>any</del><ins>every</ins> iterator <tt>k</tt>
++in the range <tt>[i,last), pred(*k) == false</tt>.
++</p></blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template&lt;class BidirectionalIterator, class Predicate&gt;
++BidirectionalIterator
++stable_partition(BidirectionalIterator first,
++ BidirectionalIterator last, Predicate pred);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-9- <i>Returns</i>: An iterator <tt>i</tt> such that for <del>any</del><ins>every</ins> iterator <tt>j</tt>
++in the range <tt>[first,i), pred(*j) != false</tt>, and for <del>any</del><ins>every</ins> iterator <tt>k</tt>
++in the range <tt>[i,last), pred(*k) == false</tt>. The relative order of the elements in both groups is preserved.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.4 [alg.sorting] p5 as indicated:</p>
++
++<blockquote><p>
++-5- A sequence is sorted with respect to a comparator <tt>comp</tt> if for <del>any</del><ins>every</ins> iterator
++<tt>i</tt> pointing to the sequence and <del>any</del><ins>every</ins> non-negative integer <tt>n</tt> such that
++<tt>i + n</tt> is a valid iterator pointing to an element of the sequence, <tt>comp(*(i + n), *i) == false</tt>.
++</p></blockquote>
++</li>
++
++<li>
++<p>Change 25.4.2 [alg.nth.element] p1 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last);
++template&lt;class RandomAccessIterator, class Compare&gt;
++void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last, Compare comp);
++</pre><blockquote><p>
++-1- After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would
++be in that position if the whole range were sorted. Also for <del>any</del><ins>every</ins> iterator <tt>i</tt>
++in the range <tt>[first,nth)</tt> and <del>any</del><ins>every</ins> iterator <tt>j</tt> in the range
++<tt>[nth,last)</tt> it holds that: <tt>!(*i &gt; *j)</tt> or <tt>comp(*j, *i) == false</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.4.3.1 [lower.bound] p2 as indicated:</p>
++
++<blockquote><pre>
++template&lt;lass ForwardIterator, class T&gt;
++ForwardIterator
++lower_bound(ForwardIterator first, ForwardIterator last,
++ const T&amp; value);
++template&lt;class ForwardIterator, class T, class Compare&gt;
++ForwardIterator
++lower_bound(ForwardIterator first, ForwardIterator last,
++ const T&amp; value, Compare comp);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-2- <i>Returns</i>: The furthermost iterator <tt>i</tt> in the range <tt>[first,last]</tt> such that for
++<del>any</del><ins>every</ins> iterator <tt>j</tt> in the range <tt>[first,i)</tt> the following corresponding
++conditions hold: <tt>*j &lt; value</tt> or <tt>comp(*j, value) != false</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.4.3.2 [upper.bound] p2 as indicated:</p>
++
++<blockquote><pre>
++template&lt;lass ForwardIterator, class T&gt;
++ForwardIterator
++upper_bound(ForwardIterator first, ForwardIterator last,
++ const T&amp; value);
++template&lt;class ForwardIterator, class T, class Compare&gt;
++ForwardIterator
++upper_bound(ForwardIterator first, ForwardIterator last,
++ const T&amp; value, Compare comp);
++</pre><blockquote><p>
++[&hellip;]
++<p/>
++-2- <i>Returns</i>: The furthermost iterator <tt>i</tt> in the range <tt>[first,last]</tt> such that for
++<del>any</del><ins>every</ins> iterator <tt>j</tt> in the range <tt>[first,i)</tt> the following corresponding
++conditions hold: <tt>!(value &lt; *j)</tt> or <tt>comp(value, *j) == false</tt>.
++</p></blockquote></blockquote>
++</li>
++
++<li>
++<p>Change 25.4.7 [alg.min.max] p21 and p23 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator&gt;
++ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
++ Compare comp);
++</pre><blockquote><p>
++-21- <i>Returns</i>: The first iterator <tt>i</tt> in the range <tt>[first,last)</tt> such that for
++<del>any</del><ins>every</ins> iterator <tt>j</tt> in the range <tt>[first,last)</tt> the following
++corresponding conditions hold: <tt>!(*j &lt; *i)</tt> or <tt>comp(*j, *i) == false</tt>. Returns
++<tt>last</tt> if <tt>first == last</tt>.
++</p></blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template&lt;class ForwardIterator&gt;
++ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
++ Compare comp);
++</pre><blockquote><p>
++-23- <i>Returns</i>: The first iterator <tt>i</tt> in the range <tt>[first,last)</tt> such that for
++<del>any</del><ins>every</ins> iterator <tt>j</tt> in the range <tt>[first,last)</tt> the following
++corresponding conditions hold: <tt>!(*i &lt; *j)</tt> or <tt>comp(*i, *j) == false</tt>. Returns
++<tt>last</tt> if <tt>first == last</tt>.
++</p></blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2159"></a>2159. <tt>atomic_flag</tt> initialization</h3>
++<p><b>Section:</b> 29.7 [atomics.flag] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Alberto Ganesh Barbati <b>Opened:</b> 2012-05-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#atomics.flag">issues</a> in [atomics.flag].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++29.7 [atomics.flag]&#47;4 describes the <tt>ATOMIC_FLAG_INIT</tt>, but it's not quite clear about a
++couple of points:
++</p>
++<ol>
++<li><p>
++it's said that <tt>ATOMIC_FLAG_INIT</tt> "can be used to initialize an object of type <tt>atomic_flag</tt>"
++and the following example:
++</p>
++<blockquote><pre>
++std::atomic_flag guard = ATOMIC_FLAG_INIT;
++</pre></blockquote>
++<p>
++is presented. It's not clear whether the macro can also be used in the other initialization contexts:
++</p>
++<blockquote><pre>
++std::atomic_flag guard ATOMIC_FLAG_INIT;
++std::atomic_flag guard {ATOMIC_FLAG_INIT};
++
++struct A { std::atomic_flag flag; A(); };
++A::A() : flag (ATOMIC_FLAG_INIT);
++A::A() : flag {ATOMIC_FLAG_INIT};
++</pre></blockquote>
++<p>
++Please also note that examples are non-normative, according to the ISO directives, meaning that the wording
++presents no normative way to use the macro.
++</p>
++</li>
++
++<li><p>
++it's said that "It is unspecified whether an uninitialized <tt>atomic_flag</tt> object has an initial state
++of set or clear.". I believe the use of "uninitialized" is inappropriate. First of all, if an object is
++uninitialized it is obvious that we cannot assert anything about its state. Secondly, it doesn't address the
++following cases:
++</p>
++<blockquote><pre>
++std::atomic_flag a; <i>// object is "initialized" by trivial default constructor</i>
++std::atomic_flag a {}; <i>// object is value-initialized</i>
++static std::atomic_flag a; <i>// object is zero-initialized</i>
++</pre></blockquote>
++<p>
++strictly speaking a trivial constructor "initializes" the object, although it doesn't actually initialize the
++sub-objects.
++</p></li>
++
++<li><p>it's said that "For a static-duration object, that initialization shall be static.". Considering
++the following example:</p>
++<blockquote><pre>
++struct A
++{
++ A(); <i>// user-provided, not constexpr</i>
++
++ std::atomic_flag flag = ATOMIC_FLAG_INIT;
++ <i>// possibly other non-static data members</i>
++};
++
++static A a;
++</pre></blockquote>
++<p>
++The object <tt>a.flag</tt> (as a sub-object of the object <tt>a</tt>) has static-duration, yet the initialization
++has to be dynamic because <tt>A::A</tt> is not <tt>constexpr</tt>.
++</p>
++
++</li>
++</ol>
++
++<p><i>[2012, Portland]</i></p>
++
++<p>
++We would like to be able to allow more initialisation contexts for example:
++</p>
++<ol>
++<li>C struct</li>
++<li>C++ constructor initializer-list</li>
++</ol>
++<p>
++However we need further input from experts with implementation specific knowledge
++to identify which additional contexts (if any) would be universally valid.
++</p>
++<p>
++Moved to open
++</p>
++
++<p><i>[2013, Chicago]</i></p>
++
++<p>
++Move to Immediate, following review.
++</p>
++<p>
++Some discussion over the explicit use of only copy initialization, and not direct initialization. This is necessary to
++allow the implementation of <tt>atomic_flag</tt> as an aggregate, and may be further reviewed in the future.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to N3376.]</i></p>
++
++
++<p>Change 29.7 [atomics.flag]&#47;4 as follows:</p>
++
++<blockquote><p>
++The macro <tt>ATOMIC_FLAG_INIT</tt> shall be defined in such a way that it can be used to initialize an object of
++type <tt>atomic_flag</tt> to the clear state. <ins>The macro can be used in the form:</ins>
++</p>
++<blockquote><pre>
++<ins>atomic_flag guard = ATOMIC_FLAG_INIT;</ins>
++</pre></blockquote>
++<p>
++<ins>It is unspecified whether the macro can be used in other initialization contexts.</ins> For a <ins>complete</ins>
++static-duration object, that initialization shall be static. <del>It is unspecified whether an uninitialized</del>
++<ins>Unless initialized with <tt>ATOMIC_FLAG_INIT</tt>, it is unspecified whether an</ins> <tt>atomic_flag</tt>
++object has an initial state of set or clear. <del><i>[ Example:</i></del>
++</p>
++<blockquote><pre>
++<del>atomic_flag guard = ATOMIC_FLAG_INIT;</del>
++</pre></blockquote>
++<p>
++<del>&mdash; <i>end example ]</i></del>
++</p>
++</blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2160"></a>2160. Unintended destruction ordering-specification of <tt>resize</tt></h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-06-07 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++As part of resolving LWG issue <a href="lwg-defects.html#2033">2033</a> a wording change was done for <tt>resize()</tt> to
++respect the problem mentioned in the question:
++</p>
++<blockquote><p>
++Does a call to 'void resize(size_type sz)' of <tt>std::vector</tt> require the element type to be
++<tt>MoveAssignable</tt> because the call <tt>erase(begin() + sz, end())</tt> mentioned in the Effects
++paragraph would require the element type to be <tt>MoveAssignable</tt>?
++</p></blockquote>
++<p>
++The wording change was to replace in 23.3.3.3 [deque.capacity] and 23.3.6.3 [vector.capacity]:
++</p>
++<blockquote><p>
++-1- <i>Effects</i>: If <tt>sz &lt;= size()</tt>, equivalent to <tt>erase(begin() + sz, end())</tt>; [&hellip;]
++</p></blockquote>
++<p>
++by:
++</p>
++<blockquote><p>
++-1- <i>Effects</i>: If <tt>sz &lt;= size()</tt>, equivalent to calling <tt>pop_back() size() - sz</tt> times. [&hellip;]
++</p></blockquote>
++<p>
++The overlooked side-effect of this wording change is that this implies a destruction order
++of the removed elements to be in reverse order of construction, but the previous version
++did not impose any specific destruction order due to the way how the semantics of <tt>erase</tt>
++is specified in Table 100.
++<p/>
++Given the program:
++</p>
++<blockquote><pre>
++#include &lt;vector&gt;
++#include &lt;iostream&gt;
++
++struct Probe {
++ int value;
++ Probe() : value(0) {}
++ Probe(int value) : value(value) {}
++ ~Probe() { std::cout &lt;&lt; "~Probe() of " &lt;&lt; value &lt;&lt; std::endl; }
++};
++
++int main() {
++ std::vector&lt;Probe&gt; v;
++ v.push_back(Probe(1));
++ v.push_back(Probe(2));
++ v.push_back(Probe(3));
++ std::cout &lt;&lt; "---" &lt;&lt; std::endl;
++ <span style="color:#C80000;font-weight:bold">v.resize(0)</span>;
++}
++</pre></blockquote>
++<p>
++the last three lines of the output for every compiler I tested was:
++</p>
++<blockquote><pre>
++~Probe() of 1
++~Probe() of 2
++~Probe() of 3
++</pre></blockquote>
++<p>
++but a conforming implementation would now need to change this order to
++</p>
++<blockquote><pre>
++~Probe() of 3
++~Probe() of 2
++~Probe() of 1
++</pre></blockquote>
++<p>
++This possible stringent interpretation makes sense, because one can argue that sequence containers
++(or at least <tt>std::vector</tt>) should have the same required destruction order of it's elements,
++as elements of a C array or controlled by memory deallocated with an array <tt>delete</tt> have.
++I also learned that libc++ does indeed implement <tt>std::vector::resize</tt> in a way that the
++second output form is observed.
++<p/>
++While I agree that required reverse-destruction would better mimic the natural behaviour of
++<tt>std::vector</tt> this was not required in C++03 and this request may be too strong. My current
++suggestion would be to restore the effects of the previous wording <em>in regard to the destruction order</em>,
++because otherwise several currently existing implementations would be broken just because of this
++additional requirement.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Jonathan says that he believes this is a valid issue.
++</p>
++<p>
++Walter wonders if this was intended when we made the previous change - if so, this would be NAD.
++</p>
++<p>
++Jonathan said that Issue <a href="lwg-defects.html#2033">2033</a> doesn't mention ordering.
++</p>
++<p>
++Walter then asked if anyone is really unhappy that we're destroying items in reverse order of construction.
++</p>
++<p>
++Jonathan points out that this conflicts with existing practice (libstc++, but not libc++).
++</p>
++<p>
++Jonathan asked for clarification as to whether this change was intended by <a href="lwg-defects.html#2033">2033</a>.
++</p>
++
++<p><i>[2014-06 Rapperswil]</i></p>
++
++<p>
++Daniel points out that the ordering change was not intended.
++<p/>
++General agreement that implementations should not be required to change.
++</p>
++
++<p><i>[2014-06-28 Daniel provides alternative wording]</i></p>
++
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 23.3.3.3 [deque.capacity] as indicated: [<i>Drafting note</i>: The chosen wording form is similar to that for
++<tt>forward_list</tt>. Note that the existing <i>Requires</i> element already specifies the necessary operational requirements
++on the value type. &mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<pre>
++void resize(size_type sz);
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects</i>: If <tt>sz &lt;<del>=</del> size()</tt>, <ins>erases the last <tt>size() - sz</tt> elements from the
++sequence</ins><del>equivalent to calling <tt>pop_back() size() - sz</tt> times</del>. <ins>Otherwise</ins><del>If <tt>size()
++&lt;= sz</tt></del>, appends <tt>sz - size()</tt> default-inserted elements to the sequence.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++void resize(size_type sz, const T&amp; c);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: If <tt>sz &lt;<del>=</del> size()</tt>, <ins>erases the last <tt>size() - sz</tt> elements from the
++sequence</ins><del>equivalent to calling <tt>pop_back() size() - sz</tt> times</del>. <ins>Otherwise</ins><del>If <tt>size()
++&lt; sz</tt></del>, appends <tt>sz - size()</tt> copies of <tt>c</tt> to the sequence.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.3 [vector.capacity] as indicated: [<i>Drafting note</i>: See <tt>deque</tt> for the rationale of the
++used wording. &mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<pre>
++void resize(size_type sz);
++</pre>
++<blockquote>
++<p>
++-12- <i>Effects</i>: If <tt>sz &lt;<del>=</del> size()</tt>, <ins>erases the last <tt>size() - sz</tt> elements from the
++sequence</ins><del>equivalent to calling <tt>pop_back() size() - sz</tt> times</del>. <ins>Otherwise</ins><del>If <tt>size()
++&lt; sz</tt></del>, appends <tt>sz - size()</tt> default-inserted elements to the sequence.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++void resize(size_type sz, const T&amp; c);
++</pre>
++<blockquote>
++<p>
++-15- <i>Effects</i>: If <tt>sz &lt;<del>=</del> size()</tt>, <ins>erases the last <tt>size() - sz</tt> elements from the
++sequence</ins><del>equivalent to calling <tt>pop_back() size() - sz</tt> times</del>. <ins>Otherwise</ins><del>If <tt>size()
++&lt; sz</tt></del>, appends <tt>sz - size()</tt> copies of <tt>c</tt> to the sequence.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2162"></a>2162. <tt>allocator_traits::max_size</tt> missing <tt>noexcept</tt></h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 20.7.8.2 [allocator.traits.members], 20.7.8 [allocator.traits] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Bo Persson <b>Opened:</b> 2012-07-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++N3376 describes in 20.7.8.2 [allocator.traits.members]/7
++</p>
++<blockquote><pre>
++static size_type max_size(Alloc&amp; a);
++</pre>
++<p>
++<i>Returns</i>: <tt>a.max_size()</tt> if that expression is well-formed; otherwise, <tt>numeric_limits&lt;size_type&gt;::max()</tt>.
++</p>
++</blockquote>
++<p>
++The <tt>max_size</tt> function is supposed to call one of two functions that are both <tt>noexcept</tt>.
++To make this intermediate function useful for containers, it should preserve the <tt>noexcept</tt> attribute.
++<p/>
++Proposed changes:
++<p/>
++In 20.7.8 [allocator.traits] and 20.7.8.2 [allocator.traits.members]/7, change the function signature to
++</p>
++<blockquote><pre>
++static size_type max_size(Alloc&amp; a) noexcept;
++</pre></blockquote>
++
++<p><i>[2012-08-05 Daniel comments]</i></p>
++
++<p>
++On the first sight this does not seem like a defect of the specification, because the Allocator requirements in
++17.6.3.5 [allocator.requirements] (Table 28) do not impose a no-throw requirement onto <tt>max_size()</tt>;
++the table just describes the fall-back implementation for <tt>max_size()</tt> if a given allocator does
++not provide such a function.
++<p/>
++<tt>std::allocator</tt> as a special model of this concept and is allowed to increase the exception-guarantees
++for <tt>max_size()</tt>, but this does not imply a corresponding rules for other allocators.
++<p/>
++Furthermore, <tt>max_size()</tt> of Containers is <em>not</em> specified in terms of
++<tt>Allocator::max_size()</tt>, so again this is not a real contradiction.
++<p/>
++Nonetheless I think that the following stronger decision should be considered:
++</p>
++<ol>
++<li><p>
++Require that for all Allocators (as specified in 17.6.3.5 [allocator.requirements]) <tt>max_size()</tt>
++never throws an exception. This would it make much more useful to call this function in situations where no
++exception should leave the context.
++</p></li>
++<li><p>
++Require that for all Allocators (as specified in 17.6.3.5 [allocator.requirements]) <tt>max_size()</tt>
++can be called on const allocator object. Together with the previous item this would allow an implementation
++of a container's <tt>max_size()</tt> function to delegate to the allocator's <tt>max_size()</tt> function.
++</p></li>
++</ol>
++<p>
++In regard to the second statement it should be mentioned that there are two current specification
++deviations from that in the draft:
++</p>
++<ol>
++<li><p>
++The synopsis of 20.7.8 [allocator.traits] uses a const allocator argument as part of the signature
++of the <tt>max_size</tt> function.
++</p></li>
++
++<li><p>
++Both the synopsis of 20.13.1 [allocator.adaptor.syn] and the member specification in
++20.13.4 [allocator.adaptor.members] p8 declare <tt>scoped_allocator_adaptor::max_size</tt>
++as const member function, but this function delegates to
++</p>
++<blockquote><pre>
++allocator_traits&lt;OuterAlloc&gt;::max_size(outer_allocator())
++</pre></blockquote>
++<p>
++where <tt>outer_allocator()</tt> resolves to the member function overload returning a
++<tt>const outer_allocator_type&amp;</tt>.
++</p>
++</li>
++</ol>
++
++<p>
++The question arises whether these current defects actually point to a defect in the Allocator
++requirements and should be fixed there.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Review
++]</i></p>
++
++
++<p>
++Consensus that the change seems reasonable, and that for any given type the template is intantiated
++with the contract should be 'wide' so this meets the guidelines we agreed in Madrid for C++11.
++</p>
++
++<p>
++Some mild concern that while we don't imagine many allocator implementations throwing on this method,
++it is technically permited by current code that we would not be breaking, by turning <tt>throw</tt>
++expressions into disguised <tt>terminate</tt> calls. In this case, an example might be an
++instrumented 'logging' allocator that writes every function call to a log file or database, and might
++throw if that connection/file were no longer available.
++</p>
++
++<p>
++Another option would be to make exception spefication a conditional no-except, much like we do for
++some <tt>swap</tt> functions and assignment operators. However, this goes against the intent of the
++Madrid adoption of <tt>noexcept</tt> which is that vendors are free to add such extensions, but we
++look for a clear line in the library specification, and do not want to introduce conditional-noexcept
++piecemeal. A change in our conventions here would require a paper addressing the library specification
++as a whole.
++</p>
++
++<p>
++Consensus was to move forward, but move the issue only to Review rather than Ready to allow time
++for further comments. This issue should be considered 'Ready' next time it is reviewed unless
++we get such comments in the meantime.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++In 20.7.8 [allocator.traits] and 20.7.8.2 [allocator.traits.members]/7, change the function signature to
++</p>
++<blockquote><pre>
++static size_type max_size(Alloc&amp; a) <ins>noexcept</ins>;
++</pre></blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2163"></a>2163. <tt>nth_element</tt> requires inconsistent post-conditions</h3>
++<p><b>Section:</b> 25.4.2 [alg.nth.element] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Peter Sommerlad <b>Opened:</b> 2012-07-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.nth.element">issues</a> in [alg.nth.element].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The specification of nth_element refers to <tt>operator&lt;</tt> whereas all sorting without a compare function is based on
++<tt>operator&lt;</tt>. While it is true that for all regular types both operators should be defined accordingly, all other
++sorting algorithms only rely on existence of <tt>operator&lt;</tt>. So I guess the paragraph p1
++</p>
++<blockquote><p>
++After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would be in that
++position if the whole range were sorted. Also for any iterator <tt>i</tt> in the range <tt>[first,nth)</tt> and any
++iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt>!(*i &gt; *j)</tt> or <tt>comp(*j, *i) == false</tt>.
++</p></blockquote>
++<p>
++should read
++</p>
++<blockquote><p>
++After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would be in that
++position if the whole range were sorted. Also for any iterator <tt>i</tt> in the range <tt>[first,nth)</tt> and any
++iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt>!(*j &lt; *i)</tt> or <tt>comp(*j, *i) == false</tt>.
++</p></blockquote>
++<p>
++Note only "<tt>!(*i &gt; *j)</tt>" was changed to "<tt>!(*j &lt; *i)</tt>" and it would be more symmetric with
++<tt>comp(*j, *i)</tt> as well.
++<p/>
++In theory this might be a semantic change to the spec, but I believe the mistake is unintended.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Ready
++]</i></p>
++
++
++<p>
++This is clearly correct by inspection, moved to Ready by unanimous consent.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 25.4.2 [alg.nth.element] p1 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last);
++template&lt;class RandomAccessIterator, class Compare&gt;
++void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last, Compare comp);
++</pre><blockquote>
++<p>
++-1- After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would be in that
++position if the whole range were sorted. Also for any iterator <tt>i</tt> in the range <tt>[first,nth)</tt> and any
++iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt><del>!(*i &gt; *j)</del><ins>!(*j &lt; *i)</ins></tt>
++or <tt>comp(*j, *i) == false</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2168"></a>2168. Inconsistent specification of <tt>uniform_real_distribution</tt> constructor</h3>
++<p><b>Section:</b> 26.5.8.2.2 [rand.dist.uni.real] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2012-07-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++uniform_real says in 26.5.8.2.2 [rand.dist.uni.real] p1:
++</p>
++<blockquote><p>
++A <tt>uniform_real_distribution</tt> random number distribution produces random numbers <tt>x</tt>, <tt>a &le; x &lt; b</tt>,
++</p></blockquote>
++<p>
++but also that (26.5.8.2.2 [rand.dist.uni.real] p2):
++</p>
++<blockquote><pre>
++explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
++</pre><blockquote><p>
++-2- <i>Requires</i>: <tt>a &le; b</tt> and <tt>b - a &le; numeric_limits&lt;RealType&gt;::max()</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++If you construct a <tt>uniform_real_distribution&lt;RealType&gt;(a, b)</tt> where there are no representable
++numbers between 'a' and 'b' (using <tt>RealType</tt>'s representation) then you cannot satisfy
++26.5.8.2.2 [rand.dist.uni.real].
++<p/>
++An obvious example is when <tt>a == b</tt>.
++</p>
++
++<p><i>[2014-11-04 Urbana]</i></p>
++
++<p>
++Jonathan provides wording.
++</p>
++
++<p><i>[2014-11-08 Urbana]</i></p>
++
++<p>
++Moved to Ready with the note.
++</p>
++<p>
++There remains concern that the constructors are permitting
++values that may (or may not) be strictly outside the domain
++of the function, but that is a concern that affects the
++design of the random number facility as a whole, and should
++be addressed by a paper reviewing and addressing the whole
++clause, not picked up in the issues list one distribution
++at a time. It is still not clear that such a paper would be
++uncontroversial.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N4140.
++</p>
++
++<ol>
++<li><p>Add a note after paragraph 1 before the synopsis in 26.5.8.2.2 [rand.dist.uni.real]:</p>
++
++<blockquote><p>
++-1- A <tt>uniform_real_distribution</tt> random number distribution produces random numbers
++<math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>x</mi>
++</math>,
++<math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>a</mi><mo>&le;</mo><mi>x</mi><mo>&lt;</mo><mi>b</mi>
++</math>,
++distributed according to the constant probability density function
++</p>
++<blockquote>
++<p>
++<math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>p</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>)</mo></mrow>
++<mo>=</mo>
++<mrow>
++<mn>1</mn><mo>&#x2215;</mo><mo>(</mo><mi>b</mi><mo>-</mo><mi>a</mi><mo>)</mo>
++</mrow>
++</math>
++.
++</p>
++</blockquote>
++<p>
++<ins>[<i>Note</i>: This implies that <math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>p</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>)</mo></mrow>
++</math> is undefined when <tt>a == b</tt>. &mdash; <i>end note</i>]</ins>
++</p></blockquote>
++<blockquote class="note">
++<p>
++<i>Drafting note</i>: <math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>p</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>)</mo></mrow>
++</math> should be in math font, and <tt>a == b</tt> should be in code font.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2169"></a>2169. Missing <tt>reset()</tt> requirements in <tt>unique_ptr</tt> specialization</h3>
++<p><b>Section:</b> 20.8.1.3.4 [unique.ptr.runtime.modifiers] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Geoffrey Romer <b>Opened:</b> 2012-07-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.runtime.modifiers">issues</a> in [unique.ptr.runtime.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In 20.8.1.3.4 [unique.ptr.runtime.modifiers]/p1-2 of N3376, the description of <tt>reset()</tt> in the
++array specialization of <tt>unique_ptr</tt> partially duplicates the description of the base template method
++(as specified in 20.8.1.2.5 [unique.ptr.single.modifiers]/p3-5), but lacks some significant requirements.
++Specifically, the text introduced in LWG <a href="lwg-defects.html#998">998</a>, and item 13 of LWG <a href="lwg-defects.html#762">762</a>, is present
++only in the base template, not the specialization.
++<p/>
++This gives the appearance that these requirements specifically do not apply to the specialization, which I
++don't believe is correct or intended: the issue of <tt>reset()</tt> operation order addressed by LWG <a href="lwg-defects.html#998">998</a>
++applies just as much to the derived template as to the base template, and the derived template has just as
++much need to rely on <tt>get_deleter()(get())</tt> being well-defined, well-formed, and not throwing exceptions
++(arguably some of those properties follow from the fact that <tt>T</tt> is required to be a complete type, but
++not all).
++<p/>
++Assuming the derived template's <tt>reset()</tt> semantics are intended to be identical to the base template's,
++there is no need to explicitly specify the semantics of <tt>reset(pointer p)</tt> at all (since
++20.8.1.3 [unique.ptr.runtime]/3 specifies "Descriptions are provided below only for member functions that
++have behavior different from the primary template."), and <tt>reset(nullptr_t p)</tt> can be specified by
++reference to the 'pointer' overload. This is more concise, and eliminates any ambiguity about intentional vs.
++accidental discrepancies.
++</p>
++
++<p><i>[2012-10 Portland: Move to Ready]</i></p>
++
++<p>
++<del>This resolution looks blatantly wrong, as it seems to do nothing but defer to primary template
++where we should describe the contract here.</del>
++</p>
++
++<p>
++Ongoing discussion points out that the primary template has a far more carefully worded semantic
++for <tt>reset(p)</tt> that we would want to copy here.
++</p>
++
++<p>
++STL points out that we need the <tt>nullptr</tt> overload for this dynamic-array form, as there is
++a deleted member function template that exists to steal overloads of pointer-to-derived, avoiding
++undifined behavior, so we need the extra overload.
++</p>
++
++<p>
++Finally notice that there is blanket wording further up the clause saying we describe only changes
++from the primary template, so the proposed wording is in fact exactly correct. Move to Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<p>Change 20.8.1.3.4 [unique.ptr.runtime.modifiers] as indicated:</p>
++
++<blockquote><pre>
++<del>void reset(pointer p = pointer()) noexcept;</del>
++void reset(nullptr_t p) noexcept;
++</pre><blockquote>
++<p>
++-1- <i>Effects</i>: <del>If <tt>get() == nullptr</tt> there are no effects. Otherwise <tt>get_deleter()(get())</tt></del>
++<ins>Equivalent to <tt>reset(pointer())</tt></ins>.
++<p/>
++<del>-2- <i>Postcondition</i>: <tt>get() == p</tt>.</del>
++</p>
++</blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2170"></a>2170. Aggregates cannot be <tt>DefaultConstructible</tt></h3>
++<p><b>Section:</b> 17.6.3.1 [utility.arg.requirements] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-07-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility.arg.requirements">issues</a> in [utility.arg.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The lack of the definition of the <tt>DefaultConstructible</tt> requirements in C++03 was fixed
++by LWG <a href="lwg-defects.html#724">724</a> at a time where the core rules of list-initialization were slightly
++different than today, at that time value-initialization (shortly) was the primary rule for
++class types, i.e. just before applying <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1301">CWG 1301</a>,
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1324">CWG 1324</a>, and
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1368">CWG 1368</a>.
++<p/>
++The order in 8.5.4 [dcl.init.list] p3 was changed to respect aggregate initialization, but that
++had the side-effect that formally aggregate types cannot satisfy the <tt>DefaultConstructible</tt>
++requirements anymore, because we require that
++</p>
++<blockquote><pre>
++T u{};
++</pre></blockquote>
++<p>
++<em>value-initializes</em> the object <tt>u</tt>.
++<p/>
++Of-course exclusion of aggregates was not intended, therefore I suggest to extend the requirements
++in Table 19 (17.6.3.1 [utility.arg.requirements]) for empty aggregate-initialization as well.
++</p>
++
++<p><i>[
++2012-10 Portland: Move to Core
++]</i></p>
++
++
++<p>
++We are not qualified to pick apart the Core rules quickly at this point, but the consensus is
++that if the core language has changed in this manner, then the fix should similarly be applied
++in Core - this is not something that we want users of the language to have to say every time
++they want to Value initialize (or aggregate initialize) an object.
++</p>
++
++<p>
++More to Open until we get a clear response from Core, Alisdair to file an issue with Mike.
++</p>
++
++<p><i>[2013-04 Bristol: Back to Library]</i></p>
++
++
++<p>
++The Core Working group opened, discussed, and resolved <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1578">CWG 1578</a>
++as NAD for this library-related problem: Empty aggregate initialization and value-initialization are different core language concepts,
++and this difference can be observed (e.g. for a type with a deleted default-constructor).
++</p>
++
++<p><i>[2014-02-15 Issaquah: Move to Ready]</i></p>
++
++<p>
++AM: core says still LWG issue, wording has been non-controversial, move to ready?
++</p>
++<p>
++NJ: what about durations? think they are ok
++</p>
++<p>
++Ville: <tt>pair</tt> and a few other have value initialize
++</p>
++<p>
++AM: look at core 1578
++</p>
++<p>
++AM: value initialize would require <tt>()</tt>, remove braces from third row?
++</p>
++<p>
++STL: no
++</p>
++<p>
++PH: core has new issue on aggregates and non-aggregates.
++</p>
++<p>
++AM: right, they said does not affect this issue
++</p>
++<p>
++NJ: why ok with <tt>pair</tt> and <tt>tuple</tt>?
++</p>
++<p>
++STL: will use <tt>()</tt>, <tt>tuple</tt> of aggregates with deleted constructor is ill-formed
++</p>
++<p>
++Ville: aggregate with reference can't have <tt>()</tt>
++</p>
++<p>
++STL: <tt>{}</tt> would be an issue too
++</p>
++<p>
++Ville: aggregate with reference will have <tt>()</tt> deleted implicitly
++</p>
++<p>
++Move to Ready.
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<p>Change Table 19 in 17.6.3.1 [utility.arg.requirements] as indicated:</p>
++
++<table border="1">
++<caption>Table 19 &mdash; <tt>DefaultConstructible</tt> requirements [defaultconstructible]</caption>
++
++<tr>
++<th>Expression</th>
++<th>Post-condition</th>
++</tr>
++
++<tr>
++<td>
++<tt>T t;</tt>
++</td>
++<td>
++object <tt>t</tt> is default-initialized
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>T u{};</tt>
++</td>
++<td>
++object <tt>u</tt> is value-initialized <ins>or aggregate-initialized</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>T()</tt><br/>
++<tt>T{}</tt>
++</td>
++<td>
++a temporary object of type <tt>T</tt> is value-initialized <ins>or aggregate-initialized</ins>
++</td>
++</tr>
++
++</table>
++
++
++
++
++
++
++<hr>
++<h3><a name="2172"></a>2172. Does <tt>atomic_compare_exchange_*</tt> accept <tt>v == nullptr</tt> arguments?</h3>
++<p><b>Section:</b> 20.8.2.6 [util.smartptr.shared.atomic] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2012-07-28 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.atomic">issues</a> in [util.smartptr.shared.atomic].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Looking at 20.8.2.6 [util.smartptr.shared.atomic]/p31
++</p>
++<blockquote><pre>
++template&lt;class T&gt;
++ bool
++ atomic_compare_exchange_strong_explicit(shared_ptr&lt;T&gt;* p,
++ shared_ptr&lt;T&gt;* v,
++ shared_ptr&lt;T&gt; w,
++ memory_order success, memory_order failure);
++</pre><blockquote><p>
++-31- <i>Requires</i>: <tt>p</tt> shall not be null.
++</p></blockquote></blockquote>
++<p>
++What about <tt>v</tt>? Can it be null? And if so, what happens?
++<p/>
++This looks closely related to C++11 issue LWG <a href="lwg-defects.html#1030">1030</a>, where we gave every signature in this section a:
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>p</tt> shall not be null.
++</p></blockquote>
++<p>
++It looks like a simple oversight to me that we did not add for the <tt>atomic_compare_exchange_*</tt>:
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>p</tt> shall not be null <ins>and <tt>v</tt> shall not be null</ins>.
++</p></blockquote>
++
++<p><i>[2012-10 Portland: Move to Ready]</i></p>
++
++<p>
++This is clearly the right thing to do, and Lawrence concurs.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<p>Change 20.8.2.6 [util.smartptr.shared.atomic] as indicated:</p>
++
++<blockquote><pre>
++template&lt;class T&gt;
++ bool atomic_compare_exchange_weak(
++ shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w);
++</pre><blockquote><p>
++-27- <i>Requires</i>: <tt>p</tt> shall not be null <ins>and <tt>v</tt> shall not be null</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++template&lt;class T&gt;
++ bool atomic_compare_exchange_weak_explicit(
++ shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w,
++ memory_order success, memory_order failure);
++template&lt;class T&gt;
++ bool atomic_compare_exchange_strong_explicit(
++ shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w,
++ memory_order success, memory_order failure);
++</pre><blockquote><p>
++-31- <i>Requires</i>: <tt>p</tt> shall not be null <ins>and <tt>v</tt> shall not be null</ins>.
++<p/>
++[&hellip;]
++</p>
++</blockquote></blockquote>
++
++
++
++
++
++
++<hr>
++<h3><a name="2174"></a>2174. <tt>wstring_convert::converted()</tt> should be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-08-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++There is no reason <tt>wstring_convert::converted()</tt> shouldn't be <tt>noexcept</tt>.
++<p/>
++It might be possible for <tt>wstring_convert::state()</tt> and <tt>wbuffer_convert::state()</tt>
++to be <tt>noexcept</tt> too, depending on the requirements on <tt>mbstate_t</tt>.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++<p>
++Defer the separate discsussion of <tt>state()</tt> to another issue, if anyone is ever motivated
++to file one.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Edit in the class template <tt>wstring_convert</tt> synopsis 22.3.3.2.2 [conversions.string] p2:</p>
++
++<blockquote><pre>
++size_t converted() const <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit the signature before 22.3.3.2.2 [conversions.string] p6:</p>
++
++<blockquote><pre>
++size_t converted() const <ins>noexcept</ins>;
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2175"></a>2175. <tt>wstring_convert</tt> and <tt>wbuffer_convert</tt> validity</h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string], 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-08-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++See discussion following <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32710">c++std-lib-32710</a>.
++<p/>
++It's not specified what happens if <tt>wstring_convert</tt> and <tt>wbuffer_convert</tt> objects are constructed
++with null <tt>Codecvt</tt> pointers.
++<p/>
++Should the constructors have preconditions that the pointers are not null? If not, are conversions expected to
++fail, or is it undefined to attempt conversions if the pointers are null?
++<p/>
++There are no observer functions to check whether objects were constructed with valid <tt>Codecvt</tt> pointers.
++If the types are made movable such observers would be necessary even if the constructors require non-null
++pointers (see also LWG <a href="lwg-defects.html#2176">2176</a>).
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Insert a new paragraph before 22.3.3.2.2 [conversions.string] paragraph 16:</p>
++
++<blockquote><pre>
++wstring_convert(Codecvt *pcvt = new Codecvt);
++wstring_convert(Codecvt *pcvt, state_type state);
++wstring_convert(const byte_string&amp; byte_err,
++ const wide_string&amp; wide_err = wide_string());
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: For the first and second constructors <tt>pcvt != nullptr</tt>.</ins>
++<p/>
++-16- <i>Effects</i>: The first constructor shall store <tt>pcvt</tt> in <tt>cvtptr</tt> and default values in
++<tt>cvtstate</tt>, <tt>byte_err_string</tt>, and <tt>wide_err_string</tt>. The second constructor shall
++store <tt>pcvt</tt> in <tt>cvtptr</tt>, <tt>state</tt> in <tt>cvtstate</tt>, and default values in
++<tt>byte_err_string</tt> and <tt>wide_err_string</tt>; moreover the stored state shall be retained between
++calls to <tt>from_bytes</tt> and <tt>to_bytes</tt>. The third constructor shall store <tt>new Codecvt</tt>
++in <tt>cvtptr</tt>, <tt>state_type()</tt> in cvtstate, <tt>byte_err</tt> in <tt>byte_err_string</tt>,
++and <tt>wide_err</tt> in <tt>wide_err_string</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Insert a new paragraph before 22.3.3.2.3 [conversions.buffer] paragraph 10:</p>
++
++<blockquote><pre>
++wbuffer_convert(std::streambuf *bytebuf = 0,
++ Codecvt *pcvt = new Codecvt, state_type state = state_type());
++</pre><blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>pcvt != nullptr</tt>.</ins>
++<p/>
++-10- <i>Effects</i>: The constructor constructs a stream buffer object, initializes <tt>bufptr</tt> to <tt>bytebuf</tt>,
++initializes <tt>cvtptr</tt> to <tt>pcvt</tt>, and initializes <tt>cvtstate</tt> to <tt>state</tt>.
++</p>
++</blockquote></blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2176"></a>2176. Special members for <tt>wstring_convert</tt> and <tt>wbuffer_convert</tt></h3>
++<p><b>Section:</b> 22.3.3.2.2 [conversions.string], 22.3.3.2.3 [conversions.buffer] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-08-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#conversions.string">active issues</a> in [conversions.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#conversions.string">issues</a> in [conversions.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++See discussion following <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32699">c++std-lib-32699</a>.
++<p/>
++The constructors for <tt>wstring_convert</tt> and <tt>wbuffer_convert</tt> should be explicit, to avoid
++implicit conversions which take ownership of a <tt>Codecvt</tt> pointer and delete it unexpectedly.
++<p/>
++Secondly, 22.3.3.2.3 [conversions.buffer] p11 describes a destructor which is not declared in the class
++synopsis in p2.
++<p/>
++Finally, and most importantly, the definitions in 22.3.3.2.2 [conversions.string] and
++22.3.3.2.3 [conversions.buffer] imply implicitly-defined copy constructors and assignment operators, which
++would do shallow copies of the owned <tt>Codecvt</tt> objects and result in undefined behaviour in the
++destructors.
++<p/>
++<tt>Codecvt</tt> is not required to be <tt>CopyConstructible</tt>, so deep copies are not possible.
++The <tt>wstring_convert</tt> and <tt>wstring_buffer</tt> types could be made move-only, but the proposed
++resolution below doesn't do so because of the lack of preconditions regarding null <tt>Codecvt</tt> pointers
++and the absence of observer functions that would allow users to check preconditions (see also LWG <a href="lwg-defects.html#2175">2175</a>).
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++Jonathan pointed out that you can have an implicit constructor that takes ownership of a heap reference,
++which would result an unexpected deletion.
++</p>
++<p>
++No-one really likes the 'naked new' in the interface here, either.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Edit the class template <tt>wstring_convert</tt> synopsis in 22.3.3.2.2 [conversions.string] p2:</p>
++
++<blockquote><pre>
++<ins>explicit</ins> wstring_convert(Codecvt *pcvt = new Codecvt);
++wstring_convert(Codecvt *pcvt, state_type state);
++<ins>explicit</ins> wstring_convert(const byte_string&amp; byte_err,
++ const wide_string&amp; wide_err = wide_string());
++~wstring_convert();
++<ins>
++wstring_convert(const wstring_convert&amp;) = delete;
++wstring_convert&amp; operator=(const wstring_convert&amp;) = delete;
++</ins>
++</pre></blockquote>
++</li>
++
++<li><p>Edit the signatures before 22.3.3.2.2 [conversions.string] p16:</p>
++
++<blockquote><pre>
++<ins>explicit</ins> wstring_convert(Codecvt *pcvt = new Codecvt);
++wstring_convert(Codecvt *pcvt, state_type state);
++<ins>explicit</ins> wstring_convert(const byte_string&amp; byte_err,
++ const wide_string&amp; wide_err = wide_string());
++</pre></blockquote>
++</li>
++
++<li><p>Edit the class template <tt>wbuffer_convert</tt> synopsis in 22.3.3.2.3 [conversions.buffer] p2:</p>
++
++<blockquote><pre>
++<ins>explicit</ins> wbuffer_convert(std::streambuf *bytebuf = 0,
++ Codecvt *pcvt = new Codecvt,
++ state_type state = state_type());
++<ins>
++~wbuffer_convert();
++
++wbuffer_convert(const wbuffer_convert&amp;) = delete;
++wbuffer_convert&amp; operator=(const wbuffer_convert&amp;) = delete;
++</ins>
++</pre></blockquote>
++</li>
++
++<li><p>Edit the signature before 22.3.3.2.3 [conversions.buffer] p10:</p>
++
++<blockquote><pre>
++<ins>explicit</ins> wbuffer_convert(std::streambuf *bytebuf = 0,
++ Codecvt *pcvt = new Codecvt, state_type state = state_type());
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2177"></a>2177. Requirements on <tt>Copy&#47;MoveInsertable</tt></h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Lo&iuml;c Joly <b>Opened:</b> 2012-08-10 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++See also discussion following <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32883">c++std-lib-32883</a>
++and <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32897">c++std-lib-32897</a>.
++<p/>
++The requirements on <tt>CopyInsertable</tt> and <tt>MoveInsertable</tt> are either incomplete, or complete but hard to
++figure out.
++<p/>
++From e-mail <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=32897">c++std-lib-32897</a>:
++<p/>
++Pablo Halpern:
++<p/>
++I agree that we need semantic requirements for all of the <tt>*Insertable</tt> concepts analogous to the requirements
++we have on similar concepts.
++<p/>
++Howard Hinnant:
++<p/>
++I've come to believe that the standard is actually correct as written in this area. But it is <em>really</em> hard
++to read. I would have no objection whatsoever to clarifications to <tt>CopyInsertable</tt> as you suggest (such as the
++post-conditions on <tt>v</tt>). And I do agree with you that the correct approach to the clarifications is to
++confirm that <tt>CopyInsertable</tt> implies <tt>MoveInsertable</tt>.
++</p>
++
++<p><i>[2012, Portland: Move to Tentatively Ready]</i></p>
++
++<p>
++Move to Tentatively Ready by unanimous consent.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Edit 23.2.1 [container.requirements.general] p13 as indicated:</p>
++
++<blockquote><p>
++-13- [&hellip;] Given a container type <tt>X</tt> having an <tt>allocator_type</tt> identical to <tt>A</tt> and
++a <tt>value_type</tt> identical to <tt>T</tt> and given an lvalue <tt>m</tt> of type <tt>A</tt>, a pointer <tt>p</tt>
++of type <tt>T*</tt>, an expression <tt>v</tt> of type (possibly <tt>const</tt>) <tt>T</tt>, and an rvalue <tt>rv</tt>
++of type <tt>T</tt>, the following terms are defined. If <tt>X</tt> is not allocator-aware, the terms below are
++defined as if <tt>A</tt> were <tt>std::allocator&lt;T&gt;</tt> &mdash; no allocator object needs to be created and
++user specializations of <tt>std::allocator&lt;T&gt;</tt> are not instantiated:
++</p>
++<ul>
++<li><p><tt>T</tt> is <em><tt>DefaultInsertable</tt> into <tt>X</tt></em> means that the following expression is
++well-formed:</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::construct(m, p)<del>;</del>
++</pre></blockquote>
++</li>
++
++<li><p>An element of <tt>X</tt> is <em>default-inserted</em> if it is initialized by evaluation of the expression</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::construct(m, p)<del>;</del>
++</pre></blockquote>
++<p>
++where <tt>p</tt> is the address of the uninitialized storage for the element allocated within <tt>X</tt>.
++</p>
++</li>
++
++<li><p><tt>T</tt> is <em><tt><del>Copy</del><ins>Move</ins>Insertable</tt> into <tt>X</tt></em> means that
++the following expression is well-formed:</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::construct(m, p, <ins>r</ins>v)<del>;</del>
++</pre></blockquote>
++<p>
++<ins>and when evaluated the following postconditions hold: The value of <tt>*p</tt> is equivalent to the value of
++<tt>rv</tt> before the evaluation. [<i>Note</i>: <tt>rv</tt> remains a valid object. Its state is unspecified &mdash;
++<i>end note</i>]</ins>
++</p>
++</li>
++
++<li><p><tt>T</tt> is <em><tt><del>Move</del><ins>Copy</ins>Insertable</tt> into <tt>X</tt></em> means
++that<ins>, in addition to satisfying the <tt>MoveInsertable</tt> requirements,</ins> the following expression is
++well-formed:</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::construct(m, p, <del>r</del>v)<del>;</del>
++</pre></blockquote>
++<p>
++<ins>and when evaluated the following postconditions hold: The value of <tt>v</tt> is unchanged and is equivalent
++to <tt>*p</tt>.</ins>
++</p>
++</li>
++
++<li><p><tt>T</tt> is <em><tt>EmplaceConstructible</tt> into <tt>X</tt> from <tt>args</tt></em>, for zero or more arguments
++<tt>args</tt>, means that the following expression is well-formed:</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::construct(m, p, args)<del>;</del>
++</pre></blockquote>
++</li>
++
++<li><p><tt>T</tt> is <em><tt>Erasable</tt> from <tt>X</tt></em> means that the following expression is well-formed:</p>
++<blockquote><pre>
++allocator_traits&lt;A&gt;::destroy(m, p)<del>;</del>
++</pre></blockquote>
++</li>
++
++</ul>
++<p>
++[<i>Note</i>: A container calls <tt>allocator_traits&lt;A&gt;::construct(m, p, args)</tt> to construct an element
++at <tt>p</tt> using <tt>args</tt>. The default construct in <tt>std::allocator</tt> will call
++<tt>::new((void*)p) T(args)</tt>, but specialized allocators may choose a different definition. &mdash; <i>end note</i>]
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2180"></a>2180. Exceptions from <tt>std::seed_seq</tt> operations</h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-08-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++26.5.7.1 [rand.util.seedseq] p1 says upfront:
++</p>
++<blockquote><p>
++No function described in this section 26.5.7.1 [rand.util.seedseq] throws an exception.
++</p></blockquote>
++<p>
++This constraint seems non-implementable to me when looking especially at the members
++</p>
++<blockquote><pre>
++template&lt;class T&gt;
++seed_seq(initializer_list&lt;T&gt; il);
++
++template&lt;class InputIterator&gt;
++seed_seq(InputIterator begin, InputIterator end);
++</pre></blockquote>
++<p>
++which have the effect of invoking <tt>v.push_back()</tt> for the exposition-only member of
++type <tt>std::vector</tt> (or its equivalent) over all elements of the provided range, so
++out-of-memory exceptions are always possible and the <tt>seed_seq</tt> object doesn't seem
++to be constructible this way.
++<p/>
++In addition to the potential lack-of-resources problem, the operations of <tt>InputIterator</tt>
++might also throw exceptions.
++<p/>
++Aside to that it should me mentioned, that a default constructor of <tt>vector&lt;uint_least32_t&gt;</tt>
++in theory can also throw exceptions, even though this seems less of a problem to me in this context, because
++such an implementation could easily use a different internal container in <tt>seed_seq</tt> that can hold
++this no-throw exception guarantee.
++<p/>
++Secondly, a slightly different problem category related to exceptions occurs for the member templates
++</p>
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++void generate(RandomAccessIterator begin, RandomAccessIterator end);
++
++template&lt;class OutputIterator&gt;
++void param(OutputIterator dest) const;
++</pre></blockquote>
++<p>
++where the actual operations performed by the implementation would never need to throw, but since they invoke
++operations of a user-provided customization point, the overall operation, like for example
++</p>
++<blockquote><pre>
++copy(v.begin(), v.end(), dest);
++</pre></blockquote>
++<p>
++could also throw exceptions. In this particular example we can just think of a <tt>std::back_insert_iterator</tt>
++applied to a container that needs to allocate its elements used as the type for <tt>OutputIterator</tt>.
++<p/>
++Even though Clause 26 [numerics] has mostly stronger exception constraints than other parts of the
++library the here discussed are overrestrictive, especially since no operation of <tt>std::seed_seq</tt>
++except the template <tt>generate</tt> is actually needed within the library implementation, as mentioned in the
++discussion of LWG <a href="lwg-closed.html#2124">2124</a>.
++<p/>
++I suggest to remove the general no-exception constraints for operations of <tt>std::seed_seq</tt> except for
++member <tt>size()</tt> and the default constructor and to provide specific wording for <tt>generate()</tt> and
++<tt>param()</tt> to ensure that the algorithm itself is a nothrow operation, which is especially for
++<tt>generate()</tt> important, because the templates specified in 26.5.3 [rand.eng] and
++26.5.4 [rand.adapt] also depend on this property indirectly, which is further discussed in LWG
++<a href="lwg-active.html#2181">2181</a>.
++<p/>
++<u>Howard</u>:
++<p/>
++I suggest to use a different form for the exception specification, something similar to
++20.9.10.3 [func.bind.bind] p4:
++</p>
++<blockquote><p>
++<i>Throws</i>: Nothing unless an operation on <tt>RandomAccessIterator</tt> throws an exception.
++</p></blockquote>
++<p>
++<u>Daniel</u>:
++<p/>
++The currently suggested "what and when" form seems a bit more specific and harmonizes with the form used for
++function template <tt>generate_canonical</tt> from 26.5.7.2 [rand.util.canonical].
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Open an editorial issue on the exception wording ("Throws: What and when").
++<p/>
++Solution: move to tentatively ready.
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Edit 26.5.7.1 [rand.util.seedseq] p1 as indicated:</p>
++
++<blockquote>
++<p>
++<del>-1- No function described in this section 26.5.7.1 [rand.util.seedseq] throws an exception.</del>
++</p>
++</blockquote>
++</li>
++
++<li><p>Edit 26.5.7.1 [rand.util.seedseq] around p2 as indicated:</p>
++
++<blockquote><pre>
++seed_seq();
++</pre><blockquote>
++<p>
++-2- <i>Effects</i>: Constructs a <tt>seed_seq</tt> object as if by default-constructing its member <tt>v</tt>.
++<p/>
++<ins>-?- <i>Throws</i>: Nothing.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 26.5.7.1 [rand.util.seedseq] around p7 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++ void generate(RandomAccessIterator begin, RandomAccessIterator end);
++</pre><blockquote>
++<p>
++-7- <i>Requires</i>: <tt>RandomAccessIterator</tt> shall meet the requirements of a mutable random access iterator
++(Table 111) type. Moreover, <tt>iterator_traits&lt;class RandomAccessIterator&gt;::value_type</tt> shall denote
++an unsigned integer type capable of accommodating 32-bit quantities.
++<p/>
++-8- <i>Effects</i>: Does nothing if <tt>begin == end</tt>. Otherwise, with <tt>s = v.size()</tt> and
++<tt>n = end - begin</tt>, fills the supplied range <tt>[begin, end)</tt> according to the following algorithm [&hellip;]
++<p/>
++<ins>-?- <i>Throws</i>: What and when <tt>RandomAccessIterator</tt> operations of <tt>begin</tt> and <tt>end</tt> throw.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 26.5.7.1 [rand.util.seedseq] around p9 as indicated:</p>
++
++<blockquote><pre>
++size_t size() const;
++</pre><blockquote>
++<p>
++-9- <i>Returns</i>: The number of 32-bit units that would be returned by a call to <tt>param()</tt>.
++<p/>
++<ins>-??- <i>Throws</i>: Nothing.</ins>
++<p/>
++-10- <i>Complexity</i>: constant time.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 26.5.7.1 [rand.util.seedseq] around p11 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class OutputIterator&gt;
++ void param(OutputIterator dest) const;
++</pre><blockquote>
++<p>
++-11- <i>Requires</i>: <tt>OutputIterator</tt> shall satisfy the requirements of an output iterator (Table 108) type.
++Moreover, the expression <tt>*dest = rt</tt> shall be valid for a value <tt>rt</tt> of type <tt>result_type</tt>.
++<p/>
++-12- <i>Effects</i>: Copies the sequence of prepared 32-bit units to the given destination, as if by executing the
++following statement:
++</p>
++<blockquote><pre>
++copy(v.begin(), v.end(), dest);
++</pre></blockquote>
++<p>
++<ins>-??- <i>Throws</i>: What and when <tt>OutputIterator</tt> operations of <tt>dest</tt> throw.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2182"></a>2182. <tt>Container::[const_]reference</tt> types are misleadingly specified</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-08-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to Table 96 (Container requirements) the return type of <tt>X::reference</tt> and
++<tt>X::const_reference</tt> is "lvalue of <tt>T</tt>" and "<tt>const</tt> lvalue of <tt>T</tt>",
++respectively. This does not make much sense, because an lvalue is an expression category, not a type.
++It could also refer to an expression that has a type, but this doesn't make sense either in this
++context, because obviously <tt>X::[const_]reference</tt> are intended to refer to types.
++<p/>
++Given the fact that <tt>vector&lt;bool&gt;</tt> has no real reference type for <tt>X::[const_]reference</tt>
++and this definition presumably is intended to cover such situations as well, one might think that the wording is
++just a sloppy form of "type that represents a [const] lvalue of <tt>T</tt>". But this is also problematic,
++because basically all proxy reference expressions are rvalues.
++<p/>
++It is unclear what the intention is. A straightward way of fixing this wording could make
++<tt>X::[const_]reference</tt> identical to <tt>[const] T&amp;</tt>. This holds for all Library containers
++except for <tt>vector&lt;bool&gt;</tt>.
++<p/>
++Another way of solving this definition problem would be to impose a requirement that holds for both
++references and reference-like proxies. Both <tt>X::reference</tt> and <tt>X::const_reference</tt>
++would need to be convertible to <tt>const T&amp;</tt>. Additionally <tt>X::reference</tt> would need to
++support for a mutable container an assignment expression of the form
++<tt>declval&lt;X::reference&gt;() = declval&lt;T&gt;()</tt> (this presentation intentionally does not require
++<tt>declval&lt;X::reference<span style="color:#C80000;font-weight:bold">&amp;</span>&gt;() = declval&lt;T&gt;()</tt>).
++<p/>
++Further, the Table 96 does not impose any relations between <tt>X::reference</tt> and <tt>X::const_reference</tt>.
++It seems that at least <tt>X::reference</tt> needs to be convertible to <tt>X::const_reference</tt>.
++<p/>
++A related question is whether <tt>X::reference</tt> is supposed to be a mutable reference-like type,
++irrespective of whether the container is an immutable container or not. The way, type <tt>match_results</tt>
++defines <tt>reference</tt> identical to <tt>const_reference</tt> indicates one specific interpretation (similarly,
++the <tt>initializer_list</tt> template also defines member type <tt>reference</tt> equal to <tt>const value_type&amp;</tt>).
++Note that this can be a different decision as that for <tt>iterator</tt> and <tt>const_iterator</tt>,
++e.g. for sets the type <tt>X::reference</tt> still is a mutable reference, even though <tt>iterator</tt>
++is described as constant iterator.
++<p/>
++The proposed resolution is incomplete in regard to the last question.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++Alisdair notes that this looks like wording in the right direction. Wonders about congruence of these
++typedefs and the similar ones for iterators.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Moved to Ready.
++</p>
++<p>
++Consensus that the requirements should require real references, just like iterators, as containers are
++required to support at least ForwardIterators, which have the same restriction on references.
++</p>
++
++<p>
++Matt will file a new issue for some additional concerns with regex <tt>match_results</tt>.
++</p>
++
++<p><i>[2014-02-10, Daniel comments]</i></p>
++
++
++<p>
++The new issue opened by Matt is LWG <a href="lwg-defects.html#2306">2306</a>.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++<p>
++Issue should have been Ready in pre-meeting mailing.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change Table 96 &mdash; "Container requirements" as indicated:</p>
++
++<table border="1">
++<caption>Table p6 &mdash; Container requirements</caption>
++
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational<br/>Semantics</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td>
++<tt>X::reference</tt>
++</td>
++<td>
++<del>lvalue of </del><tt>T<ins>&amp;</ins></tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++</td>
++<td>
++compile time
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X::const_reference</tt>
++</td>
++<td>
++<del>const lvalue of</del><ins><tt>const</tt></ins> <tt>T<ins>&amp;</ins></tt>
++</td>
++<td>
++&nbsp;
++</td>
++<td>
++</td>
++<td>
++compile time
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2185"></a>2185. Missing throws clause for <tt>future/shared_future::wait_for/wait_until</tt></h3>
++<p><b>Section:</b> 30.6.6 [futures.unique_future], 30.6.7 [futures.shared_future] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Vicente J. Botet Escriba <b>Opened:</b> 2012-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.unique_future">issues</a> in [futures.unique_future].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The functions <tt>future::wait_for</tt>, <tt>future::wait_until</tt>, <tt>shared_future::wait_for</tt>, and
++<tt>shared_future::wait_for</tt> can throw any timeout-related exceptions. It would be better if the wording
++could be more explicit. This is in line with the changes proposed in LWG <a href="lwg-defects.html#2093">2093</a>'s <em>Throws</em> element
++of <tt>condition_variable::wait</tt> with predicate.
++</p>
++
++<p><i>[2012, Portland: move to Review]</i></p>
++
++<p>
++The phrase timeout-related exception does not exist.
++</p>
++<p><a href="lwg-defects.html#2093">2093</a> was put in review, and there is some dependency here with this issue.
++</p>
++<p>If you provide a user-defined clock that throws, we need to put back an exception to allow that to be done.
++</p>
++<p>
++We will put this in review and say that this cannot go in before <a href="lwg-defects.html#2093">2093</a>.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This resolution should not be adopted before resolving <a href="lwg-defects.html#2093">2093</a>]</i></p>
++
++
++<p><i>[This wording is relative to N3376.]</i></p>
++
++
++<ol>
++<li><p>Change 30.6.6 [futures.unique_future] as indicated:</p>
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++future_status wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
++</pre><blockquote><p>
++-21- <i>Effects</i>: none if the shared state contains a deferred function (30.6.8 [futures.async]), otherwise
++blocks until the shared state is ready or until the relative timeout (30.2.4 [thread.req.timing]) specified by
++<tt>rel_time</tt> has expired.
++<p/>
++-22- <i>Returns</i>: [&hellip;]
++<p/>
++<ins>-??- <i>Throws</i>: timeout-related exceptions (30.2.4 [thread.req.timing]).</ins>
++</p>
++</blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++future_status wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
++</pre><blockquote><p>
++-23- <i>Effects</i>: none if the shared state contains a deferred function (30.6.8 [futures.async]), otherwise
++blocks until the shared state is ready or until the absolute timeout (30.2.4 [thread.req.timing]) specified by
++<tt>abs_time</tt> has expired.
++<p/>
++-24- <i>Returns</i>: [&hellip;]
++<p/>
++<ins>-??- <i>Throws</i>: timeout-related exceptions (30.2.4 [thread.req.timing]).</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Change 30.6.7 [futures.shared_future] as indicated:</p>
++<blockquote><pre>
++template &lt;class Rep, class Period&gt;
++future_status wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
++</pre><blockquote><p>
++-23- <i>Effects</i>: none if the shared state contains a deferred function (30.6.8 [futures.async]), otherwise
++blocks until the shared state is ready or until the relative timeout (30.2.4 [thread.req.timing]) specified by
++<tt>rel_time</tt> has expired.
++<p/>
++-24- <i>Returns</i>: [&hellip;]
++<p/>
++<ins>-??- <i>Throws</i>: timeout-related exceptions (30.2.4 [thread.req.timing]).</ins>
++</p>
++</blockquote><pre>
++template &lt;class Clock, class Duration&gt;
++future_status wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
++</pre><blockquote><p>
++-25- <i>Effects</i>: none if the shared state contains a deferred function (30.6.8 [futures.async]), otherwise
++blocks until the shared state is ready or until the absolute timeout (30.2.4 [thread.req.timing]) specified by
++<tt>abs_time</tt> has expired.
++<p/>
++-26- <i>Returns</i>: [&hellip;]
++<p/>
++<ins>-??- <i>Throws</i>: timeout-related exceptions (30.2.4 [thread.req.timing]).</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2186"></a>2186. Incomplete action on <tt>async/launch::deferred</tt></h3>
++<p><b>Section:</b> 30.6.8 [futures.async] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Vicente J. Botet Escriba <b>Opened:</b> 2012-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.async">issues</a> in [futures.async].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The description of the effects of <tt>async</tt> when the launch policy is <tt>launch::deferred</tt> doesn't
++state what is done with the result of the deferred function invocation and the possible exceptions as it is done
++for the asynchronous function when the policy is <tt>launch::async</tt>.
++</p>
++
++<p><i>[2012, Portland: move to Open]</i></p>
++
++<p>
++Detlef: agree with the problem but not with the resolution. The wording should be applied to all launch policies
++ rather than having to be separately specified for each one.
++</p>
++<p>
++Hans: we should redraft to factor out the proposed text outside the two bullets. Needs to be carefully worded to
++ be compatible with the resolution of <a href="lwg-defects.html#2120">2120</a> (see above).
++</p>
++<p>
++Moved to open
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate after SG1 review]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>[This wording is relative to N3376.]</i></p>
++
++
++<ol>
++<li><p>Change 30.6.8 [futures.async] p3 bullet 2 as indicated:</p>
++<blockquote><pre>
++template &lt;class F, class... Args&gt;
++future&lt;typename result_of&lt;typename decay&lt;F&gt;::type(typename decay&lt;Args>::type...)&gt;::type&gt;
++async(F&amp;&amp; f, Args&amp;&amp;... args);
++template &lt;class F, class... Args&gt;
++future&lt;typename result_of&lt;typename decay&lt;F&gt;::type(typename decay&lt;Args&gt;::type...)&gt;::type&gt;
++async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
++</pre><blockquote><p>
++-2- <i>Requires</i>: [&hellip;]
++<p/>
++-3- <i>Effects:</i>: The first function behaves the same as a call to the second function with a <tt>policy</tt> argument of
++<tt>launch::async | launch::deferred</tt> and the same arguments for <tt>F</tt> and <tt>Args</tt>. [&hellip;] The further
++behavior of the second function depends on the <tt>policy</tt> argument as follows (if more than one of these conditions
++applies, the implementation may choose any of the corresponding policies):
++</p>
++<ul>
++<li><p>if <tt>policy &amp; launch::async</tt> is non-zero [&hellip;]</p></li>
++<li><p>if <tt>policy &amp; launch::deferred</tt> is non-zero &mdash; Stores <tt><i>DECAY_COPY</i>(std::forward&lt;F&gt;(f))</tt>
++and <tt><i>DECAY_COPY</i>(std::forward&lt;Args>(args))...</tt> in the shared state. These copies of <tt>f</tt> and <tt>args</tt>
++constitute a <em>deferred function</em>. Invocation of the deferred function evaluates <tt><i>INVOKE</i>(std::move(g), std::move(xyz))</tt>
++where <tt>g</tt> is the stored value of <tt><i>DECAY_COPY</i>(std::forward&lt;F>(f))</tt> and <tt>xyz</tt> is
++the stored copy of <tt><i>DECAY_COPY</i>(std::forward&lt;Args>(args))...</tt>. <ins>Any return value is stored as the
++result in the shared state. Any exception propagated from the execution of the deferred function is stored as the
++exceptional result in the shared state.</ins> The shared state is not made ready until the function has completed.
++The first call to a non-timed waiting function (30.6.4 [futures.state]) on an asynchronous return object referring
++to this shared state shall invoke the deferred function in the thread that called the waiting function. Once evaluation
++of <tt><i>INVOKE</i>(std::move(g), std::move(xyz))</tt> begins, the function is no longer considered deferred.
++[<i>Note</i>: If this policy is specified together with other policies, such as when using a policy value of
++<tt>launch::async | launch::deferred</tt>, implementations should defer invocation or the selection of the <tt>policy</tt>
++when no more concurrency can be effectively exploited. &mdash; <i>end note</i>]
++</p></li>
++</ul>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2187"></a>2187. <tt>vector&lt;bool&gt;</tt> is missing <tt>emplace</tt> and <tt>emplace_back</tt> member functions</h3>
++<p><b>Section:</b> 23.3.7 [vector.bool] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nevin Liber <b>Opened:</b> 2012-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.bool">issues</a> in [vector.bool].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++It should have them so that it more closely matches the <tt>vector&lt;T&gt;</tt> interface, as this helps when
++writing generic code.
++</p>
++
++<p><i>[2012, Portland: Move to Tentatively Ready]</i></p>
++
++<p>
++Question on whether the variadic template is really needed, but it turns out to be needed to support
++<tt>emplace</tt> of no arguments.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change the class template <tt>vector&lt;bool&gt;</tt> synopsis, 23.3.7 [vector.bool] p1, as indicated:</p>
++<blockquote><pre>
++namespace std {
++ template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
++ public:
++ [&hellip;]
++ <i>// modifiers:</i>
++ <ins>template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);</ins>
++ void push_back(const bool&amp; x);
++ void pop_back();
++ <ins>template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);</ins>
++ iterator insert(const_iterator position, const bool&amp; x);
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2188"></a>2188. Reverse iterator does not fully support targets that overload <tt>operator&amp;</tt></h3>
++<p><b>Section:</b> 24.5.1.3.5 [reverse.iter.opref] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-09-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iter.opref">issues</a> in [reverse.iter.opref].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The specification for <tt>reverse_iterator::operator-></tt>
++returns the address of the object yielded by dereferencing
++with <tt>operator*</tt>, but does not have the usual
++wording about returning the true address of the object. As
++<tt>reverse_iterator</tt> requires the adapted iterator have
++at least the bidirectional iterator category, we know that
++the returned reference is a true reference, and not a proxy,
++hence we can use <tt>std::addressof</tt> on the reference
++to get the right answer.
++</p>
++<p>
++This will most likely show itself as an issue with a <tt>list</tt>
++or <tt>vector</tt> of a type with such an overloaded operator,
++where algorithms are likely to work with a forward iteration, but
++not with reverse iteration.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Resolution: Goes to open now and move to review as soon as Daniel proposes a new wording.
++</p>
++
++<p><i>[2014-02-12 Issaquah meeting]</i></p>
++
++<p>
++Use <tt>std::addressof</tt> as the library uses elsewhere, then move as Immediate.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Revise 24.5.1.3.5 [reverse.iter.opref] p1, as indicated:
++</p>
++<p>
++<i>Returns:</i> <tt><ins>addressof</ins><del>&amp;(</del>operator*()<del>)</del></tt>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2190"></a>2190. Condition variable specification</h3>
++<p><b>Section:</b> 30.5 [thread.condition] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Hans Boehm <b>Opened:</b> 2012-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition">issues</a> in [thread.condition].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The condition variable specification possibly leaves it unclear whether the effect of a <tt>notify_one()</tt>
++call can effectively be delayed, so that a call unblocks a <tt>wait()</tt> call that happens after the
++<tt>notify_one</tt> call. (For <tt>notify_all()</tt> this is not detectable, since it only results in spurious
++wake-ups.) Although this may at first glance seem like a contrived interpretation, it gains relevance since
++glibc in fact allows the analogous behavior (see <a href="http://sourceware.org/bugzilla/show_bug.cgi?id=13165">here</a>)
++and it is currently controversial whether this is correct and the Posix specification allows it (see
++<a href="http://austingroupbugs.net/view.php?id=609">here</a>).
++</p>
++<p>
++The following proposed resolution disallows the glibc implementation, remaining consistent with the believed intent of C++11.
++To make that clear, we require that the "unspecified total order" O from 30.5 [thread.condition] p4 be
++consistent with <em>happens-before</em>. We also intend that the 3 components of a wait occur in order in O,
++but stating that explicitly seems too pedantic. Since they are numbered, it appears clear enough that they are
++sequenced one after the other.
++</p>
++<p>
++Another uncertainty with the current phrasing is whether there is a single total order that includes all c.v.
++accesses, or one total order per c.v. We believe it actually doesn't matter, because there is no way to tell the
++difference, but this requires a bit more thought. We resolved it one way, just to remove the potential ambiguity.
++</p>
++
++<p><i>[2012, Portland: Move to Review]</i></p>
++
++<p>
++This is linked to a <a href="http://sourceware.org/bugzilla/show_bug.cgi?id=13165">glibc issue</a>, and
++a <a href="http://austingroupbugs.net/view.php?id=609">POSIX specification issue</a>.
++</p>
++
++<p>
++We believe the proposed wording fixes the ambiguity in C++ and is compatible with the proposed resolution
++for Posix (which confirms the glibc behaviour as illegal).
++</p>
++
++<p>
++Moved to review (Detlef hopes to send some improved wording to the reflector).
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Accepted for the working paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 30.5 [thread.condition] p4 as indicated:</p>
++<blockquote><p>
++-4- The implementation shall behave as if <ins>all executions of</ins> <tt>notify_one</tt>, <tt>notify_all</tt>,
++and each part of the <tt>wait</tt>, <tt>wait_for</tt>, and <tt>wait_until</tt> executions are executed in
++<del>some</del><ins>a single</ins> unspecified total order <ins>consistent with the "happens before" order</ins>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2193"></a>2193. Default constructors for standard library containers are explicit</h3>
++<p><b>Section:</b> 23 [containers] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2012-10-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#containers">active issues</a> in [containers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#containers">issues</a> in [containers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Most (all?) of the standard library containers have explicit default constructors. Consequently:
++</p>
++<blockquote><pre>
++std::set&lt;int&gt; s1 = { 1, 2 }; // ok
++std::set&lt;int&gt; s2 = { 1 }; // ok
++std::set&lt;int&gt; s3 = {}; // ill-formed, copy-list-initialization selected an explicit constructor
++</pre></blockquote>
++<p>
++Note that Clang + libc++ rejects the declaration of <tt>s3</tt> for this reason. This cannot possibly match the intent.
++</p>
++<p>
++Suggested fix: apply this transformation throughout the standard library:
++</p>
++<blockquote><pre>
++<ins>set() : set(Compare()) {}</ins>
++explicit set(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++
++<p><i>[
++2012-10-06: Daniel adds concrete wording.
++]</i></p>
++
++
++<p><i>[2012, Portland: Move to Open]</i></p>
++
++<p>
++This may be an issue better solved by a core language tweak. Throw the issue over to EWG and see whether they
++believe the issue is better resolved in Core or Library.
++</p>
++
++<p>
++AJM suggest we spawn a new status of 'EWG' to handle such issues - and will move this issue appropriately when
++the software can record such resolutions.
++</p>
++
++<p><i>[2013-08-27, Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz comments:]</i></p>
++
++
++<p>
++For the record, I'd like to point out that the resolution proposed by the submitter, namely replacing
++</p>
++
++<blockquote><pre>
++explicit basic_string(const Allocator&amp; a = Allocator());
++</pre></blockquote>
++
++<p>
++by
++</p>
++
++<blockquote><pre>
++basic_string() : basic_string(Allocator()) {}
++explicit basic_string(const Allocator&amp; a);
++</pre></blockquote>
++
++<p>
++(and similarly for other container and container-like classes) might introduce a potential
++backwards-compatibility problem related with explicit instantiation. Consider for instance
++</p>
++
++<blockquote><pre>
++struct my_allocator
++{
++ my_allocator(...); // no default ctor
++ ...
++};
++
++template class std::basic_string&lt;char, std::char_traits&lt;char&gt;, my_allocator&lt;char&gt;&gt;;
++</pre></blockquote>
++
++<p>
++This (which I understand is currently a valid explicit instantiation of <tt>std::basic_string</tt>) will break if
++<tt>std::basic_string</tt> ctors are modified as proposed by this issue, since <tt>my_allocator</tt> doesn't have
++a default ctor.
++</p>
++
++<p><i>[2013-10-06, Daniel comments:]</i></p>
++
++
++<p>
++Issue <a href="lwg-active.html#2303">2303</a> describes the more general problem related to explicit instantiation requests in the current
++library and may help to solve this problem here as well.
++</p>
++
++<p><i>[2014-02-13, Issaquah, Jonathan revises wording]</i></p>
++
++
++<p><strong>Previous resolution from Daniel [SUPERSEDED]:</strong></p>
++
++<blockquote class="note">
++
++<p>This wording is relative to N3376.</p>
++
++<p>The more general criterion for performing the suggested transformation was: Any type with an initializer-list
++constructor that also has an explicit default constructor.</p>
++
++<ol>
++<li><p>Change class template <tt>basic_string</tt> synopsis, 21.4 [basic.string] p5 as indicated:</p>
++<blockquote><pre>
++<ins>basic_string() : basic_string(Allocator()) {}</ins>
++explicit basic_string(const Allocator&amp; a<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.2 [string.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit basic_string(const Allocator&amp; a<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>deque</tt> synopsis, 23.3.3.1 [deque.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>deque() : deque(Allocator()) {}</ins>
++explicit deque(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.3.2 [deque.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit deque(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>forward_list</tt> synopsis, 23.3.4.1 [forwardlist.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>forward_list() : forward_list(Allocator()) {}</ins>
++explicit forward_list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.4.2 [forwardlist.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit forward_list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>list</tt> synopsis, 23.3.5.1 [list.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>list() : list(Allocator()) {}</ins>
++explicit list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.5.2 [list.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>vector</tt> synopsis, 23.3.6.1 [vector.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>vector() : vector(Allocator()) {}</ins>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.6.2 [vector.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template specialization <tt>vector&lt;bool&gt;</tt> synopsis, 23.3.7 [vector.bool] p1 as indicated:</p>
++<blockquote><pre>
++<ins>vector() : vector(Allocator()) {}</ins>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>map</tt> synopsis, 23.4.4.1 [map.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>map() : map(Compare()) {}</ins>
++explicit map(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.4.2 [map.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit map(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>multimap</tt> synopsis, 23.4.5.1 [multimap.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>multimap() : multimap(Compare()) {}</ins>
++explicit multimap(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.5.2 [multimap.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit multimap(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>set</tt> synopsis, 23.4.6.1 [set.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>set() : set(Compare()) {}</ins>
++explicit set(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.6.2 [set.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit set(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>multiset</tt> synopsis, 23.4.7.1 [multiset.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>multiset() : multiset(Compare()) {}</ins>
++explicit multiset(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.7.2 [multiset.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit multiset(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_map</tt> synopsis, 23.5.4.1 [unord.map.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_map() : unordered_map(<i>see below</i>) {}</ins>
++explicit unordered_map(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.4.2 [unord.map.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_map() : unordered_map(<i>see below</i>) {}</ins>
++explicit unordered_map(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_multimap</tt> synopsis, 23.5.5.1 [unord.multimap.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multimap() : unordered_multimap(<i>see below</i>) {}</ins>
++explicit unordered_multimap(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.5.2 [unord.multimap.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multimap() : unordered_multimap(<i>see below</i>) {}</ins>
++explicit unordered_multimap(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_set</tt> synopsis, 23.5.6.1 [unord.set.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_set() : unordered_set(<i>see below</i>) {}</ins>
++explicit unordered_set(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.6.2 [unord.set.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_set() : unordered_set(<i>see below</i>) {}</ins>
++explicit unordered_set(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_multiset</tt> synopsis, 23.5.7.1 [unord.multiset.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multiset() : unordered_multiset(<i>see below</i>) {}</ins>
++explicit unordered_multiset(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.7.2 [unord.multiset.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multiset() : unordered_multiset(<i>see below</i>) {}</ins>
++explicit unordered_multiset(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate after final review]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<p>The more general criterion for performing the suggested transformation was: Any type with an initializer-list
++constructor that also has an explicit default constructor.</p>
++
++<ol>
++<li><p>Change class template <tt>basic_string</tt> synopsis, 21.4 [basic.string] p5 as indicated:</p>
++<blockquote><pre>
++<ins>basic_string() : basic_string(Allocator()) { }</ins>
++explicit basic_string(const Allocator&amp; a<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.2 [string.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit basic_string(const Allocator&amp; a<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>deque</tt> synopsis, 23.3.3.1 [deque.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>deque() : deque(Allocator()) { }</ins>
++explicit deque(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.3.2 [deque.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit deque(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>forward_list</tt> synopsis, 23.3.4.1 [forwardlist.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>forward_list() : forward_list(Allocator()) { }</ins>
++explicit forward_list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.4.2 [forwardlist.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit forward_list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>list</tt> synopsis, 23.3.5.1 [list.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>list() : list(Allocator()) { }</ins>
++explicit list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.5.2 [list.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit list(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>vector</tt> synopsis, 23.3.6.1 [vector.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>vector() : vector(Allocator()) { }</ins>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.3.6.2 [vector.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template specialization <tt>vector&lt;bool&gt;</tt> synopsis, 23.3.7 [vector.bool] p1 as indicated:</p>
++<blockquote><pre>
++<ins>vector() : vector(Allocator()) { }</ins>
++explicit vector(const Allocator&amp;<del> = Allocator()</del>);
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>map</tt> synopsis, 23.4.4.1 [map.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>map() : map(Compare()) { }</ins>
++explicit map(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.4.2 [map.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit map(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>multimap</tt> synopsis, 23.4.5.1 [multimap.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>multimap() : multimap(Compare()) { }</ins>
++explicit multimap(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.5.2 [multimap.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit multimap(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>set</tt> synopsis, 23.4.6.1 [set.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>set() : set(Compare()) { }</ins>
++explicit set(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.6.2 [set.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit set(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>multiset</tt> synopsis, 23.4.7.1 [multiset.overview] p2 as indicated:</p>
++<blockquote><pre>
++<ins>multiset() : multiset(Compare()) { }</ins>
++explicit multiset(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.7.2 [multiset.cons] before p1 as indicated:</p>
++<blockquote><pre>
++explicit multiset(const Compare&amp; comp<del> = Compare()</del>,
++ const Allocator&amp; = Allocator());
++</pre></blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_map</tt> synopsis, 23.5.4.1 [unord.map.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_map();</ins>
++explicit unordered_map(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.4.2 [unord.map.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_map() : unordered_map(size_type(<i>see below</i>)) { }</ins>
++explicit unordered_map(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre>
++
++-1- <i>Effects:</i> Constructs an empty <code>unordered_map</code> using the specified hash function, key equality func-<br />
++tion, and allocator, and using at least <i>n</i> buckets. <del>If <i>n</i> is not provided,</del> <ins>For the default constructor</ins><br />
++the number of buckets is implementation-defined. <code>max_load_factor()</code> returns 1.0.
++</blockquote>
++
++</li>
++
++<li><p>Change class template <tt>unordered_multimap</tt> synopsis, 23.5.5.1 [unord.multimap.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multimap();</ins>
++explicit unordered_multimap(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.5.2 [unord.multimap.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multimap() : unordered_multimap(size_type(<i>see below</i>)) { }</ins>
++explicit unordered_multimap(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre>
++
++-1- <i>Effects:</i> Constructs an empty <code>unordered_multimap</code> using the specified hash function, key equality<br />
++function, and allocator, and using at least <i>n</i> buckets. <del>If <i>n</i> is not provided,</del> <ins>For the default constructor</ins><br />
++the number of buckets is implementation-defined. <code>max_load_factor()</code> returns 1.0.
++
++</blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_set</tt> synopsis, 23.5.6.1 [unord.set.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_set();</ins>
++explicit unordered_set(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.6.2 [unord.set.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_set() : unordered_set(size_type(<i>see below</i>)) { }</ins>
++explicit unordered_set(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre>
++
++-1- <i>Effects:</i> Constructs an empty <code>unordered_set</code> using the specified hash function, key equality func-<br />
++tion, and allocator, and using at least <i>n</i> buckets. <del>If <i>n</i> is not provided,</del> <ins>For the default constructor</ins><br />
++the number of buckets is implementation-defined. <code>max_load_factor()</code> returns 1.0.
++
++</blockquote>
++</li>
++
++<li><p>Change class template <tt>unordered_multiset</tt> synopsis, 23.5.7.1 [unord.multiset.overview] p3 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multiset();</ins>
++explicit unordered_multiset(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.7.2 [unord.multiset.cnstr] before p1 as indicated:</p>
++<blockquote><pre>
++<ins>unordered_multiset() : unordered_multiset(size_type(<i>see below</i>)) { }</ins>
++explicit unordered_multiset(size_type n<del> = <i>see below</i></del>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre>
++
++-1- <i>Effects:</i> Constructs an empty <code>unordered_multiset</code> using the specified hash function, key equality<br />
++function, and allocator, and using at least <i>n</i> buckets. <del>If <i>n</i> is not provided,</del> <ins>For the default constructor</ins><br />
++the number of buckets is implementation-defined. <code>max_load_factor()</code> returns 1.0.
++
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2194"></a>2194. Impossible container requirements for adaptor types</h3>
++<p><b>Section:</b> 23.6 [container.adaptors] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Sebastian Mach <b>Opened:</b> 2012-10-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.adaptors">issues</a> in [container.adaptors].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The <tt>stack</tt> class template does not have an member type <tt>iterator</tt>, and therefore instantiations do not
++meet the general container requirements as described in 23.2.1 [container.requirements.general]. But
++23.6.1 [container.adaptors.general] p1 says:
++</p>
++<blockquote><p>
++The headers <tt>&lt;queue&gt;</tt> and <tt>&lt;stack&gt;</tt> define the container adaptors <tt>queue</tt>,
++<tt>priority_queue</tt>, and <tt>stack</tt>. These container adaptors meet the requirements for sequence containers.
++</p></blockquote>
++<p>
++Since sequence containers is a subset of general containers, this imposes requirements on the container adaptors that
++are not satisfied.
++</p>
++<p>
++<u>Daniel Kr&uuml;gler</u>: The wording change was performed as an editorial reorganization as requested
++by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3296.html#GB116">GB 116</a> occuring first in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf">N3242</a>, as a side-effect it
++does now make the previous implicit C++03 classification to [lib.sequences]/1 more obvious. As the NB comment
++noticed, the adaptors really are not sequences nor containers, so this wording needs to be fixed.
++The most simple way to realize that is to strike the offending sentence.
++</p>
++
++<p><i>[
++Daniel adds concrete wording.
++]</i></p>
++
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++
++<p>
++Unanimous consensus that <tt>queue</tt> and <tt>stack</tt> are not meant to be sequences.
++<p/>
++Decision: move to tentatively ready
++</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>
++Apply to Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 23.6.1 [container.adaptors.general] p1 as indicated:</p>
++<blockquote><p>
++-1- The headers <tt>&lt;queue&gt;</tt> and <tt>&lt;stack&gt;</tt> define the container adaptors <tt>queue</tt>,
++<tt>priority_queue</tt>, and <tt>stack</tt>. <del>These container adaptors meet the requirements for sequence containers.</del>
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2196"></a>2196. Specification of <tt>is_*[copy/move]_[constructible/assignable]</tt> unclear for non-referencable types</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-10-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The pre-conditions for the type <tt>is_copy_constructible</tt> allow for template argument types were the language forbids
++forming a reference, namely <tt>void</tt> types and function types that have <em>cv</em>-qualifiers or a <em>ref</em>-qualifier.
++<p/>
++But the current wording in Table 49 defining the predicate condition,
++</p>
++<blockquote><p>
++<tt>is_constructible&lt;T, const T&amp;&gt;::value</tt> is <tt>true</tt>.
++</p></blockquote>
++<p>
++leaves it open whether such argument types would (a) create a well-formed instantiation of the trait template or if so (b) what
++the outcome of the trait evaluation would be, as an example consider <tt>std::is_copy_constructible&lt;void&gt;</tt>.
++<p/>
++Current implementations differ, e.g. gcc accepts the instantiation and returns a false result, VS 2012
++also accepts the instantiation but returns true.
++<p/>
++I would suggest that the wording clarifies that the instantiation would be valid for these types and I also would strongly
++prefer the outcome that the trait would always return false for these types. The latter seems rather natural
++to me, because there is no way to define a variable of <tt>void</tt> type or of function type at all, so it would be surprising
++to return a positive result for copy or move construction if no other construction could succeed. It is also not
++possible to assign to a any of these values (because there is no way to form lvalues of them), so the same argumentation
++can be applied to the <tt>is_copy/move_assignable</tt> traits as well.
++<p/>
++To reduce the amount of wording changes and repetitions, I suggest to define the term <em>referenceable type</em> in
++sub-clause 17.3 [definitions] or alternatively in the core language to describe types to which references
++can be created via a typedef name. This definition corresponds to what the support concept <tt>ReferentType</tt> intended
++to describe during concept time.
++<p/>
++In addition, LWG issue <a href="lwg-active.html#2101">2101</a> can also take advantage of the definition of a <em>referenceable type</em>.
++<p/>
++If the proposed resolution for LWG issue <a href="lwg-active.html#2101">2101</a> would be accepted, there is an alternative solution possible
++with the same effects. Now we would be able to use the now always well-formed instantiation of
++<tt>std::add_lvalue_reference</tt> to modify the current definition of <tt>is_copy_constructible</tt> to
++</p>
++<blockquote><p>
++<tt>is_constructible&lt;T,<br/>
++ typename add_lvalue_reference&lt;<br/>
++ typename add_const&lt;T&gt;::type&gt;::type&gt;::value</tt> is true.
++</p></blockquote>
++<p>
++and similar changes for the other affected traits.
++</p>
++
++<p><i>[2012-10 Portland: Move to Open]</i></p>
++
++<p>
++Referencable-type should be defined as "something that can be bound into a reference" or similar,
++rather than a list of types where that is true today. We can then provide the list of known types
++that cannot be bound as examples that do not qualify in a note.
++</p>
++
++<p>
++Otherwise we are happy with the wording. AJM to redraft the definition and move to Review.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Add the following new definition to 17.3 [definitions] as indicated:</p>
++<p><b>referenceable type</b> [defns.referenceable]</p>
++<blockquote><p>
++An object type, a function type that does not have <em>cv</em>-qualifiers or a <em>ref</em>-qualifier, or a reference type.
++[<i>Note</i>: The term describes a type to which a reference can be created, including reference types. &mdash; <i>end note</i>]
++</p></blockquote>
++</li>
++
++<li><p>Change Table 49 as indicated:</p>
++
++<table border="1">
++<caption>Table 49 &mdash; Type property predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Preconditions</th>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_copy_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_constructible&lt;T,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_move_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_constructible&lt;T,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_copy_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_assignable&lt;T&amp;,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_move_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_assignable&lt;T&amp;,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_trivially_copy_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_trivially_constructible&lt;T,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_trivially_move_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_trivially_constructible&lt;T,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_trivially_copy_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_trivially_assignable&lt;T&amp;,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_trivially_move_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_trivially_assignable&lt;T&amp;,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_nothrow_copy_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_nothrow_constructible&lt;T,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_nothrow_move_constructible;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_nothrow_constructible&lt;T,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_nothrow_copy_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_nothrow_assignable&lt;T&amp;,</tt><br/>
++<tt>const T&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_nothrow_move_assignable;</tt>
++</td>
++<td>
++<ins>For a referenceable type <tt>T</tt>, the same result as</ins><br/>
++<tt>is_nothrow_assignable&lt;T&amp;,</tt><br/>
++<tt>T&amp;&amp;&gt;::value</tt><del> is true</del><ins>, otherwise false</ins>.
++</td>
++<td>
++<tt>T</tt> shall be a complete type,<br/>
++(possibly <em>cv</em>-qualified) <tt>void</tt>, or an<br/>
++array of unknown bound.
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2197"></a>2197. Specification of <tt>is_[un]signed</tt> unclear for non-arithmetic types</h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2012-10-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The pre-conditions for the trait <tt>is_signed</tt> allow for any types as template arguments,
++including non-arithmetic ones.
++<p/>
++But the current wording in Table 49 defining the predicate condition,
++</p>
++<blockquote><pre>
++is_arithmetic&lt;T&gt;::value &amp;&amp; T(-1) &lt; T(0)
++</pre></blockquote>
++<p>
++looks like real code and so leaves it open whether such argument types would create a well-formed
++instantiation of the trait template or not. As written this definition would lead to a hard
++instantiation error for a non-arithmetic type like e.g.
++</p>
++<blockquote><pre>
++struct S {};
++</pre></blockquote>
++<p>
++I would suggest that the wording clarifies that the instantiation would be valid for such types as well,
++by means of a specification that is not an exact code pattern. This also reflects how existing
++implementations behave.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change Table 49 as indicated:</p>
++
++<table border="1">
++<caption>Table 49 &mdash; Type property predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Preconditions</th>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_signed;</tt>
++</td>
++<td>
++<ins>If </ins><tt>is_arithmetic&lt;T&gt;::value<del> &amp;&amp;</del></tt><ins> is true, the same result as</ins><br/>
++<tt><ins>integral_constant&lt;bool,</ins> T(-1) &lt; T(0)<ins>&gt;::value</ins></tt><ins>;<br/>
++otherwise, false.</ins>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;</tt><br/>
++<tt>struct is_unsigned;</tt>
++</td>
++<td>
++<ins>If </ins><tt>is_arithmetic&lt;T&gt;::value<del> &amp;&amp;</del></tt><ins> is true, the same result as</ins><br/>
++<tt><ins>integral_constant&lt;bool,</ins> T(0) &lt; T(-1)<ins>&gt;::value</ins></tt><ins>;<br/>
++otherwise, false.</ins>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++</table>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2200"></a>2200. Data race avoidance for all containers, not only for sequences</h3>
++<p><b>Section:</b> 23.2.2 [container.requirements.dataraces] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-10-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.dataraces">issues</a> in [container.requirements.dataraces].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++23.2.2 [container.requirements.dataraces]/2 says "[&hellip;] implementations are
++required to avoid data races when the contents of the contained object in different
++elements in the same sequence, excepting <tt>vector&lt;bool&gt;</tt>, are modified
++concurrently."
++</p>
++<p>
++This should say "same container" instead of "same sequence", to avoid
++the interpretation that it only applies to sequence containers.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 23.2.2 [container.requirements.dataraces]/2 as indicated:</p>
++<blockquote><p>
++-2- Notwithstanding (17.6.5.9 [res.on.data.races]), implementations are required to avoid data races when
++the contents of the contained object in different elements in the same <del>sequence</del><ins>container</ins>,
++excepting <tt>vector&lt;bool&gt;</tt>, are modified concurrently.
++<p/>
++-3- [<i>Note</i>: For a <tt>vector&lt;int&gt; x</tt> with a size greater than one, <tt>x[1] = 5</tt> and
++<tt>*x.begin() = 10</tt> can be executed concurrently without a data race, but <tt>x[0] = 5</tt> and
++<tt>*x.begin() = 10</tt> executed concurrently may result in a data race. As an exception to the general
++rule, for a <tt>vector&lt;bool&gt; y, y[0] = true</tt> may race with <tt>y[1] = true</tt>. &mdash; <i>end note</i> ]
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2203"></a>2203. <tt>scoped_allocator_adaptor</tt> uses wrong argument types for piecewise construction</h3>
++<p><b>Section:</b> 20.13.4 [allocator.adaptor.members] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-10-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.adaptor.members">issues</a> in [allocator.adaptor.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++In 20.13.4 [allocator.adaptor.members] paragraph 11 the effects
++clause says a tuple should be constructed with <tt>inner_allocator_type()</tt>,
++but that creates an rvalue which cannot bind to <tt>inner_allocator_type&amp;</tt>,
++and would also be wrong if <tt>this->inner_allocator() != inner_allocator_type()</tt>.
++This could be considered editorial, since the current wording doesn't even compile.
++</p>
++<p>
++Secondly, in the same paragraph, the tuple objects <tt>xprime</tt> and <tt>yprime</tt>
++seem to be lvalues and might be constructed by copying <tt>x</tt> and <tt>y</tt>. This
++prevents using <tt>scoped_allocator</tt> to construct pairs from arguments of
++move-only types. I believe the <tt>tuple_cast()</tt> expressions should use
++<tt>std::move(x)</tt> and <tt>std::move(y)</tt> to move from the incoming arguments
++(which are passed by value to candidates for moving) and the final sentence of the paragraph
++should be:
++</p>
++<p>
++then calls <tt>OUTERMOST_ALLOC_TRAITS(*this)::construct(OUTERMOST (*this), p, piecewise_construct,
++std::move(xprime), std::move(yprime))</tt>.
++</p>
++<p>
++so that the objects are passed to <tt>std::pair</tt>'s piecewise constructor as rvalues and
++are eligible for moving into the constructor arguments. This could also be considered editorial,
++as the current wording prevents certain uses which were intended to be supported.
++<p/>
++I've implemented these changes and can confirm they allow code to work that can't be compiled
++according to the current wording.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++The resolution looks good, with wording provided by a recent implementer. However, it will take more
++time than the telecon allows to review with confidence, and we would like Pablo to at least take a
++look over the resolution and confirm that it matches the design intent.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change 20.13.4 [allocator.adaptor.members] paragraph 11 as indicated:</p>
++
++<blockquote>
++<p>
++-11- <i>Effects</i>: Constructs a <tt>tuple</tt> object <tt>xprime</tt> from <tt>x</tt> by the following rules:
++</p>
++<ul>
++<li><p>
++If <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and
++<tt>is_constructible&lt;T1, Args1...&gt;::value</tt> is <tt>true</tt>, then <tt>xprime</tt> is <tt>x</tt>.
++</p></li>
++
++<li><p>
++Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and
++<tt>is_constructible&lt;T1, allocator_arg_t, inner_allocator_type, Args1...&gt;::value</tt> is <tt>true</tt>,
++then <tt>xprime</tt> is <tt>tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;( allocator_arg,
++inner_allocator<del>_type</del>()), <ins>std::move(</ins>x<ins>)</ins>)</tt>.
++</p></li>
++
++<li><p>
++Otherwise, if <tt>uses_allocator&lt;T1, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and
++<tt>is_constructible&lt;T1, Args1..., inner_allocator_type&gt;::value</tt> is <tt>true</tt>, then <tt>xprime</tt>
++is <tt>tuple_cat(<ins>std::move(</ins>x<ins>)</ins>,
++tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator<del>_type</del>()))</tt>.
++</p></li>
++
++<li><p>
++Otherwise, the program is ill-formed.
++</p></li>
++</ul>
++<p>
++and constructs a <tt>tuple</tt> object <tt>yprime</tt> from <tt>y</tt> by the following rules:
++</p>
++<ul>
++<li><p>
++If <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>false</tt> and
++<tt>is_constructible&lt;T2, Args2...&gt;::value</tt> is <tt>true</tt>, then <tt>yprime</tt> is <tt>y</tt>.
++</p></li>
++
++<li><p>
++Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and
++<tt>is_constructible&lt;T2, allocator_arg_t, inner_allocator_type, Args2...&gt;::value</tt> is <tt>true</tt>,
++then <tt>yprime</tt> is <tt>tuple_cat(tuple&lt;allocator_arg_t, inner_allocator_type&amp;&gt;( allocator_arg,
++inner_allocator<del>_type</del>()), <ins>std::move(</ins>y<ins>)</ins>)</tt>.
++</p></li>
++
++<li><p>
++Otherwise, if <tt>uses_allocator&lt;T2, inner_allocator_type&gt;::value</tt> is <tt>true</tt> and
++<tt>is_constructible&lt;T2, Args2..., inner_allocator_type&gt;::value</tt> is <tt>true</tt>, then <tt>yprime</tt>
++is <tt>tuple_cat(<ins>std::move(</ins>y<ins>)</ins>,
++tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator<del>_type</del>()))</tt>.
++</p></li>
++
++<li><p>
++Otherwise, the program is ill-formed.
++</p></li>
++</ul>
++<p>
++then calls <tt><i>OUTERMOST_ALLOC_TRAITS</i>(*this)::construct(<i>OUTERMOST</i>(*this), p,
++piecewise_construct, <ins>std::move(</ins>xprime<ins>)</ins>, <ins>std::move(</ins>yprime<ins>)</ins>)</tt>.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2205"></a>2205. Problematic postconditions of <tt>regex_match</tt> and <tt>regex_search</tt></h3>
++<p><b>Section:</b> 28.11.2 [re.alg.match], 28.11.3 [re.alg.search] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-10-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.match">issues</a> in [re.alg.match].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++Table 142 lists post-conditions on the <tt>match_results</tt> object when a call to <tt>regex_match</tt> succeeds.
++<tt>regex_match</tt> is required to match the entire target sequence. The post-condition for <tt>m[0].matched</tt>
++is "true if a full match was found." Since these are conditions for a successful search which is, by definition,
++a full match, the post-condition should be simply "true".
++</p>
++<p>
++There's an analogous probem in Table 143: the condition for <tt>m[0].matched</tt> is "true if a match was found,
++false otherwise." But Table 143 gives post-conditions for a successful match, so the condition should be simply
++"true".
++</p>
++<p>
++Furthermore, they have explicit requirements for <tt>m[0].first</tt>, <tt>m[0].second</tt>, and <tt>m[0].matched</tt>.
++They also have requirements for the other elements of <tt>m</tt>, described as <tt>m[n].first</tt>, <tt>m[n].second</tt>,
++and <tt>m[n].matched</tt>, in each case qualifying the value of <tt>n</tt> as "for <tt>n &lt; m.size()</tt>". Since
++there is an explicit description for <tt>n == 0</tt>, this qualification should be "for <tt>0 &lt; n &lt; m.size()</tt>"
++in all 6 places.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Change Table 142 as indicated:</p>
++
++<table border="1">
++<caption>Table 142 &mdash; Effects of <tt>regex_match</tt> algorithm</caption>
++<tr>
++<th>Element</th>
++<th>Value</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].first</tt>
++</td>
++<td>
++<tt>first</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].second</tt>
++</td>
++<td>
++<tt>last</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].matched</tt>
++</td>
++<td>
++<tt>true</tt> <del>if a full match was found.</del>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].first</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, the start of the sequence
++that matched sub-expression <tt>n</tt>.<br/>
++Alternatively, if subexpression <tt>n</tt> did not participate in the match, then <tt>last</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].second</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, the end of the sequence that
++matched sub-expression <tt>n</tt>.<br/>
++Alternatively, if sub-expression <tt>n</tt> did not participate in the match, then <tt>last</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].matched</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, <tt>true</tt> if sub-expression
++<tt>n</tt> participated in the match, <tt>false</tt> otherwise.
++</td>
++</tr>
++
++</table>
++</li>
++
++<li><p>Change Table 143 as indicated:</p>
++
++<table border="1">
++<caption>Table 143 &mdash; Effects of <tt>regex_search</tt> algorithm</caption>
++<tr>
++<th>Element</th>
++<th>Value</th>
++</tr>
++
++<tr>
++<td colspan="2" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].first</tt>
++</td>
++<td>
++The start of the sequence of characters that matched the regular expression
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].second</tt>
++</td>
++<td>
++The end of the sequence of characters that matched the regular expression
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[0].matched</tt>
++</td>
++<td>
++<tt>true</tt> <del>if a match was found, and false otherwise.</del>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].first</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, the start of the sequence
++that matched sub-expression <tt>n</tt>.<br/>
++Alternatively, if subexpression <tt>n</tt> did not participate in the match, then <tt>last</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].second</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, the end of the sequence that
++matched sub-expression <tt>n</tt>.<br/>
++Alternatively, if sub-expression <tt>n</tt> did not participate in the match, then <tt>last</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>m[n].matched</tt>
++</td>
++<td>
++For all integers <tt><ins>0 &lt;</ins> n &lt; m.size()</tt>, <tt>true</tt> if sub-expression
++<tt>n</tt> participated in the match, <tt>false</tt> otherwise.
++</td>
++</tr>
++
++</table>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2207"></a>2207. <tt>basic_string::at</tt> should not have a Requires clause</h3>
++<p><b>Section:</b> 21.4.5 [string.access] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nevin Liber <b>Opened:</b> 2012-10-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.access">issues</a> in [string.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++<tt>basic_string::at()</tt> has a wide contract and should not have a "Requires" clause on it.
++</p>
++
++<p><i>[2013-01-17, Juan Soulie comments]</i></p>
++
++
++<p>This issue would also apply to every member function of <tt>basic_string</tt> that throws
++<tt>out_of_range</tt>, and to some cases where a <tt>length_error</tt> can be thrown.</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++While this could simply move to Ready on inspection, there is concern that this will not be the
++only such case. Alisdair volunteers to review clause 21/23 for more of such issues for Bristol,
++and update the proposed resolution as necessary.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Remove 21.4.5 [string.access] p5:</p>
++
++<blockquote><pre>
++const_reference at(size_type pos) const;
++reference at(size_type pos);
++</pre><blockquote>
++<p>
++<del>-5- <i>Requires</i>: <tt>pos &lt; size()</tt></del>
++<p/>
++-6- <i>Throws</i>: <tt>out_of_range</tt> if <tt>pos &gt;= size()</tt>.
++<p/>
++-7- <i>Returns</i>: <tt>operator[](pos)</tt>.
++</p>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2209"></a>2209. <tt>assign()</tt> overspecified for sequence containers</h3>
++<p><b>Section:</b> 23.3 [sequences] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-10-31 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequences">issues</a> in [sequences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++DR <a href="lwg-defects.html#704">704</a> ensures allocator-aware containers can reuse existing
++elements during copy/move assignment, and sequence containers can do
++the same for <tt>assign()</tt>.
++<p/>
++But apart from <tt>std::list</tt> (which was changed by DR <a href="lwg-defects.html#320">320</a>) the sequence
++containers define the Effects of <tt>assign()</tt> in terms of <tt>clear()</tt> followed
++by <tt>insert</tt>. A user-defined allocator can easily tell whether all old
++elements are cleared and then new elements inserted or whether existing elements are assigned
++to, so those Effects clauses cannot be ignored via the as-if rule.
++<p/>
++The descriptions of the <tt>assign()</tt> members for <tt>deque</tt>, <tt>forward_list</tt> and
++<tt>vector</tt> should be removed. Their intended effects are entirely described by the
++sequence container requirements table, and the specific definitions of them are worse than
++redundant, they're contradictory (if the operations are defined in terms of <tt>erase</tt> and
++<tt>insert</tt> then there's no need for elements to be assignable.) The descriptions of
++<tt>assign()</tt> for <tt>list</tt> are correct but redundant, so should be removed too.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3376.</p>
++
++<ol>
++<li><p>Edit 23.3.3.2 [deque.cons] to remove everything after paragraph 10:</p>
++
++<blockquote>
++<pre>
++<del>template &lt;class InputIterator&gt;
++void assign(InputIterator first, InputIterator last);</del>
++</pre>
++<blockquote>
++<p>
++<del>-11- <i>Effects</i>:</del>
++</p>
++<blockquote><pre>
++<del>erase(begin(), end());
++insert(begin(), first, last);</del>
++</pre></blockquote>
++</blockquote>
++
++<pre>
++<del>void assign(size_type n, const T&amp; t);</del>
++</pre>
++<blockquote>
++<p>
++<del>-12- <i>Effects</i>:</del>
++</p>
++<blockquote><pre>
++<del>erase(begin(), end());
++insert(begin(), n, t);</del>
++</pre></blockquote>
++</blockquote>
++</blockquote>
++
++</li>
++
++<li><p>Edit 23.3.4.2 [forwardlist.cons] to remove everything after paragraph 10:</p>
++
++<blockquote>
++<pre>
++<del>template &lt;class InputIterator&gt;
++void assign(InputIterator first, InputIterator last);</del>
++</pre>
++<blockquote>
++<p>
++<del>-11- <i>Effects</i>: <tt>clear(); insert_after(before_begin(), first, last);</tt></del>
++</p>
++</blockquote>
++
++<pre>
++<del>void assign(size_type n, const T&amp; t);</del>
++</pre>
++<blockquote>
++<p>
++<del>-12- <i>Effects</i>: <tt>clear(); insert_after(before_begin(), n, t);</tt></del>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++
++<li><p>Edit 23.3.5.2 [list.cons] to remove everything after paragraph 10:</p>
++
++<blockquote>
++<pre>
++<del>template &lt;class InputIterator&gt;
++void assign(InputIterator first, InputIterator last);</del>
++</pre>
++<blockquote>
++<p>
++<del>-11- <i>Effects</i>: Replaces the contents of the list with the range <tt>[first, last)</tt>.</del>
++</p>
++</blockquote>
++
++<pre>
++<del>void assign(size_type n, const T&amp; t);</del>
++</pre>
++<blockquote>
++<p>
++<del>-12- <i>Effects</i>: Replaces the contents of the list with <tt>n</tt> copies of <tt>t</tt>.</del>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++
++<li><p>Edit 23.3.6.2 [vector.cons] to remove everything after paragraph 10:</p>
++
++<blockquote>
++<pre>
++<del>template &lt;class InputIterator&gt;
++void assign(InputIterator first, InputIterator last);</del>
++</pre>
++<blockquote>
++<p>
++<del>-11- <i>Effects</i>:</del>
++</p>
++<blockquote><pre>
++<del>erase(begin(), end());
++insert(begin(), first, last);</del>
++</pre></blockquote>
++</blockquote>
++
++<pre>
++<del>void assign(size_type n, const T&amp; t);</del>
++</pre>
++<blockquote>
++<p>
++<del>-12- <i>Effects</i>:</del>
++</p>
++<blockquote><pre>
++<del>erase(begin(), end());
++insert(begin(), n, t);</del>
++</pre></blockquote>
++</blockquote>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2210"></a>2210. Missing allocator-extended constructor for allocator-aware containers</h3>
++<p><b>Section:</b> 23.3 [sequences], 23.4 [associative], 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequences">issues</a> in [sequences].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The <tt>forward_list(size_type)</tt> constructor has no allocator-extended
++equivalent, preventing the following code from compiling:
++</p>
++<blockquote><pre>
++#include &lt;forward_list&gt;
++#include &lt;vector&gt;
++#include &lt;scoped_allocator&gt;
++
++using namespace std;
++
++int main()
++{
++ using list = forward_list&lt;int&gt;;
++ vector&lt;list, scoped_allocator_adaptor&lt;list::allocator_type&gt;&gt; v;
++ v.emplace_back(1u);
++}
++</pre></blockquote>
++<p>
++The very same problem exists for all allocator-aware sequence containers.
++<p/>
++In addition it exists for associative containers. For example, it's possible to construct
++<tt>std::set&lt;int&gt;{0, 1, 2}</tt> but not <tt>std::set&lt;int&gt;{{0, 1, 2}, alloc}</tt>,
++and possible to construct <tt>std::set&lt;int&gt;{begin, end}</tt> but not
++<tt>std::set&lt;int&gt;{begin, end, alloc}</tt>.
++<p/>
++This makes the following program fail when <tt>SCOPED</tt> is defined:
++</p>
++<blockquote><pre>
++#include &lt;set&gt;
++#include &lt;vector&gt;
++#include &lt;scoped_allocator&gt;
++
++#if SCOPED
++using A = std::scoped_allocator_adaptor&lt;std::allocator&lt;int&gt;&gt;;
++#else
++using A = std::allocator&lt;int&gt;;
++#endif
++
++int main()
++{
++ int values[] = {0, 1, 2};
++ std::vector&lt;std::set&lt;int&gt;, A&gt; v;
++ v.emplace_back(std::begin(values), std::end(values));
++}
++</pre></blockquote>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++Jonathan: There are lots of places where this is missing.
++</p>
++<p>
++Howard: We should ping Pablo, this might be a deliberate design decision.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit the synopsis in 23.3.3.1 [deque.overview]/2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
++ class deque {
++ public:
++ [&hellip;]
++ explicit deque(const Allocator&amp; = Allocator());
++ explicit deque(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.3.2 [deque.cons]/2:</p>
++
++<blockquote>
++<pre>
++explicit deque(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: Constructs a <tt>deque</tt> with <tt>n</tt> default-inserted elements
++<ins>using the specified allocator</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit the synopsis in 23.3.4.1 [forwardlist.overview]/3:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
++ class forward_list {
++ public:
++ [&hellip;]
++ explicit forward_list(const Allocator&amp; = Allocator());
++ explicit forward_list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.4.2 [forwardlist.cons]/3:</p>
++
++<blockquote>
++<pre>
++explicit forward_list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: Constructs a <tt>forward_list</tt> object with <tt>n</tt> default-inserted elements
++<ins>using the specified allocator</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit the synopsis in 23.3.5.1 [list.overview]/2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
++ class list {
++ public:
++ [&hellip;]
++ explicit list(const Allocator&amp; = Allocator());
++ explicit list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.5.2 [list.cons]/3:</p>
++
++<blockquote>
++<pre>
++explicit list(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: Constructs a <tt>list</tt> with <tt>n</tt> default-inserted elements
++<ins>using the specified allocator</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit the synopsis in 23.3.6.1 [vector.overview]/2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
++ class vector {
++ public:
++ [&hellip;]
++ explicit vector(const Allocator&amp; = Allocator());
++ explicit vector(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.6.2 [vector.cons]/3:</p>
++
++<blockquote>
++<pre>
++explicit vector(size_type n<ins>, const Allocator&amp; = Allocator()</ins>);
++</pre>
++<blockquote>
++<p>
++-3- <i>Effects</i>: Constructs a <tt>vector</tt> with <tt>n</tt> default-inserted elements
++<ins>using the specified allocator</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit the synopsis in 23.3.7 [vector.bool]/1:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
++ class vector {
++ public:
++ [&hellip;]
++ explicit vector(const Allocator&amp; = Allocator());
++ <ins>explicit vector(size_type n, const Allocator&amp; = Allocator());</ins>
++ <del>explicit</del> vector(size_type n, const bool&amp; value<del> = bool()</del>,
++ const Allocator&amp; = Allocator());
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.4.4.1 [map.overview] p2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt; {
++ class map {
++ public:
++ [&hellip;]
++ map(initializer_list&lt;value_type&gt;,
++ const Compare&amp; = Compare(),
++ const Allocator&amp; = Allocator());
++ <ins>template &lt;class InputIterator&gt;
++ map(InputIterator first, InputIterator last, const Allocator&amp; a)
++ : map(first, last, Compare(), a) { }
++ map(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
++ : map(il, Compare(), a) { }</ins>
++ ~map();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.4.5.1 [multimap.overview] p2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt; {
++ class multimap {
++ public:
++ [&hellip;]
++ multimap(initializer_list&lt;value_type&gt;,
++ const Compare&amp; = Compare(),
++ const Allocator&amp; = Allocator());
++ <ins>template &lt;class InputIterator&gt;
++ multimap(InputIterator first, InputIterator last, const Allocator&amp; a)
++ : multimap(first, last, Compare(), a) { }
++ multimap(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
++ : multimap(il, Compare(), a) { }</ins>
++ ~multimap();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.4.6.1 [set.overview] p2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;Key&gt; &gt; {
++ class set {
++ public:
++ [&hellip;]
++ set(initializer_list&lt;value_type&gt;,
++ const Compare&amp; = Compare(),
++ const Allocator&amp; = Allocator());
++ <ins>template &lt;class InputIterator&gt;
++ set(InputIterator first, InputIterator last, const Allocator&amp; a)
++ : set(first, last, Compare(), a) { }
++ set(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
++ : set(il, Compare(), a) { }</ins>
++ ~set();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.4.7.1 [multiset.overview] p2:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class Compare = less&lt;Key&gt;,
++ class Allocator = allocator&lt;Key&gt; &gt; {
++ class multiset {
++ public:
++ [&hellip;]
++ multiset(initializer_list&lt;value_type&gt;,
++ const Compare&amp; = Compare(),
++ const Allocator&amp; = Allocator());
++ <ins>template &lt;class InputIterator&gt;
++ multiset(InputIterator first, InputIterator last, const Allocator&amp; a)
++ : multiset(first, last, Compare(), a) { }
++ multiset(initializer_list&lt;value_type&gt; il, const Allocator&amp; a)
++ : multiset(il, Compare(), a) { }</ins>
++ ~multiset();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.5.4.1 [unord.map.overview] p3:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt; {
++ class unordered_map {
++ public:
++ [&hellip;]
++ unordered_map(initializer_list&lt;value_type&gt;,
++ size_type = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++ <ins>unordered_map(size_type n, const allocator_type&amp; a)
++ : unordered_map(n, hasher(), key_equal(), a) { }
++ unordered_map(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
++ : unordered_map(n, hf, key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
++ : unordered_map(f, l, n, hasher(), key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_map(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_map(f, l, n, hf, key_equal(), a) { }
++ unordered_map(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
++ : unordered_map(il, n, hasher(), key_equal(), a) { }
++ unordered_map(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_map(il, n, hf, key_equal(), a) { }</ins>
++ ~unordered_map();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.5.5.1 [unord.multimap.overview] p3:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key, class T,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt; {
++ class unordered_multimap {
++ public:
++ [&hellip;]
++ unordered_multimap(initializer_list&lt;value_type&gt;,
++ size_type = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++ <ins>unordered_multimap(size_type n, const allocator_type&amp; a)
++ : unordered_multimap(n, hasher(), key_equal(), a) { }
++ unordered_multimap(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
++ : unordered_multimap(n, hf, key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
++ : unordered_multimap(f, l, n, hasher(), key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_multimap(f, l, n, hf, key_equal(), a) { }
++ unordered_multimap(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
++ : unordered_multimap(il, n, hasher(), key_equal(), a) { }
++ unordered_multimap(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_multimap(il, n, hf, key_equal(), a) { }</ins>
++ ~unordered_multimap();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.5.6.1 [unord.set.overview] p3:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;Key&gt; &gt; {
++ class unordered_set {
++ public:
++ [&hellip;]
++ unordered_set(initializer_list&lt;value_type&gt;,
++ size_type = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++ <ins>unordered_set(size_type n, const allocator_type&amp; a)
++ : unordered_set(n, hasher(), key_equal(), a) { }
++ unordered_set(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
++ : unordered_set(n, hf, key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
++ : unordered_set(f, l, n, hasher(), key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_set(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_set(f, l, n, hf, key_equal(), a) { }
++ unordered_set(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
++ : unordered_set(il, n, hasher(), key_equal(), a) { }
++ unordered_set(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_set(il, n, hf, key_equal(), a) { }</ins>
++ ~unordered_set();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Add to the synopsis in 23.5.7.1 [unord.multiset.overview] p3:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ template &lt;class Key,
++ class Hash = hash&lt;Key&gt;,
++ class Pred = std::equal_to&lt;Key&gt;,
++ class Allocator = std::allocator&lt;Key&gt; &gt; {
++ class unordered_multiset {
++ public:
++ [&hellip;]
++ unordered_multiset(initializer_list&lt;value_type&gt;,
++ size_type = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++ <ins>unordered_multiset(size_type n, const allocator_type&amp; a)
++ : unordered_multiset(n, hasher(), key_equal(), a) { }
++ unordered_multiset(size_type n, const hasher&amp; hf, const allocator_type&amp; a)
++ : unordered_multiset(n, hf, key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type&amp; a)
++ : unordered_multiset(f, l, n, hasher(), key_equal(), a) { }
++ template &lt;class InputIterator&gt;
++ unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_multiset(f, l, n, hf, key_equal(), a) { }
++ unordered_multiset(initializer_list&lt;value_type&gt; il, size_type n, const allocator_type&amp; a)
++ : unordered_multiset(il, n, hasher(), key_equal(), a) { }
++ unordered_multiset(initializer_list&lt;value_type&gt; il, size_type n, const hasher&amp; hf,
++ const allocator_type&amp; a)
++ : unordered_multiset(il, n, hf, key_equal(), a) { }</ins>
++ ~unordered_multiset();
++ [&hellip;]
++ };
++}
++</pre>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2211"></a>2211. Replace ambiguous use of "Allocator" in container requirements</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-11-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++23.2.1 [container.requirements.general]/7 says:
++</p>
++<blockquote><p>
++All other constructors for these container types take an <tt>Allocator&amp;</tt> argument
++(17.6.3.5 [allocator.requirements]), an allocator whose value type is the same as the
++container's value type.
++</p></blockquote>
++<p>
++This is a strange place to state the requirement on the allocator's
++<tt>value_type</tt>, because the allocator is a property (and template
++parameter) of the container type not of some of its constructors.
++It's also unclear whether "<tt>Allocator&amp;</tt>" refers to the concept (as
++implied by the cross-reference to the allocator requirements in Clause 17)
++or to the container's template parameter (as implied by the fact
++it's shown as an lvalue-reference type.) I believe the latter is
++intended, because those constructors can't take any model of the
++allocator concept, they can only take the container's <tt>allocator_type</tt>.
++<p/>
++I think it would be clearer to remove the value type requirement earlier
++in the paragraph (Table 99 already imposes that requirement) and to make it clear
++the constructor arguments are the container's <tt>allocator_type</tt>. There is
++already a cross-reference to the allocator requirements earlier in the paragraph,
++so it doesn't need to be repeated in another place where it causes confusion.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 23.2.1 [container.requirements.general] paragraph 7:</p>
++
++<blockquote>
++<p>
++Unless otherwise specified, all containers defined in this clause obtain memory using an allocator
++(see 17.6.3.5 [allocator.requirements]). Copy constructors for these container types obtain an
++allocator by calling <tt>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</tt>
++on their first parameters. Move constructors obtain an allocator by move construction from the allocator
++belonging to the container being moved. Such move construction of the allocator shall not exit via
++an exception. All other constructors for these container types take <del>an <tt>Allocator&amp;</tt> argument
++(17.6.3.5 [allocator.requirements]), an allocator whose value type is the same as the container's value
++type</del><ins>a <tt>const allocator_type&amp;</tt> argument</ins>. [<i>Note</i>: If an invocation of a
++constructor uses the default value of an optional allocator argument, then the <tt>Allocator</tt> type
++must support value initialization. &mdash; <i>end note</i>] A copy of this allocator is used for any
++memory allocation performed, by these constructors and by all member functions, during the lifetime of each
++container object or until the allocator is replaced. [&hellip;]
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2212"></a>2212. <tt>tuple_size</tt> for <tt>const pair</tt> request <tt>&lt;tuple&gt;</tt> header</h3>
++<p><b>Section:</b> 20.2 [utility] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Alisdair Meredith <b>Opened:</b> 2012-11-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#utility">active issues</a> in [utility].</p>
++<p><b>View all other</b> <a href="lwg-index.html#utility">issues</a> in [utility].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>&lt;utility&gt;</tt> header declares sufficient of the tuple API to specialize
++the necessary templates for <tt>pair</tt>, notably <tt>tuple_size</tt> and
++<tt>tuple_element</tt>. However, it does not make available the partial specializations
++that support cv-qualified template arguments, so while I can write the following after
++including only <tt>&lt;utility&gt;</tt>:
++</p>
++<blockquote><pre>
++#include &lt;utility&gt;
++
++using TestType = std::pair&lt;int, int&gt;;
++static_assert(2 == std::tuple_size&lt;TestType&gt;(), "Pairs have two elements");
++std::tuple_element&lt;0, TestType&gt;::type var{1};
++</pre></blockquote>
++<p>
++the following may fail to compile unless I also include <tt>&lt;tuple&gt;</tt>:
++</p>
++<blockquote><pre>
++#include &lt;utility&gt;
++
++using TestType = const std::pair&lt;int, int&gt;;
++static_assert(2 == std::tuple_size&lt;TestType&gt;(), "Pairs have two elements");
++std::tuple_element&lt;0, TestType&gt;::type var{1};
++</pre></blockquote>
++<p>
++Note, however, that the latter <em>may</em> compile with some standard library implementations
++but not others, leading to subtle portability issues.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Howard notes that we have the same issue with array, so any resolution should apply to that header too.
++</p>
++
++<p><i>[2013-10-18 Daniel provides wording]</i></p>
++
++
++<p>
++The suggested wording uses a similar approach as we already have in 24.7 [iterator.range] to
++ensure that the range access templates are available when at least one of an enumerated list of header files is
++included.
++<p/>
++I also think that the restricted focus on <tt>tuple_size</tt> of this issue is too narrow and should be extended to
++the similar partial template specializations of <tt>tuple_element</tt> as well. Therefore the suggested wording
++ensures this as well.
++</p>
++
++<p><i>[2014-03-27 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on eight votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.4.2.5 [tuple.helper] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class T&gt; class tuple_size&lt;const T&gt;;
++template &lt;class T&gt; class tuple_size&lt;volatile T&gt;;
++template &lt;class T&gt; class tuple_size&lt;const volatile T&gt;;
++</pre><blockquote>
++<p>
++-3- Let <tt><i>TS</i></tt> denote <tt>tuple_size&lt;T&gt;</tt> of the <i>cv</i>-unqualified type <tt>T</tt>. Then
++each of the three templates shall meet the <tt>UnaryTypeTrait</tt> requirements (20.10.1) with a <tt>BaseCharacteristic</tt> of
++</p>
++<blockquote><pre>
++integral_constant&lt;size_t, <i>TS</i>::value&gt;
++</pre></blockquote>
++<p>
++<ins>-?- In addition to being available via inclusion of the <tt>&lt;tuple&gt;</tt> header, each of the three templates are
++available when any of the headers <tt>&lt;array&gt;</tt> or <tt>&lt;utility&gt;</tt> are included.</ins>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++template &lt;size_t I, class T&gt; class tuple_element&lt;I, const T&gt;;
++template &lt;size_t I, class T&gt; class tuple_element&lt;I, volatile T&gt;;
++template &lt;size_t I, class T&gt; class tuple_element&lt;I, const volatile T&gt;;
++</pre><blockquote>
++<p>
++<ins>-?-</ins> Let <tt><i>TE</i></tt> denote <tt>tuple_element&lt;I, T&gt;</tt> of the <i>cv</i>-unqualified type <tt>T</tt>.
++Then each of the three templates shall meet the <tt>TransformationTrait</tt> requirements (20.10.1) with a member typedef
++<tt>type</tt> that names the following type:
++</p>
++<ul>
++<li><p>
++for the first specialization, <tt>add_const&lt;<i>TE</i>::type&gt;::type</tt>,
++</p></li>
++<li><p>
++for the second specialization, <tt>add_volatile&lt;<i>TE</i>::type&gt;::type</tt>, and
++</p></li>
++<li><p>
++for the third specialization, <tt>add_cv&lt;<i>TE</i>::type&gt;::type</tt>.
++</p></li>
++</ul>
++<p>
++<ins>-?- In addition to being available via inclusion of the <tt>&lt;tuple&gt;</tt> header, each of the three templates are
++available when any of the headers <tt>&lt;array&gt;</tt> or <tt>&lt;utility&gt;</tt> are included.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2213"></a>2213. Return value of <tt>std::regex_replace</tt></h3>
++<p><b>Section:</b> 28.11.4 [re.alg.replace] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Pete Becker <b>Opened:</b> 2012-11-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.alg.replace">issues</a> in [re.alg.replace].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 28.11.4 [re.alg.replace], the first two variants of <tt>std::regex_replace</tt> take an output iterator named
++"out" as their first argument. Paragraph 2 of that section says that the functions return "out". When I first implemented
++this, many years ago, I wrote it to return the value of the output iterator after all the insertions (cf. <tt>std::copy</tt>),
++which seems like the most useful behavior. But looking at the requirement now, it like the functions should return the
++original value of "out" (i.e. they have to keep a copy of the iterator for no reason except to return it). Is that
++really what was intended?
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 28.11.4 [re.alg.replace] as indicated:</p>
++<blockquote><pre>
++template &lt;class OutputIterator, class BidirectionalIterator,
++ class traits, class charT, class ST, class SA&gt;
++OutputIterator
++regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last,
++ const basic_regex&lt;charT, traits&gt;&amp; e, const basic_string&lt;charT, ST, SA&gt;&amp; fmt,
++ regex_constants::match_flag_type flags = regex_constants::match_default);
++template &lt;class OutputIterator, class BidirectionalIterator,
++ class traits, class charT&gt;
++OutputIterator
++regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last,
++ const basic_regex&lt;charT, traits&gt;&amp; e, const charT* fmt,
++ regex_constants::match_flag_type flags = regex_constants::match_default);
++</pre><blockquote>
++<p>
++-1- <i>Effects</i>: Constructs a <tt>regex_iterator</tt> object <tt>i</tt> as if by
++<tt>regex_iterator&lt;BidirectionalIterator, charT, traits&gt; i(first, last, e, flags)</tt>,
++and uses <tt>i</tt> to enumerate through all of the matches <tt>m</tt> of type
++<tt>match_results&lt;BidirectionalIterator&gt;</tt> that occur within the sequence <tt>[first, last)</tt>.
++If no such matches are found and <tt>!(flags &amp; regex_constants ::format_no_copy)</tt> then calls
++<tt><ins>out = </ins>std::copy(first, last, out)</tt>. If any matches are found then, for each such match, if
++<tt>!(flags &amp; regex_constants::format_no_copy)</tt>, calls <tt><ins>out = </ins>std::copy(m.prefix().first,
++m.prefix().second, out)</tt>, and then calls <tt><ins>out = </ins>m.format(out, fmt, flags)</tt>
++for the first form of the function and <tt><ins>out = </ins>m.format(out, fmt, fmt +
++char_traits&lt;charT&gt;::length(fmt), flags)</tt> for the second. Finally, if such a match is found
++and <tt>!(flags &amp; regex_constants ::format_no_copy)</tt>, calls
++<tt><ins>out = </ins>std::copy(last_m.suffix().first, last_m.suffix().second, out)</tt> where
++<tt>last_m</tt> is a copy of the last match found. If <tt>flags &amp; regex_constants::format_first_only</tt>
++is non-zero then only the first match found is replaced.
++<p/>
++-2- <i>Returns</i>: <tt>out</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2217"></a>2217. <tt>operator==(sub_match, string)</tt> slices on embedded <tt>'\0'</tt>s</h3>
++<p><b>Section:</b> 28.9.2 [re.submatch.op] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2012-11-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.submatch.op">issues</a> in [re.submatch.op].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator==(
++ const basic_string&lt;
++ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
++ const sub_match&lt;BiIter&gt;&amp; rhs);
++</pre></blockquote>
++<p>
++is specified as:
++</p>
++<blockquote><p>
++<i>Returns</i>: <tt>rhs.compare(lhs.c_str()) == 0</tt>.
++</p></blockquote>
++<p>
++This is odd because <tt>sub_match::compare(basic_string)</tt> is defined to
++honor embedded <tt>'\0'</tt> characters. This could allow a <tt>sub_match</tt> to <tt>==</tt> or
++<tt>!=</tt> a <tt>std::string</tt> unexpectedly.
++</p>
++
++<p><i>[Daniel:]</i></p>
++
++<p>
++This wording change was done intentionally as of LWG <a href="lwg-defects.html#1181">1181</a>, but the here mentioned slicing
++effect was not considered at that time. It seems best to use another overload of compare to fix this problem:
++</p>
++<blockquote><p>
++<i>Returns</i>: <tt>rhs.str().compare(0, rhs.length(), lhs.data(), lhs.size()) == 0</tt>.
++</p></blockquote>
++<p>
++or
++</p>
++<blockquote><p>
++<i>Returns</i>: <tt>rhs.compare(sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())) == 0</tt>.
++</p></blockquote>
++
++<p><i>[2013-10-17: Daniel provides concrete wording]</i></p>
++
++
++<p>
++The original wording was suggested to reduce the need to allocate memory during comparisons. The specification would be
++very much easier, if <tt>sub_match</tt> would provide an additional <tt>compare</tt> overload of the form:
++</p>
++<blockquote><pre>
++int compare(const value_type* s, size_t n) const;
++</pre></blockquote>
++<p>
++But given the fact that currently <em>all</em> of <tt>basic_string</tt>'s <tt>compare</tt> overloads are defined in terms
++of temporary string constructions, the following proposed wording does follow the same string-construction route as
++<tt>basic_string</tt> does (where needed to fix the embedded zeros issue) and to hope that existing implementations
++ignore to interpret this semantics in the literal sense.
++<p/>
++I decided to use the second replacement form
++</p>
++<blockquote><pre>
++<i>Returns</i>: <tt>rhs.compare(sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())) == 0</tt>.
++</pre></blockquote>
++<p>
++because it already reflects the existing style used in 28.9.2 [re.submatch.op] p31.
++</p>
++
++
++<p><i>[2014-02-15 post-Issaquah session : move to Tentatively Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 28.9.2 [re.submatch.op] as indicated:</p>
++
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator==(
++ const basic_string&lt;
++ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
++ const sub_match&lt;BiIter&gt;&amp; rhs);
++</pre><blockquote>
++<p>
++-7- <i>Returns:</i> <tt>rhs.compare(<del>lhs.c_str()</del><ins>typename sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())</ins>) == 0</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator&lt;(
++ const basic_string&lt;
++ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
++ const sub_match&lt;BiIter&gt;&amp; rhs);
++</pre><blockquote>
++<p>
++-9- <i>Returns:</i> <tt>rhs.compare(<del>lhs.c_str()</del><ins>typename sub_match&lt;BiIter&gt;::string_type(lhs.data(), lhs.size())</ins>) &gt; 0</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator==(const sub_match&lt;BiIter&gt;&amp; lhs,
++ const basic_string&lt;
++ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA>&amp; rhs);
++</pre><blockquote>
++<p>
++-13- <i>Returns:</i> <tt>lhs.compare(<del>rhs.c_str()</del><ins>typename sub_match&lt;BiIter&gt;::string_type(rhs.data(), rhs.size())</ins>) == 0</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++[&hellip;]
++</p>
++<blockquote><pre>
++template &lt;class BiIter, class ST, class SA&gt;
++ bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
++ const basic_string&lt;
++ typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA>&amp; rhs);
++</pre><blockquote>
++<p>
++-15- <i>Returns:</i> <tt>lhs.compare(<del>rhs.c_str()</del><ins>typename sub_match&lt;BiIter&gt;::string_type(rhs.data(), rhs.size())</ins>) &lt; 0</tt>.
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++</pre><blockquote>
++<p>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++</pre><blockquote>
++<p>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++</pre><blockquote>
++<p>
++</p>
++</blockquote></blockquote>
++
++<blockquote><pre>
++</pre><blockquote>
++<p>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2222"></a>2222. Inconsistency in description of <tt>forward_list::splice_after</tt> single-element overload</h3>
++<p><b>Section:</b> 23.3.4.6 [forwardlist.ops] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Edward Catmur <b>Opened:</b> 2012-12-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#forwardlist.ops">issues</a> in [forwardlist.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++23.3.4.6 [forwardlist.ops] p6 has
++</p>
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&amp; x, const_iterator i);
++void splice_after(const_iterator position, forward_list&amp;&amp; x, const_iterator i);
++</pre><p>
++<i>Effects</i>: Inserts the element following <tt>i</tt> into <tt>*this</tt>, following <tt>position</tt>,
++and removes it from <tt>x</tt>. The result is unchanged if <tt>position == i</tt> or <tt>position == ++i</tt>.
++Pointers and references to <tt>*i</tt> continue to refer to the same element but as a member of <tt>*this</tt>.
++Iterators to <tt>*i</tt> (including <tt>i</tt> itself) continue to refer to the same element, but now behave
++as iterators into <tt>*this</tt>, not into <tt>x</tt>.
++</p>
++</blockquote>
++<p>
++This overload splices the element <em>following</em> <tt>i</tt> from <tt>x</tt> to <tt>*this</tt>, so the
++language in the two latter sentences should refer to <tt>++i</tt>:
++</p>
++<blockquote><p>
++Pointers and references to <tt>*++i</tt> continue to refer to the same element but as a member of
++<tt>*this</tt>. Iterators to <tt>*++i</tt> continue to refer to the same element, but now behave as iterators
++into <tt>*this</tt>, not into <tt>x</tt>.
++</p></blockquote>
++<p>
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 23.3.4.6 [forwardlist.ops] p6 as indicated:</p>
++<blockquote><pre>
++void splice_after(const_iterator position, forward_list&amp; x, const_iterator i);
++void splice_after(const_iterator position, forward_list&amp;&amp; x, const_iterator i);
++</pre>
++<p>
++-5- <i>Requires</i>: <tt>position</tt> is <tt>before_begin()</tt> or is a dereferenceable iterator
++in the range <tt>[begin(),end())</tt>. The iterator following <tt>i</tt> is a dereferenceable iterator
++in <tt>x</tt>. <tt>get_allocator() == x.get_allocator()</tt>.
++<p/>
++-6- <i>Effects</i>: Inserts the element following <tt>i</tt> into <tt>*this</tt>, following <tt>position</tt>,
++and removes it from <tt>x</tt>. The result is unchanged if <tt>position == i</tt> or <tt>position == ++i</tt>.
++Pointers and references to <tt>*<ins>++</ins>i</tt> continue to refer to the same element but as a member of
++<tt>*this</tt>. Iterators to <tt>*<ins>++</ins>i</tt> <del>(including <tt>i</tt> itself)</del> continue to
++refer to the same element, but now behave as iterators into <tt>*this</tt>, not into <tt>x</tt>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2225"></a>2225. Unrealistic header inclusion checks required</h3>
++<p><b>Section:</b> 17.6.2.2 [using.headers] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2012-12-18 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#using.headers">issues</a> in [using.headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++17.6.2.2 [using.headers]/3 says:
++<p/>
++A translation unit shall include a header only outside of any external declaration or definition, and shall
++include the header lexically before the first reference in that translation unit to any of the entities
++declared in that header.
++<p/>
++Per 1.4 [intro.compliance]/1, programs which violate this rule are ill-formed, and a conforming
++implementation is required to produce a diagnostic. This does not seem to match reality. Presumably, this
++paragraph is missing a "no diagnostic is required".
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Edit 17.6.2.2 [using.headers] p3 as indicated:</p>
++<p>-3- A translation unit shall include a header only outside of any external declaration or definition, and shall
++include the header lexically before the first reference in that translation unit to any of the entities declared
++in that header. <ins>No diagnostic is required.</ins></p>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2228"></a>2228. Missing <em>SFINAE</em> rule in <tt>unique_ptr</tt> templated assignment</h3>
++<p><b>Section:</b> 20.8.1.2.3 [unique.ptr.single.asgn] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Geoffrey Romer <b>Opened:</b> 2012-12-20 <b>Last modified:</b> 2015-05-06</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.asgn">issues</a> in [unique.ptr.single.asgn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++20.8.1.2.3 [unique.ptr.single.asgn]/5 permits <tt>unique_ptr</tt>'s templated assignment operator to participate
++in overload resolution even when incompatibilities between <tt>D</tt> and <tt>E</tt> will render the result ill-formed,
++but the corresponding templated copy constructor is removed from the overload set in those situations (see the third
++bullet point of 20.8.1.2.1 [unique.ptr.single.ctor]/19). This asymmetry is confusing, and presumably unintended;
++it may lead to situations where constructing one <tt>unique_ptr</tt> from another is well-formed, but assigning from
++the same <tt>unique_ptr</tt> would be ill-formed.
++<p/>
++There is a slight coupling between this and LWG <a href="lwg-defects.html#2118">2118</a>, in that my PR for LWG <a href="lwg-defects.html#2118">2118</a> incorporates
++equivalent wording in the specification of the templated assignment operator for the array specialization; the two PRs
++are logically independent, but if my PR for <a href="lwg-defects.html#2118">2118</a> is accepted but the above PR is not, the discrepancy
++between the base template and the specialization could be confusing.
++</p>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3485.</p>
++<ol>
++<li><p>Revise 20.8.1.2.3 [unique.ptr.single.asgn] p5 as follows:</p>
++
++<blockquote><pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;
++</pre><blockquote>
++<p>
++-4- <i>Requires</i>: If <tt>E</tt> is not a reference type, assignment of the deleter from an rvalue of type <tt>E</tt>
++shall be well-formed and shall not throw an exception. Otherwise, <tt>E</tt> is a reference type and assignment of the
++deleter from an lvalue of type <tt>E</tt> shall be well-formed and shall not throw an exception.
++<p/>
++-5- <i>Remarks</i>: This operator shall not participate in overload resolution unless:
++</p>
++<ul>
++<li><p><tt>unique_ptr&lt;U, E&gt;::pointer</tt> is implicitly convertible to <tt>pointer</tt> and</p></li>
++<li><p><tt>U</tt> is not an array type<del>.</del><ins>, and</ins></p></li>
++<li><p><ins>either <tt>D</tt> is a reference type and <tt>E</tt> is the same type as <tt>D</tt>, or <tt>D</tt> is
++not a reference type and <tt>E</tt> is implicitly convertible to <tt>D</tt>.</ins></p></li>
++</ul>
++<p>
++-6- <i>Effects</i>: Transfers ownership from <tt>u</tt> to <tt>*this</tt> as if by calling <tt>reset(u.release())</tt>
++followed by an assignment from <tt>std::forward&lt;E&gt;(u.get_deleter())</tt>.
++<p/>
++-7- <i>Returns</i>: <tt>*this</tt>.
++</p>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++The wording looks good, but we want a little more time than the telecon permits to be truly comfortable.
++We expect this issue to resolve fairly easily in Bristol.
++</p>
++
++<p><i>[2015-05-18, Howard comments]</i></p>
++
++<p>
++Updated proposed wording has been provided in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366.html">N4366</a>.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++Straw poll: send <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366.html">N4366</a> to full committee,
++with both fixes from the sections "What is the correct fix?" and "<tt>unique_ptr&lt;T[]&gt;</tt> needs the correct fix too"
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Resolved by accepting <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366.html">N4366</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2229"></a>2229. Standard code conversion facets underspecified</h3>
++<p><b>Section:</b> 22.5 [locale.stdcvt] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Beman Dawes <b>Opened:</b> 2012-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>The only specification for the non-inherited members of classes <tt>codecvt_utf8</tt>,
++<tt>codecvt_utf16</tt>, and <tt>codecvt_utf8_utf16</tt> is a comment line in the synopsis
++that says <i><tt>// unspecified</tt></i>. There is no further indication of functionality,
++so a user does not know if one of these classes can be constructed or destroyed.</p>
++
++<p>The proposed resolution adds a constructor that mimics the class <tt>codecvt</tt>
++constructor, and also adds a destructor. Following the practice of class <tt>codecvt</tt>,
++the semantics are not specified.</p>
++
++<p>The only existing implementation I could find was libc++, and it does supply the
++proposed constructor and destructor for each of the three classes.</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++There was concern about the unspecified semantics - but that matches what is done in <tt>codecvt</tt>.
++</p>
++<p>
++Jonathan: Should these constructor/destructors be public? Proposed wording is private.
++Base class constructor is public.
++</p>
++<p>
++Howard noted that other facets do not have specified constructors.
++</p>
++<p>
++Alisdair noted that this whole section was new in C++11.
++</p>
++<p>
++Howard suggested looking at section 22.3.1.1.2 [locale.facet]p2/p3 for more info.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p><i>In [locale.stdcvt] paragraph 2, Header codecvt synopsis:</i></p>
++<blockquote>
++ <pre>template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
++ codecvt_mode Mode = (codecvt_mode)0&gt;
++class codecvt_utf8
++ : public codecvt&lt;Elem, char, mbstate_t&gt; {
++ <del><i>// unspecified</i></del>
++<ins>public:</ins>
++ <ins>explicit codecvt_utf8(size_t refs = 0);</ins>
++ <ins>~codecvt_utf8();</ins>
++ };
++
++template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
++ codecvt_mode Mode = (codecvt_mode)0&gt;
++class codecvt_utf16
++ : public codecvt&lt;Elem, char, mbstate_t&gt; {
++ <del><i>// unspecified</i></del>
++<ins>public:</ins>
++ <ins>explicit codecvt_utf16(size_t refs = 0);</ins>
++ <ins>~codecvt_utf16();</ins>
++ };
++
++template&lt;class Elem, unsigned long Maxcode = 0x10ffff,
++ codecvt_mode Mode = (codecvt_mode)0&gt;
++class codecvt_utf8_utf16
++ : public codecvt&lt;Elem, char, mbstate_t&gt; {
++ <del><i>// unspecified</i></del>
++<ins>public:</ins>
++ <ins>explicit codecvt_utf8_utf16(size_t refs = 0);</ins>
++ <ins>~codecvt_utf8_utf16();</ins>
++ };</pre>
++</blockquote>
++
++
++
++
++
++<hr>
++<h3><a name="2230"></a>2230. &quot;<em>see below</em>&quot; for initializer-list constructors of unordered containers</h3>
++<p><b>Section:</b> 23.5 [unord] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-01-06 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord">issues</a> in [unord].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <tt>unordered_map</tt> class definition in 23.5.4.1 [unord.map.overview] declares an
++initializer-list constructor that says "see below":
++</p>
++
++<blockquote><pre>
++unordered_map(initializer_list&lt;value_type&gt;,
++ size_type = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++</pre></blockquote>
++
++<p>
++But that constructor isn't defined below. The same problem exists for the other unordered associative containers.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++STL: ordered are also missing declarations, but issue is forthcoming
++<p/>
++Walter: how does adding a signature address issue? &mdash; nevermind
++<p/>
++Jayson: in his wording, isn't he just dropping the <tt>size_type</tt>?
++<p/>
++Walter: partial fix is to introduce the name
++<p/>
++Stefanus: explanation of requiring name because of n buckets
++<p/>
++STL: solution for his issue satisfies both ordered and unordered and is simplier than provided wording
++<p/>
++STL: patches general table instead
++<p/>
++STL: proposes adding extra rows instead of extra declarations
++<p/>
++Stefanus: clarify <tt>n</tt> in the synopsis
++<p/>
++Walter: general rule, name is optional in declaration
++<p/>
++Stefanus: how to proceed
++<p/>
++Walter: significant overlap with forthcoming issue, suggestion to defer
++</p>
++
++<p><i>[2014-02-20 Re-open Deferred issues as Priority 4]</i></p>
++
++
++<p><i>[2014-03-27 Jonathan improves proposed wording]</i></p>
++
++
++<p><i>[2014-05-20 STL and Jonathan communicate]</i></p>
++
++
++<p>
++STL: With <a href="lwg-defects.html#2322">2322</a> resolved, is there anything left for this issue to fix?
++<p/>
++Jonathan: The synopsis still says "<em>see below</em>" and it's not immediately clear
++that "<em>see below</em>" means "see the definition of a different constructor,
++which defines the behaviour of this one due to a table defined much earlier".
++</p>
++
++<p><i>[2014-05-23 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on five votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 23.5.4.1 [unord.map.overview], class template <tt>unordered_map</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++[&hellip;]
++unordered_map(initializer_list&lt;value_type&gt; <ins>il</ins>,
++ size_type <ins>n</ins> = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Edit 23.5.4.2 [unord.map.cnstr] as follows:</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_map(InputIterator f, InputIterator l,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++<ins>unordered_map(initializer_list&lt;value_type&gt; il,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());</ins>
++</pre><blockquote>
++<p>
++-3- <i>Effects</i>: Constructs an empty <tt>unordered_map</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++implementation-defined. Then inserts elements from the range <tt>[f, l)</tt> <ins>for the first form, or from the range
++<tt>[il.begin(), il.end())</tt> for the second form</ins>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.5.5.1 [unord.multimap.overview], class template <tt>unordered_multimap</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++[&hellip;]
++unordered_multimap(initializer_list&lt;value_type&gt; <ins>il</ins>,
++ size_type <ins>n</ins> = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Edit 23.5.5.2 [unord.multimap.cnstr] as follows:</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_multimap(InputIterator f, InputIterator l,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++<ins>unordered_multimap(initializer_list&lt;value_type&gt; il,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());</ins>
++</pre><blockquote>
++<p>
++-3- <i>Effects</i>: Constructs an empty <tt>unordered_multimap</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++implementation-defined. Then inserts elements from the range <tt>[f, l)</tt> <ins>for the first form, or from the range
++<tt>[il.begin(), il.end())</tt> for the second form</ins>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.5.6.1 [unord.set.overview], class template <tt>unordered_set</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++[&hellip;]
++unordered_set(initializer_list&lt;value_type&gt; <ins>il</ins>,
++ size_type <ins>n</ins> = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Edit 23.5.6.2 [unord.set.cnstr] as follows:</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_set(InputIterator f, InputIterator l,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++<ins>unordered_set(initializer_list&lt;value_type&gt; il,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());</ins>
++</pre><blockquote>
++<p>
++-3- <i>Effects</i>: Constructs an empty <tt>unordered_set</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++implementation-defined. Then inserts elements from the range <tt>[f, l)</tt> <ins>for the first form, or from the range
++<tt>[il.begin(), il.end())</tt> for the second form</ins>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.5.7.1 [unord.multiset.overview], class template <tt>unordered_multiset</tt> synopsis, as follows:</p>
++
++<blockquote><pre>
++[&hellip;]
++unordered_multiset(initializer_list&lt;value_type&gt; <ins>il</ins>,
++ size_type <ins>n</ins> = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Edit 23.5.7.2 [unord.multiset.cnstr] as follows:</p>
++<blockquote><pre>
++template &lt;class InputIterator&gt;
++unordered_multiset(InputIterator f, InputIterator l,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());
++<ins>unordered_multiset(initializer_list&lt;value_type&gt; il,
++ size_type n = <em>see below</em>,
++ const hasher&amp; hf = hasher(),
++ const key_equal&amp; eql = key_equal(),
++ const allocator_type&amp; a = allocator_type());</ins>
++</pre><blockquote>
++<p>
++-3- <i>Effects</i>: Constructs an empty <tt>unordered_multiset</tt> using the specified hash function, key equality function,
++and allocator, and using at least <tt>n</tt> buckets. If <tt>n</tt> is not provided, the number of buckets is
++implementation-defined. Then inserts elements from the range <tt>[f, l)</tt> <ins>for the first form, or from the range
++<tt>[il.begin(), il.end())</tt> for the second form</ins>. <tt>max_load_factor()</tt> returns <tt>1.0</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2231"></a>2231. DR 704 removes complexity guarantee for <tt>clear()</tt></h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2012-12-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++From the question at <a href="http://stackoverflow.com/q/14094408/981959">stackoverflow</a>.
++</p>
++
++<p>
++Were we aware that the resolution to LWG <a href="lwg-defects.html#704">704</a> means there is no complexity guarantee for
++<tt>clear()</tt> on most sequence containers? Previously it was implied by defining it in terms of
++<tt>erase(begin(), end())</tt> but we no longer do that.
++</p>
++
++<p>
++There are explicit complexity requirements for <tt>std::list::clear()</tt>, but not the other sequence containers.
++</p>
++
++<p>Daniel:</p>
++
++<p>
++The idea was that the notion of "destroys all elements in <tt>a</tt>" would imply a linear complexity, but the wording
++needs to be clearer, because this doesn't say that this step is the actual complexity bound.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Tentatively Ready.
++</p>
++
++<p><i>[2013-04-20 Bristol]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Change Table 100 as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 100 &mdash; Sequence container requirements (in addition to container) (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.clear()</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++Destroys all elements in <tt>a</tt>. Invalidates all<br/>
++references, pointers, and iterators referring to<br/>
++the elements of <tt>a</tt> and may invalidate the<br/>
++past-the-end iterator.<br/>
++post: <tt>a.empty()</tt> returns <tt>true</tt><br/>
++<ins>complexity: linear</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2233"></a>2233. <tt>bad_function_call::what()</tt> unhelpful</h3>
++<p><b>Section:</b> 20.9.12.1 [func.wrap.badcall] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-01-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++A strict reading of the standard implies <tt>std::bad_function_call{}.what()</tt> returns the same string as
++<tt>std::exception{}.what()</tt> which doesn't help to know what happened if you catch an exception by reference
++to <tt>std::exception</tt>.
++</p>
++
++<p>
++For consistency with <tt>bad_weak_ptr::what()</tt> it should return <tt>"bad_function_call"</tt>.
++</p>
++
++<p>
++See <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=33515">c++std-lib-33515</a> for other details.
++</p>
++
++<p>
++There was a considerable support on the reflector to instead change the specification of both <tt>bad_weak_ptr::what()</tt>
++and <tt>bad_function_call::what()</tt> to return an implementation-defined string instead.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Open.
++</p>
++<p>
++Consensus that we want consistency in how this is treated. Less consensus on what the common
++direction should be.
++</p>
++<p>
++Alisdair to provide wording proposing that all string literals held by standard exception objects are
++either unspecified, or implmentation defined.
++</p>
++
++<p><i>[2014-02-15 Issauqah]</i></p>
++
++<p>
++STL: I think it should be an implementation-defined NTBS, same on <tt>bad_weak_ptr</tt>. I will write a PR.
++</p>
++
++<p><i>[2014-03-27, STL provides improved wording]</i></p>
++
++
++<p>
++The new wording reflects better the general agreement of the committee, see also issue <a href="lwg-defects.html#2376">2376</a> for similar wording.
++</p>
++
++<p><i>[2014-03-28 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on five votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 20.9.12.1.1 [func.wrap.badcall.const]:</p>
++<blockquote><pre>
++bad_function_call() noexcept;
++</pre><blockquote>
++<p>
++-1- <i>Effects</i>: constructs a <tt>bad_function_call object</tt>.
++<p/>
++<ins>-?- <i>Postconditions</i>: <tt>what()</tt> returns an implementation-defined NTBS.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2235"></a>2235. Undefined behavior without proper requirements on <tt>basic_string</tt> constructors</h3>
++<p><b>Section:</b> 21.4.2 [string.cons] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-01-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.cons">issues</a> in [string.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 21.4.2 [string.cons], I believe tighter requirements should be imposed on <tt>basic_string</tt>'s constructors
++taking an <tt>s</tt> argument (or, a behavior should be provided for the undefined cases).
++These requirements are properly stated in the other members functions taking <tt>s</tt> arguments (<tt>append</tt>,
++<tt>assign</tt>, <tt>insert</tt>,...).
++</p>
++
++<blockquote><pre>
++basic_string(const charT* s, size_type n, const Allocator&amp; a = Allocator());
++</pre></blockquote>
++
++<p>
++Relative to N3485, 21.4.2 [string.cons]/6 says "Requires: <tt>s</tt> shall not be a null pointer and <tt>n &lt; npos</tt>",
++where it should say: "Requires: <tt>s</tt> points to an array of at least <tt>n</tt> elements of <tt>charT</tt>"
++</p>
++
++<blockquote><pre>
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++</pre></blockquote>
++
++<p>
++21.4.2 [string.cons]/8 says "Requires: <tt>s</tt> shall not be a null pointer.", where it should say:
++"Requires: <tt>s</tt> points to an array of at least <tt>traits::length(s) + 1</tt> elements of <tt>charT</tt>"
++</p>
++
++<p>Daniel:</p>
++<p>
++I think that 17.6.4.9 [res.on.arguments] p1 b2 basically requires this already, but the wording is indeed worth
++improving it.
++</p>
++
++<p><i>[2013-03-15 Issues Teleconference]</i></p>
++
++<p>
++Moved to Review.
++</p>
++<p>
++The resolution could be worded more cleanly, and there is some concern about redundancy between
++<i>Requirements</i> and <i>Effects</i> clauses. Consensus that we do want to say something like
++this for the <i>Requirements</i> though.
++</p>
++
++<p><i>[2013-04-18, Bristol]</i></p>
++
++
++<p>Move to Ready</p>
++
++<p><i>[2013-09-29, Bristol]</i></p>
++
++
++<p>Apply to the Working Paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li><p>Change 21.4.2 [string.cons]/6 as indicated:</p>
++
++<blockquote><pre>
++basic_string(const charT* s, size_type n, const Allocator&amp; a = Allocator());
++</pre><blockquote>
++<p>
++-6- <i>Requires</i>: <tt>s</tt> <del>shall not be a null pointer and <tt>n &lt; npos</tt></del><ins>points to an array
++of at least <tt>n</tt> elements of <tt>charT</tt></ins>.
++</p>
++</blockquote></blockquote>
++
++</li>
++
++<li><p>Change 21.4.2 [string.cons]/8 as indicated:</p>
++
++<blockquote><pre>
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++</pre><blockquote>
++<p>
++-8- <i>Requires</i>: <tt>s</tt> <del>shall not be a null pointer</del><ins>points to an array
++of at least <tt>traits::length(s) + 1</tt> elements of <tt>charT</tt></ins>.
++</p>
++</blockquote></blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2239"></a>2239. <tt>min/max/minmax</tt> requirements</h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-01-26 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++25.4.7 [alg.min.max] requires type <tt>T</tt> in <tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt> to be
++<tt>LessThanComparable</tt>, but I don't believe this should be required for the versions that take a <tt>Compare</tt>
++argument.
++<p/>
++Paragraphs 1 to 4 of 25.4 [alg.sorting] should apply anyway, although I'm not sure about <tt>Compare</tt>
++being required to induce a strict weak ordering here.
++<p/>
++Further, <tt>min</tt> and <tt>max</tt> also lack formal complexity guarantees.
++</p>
++
++<p><i>[2014-06-07 Daniel comments and provides wording]</i></p>
++
++
++<p>
++Certainly, the functions with <tt>Compare</tt> should not impose <tt>LessThanComparable</tt> requirements.
++<p/>
++In regard to the question whether a strict weak ordering should be required as implied by the <tt>Compare</tt>
++requirements, I would like to point out that this is requirement is in fact needed, because the specification of
++the normative <i>Remarks</i> elements (e.g. "Returns the first argument when the arguments are equivalent.") do depend
++on the existence of a <em>equivalence relation</em> that can be relied on and this is also consistent with the same
++strict weak ordering requirement that is indirectly imposed by the <tt>LessThanComparable</tt> requirement set for
++functions referring to <tt>operator&lt;</tt> (Let me note that the very same <tt>StrictWeakOrder</tt> language
++concept had intentionally been required for similar reasons during "concept-time" in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf">N2914</a>).
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++JY: We have library-wide requirements that <tt>Comp</tt> induce a strict weak ordering.
++<p/>
++JY/MC: The un-marked-up "Complexity" (p16) is wrong. DK: I'll fix that.
++<p/>
++DK will update the wording for Lenexa.
++</p>
++
++<p><i>[2015-03-30 Daniel comments]</i></p>
++
++<p>
++The Complexity element of p16 is correct, but some others involving <tt>initializer_list</tt> arguments are wrong.
++</p>
++
++<p><i>[2015-04-02 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 25.4.7 [alg.min.max] as indicated:
++</p>
++
++<blockquote>
++<pre>
++template&lt;class T&gt; constexpr const T&amp; min(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++ constexpr const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
++</pre>
++<blockquote>
++<p>
++-1- <i>Requires</i>: <ins>For the first form, type <tt>T</tt> shall be</ins><del>Type <tt>T</tt> is</del> <tt>LessThanComparable</tt>
++(Table 18).
++<p/>
++-2- <i>Returns</i>: The smaller value.
++<p/>
++-3- <i>Remarks</i>: Returns the first argument when the arguments are equivalent.
++<p/>
++<ins>-?- <i>Complexity</i>: Exactly one comparison.</ins>
++</p>
++</blockquote>
++
++<pre>
++template&lt;class T&gt;
++ constexpr T min(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare&gt;
++ constexpr T min(initializer_list&lt;T&gt; t, Compare comp);
++</pre>
++<blockquote>
++<p>
++-4- <i>Requires</i>: <tt>T</tt> <del>is <tt>LessThanComparable</tt> and</del><ins>shall be</ins> <tt>CopyConstructible</tt> and
++<tt>t.size() &gt; 0</tt>. <ins>For the first form, type <tt>T</tt> shall be <tt>LessThanComparable</tt>.</ins>
++<p/>
++-5- <i>Returns</i>: [&hellip;]
++<p/>
++-6- <i>Remarks</i>: [&hellip;]
++<p/>
++<ins>-?- <i>Complexity</i>: Exactly <tt>t.size() - 1</tt> comparisons.</ins>
++</p>
++</blockquote>
++
++<pre>
++template&lt;class T&gt; constexpr const T&amp; max(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++ constexpr const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);
++</pre>
++<blockquote>
++<p>
++-7- <i>Requires</i>: <ins>For the first form, type <tt>T</tt> shall be</ins><del>Type <tt>T</tt> is</del> <tt>LessThanComparable</tt>
++(Table 18).
++<p/>
++-8- <i>Returns</i>: [&hellip;]
++<p/>
++-9- <i>Remarks</i>: [&hellip;]
++<p/>
++<ins>-?- <i>Complexity</i>: Exactly one comparison.</ins>
++</p>
++</blockquote>
++
++<pre>
++template&lt;class T&gt;
++ constexpr T max(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare&gt;
++ constexpr T max(initializer_list&lt;T&gt; t, Compare comp);
++</pre>
++<blockquote>
++<p>
++-10- <i>Requires</i>: <tt>T</tt> <del>is <tt>LessThanComparable</tt> and</del><ins>shall be</ins> <tt>CopyConstructible</tt> and
++<tt>t.size() &gt; 0</tt>. <ins>For the first form, type <tt>T</tt> shall be <tt>LessThanComparable</tt>.</ins>
++<p/>
++-11- <i>Returns</i>: [&hellip;]
++<p/>
++-12- <i>Remarks</i>: [&hellip;]
++<p/>
++<ins>-?- <i>Complexity</i>: Exactly <tt>t.size() - 1</tt> comparisons.</ins>
++</p>
++</blockquote>
++
++<pre>
++template&lt;class T&gt; constexpr pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++ constexpr pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b, Compare comp);
++</pre>
++<blockquote>
++<p>
++-13- <i>Requires</i>: <ins>For the first form, t</ins><del>T</del>ype <tt>T</tt> shall be <tt>LessThanComparable</tt>
++(Table 18).
++<p/>
++-14- <i>Returns</i>: [&hellip;]
++<p/>
++-15- <i>Remarks</i>: [&hellip;]
++<p/>
++-16- <i>Complexity</i>: Exactly one comparison.
++</p>
++</blockquote>
++
++<pre>
++template&lt;class T&gt;
++ constexpr pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare&gt;
++ constexpr pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t, Compare comp);
++</pre>
++<blockquote>
++<p>
++-17- <i>Requires</i>: <tt>T</tt> <del>is <tt>LessThanComparable</tt> and</del><ins>shall be</ins> <tt>CopyConstructible</tt> and
++<tt>t.size() &gt; 0</tt>. <ins>For the first form, type <tt>T</tt> shall be <tt>LessThanComparable</tt>.</ins>
++<p/>
++-18- <i>Returns</i>: [&hellip;]
++<p/>
++-19- <i>Remarks</i>: [&hellip;]
++<p/>
++-20- <i>Complexity</i>: At most <tt>(3/2) * t.size()</tt> applications of the corresponding predicate.
++</p>
++</blockquote>
++
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2240"></a>2240. Probable misuse of term "function scope" in [thread.condition]</h3>
++<p><b>Section:</b> 30.5.1 [thread.condition.condvar], 30.5.2 [thread.condition.condvarany] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> FrankHB1989 <b>Opened:</b> 2013-02-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.condition.condvar">issues</a> in [thread.condition.condvar].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++All usages of "function scope" in 30.5.1 [thread.condition.condvar] and 30.5.2 [thread.condition.condvarany],
++such as 30.5.1 [thread.condition.condvar] p10 b4:
++</p>
++
++<blockquote><p>
++If the function exits via an exception, lock.lock() shall be called prior to exiting the <strong>function scope</strong>.
++</p></blockquote>
++
++<p>
++seem to be inappropriate compared to the actual core language definition of 3.3.5 [basic.funscope]:
++</p>
++
++<blockquote><p>
++Labels (6.1) have function scope and may be used anywhere in the function in which they are declared. <strong>Only
++labels have function scope</strong>.
++</p></blockquote>
++
++<p>
++Probably the intended meaning is "outermost block scope of the function".
++</p>
++
++<p><i>[2013-09 Chicago: Resolved by proposed resolution of LWG <a href="lwg-defects.html#2135">2135</a>]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>
++Resolved by proposed resolution of LWG <a href="lwg-defects.html#2135">2135</a>.
++</p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2246"></a>2246. <tt>unique_ptr</tt> assignment effects w.r.t. deleter</h3>
++<p><b>Section:</b> 20.8.1.2.3 [unique.ptr.single.asgn] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-03-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single.asgn">issues</a> in [unique.ptr.single.asgn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++The Effects clauses for <tt>unique_ptr</tt> assignment don't make sense, what
++is the target of "an assignment from <tt>std::forward&lt;D&gt;(u.get_deleter())</tt>"?
++<p/>
++Obviously it's intended to be the deleter, but that isn't stated clearly.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Move to Ready</p>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++<p>Apply to Working Paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li>
++<p>
++Edit 20.8.1.2.3 [unique.ptr.single.asgn] paragraph 2:
++</p>
++<blockquote><pre>
++unique_ptr&amp; operator=(unique_ptr&amp;&amp; u) noexcept;
++</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-2- <i>Effects</i>: Transfers ownership from <tt>u</tt> to <tt>*this</tt> as if by calling
++<tt>reset(u.release())</tt> followed by <del>an assignment from</del><tt><ins>get_deleter() = </ins>std::forward&lt;D&gt;(u.get_deleter())</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li>
++<p>
++Edit 20.8.1.2.3 [unique.ptr.single.asgn] paragraph 6:
++</p>
++<blockquote><pre>
++template &lt;class U, class E&gt; unique_ptr&amp; operator=(unique_ptr&lt;U, E&gt;&amp;&amp; u) noexcept;
++</pre>
++<blockquote><p>
++[&hellip;]
++<p/>
++-6- <i>Effects</i>: Transfers ownership from <tt>u</tt> to <tt>*this</tt> as if by calling
++<tt>reset(u.release())</tt> followed by <del>an assignment from</del><tt><ins>get_deleter() = </ins>std::forward&lt;E&gt;(u.get_deleter())</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2247"></a>2247. Type traits and <tt>std::nullptr_t</tt></h3>
++<p><b>Section:</b> 20.10.4.1 [meta.unary.cat] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2013-03-15 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to 20.10.4.1 [meta.unary.cat], for every type <tt>T</tt>, exactly one of the primary type traits is true.
++So which is true for the type <tt>std::nullptr_t</tt>? By 2.13.7 [lex.nullptr] <tt>std::nullptr_t</tt> is not a
++pointer type or a pointer-to-member type, so <tt>is_pointer</tt>, <tt>is_member_object_pointer</tt> and
++<tt>is_member_function_pointer</tt> can't be true for <tt>std::nullptr_t</tt>, and none of the other primary type traits
++seem to apply.
++</p>
++
++<p><i>[2013-04-20, Bristol]</i></p>
++
++<p>Rename to <tt>is_null_pointer</tt>, move to Ready</p>
++
++<p>Previous wording:</p>
++
++<blockquote class="note">
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li>
++<p>
++Edit 20.10.2 [meta.type.synop], header <tt>&lt;type_traits&gt;</tt> synopsis:
++</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ // 20.9.4.1, primary type categories:
++ template &lt;class T&gt; struct is_void;
++ <ins>template &lt;class T&gt; struct is_nullptr;</ins>
++ template &lt;class T&gt; struct is_integral;
++ template &lt;class T&gt; struct is_floating_point;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Edit Table 47 &mdash; "Primary type category predicates" as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 47 &mdash; Primary type category predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>template &lt;class T&gt;<br/>
++struct is_nullptr;</tt></ins>
++</td>
++<td>
++<ins><tt>T</tt> is <tt>std::nullptr_t</tt> ([basic.fundamental])</ins>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2013-09-29, Chicago]</i></p>
++
++
++<p>Apply to the Working Paper</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3485.</p>
++
++<ol>
++<li>
++<p>
++Edit 20.10.2 [meta.type.synop], header <tt>&lt;type_traits&gt;</tt> synopsis:
++</p>
++<blockquote><pre>
++namespace std {
++ [&hellip;]
++ // 20.9.4.1, primary type categories:
++ template &lt;class T&gt; struct is_void;
++ <ins>template &lt;class T&gt; struct is_null_pointer;</ins>
++ template &lt;class T&gt; struct is_integral;
++ template &lt;class T&gt; struct is_floating_point;
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++<li>
++<p>
++Edit Table 47 &mdash; "Primary type category predicates" as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 47 &mdash; Primary type category predicates</caption>
++<tr>
++<th>Template</th>
++<th>Condition</th>
++<th>Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>template &lt;class T&gt;<br/>
++struct is_null_pointer;</tt></ins>
++</td>
++<td>
++<ins><tt>T</tt> is <tt>std::nullptr_t</tt> ([basic.fundamental])</ins>
++</td>
++<td>
++&nbsp;
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2249"></a>2249. [CD] Remove <tt>gets</tt> from <tt>&lt;cstdio&gt;</tt></h3>
++<p><b>Section:</b> 27.9.2 [c.files] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-04-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.files">issues</a> in [c.files].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses GB 9</b></p>
++
++<p>
++In 27.9.2 [c.files] the current C++ standard claims that <tt>&lt;cstdio&gt;</tt> defines a
++function called "gets" but it has no declaration or semantics, because it was removed from C11,
++having been deprecated since C99. We should remove it for C++14.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Will resolve with the wording in the NB comment.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>Resolved by resolution as suggested by NB comment <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3733.pdf">GB 9</a></p>
++
++
++
++
++
++
++<hr>
++<h3><a name="2252"></a>2252. Strong guarantee on <tt>vector::push_back()</tt> still broken with C++11?</h3>
++<p><b>Section:</b> 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2013-04-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.modifiers">active issues</a> in [vector.modifiers].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.modifiers">issues</a> in [vector.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++
++<p>
++According to my understanding, the strong guarantee of <tt>push_back()</tt> led to the introduction of <tt>noexcept</tt>
++and to the typical implementation that vectors usually copy their elements on reallocation unless the move operations of
++their element type guarantees not to throw.
++<p/>
++However, if I read the standard correctly, we still don't give the strong guarantee any more:
++Yes, 23.2.1 [container.requirements.general]/10 specifies:
++</p>
++<blockquote>
++<p>
++Unless otherwise specified (see 23.2.4.1, 23.2.5.1, 23.3.3.4, and 23.3.6.5) all container types defined in this
++Clause meet the following additional requirements:
++</p>
++<ul>
++<li>[&hellip;]</li>
++<li>if an exception is thrown by a <tt>push_back()</tt> or <tt>push_front()</tt> function, that function has no effects.</li>
++</ul>
++</blockquote>
++<p>
++However, 23.3.6.5 [vector.modifiers] specifies for vector modifiers, <em>including</em> <tt>push_back()</tt>:
++</p>
++<blockquote>
++<p>
++If an exception is thrown other than by the copy constructor, move constructor, assignment operator, or move
++assignment operator of <tt>T</tt> or by any <tt>InputIterator</tt> operation there are no effects. If an exception
++is thrown by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</p>
++</blockquote>
++<p>
++I would interpret this as an "otherwise specified" behavior for <tt>push_back()</tt>, saying that the strong guarantee
++is only given if constructors and assignments do not throw.
++<p/>
++That means, the strong guarantee of C++03 is broken with C++11.
++<p/>
++In addition to all that 23.2.1 [container.requirements.general] p10 b2 doesn't mention the corresponding functions
++<tt>emplace_back()</tt> and <tt>emplace_front()</tt>. These are similar single-element additions and should provide the same
++strong guarantee.
++<p/>
++Daniel adds:
++<p/>
++It seems the error came in when <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2350.pdf">N2350</a>
++and <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2345.pdf">N2345</a> became accepted and where
++integrated into the working draft <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2369.pdf">N2369</a>.
++The merge resulted in a form that changed the previous meaning and as far as I understand it, this effect was not intended.
++</p>
++
++<p><i>[2013-09-16, Nico provides concrete wording]</i></p>
++
++
++<p><i>[2013-09-26, Nico improves wording]</i></p>
++
++
++<p>
++The new proposed resolution is driven as follows:
++</p>
++<ul>
++ <li> <p>In the container requirements section, there shall be general statements that single element insertions
++ and <tt>push_back()</tt>, <tt>pop_back</tt>, <tt>emplace_front()</tt>, and <tt>emplace_back()</tt> have no effect
++ on any exception.
++ <p/>
++ That is: we extend the first two statements by adding <tt>emplace_front()</tt> and <tt>emplace_back()</tt>, which
++ are missing.
++ </p>
++</li>
++ <li> <p>Formulate only the exceptions from that (or where other general statements might
++ lead to the impression, that the blanket statement no longer applies):</p>
++ <ul>
++ <li> <p>remove the statement in <tt>list::push_back()</tt> saying again that exceptions have to effect.</p></li>
++ <li> <p>Clarify that all single-element insertions at either end of a <tt>deque</tt> have the strong guarantee.</p> </li>
++ <li> <p>Clarify that all single-element insertions at the end of a <tt>vector</tt> have the strong guarantee.</p></li>
++ </ul>
++</li>
++</ul>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 23.2.1 [container.requirements.general] p10 b2 as indicated:</p>
++
++<ul>
++<li><p>
++if an exception is thrown by an <tt>insert()</tt> or <tt>emplace()</tt> function while inserting a single element, that
++function has no effects.
++</p></li>
++<li><p>
++if an exception is thrown by a <tt>push_back()</tt> <del>or</del><ins>,</ins> <tt>push_front()</tt><ins>, <tt>emplace_back()</tt>, or
++<tt>emplace_front()</tt></ins> function, that function has no effects.
++</p></li>
++</ul>
++
++</li>
++
++<li><p>Edit 23.3.3.4 [deque.modifiers] as indicated:</p>
++
++<blockquote>
++<pre>iterator insert(const_iterator position, const T&amp; x);
++iterator insert(const_iterator position, T&amp;&amp; x);
++iterator insert(const_iterator position, size_type n, const T&amp; x);
++template &lt;class InputIterator&gt;
++ iterator insert(const_iterator position,
++ InputIterator first, InputIterator last);
++iterator insert(const_iterator position, initializer_list&lt;T&gt;);
++template &lt;class... Args&gt; void emplace_front(Args&amp;&amp;... args);
++template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
++void push_front(const T&amp; x);
++void push_front(T&amp;&amp; x);
++void push_back(const T&amp; x);
++void push_back(T&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects:</i> An insertion in the middle of the deque invalidates all the iterators and references to elements
++of the deque. An insertion at either end of the deque invalidates all the iterators to the deque, but has
++no effect on the validity of references to elements of the deque.
++</p><p>
++-2- <i>Remarks:</i>
++If an exception is thrown other than by the copy constructor, move constructor, assignment
++operator, or move assignment operator of <tt>T</tt> there are no effects.
++<ins>
++If an exception is thrown while inserting a single element at either end, there are no effects.
++</ins>
++<del>If</del><ins>Otherwise, if</ins> an exception is thrown by the move
++constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</p><p>
++-3- <i>Complexity:</i> The complexity is linear in the number of elements inserted plus the lesser of the distances
++to the beginning and end of the deque. Inserting a single element either at the beginning or end of a
++deque always takes constant time and causes a single call to a constructor of <tt>T</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.3.6.5 [vector.modifiers] as indicated:</p>
++
++<blockquote>
++<pre>iterator insert(const_iterator position, const T&amp; x);
++iterator insert(const_iterator position, T&amp;&amp; x);
++iterator insert(const_iterator position, size_type n, const T&amp; x);
++template &lt;class InputIterator&gt;
++ iterator insert(const_iterator position, InputIterator first, InputIterator last);
++iterator insert(const_iterator position, initializer_list&lt;T&gt;);
++template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
++void push_back(const T&amp; x);
++void push_back(T&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++-1- <i>Remarks:</i> Causes reallocation if the new size is greater than the old capacity. If no reallocation happens,
++all the iterators and references before the insertion point remain valid.
++If an exception is thrown other
++than by the copy constructor, move constructor, assignment operator, or move assignment operator
++of <tt>T</tt> or by any <tt>InputIterator</tt> operation there are no effects.
++<ins>
++If an exception is thrown while inserting a single element at the end and <tt>T</tt> is <tt>CopyInsertable</tt>
++or <tt>is_nothrow_move_constructible&lt;T&gt;::value</tt> is <tt>true</tt>, there are no effects.
++</ins>
++<del>If</del><ins>Otherwise, if</ins> an exception is thrown by the move
++constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt>, the effects are unspecified.
++</p><p>
++-2- <i>Complexity:</i> The complexity is linear in the number of elements inserted plus the distance to the end
++of the vector.
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2257"></a>2257. Simplify container requirements with the new algorithms</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2013-05-29 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Currently (n3690) Table 96 says, in the row for &quot;<tt>a == b</tt>&quot;, that the
++Operational semantics are:
++</p>
++<blockquote>
++ <tt>==</tt> is an equivalence relation.<br/>
++ <tt>distance(a.begin(), a.end()) == distance(b.begin(), b.end()) &amp;&amp; equal(a.begin(), a.end(),b.begin())</tt>
++</blockquote>
++<p>
++Given the extension of equal for C++14, this can be simplified to:
++</p>
++<blockquote>
++ <tt>==</tt> is an equivalence relation.<br/>
++ <tt>equal(a.begin(), a.end(), b.begin(), b.end())</tt>
++</blockquote>
++
++<p><i>[
++Alisdair notes that a similar edit would apply to the unordered containers requirements.
++]</i></p>
++
++
++<p>
++Previous resolution from Marshall Clow:
++</p>
++<blockquote class="note">
++<p>
++Ammend the Operational Semantics for 23.2.1 [container.requirements.general], Table 96, row &quot;<tt>a == b</tt>&quot;
++</p>
++<blockquote>
++ <tt>==</tt> is an equivalence relation.<br/>
++ <tt><del>distance(a.begin(), a.end()) == distance(b.begin(), b.end()) &amp;&amp;</del> equal(a.begin(), a.end(), b.begin()<ins>, b.end()</ins>)</tt>
++</blockquote>
++
++<p>
++Ammend 23.2.5 [unord.req] p12:
++</p>
++<blockquote>
++Two unordered containers <tt>a</tt> and <tt>b</tt> compare equal if <tt>a.size() == b.size()</tt>
++and, for every equivalent-key group <tt>[Ea1,Ea2)</tt> obtained from <tt>a.equal_range(Ea1)</tt>,
++there exists an equivalent-key group <tt>[Eb1,Eb2)</tt> obtained from <tt>b.equal_range(Ea1)</tt>,
++such that <del><tt>distance(Ea1, Ea2) == distance(Eb1, Eb2)</tt> and</del>
++<tt>is_permutation(Ea1, Ea2, Eb1<ins>, Eb2</ins>)</tt>
++returns <tt>true</tt>. For ...
++</blockquote>
++</blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++
++<p>
++Marshall improves wording
++</p>
++
++<p><i>[2013-09 Chicago (evening issues)]</i></p>
++
++<p>
++Moved to ready, after confirming latest wording reflects the discussion earlier in the day.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li>
++<p>
++Ammend 23.2.1 [container.requirements.general], Table 96 as indicated:
++</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 96 &mdash; Container requirements (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational<br/>semantics</th>
++<th>Assertion/note<br/>pre-/post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="5" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a == b</tt>
++</td>
++<td>
++convertible to <tt>bool</tt>
++</td>
++<td>
++<tt>==</tt> is an equivalence relation.<br/>
++<tt><del>distance(a.begin(),<br/>
++a.end()) == <br/>
++distance(b.begin(),<br/>
++b.end()) &amp;&amp;</del><br/>
++equal(a.begin(),<br/>
++a.end(),<br/>
++b.begin()<ins>, b.end()</ins>)</tt>
++</td>
++<td>
++<i>Requires:</i> <tt>T</tt> is<br/>
++<tt>EqualityComparable</tt>
++</td>
++<td>
++<ins>Constant if <tt>a.size() != b.size()</tt>,</ins> linear <ins>otherwise</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="5" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++<li>
++<p>
++Ammend 23.2.5 [unord.req] p12:
++</p>
++<blockquote>
++Two unordered containers <tt>a</tt> and <tt>b</tt> compare equal if <tt>a.size() == b.size()</tt>
++and, for every equivalent-key group <tt>[Ea1,Ea2)</tt> obtained from <tt>a.equal_range(Ea1)</tt>,
++there exists an equivalent-key group <tt>[Eb1,Eb2)</tt> obtained from <tt>b.equal_range(Ea1)</tt>,
++such that <del><tt>distance(Ea1, Ea2) == distance(Eb1, Eb2)</tt> and</del>
++<tt>is_permutation(Ea1, Ea2, Eb1<ins>, Eb2</ins>)</tt>
++returns <tt>true</tt>. For [&hellip;]
++</blockquote>
++</li>
++
++<li><p>Amend 23.3.4.1 [forwardlist.overview] p2:</p>
++<blockquote><p>
++-2- A <tt>forward_list</tt> satisfies all of the requirements of a container (Table 96), except that the <tt>size()</tt> member
++function is not provided <ins>and <tt>operator==</tt> has linear complexity</ins>. [&hellip;]
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2258"></a>2258. <tt>a.erase(q1, q2)</tt> unable to directly return <tt>q2</tt></h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Geoff Alexander <b>Opened:</b> 2013-05-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Section 23.2.4 [associative.reqmts], Table 102, page 743 of the C++ 2011 Standard states that <tt>a.erase(q1, q2)</tt>
++returns <tt>q2</tt>. The problem is that <tt>a.erase(q1, q2)</tt> cannot directly return <tt>q2</tt> as the return type,
++<tt>iterator</tt>, differs from that of <tt>q2</tt>, <tt>const_iterator</tt>.
++</p>
++
++<p><i>[2013-09 Chicago (evening issues group)]</i></p>
++
++<p>
++The wording looks good, but is worded slightly differently to how we say the same for sequence containers, and for unordered
++associative containers. We should apply consistent wording in all three cases.
++</p>
++<p>
++Alisdair to provide the wording.
++</p>
++
++<p><i>[2014-02-12 Issaquah meeting]</i></p>
++
++<p>
++Move a Immediate.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>In the specification of <tt>a.erase(q1, q2)</tt> in sub-clause 23.2.4 [associative.reqmts], Table 102 change as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements (in addition to container) (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.erase(q1, q2)</tt>
++</td>
++<td>
++<tt>iterator</tt>
++</td>
++<td>
++erases all the elements in the range <tt>[q1,q2)</tt>. Returns <del><tt>q2</tt></del><ins>
++an iterator pointing to the element pointed to by <tt>q2</tt> prior to any elements
++being erased. If no such element exists, <tt>a.end()</tt> is returned</ins>.
++</td>
++<td>
++<tt>log(a.size()) + N</tt> where <tt>N</tt> has the value <tt>distance(q1, q2)</tt>.
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2263"></a>2263. Comparing iterators and allocator pointers with different const-character</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 23.2 [container.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-06-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++This ancient issue <a href="lwg-defects.html#179">179</a> says one ought to be able to compare iterators with <tt>const_iterators</tt>
++from any given container. I'm having trouble finding words that guarantee this in C++11. This impacts not only a
++container's iterators, but also the allocator requirements in allocator.requirements] surrounding
++<tt>pointer</tt>, <tt>const_pointer</tt>, <tt>void_pointer</tt> and <tt>const_void_pointer</tt>. E.g. can one
++compare a <tt>pointer</tt> with a <tt>const_pointer</tt>?
++<p/>
++Since <tt>allocator::pointer</tt> and <tt>const_pointer</tt> are required to be random access iterators, one could
++expect that the <a href="lwg-defects.html#179">179</a> guarantees apply for them as well.
++</p>
++
++<p><i>[
++Daniel comments:
++]</i></p>
++
++
++<p>
++The wording for <a href="lwg-defects.html#179">179</a> was part of several working drafts (e.g. also in
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf">N3092</a>) over some time and suddenly got lost
++in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf">N3242</a>, presumably by accident. Whatever we
++decide for allocator pointers, I expect that we need to restore the <a href="lwg-defects.html#179">179</a> wording as part of the overall resolution:
++</p>
++
++<p>Reinsert after 23.2 [container.requirements] p6:</p>
++
++<blockquote>
++<p>
++-6- <tt>begin()</tt> returns an iterator referring to the first element in the container. <tt>end()</tt> returns an iterator which
++is the past-the-end value for the container. If the container is empty, then <tt>begin() == end()</tt>;
++<p/>
++<ins>-?- In the expressions</ins>
++</p>
++<blockquote><pre>
++<ins>i == j
++i != j
++i &lt; j
++i &lt;= j
++i &gt;= j
++i &gt; j
++i - j</ins>
++</pre></blockquote>
++<p>
++<ins>where <tt>i</tt> and <tt>j</tt> denote objects of a container's <tt>iterator</tt> type, either or both may be replaced by an object
++of the container's <tt>const_iterator</tt> type referring to the same element with no change in semantics.</ins>
++</p>
++</blockquote>
++
++<p><i>[2014-02-13 Issaquah, Daniel comments and suggests wording]</i></p>
++
++
++<p>
++First, I didn't originally move the seemingly lost wording to the resolution section because I wanted to ensure that the
++committee double-checks the reason of this loss.
++<p/>
++Second, albeit restoring this wording will restore the comparability of <tt>const_iterator</tt> and <tt>iterator</tt> of
++containers specified in Clause 23, but this alone would <em>not</em> imply that this guarantee automatically extends to
++<em>all other</em> iterators, simply because there is no fundamental relation between a mutable iterator and a constant
++iterator by itself. This relation only exists under specific conditions, for example for containers which provide two such
++<tt>typedefs</tt> of that kind. Thus the wording restoration would <em>not</em> ensure that allocator <tt>pointer</tt> and
++<tt>const_pointer</tt> would be comparable with each other. To realize that, we would need additional guarantees added
++to the allocator requirements. In fact, it is crucial to separate these things, because allocators are <em>not</em>
++restricted to be used within containers, they have their own legitimate use for other places as well (albeit containers
++presumably belong to the most important use-cases), and this is also stated in the introduction of 17.6.3.5 [allocator.requirements],
++where it says:
++</p>
++<blockquote><p>
++All of the string types (Clause 21), containers (Clause 23) (except array), string buffers and string streams (Clause 27),
++and <tt>match_results</tt> (Clause 28) are parameterized in terms of allocators.
++</p></blockquote>
++
++<p><i>[2014-02-12 Issaquah meeting]</i></p>
++
++<p>
++Move a Immediate.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Insert after 17.6.3.5 [allocator.requirements] p4 as indicated:</p>
++
++<blockquote><p>
++-4- An allocator type <tt>X</tt> shall satisfy the requirements of <tt>CopyConstructible</tt> (17.6.3.1). The <tt>X::pointer</tt>,
++<tt>X::const_pointer</tt>, <tt>X::void_pointer</tt>, and <tt>X::const_void_pointer</tt> types shall satisfy the requirements
++of <tt>NullablePointer</tt> (17.6.3.3). No constructor, comparison operator, copy operation, move operation, or
++swap operation on these types shall exit via an exception. <tt>X::pointer</tt> and <tt>X::const_pointer</tt> shall also
++satisfy the requirements for a random access iterator (24.2).
++<p/>
++<ins>-?- Let <tt>x1</tt> and <tt>x2</tt> denote objects of (possibly different) types <tt>X::void_pointer</tt>,
++<tt>X::const_void_pointer</tt>, <tt>X::pointer</tt>, or <tt>X::const_pointer</tt>. Then, <tt>x1</tt> and <tt>x2</tt>
++are <em>equivalently-valued</em> pointer values, if and only if both <tt>x1</tt> and <tt>x2</tt> can be explicitly converted
++to the two corresponding objects <tt>px1</tt> and <tt>px2</tt> of type <tt>X::const_pointer</tt>, using a sequence of
++<tt>static_cast</tt>s using only these four types, and the expression <tt>px1 == px2</tt> evaluates to <tt>true</tt>.</ins>
++</p>
++<blockquote class="note"><p>
++<em>Drafting note:</em> This wording uses the seemingly complicated route via <tt>X::const_pointer</tt>, because these are (contrary to
++<tt>X::const_void_pointer</tt>) random access iterators and we can rely here for dereferenceable values on the fundamental pointee
++equivalence of 24.2.5 [forward.iterators] p6:
++</p>
++<blockquote><p>
++If <tt>a</tt> and <tt>b</tt> are both dereferenceable, then <tt>a == b</tt> if and only if <tt>*a</tt> and <tt>*b</tt> are
++bound to the same object.
++</p></blockquote>
++<p>
++while for null pointer values we can rely on the special equality relation induced by 17.6.3.3 [nullablepointer.requirements].
++</p>
++</blockquote>
++<p>
++<ins>-?- Let <tt>w1</tt> and <tt>w2</tt> denote objects of type <tt>X::void_pointer</tt>. Then for the expressions</ins>
++</p>
++<blockquote><pre>
++<ins>w1 == w2
++w1 != w2</ins>
++</pre></blockquote>
++<p>
++<ins>either or both objects may be replaced by an equivalently-valued object of type <tt>X::const_void_pointer</tt> with no
++change in semantics.</ins>
++<p/>
++<ins>-?- Let <tt>p1</tt> and <tt>p2</tt> denote objects of type <tt>X::pointer</tt>. Then for the expressions</ins>
++</p>
++<blockquote><pre>
++<ins>p1 == p2
++p1 != p2
++p1 &lt; p2
++p1 &lt;= p2
++p1 &gt;= p2
++p1 &gt; p2
++p1 - p2</ins>
++</pre></blockquote>
++<p>
++<ins>either or both objects may be replaced by an equivalently-valued object of type <tt>X::const_pointer</tt> with no
++change in semantics.</ins>
++</p>
++</blockquote>
++</li>
++<li><p>Reinsert after 23.2 [container.requirements] p6:</p>
++
++<blockquote><p>
++-6- <tt>begin()</tt> returns an iterator referring to the first element in the container. <tt>end()</tt> returns an iterator which
++is the past-the-end value for the container. If the container is empty, then <tt>begin() == end()</tt>;
++<p/>
++<ins>-?- In the expressions</ins>
++</p>
++<blockquote><pre>
++<ins>i == j
++i != j
++i &lt; j
++i &lt;= j
++i &gt;= j
++i &gt; j
++i - j</ins>
++</pre></blockquote>
++<p>
++<ins>where <tt>i</tt> and <tt>j</tt> denote objects of a container's <tt>iterator</tt> type, either or both may be replaced by an object
++of the container's <tt>const_iterator</tt> type referring to the same element with no change in semantics.</ins>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2266"></a>2266. <tt>vector</tt> and <tt>deque</tt> have incorrect <tt>insert</tt> requirements</h3>
++<p><b>Section:</b> 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Ahmed Charles <b>Opened:</b> 2013-05-17 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#sequence.reqmts">issues</a> in [sequence.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to Table 100 in n3485 23.2.3 [sequence.reqmts]/4 the notes for the expression <tt>a.insert(p,i,j)</tt>
++say:
++</p>
++
++<blockquote><p>
++<i>Requires:</i> <tt>T</tt> shall be <tt>EmplaceConstructible</tt>
++into <tt>X</tt> from <tt>*i</tt>. For <tt>vector</tt>, if the iterator
++does not meet the forward iterator requirements (24.2.5), <tt>T</tt> shall also be
++<tt>MoveInsertable</tt> into <tt>X</tt> and <tt>MoveAssignable</tt>.
++<p/>
++Each iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly once.
++<p/>
++<i>pre:</i> <tt>i</tt> and <tt>j</tt> are not iterators into <tt>a</tt>.
++<p/>
++Inserts copies of elements in <tt>[i, j)</tt> before <tt>p</tt>
++</p></blockquote>
++
++<p>
++There are two problems with that wording: First, the special constraints for <tt>vector</tt>, that are expressed to be valid for
++forward iterators only, are necessary for all iterator categories. Second, the same special constraints are needed for <tt>deque</tt>, too.
++</p>
++
++<p><i>[2013-10-05, Stephan T. Lavavej comments and provides alternative wording]</i></p>
++
++<p>
++In Chicago, we determined that the original proposed resolution was correct, except that it needed additional requirements.
++When <tt>vector</tt> <tt>insert(p, i, j)</tt> is called with input-only iterators, it can't know how many elements will be inserted,
++which is obviously problematic for insertion anywhere other than at the end. Therefore, implementations typically append elements
++(geometrically reallocating), followed by <tt>rotate()</tt>. Given forward+ iterators, some implementations append and
++<tt>rotate()</tt> when they determine that there is sufficient capacity. Additionally, <tt>deque</tt> <tt>insert(p, i, j)</tt> is
++typically implemented with prepending/appending, with a possible call to <tt>reverse()</tt>, followed by a call to <tt>rotate()</tt>.
++Note that <tt>rotate()</tt>'s requirements are strictly stronger than <tt>reverse()</tt>'s.
++<p/>
++Therefore, when patching Table 100, we need to add <tt>rotate()</tt>'s requirements. Note that this does not physically affect code
++(implementations were already calling <tt>rotate()</tt> here), and even in Standardese terms it is barely noticeable &mdash; if an
++element is <tt>MoveInsertable</tt> and <tt>MoveAssignable</tt> then it is almost certainly <tt>MoveConstructible</tt> and swappable.
++However, this patch is necessary to be strictly correct.
++</p>
++
++<p>
++Previous resolution from Ahmed Charles:
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Change Table 100 as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 100 &mdash; Sequence container requirements (in addition to container) (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.insert(p,i,j)</tt>
++</td>
++<td>
++<tt>iterator</tt>
++</td>
++<td>
++<i>Requires:</i> <tt>T</tt> shall be <tt>EmplaceConstructible</tt>
++into <tt>X</tt> from <tt>*i</tt>. For <tt>vector</tt> <ins>and <tt>deque</tt></ins>, <del>if the iterator
++does not meet the forward iterator requirements (24.2.5),</del> <tt>T</tt> shall also be
++<tt>MoveInsertable</tt> into <tt>X</tt> and <tt>MoveAssignable</tt>.<br/>
++Each iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly once.<br/>
++<i>pre:</i> <tt>i</tt> and <tt>j</tt> are not iterators into <tt>a</tt>.<br/>
++Inserts copies of elements in <tt>[i, j)</tt> before <tt>p</tt>
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-02-15 post-Issaquah session : move to Tentatively Ready]</i></p>
++
++<p>
++Pablo: We might have gone too far with the fine-grained requirements. Typically these things come in groups.
++</p>
++<p>
++Alisdair: I think the concepts folks assumed we would take their guidance.
++</p>
++<p>
++Move to Tentatively Ready.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Change Table 100 as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 100 &mdash; Sequence container requirements (in addition to container) (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>a.insert(p,i,j)</tt>
++</td>
++<td>
++<tt>iterator</tt>
++</td>
++<td>
++<i>Requires:</i> <tt>T</tt> shall be <tt>EmplaceConstructible</tt> into <tt>X</tt><br/>
++from <tt>*i</tt>. For <tt>vector</tt> <ins>and <tt>deque</tt></ins>, <del>if the iterator</del><br/>
++<del>does not meet the forward iterator requirements (24.2.5),</del> <tt>T</tt> shall also be<br/>
++<tt>MoveInsertable</tt> into <tt>X</tt><ins>, <tt>MoveConstructible</tt>,</ins><br/>
++<del>and</del> <tt>MoveAssignable</tt><ins>, and swappable (17.6.3.2 [swappable.requirements])</ins>.<br/>
++Each iterator in the range <tt>[i,j)</tt> shall be dereferenced exactly once.<br/>
++<i>pre:</i> <tt>i</tt> and <tt>j</tt> are not iterators into <tt>a</tt>.<br/>
++Inserts copies of elements in <tt>[i, j)</tt> before <tt>p</tt>
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2268"></a>2268. Setting a default argument in the declaration of a member function <tt>assign</tt> of <tt>std::basic_string</tt></h3>
++<p><b>Section:</b> 21.4 [basic.string] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Vladimir Grigoriev <b>Opened:</b> 2013-06-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#basic.string">active issues</a> in [basic.string].</p>
++<p><b>View all other</b> <a href="lwg-index.html#basic.string">issues</a> in [basic.string].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Constructors and member functions <tt>assign</tt> of class <tt>std::basic_string</tt> have one to one relation (except the
++explicit constructor that creates an empty string). The following list shows this relation:
++</p>
++
++<blockquote><pre>
++explicit basic_string(const Allocator&amp; a = Allocator());
++
++basic_string(const basic_string&amp; str);
++basic_string&amp; assign(const basic_string&amp; str);
++
++basic_string(basic_string&amp;&amp; str) noexcept;
++basic_string&amp; assign(basic_string&amp;&amp; str) noexcept;
++
++basic_string(const basic_string&amp; str, size_type pos, size_type n = npos,
++ const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const basic_string&amp; str, size_type pos,
++ size_type n);
++
++basic_string(const charT* s,
++ size_type n, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const charT* s, size_type n);
++
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const charT* s);
++
++basic_string(size_type n, charT c, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(size_type n, charT c);
++
++template&lt;class InputIterator&gt;
++basic_string(InputIterator begin, InputIterator end,
++ const Allocator&amp; a = Allocator());
++template&lt;class InputIterator&gt;
++basic_string&amp; assign(InputIterator first, InputIterator last);
++
++basic_string(initializer_list&lt;charT&gt;, const Allocator&amp; = Allocator());
++basic_string&amp; assign(initializer_list&lt;charT&gt;);
++</pre></blockquote>
++
++<p>
++So in fact any creating of an object of type <tt>std::basic_string</tt> using any of the above constructors
++except the explicit constructor can be substituted for creating a (possibly non-empty) string and
++then applying to it the corresponding method assign.
++<p/>
++For example these two code snippets give the same result:
++</p>
++
++<blockquote><pre>
++std::string s("Hello World");
++</pre></blockquote>
++
++<p>
++and
++</p>
++
++<blockquote><pre>
++std::string s;
++s.assign("Hello World");
++</pre></blockquote>
++
++<p>
++However there is one exception that has no a logical support. It is the pair of the following constructor and member function
++<tt>assign</tt>
++</p>
++
++<blockquote><pre>
++basic_string(const basic_string&amp; str, size_type pos, size_type n = npos,
++ const Allocator&amp; a = Allocator());
++
++basic_string&amp; assign(const basic_string&amp; str, size_type pos, size_type n);
++</pre></blockquote>
++
++<p>
++The third parameter of the constructor has a default argument while in the <tt>assign</tt> function it is absent. So it is impossible
++one to one to substitute the following code snippet
++</p>
++
++<blockquote><pre>
++std::string s("Hello World");
++std::string t(s, 6);
++</pre></blockquote>
++
++<p>
++by
++</p>
++
++<blockquote><pre>
++std::string s("Hello World");
++std::string t;
++t.assign(s, 6); // error: no such function
++</pre></blockquote>
++
++<p>
++To get an equivalent result using the <tt>assign</tt> function the programmer has to complicate the code that is error-prone
++</p>
++
++<blockquote><pre>
++std::string s("Hello World");
++std::string t;
++t.assign(s, 6, s.size() - 6);
++</pre></blockquote>
++
++<p>
++To fix that, the declaration of the member function <tt>assign</tt> should be changed in such a way that its declaration
++would be fully compatible with the declaration of the corresponding constructor, that is to specify the same default argument
++for the third parameter of the <tt>assign</tt>.
++</p>
++
++<p>
++The <tt>assign</tt> function is not the only function that requires to be revised.
++<p/>
++Now let include in the list of pairs constructor-assign with the modified method <tt>assign</tt> one more member function
++<tt>append</tt>. We will get:
++</p>
++
++<blockquote><pre>
++explicit basic_string(const Allocator&amp; a = Allocator());
++
++basic_string(const basic_string&amp; str);
++basic_string&amp; assign(const basic_string&amp; str);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(const basic_string&amp; str);</span>
++
++basic_string(basic_string&amp;&amp; str) noexcept;
++basic_string&amp; assign(basic_string&amp;&amp; str) noexcept;
++
++basic_string(const basic_string&amp; str, size_type pos, size_type n = npos,
++ const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const basic_string&amp; str, size_type pos,
++ size_type n);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(const basic_string&amp; str, size_type pos,
++ size_type n);</span>
++
++basic_string(const charT* s,
++ size_type n, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const charT* s, size_type n);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(const charT* s, size_type n);</span>
++
++basic_string(const charT* s, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const charT* s);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(const charT* s);</span>
++
++basic_string(size_type n, charT c, const Allocator&amp; a = Allocator());
++basic_string&amp; assign(size_type n, charT c);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(size_type n, charT c);</span>
++
++template&lt;class InputIterator&gt;
++basic_string(InputIterator begin, InputIterator end,
++ const Allocator&amp; a = Allocator());
++template&lt;class InputIterator&gt;
++basic_string&amp; assign(InputIterator first, InputIterator last);
++<span style="color:#009900;font-weight:bold">template&lt;class InputIterator&gt;
++basic_string&amp; append(InputIterator first, InputIterator last);</span>
++
++basic_string(initializer_list&lt;charT&gt;, const Allocator&amp; = Allocator());
++basic_string&amp; assign(initializer_list&lt;charT&gt;);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(initializer_list&lt;charT&gt;);</span>
++</pre></blockquote>
++
++<p>As it seen from this record:</p>
++
++<blockquote><pre>
++basic_string(const basic_string&amp; str, size_type pos, size_type n = npos,
++ const Allocator&amp; a = Allocator());
++basic_string&amp; assign(const basic_string&amp; str, size_type pos,
++ size_type n);
++<span style="color:#009900;font-weight:bold">basic_string&amp; append(const basic_string&amp; str, size_type pos,
++ size_type n);</span>
++</pre></blockquote>
++
++<p>
++it is obvious that the function <tt>append</tt> also should have the default argument that is that it should be declared as:
++</p>
++
++<blockquote><pre>
++basic_string&amp; append(const basic_string&amp; str, size_type pos,
++ size_type n <ins>= npos</ins>);
++</pre></blockquote>
++
++<p>
++In fact there is no a great difference in using <tt>assign</tt> or <tt>append</tt> especially when the string is empty:
++</p>
++
++<blockquote><pre>
++std::string s("Hello World");
++std::string t;
++t.assign(s, 6);
++
++std::string s("Hello World");
++std::string t;
++t.append(s, 6);
++</pre></blockquote>
++
++<p>
++In both cases the result will be the same. So the <tt>assign</tt> and <tt>append</tt> will be interchangeable from the point
++of view of used arguments.
++<p/>
++There are another three member functions in class <tt>std::basic_string</tt> that could be brought in conformity with considered above functions.
++They are member functions <tt>insert</tt>, <tt>replace</tt>, and <tt>compare</tt>.
++<p/>
++So it is suggested to substitute the following declarations of <tt>insert</tt>, <tt>replace</tt>, and <tt>compare</tt>:
++</p>
++
++<blockquote><pre>
++basic_string&amp; insert(size_type pos1, const basic_string&amp; str,
++ size_type pos2, size_type n);
++
++basic_string&amp; replace(size_type pos1, size_type n1,
++ const basic_string&amp; str, size_type pos2, size_type n2);
++
++int compare(size_type pos1, size_type n1,
++ const basic_string&amp; str, size_type pos2, size_type n2) const;
++</pre></blockquote>
++
++<p>
++by the declarations:
++</p>
++
++<blockquote><pre>
++basic_string&amp; insert(size_type pos1, const basic_string&amp; str,
++ size_type pos2, size_type n <ins>= npos</ins>);
++
++basic_string&amp; replace(size_type pos1, size_type n1,
++ const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>);
++
++int compare(size_type pos1, size_type n1,
++ const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>) const;
++</pre></blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Howard: Are we positive this won't conflict with any other overloads?
++<p/>
++They all appear to be unambiguous.
++<p/>
++Alisdair: Ok, move to Ready.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Change class template <tt>basic_string</tt> synopsis, 21.4 [basic.string] p5, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class charT, class traits = char_traits&lt;charT&gt;,
++ class Allocator = allocator&lt;charT&gt; &gt;
++ class basic_string {
++ public:
++ [&hellip;]
++ basic_string&amp; append(const basic_string&amp; str, size_type pos, size_type n <ins>= npos</ins>);
++ [&hellip;]
++ basic_string&amp; assign(const basic_string&amp; str, size_type pos, size_type n <ins>= npos</ins>);
++ [&hellip;]
++ basic_string&amp; insert(size_type pos1, const basic_string&amp; str, size_type pos2, size_type n <ins>= npos</ins>);
++ [&hellip;]
++ basic_string&amp; replace(size_type pos1, size_type n1, const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>);
++ [&hellip;]
++ int compare(size_type pos1, size_type n1, const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>) const;
++ [&hellip;]
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.6.2 [string::append] before p3 as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; append(const basic_string&amp; str, size_type pos, size_type n <ins>= npos</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.6.3 [string::assign] before p4 as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; assign(const basic_string&amp; str, size_type pos, size_type n <ins>= npos</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.6.4 [string::insert] before p5 as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; insert(size_type pos1, const basic_string&amp; str, size_type pos2, size_type n <ins>= npos</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.6.6 [string::replace] before p5 as indicated:</p>
++
++<blockquote><pre>
++basic_string&amp; replace(size_type pos1, size_type n1, const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>);
++</pre></blockquote>
++</li>
++
++<li><p>Change 21.4.7.9 [string::compare] before p4 as indicated:</p>
++
++<blockquote><pre>
++int compare(size_type pos1, size_type n1, const basic_string&amp; str, size_type pos2, size_type n2 <ins>= npos</ins>) const;
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2271"></a>2271. <tt>regex_traits::lookup_classname</tt> specification unclear</h3>
++<p><b>Section:</b> 28.7 [re.traits] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-07-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.traits">issues</a> in [re.traits].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++28.7 [re.traits] p9 says that <tt>regex_traits::lookup_classname</tt> should
++return a value that compares equal to 0, but there is no requirement
++that a bitmask type is equality comparable with 0, e.g. 17.5.2.1.3 [bitmask.types] says bitmask types
++can be implemented using <tt>std::bitset</tt>.
++<p/>
++Either there should be an additional requirement on the type or the function definition should be fixed.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Stefanus: Resolution looks good, doesn't seem to need fixing anywhere else from a quick look through the draft.
++<p/>
++Any objection to Ready?
++<p/>
++No objection.
++<p/>
++Action: Move to Ready. </p>
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 28.7 [re.traits] p9:</p>
++
++<blockquote>
++<pre>
++template &lt;class ForwardIterator&gt;
++ char_class_type lookup_classname(
++ ForwardIterator first, ForwardIterator last, bool icase = false) const;
++</pre>
++<blockquote>
++<p>
++-9- <i>Returns:</i> an unspecified value that represents the character classification named by the character
++sequence designated by the iterator range <tt>[first,last)</tt>. If the parameter <tt>icase</tt> is true then the
++returned mask identifies the character classification without regard to the case of the characters being
++matched, otherwise it does honor the case of the characters being matched. The value returned shall
++be independent of the case of the characters in the character sequence. If the name is not recognized
++then returns <del>a value that compares equal to 0</del><ins><tt>char_class_type()</tt></ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2272"></a>2272. <tt>quoted</tt> should use <tt>char_traits::eq</tt> for character comparison</h3>
++<p><b>Section:</b> 27.7.6 [quoted.manip] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2013-07-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#quoted.manip">issues</a> in [quoted.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 27.7.6 [quoted.manip] p2 b2:
++</p>
++<blockquote>
++<p>
++&mdash; Each character in <tt>s</tt>. If the character to be output is equal to <tt>escape</tt> or <tt>delim</tt>,
++as determined by <tt>operator==</tt>, first output <tt>escape</tt>.
++</p>
++</blockquote>
++<p>
++In 27.7.6 [quoted.manip] p3 b1 sb1:
++</p>
++<blockquote>
++<p>
++&mdash; If the first character extracted is equal to <tt>delim</tt>, as determined by <tt>operator==</tt>, [&hellip;]
++</p>
++</blockquote>
++
++<p>
++these should both use <tt>traits::eq</tt>.
++</p>
++
++<p>
++Also, I believe that 27.7.6 [quoted.manip] p3 implies that:
++</p>
++<blockquote>
++<pre>
++std::ostream _stream;
++std::string _string;
++_stream &lt;&lt; _string;
++_stream &lt;&lt; quoted(_string);
++</pre>
++</blockquote>
++<p>
++should both compile, or both fail to compile, based on whether or not their <tt>char_traits</tt> match.
++But I believe that the standard should say that explicitly.
++</p>
++
++<p><i>[
++2013-09 Chicago
++]</i></p>
++
++
++<p>
++Marshall Clow improved the wording with support from Stefanus.
++</p>
++
++<p><i>[
++2013-09 Chicago (late night issues)
++]</i></p>
++
++
++<p>
++Moved to Ready, after confirming wording correctly reflects discussion earlier in the day.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 27.7.6 [quoted.manip] p2+3 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class charT&gt;
++ <i>unspecified</i> quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\'));
++template &lt;class charT, class traits, class Allocator&gt;
++ <i>unspecified</i> quoted(const basic_string&lt;charT, traits, Allocator>&amp; s,
++ charT delim=charT('"'), charT escape=charT('\\'));
++</pre>
++<blockquote>
++<p>
++-2- <i>Returns:</i> An object of unspecified type such that if <tt>out</tt> is an instance of <tt>basic_ostream</tt> with member
++type <tt>char_type</tt> the same as <tt>charT</tt> <ins>and with member type <tt>traits_type</tt>, which in the second form is
++the same as <tt>traits</tt></ins>, then the expression
++<tt>out &lt;&lt; quoted(s, delim, escape)</tt> behaves
++as if it inserts the following characters into <tt>out</tt> using character inserter function templates (27.7.3.6.4),
++which may throw <tt>ios_base::failure</tt> (27.5.3.1.1):
++</p>
++<ul>
++<li><p><tt>delim</tt></p></li>
++<li><p>Each character in <tt>s</tt>. If the character to be output is equal to <tt>escape</tt> or <tt>delim</tt>,
++as determined by <del><tt>operator==</tt></del><ins><tt>traits_type::eq</tt></ins>, first output <tt>escape</tt>.</p></li>
++<li><p><tt>delim</tt></p></li>
++</ul>
++</blockquote>
++
++<pre>
++template &lt;class charT, class traits, class Allocator&gt;
++ <i>unspecified</i> quoted(basic_string&lt;charT, traits, Allocator>&amp; s,
++ charT delim=charT('"'), charT escape=charT('\\'));
++</pre>
++<blockquote>
++<p>
++-3- <i>Returns:</i> An object of unspecified type such that:
++</p>
++<ul>
++<li><p>If <tt>in</tt> is an instance of <tt>basic_istream</tt> with member type<ins>s</ins> <tt>char_type</tt>
++<ins>and <tt>traits_type</tt></ins> the same as <tt>charT</tt> <ins>and <tt>traits</tt>, respectively</ins>, then the
++expression <tt>in &gt;&gt; quoted(s, delim, escape)</tt> behaves as if it extracts
++the following characters from in using <tt>basic_istream::operator&gt;&gt;</tt> (27.7.2.2.3) which may throw
++<tt>ios_base::failure</tt> (27.5.3.1.1):
++</p>
++<ul>
++<li><p>If the first character extracted is equal to <tt>delim</tt>, as determined by
++<del><tt>operator==</tt></del><ins><tt>traits_type::eq</tt></ins>, then: [&hellip;]</p></li>
++</ul>
++</li>
++<li><p>
++If <tt>out</tt> is an instance of <tt>basic_ostream</tt> with member type<ins>s</ins> <tt>char_type</tt>
++<ins>and <tt>traits_type</tt></ins> the same as <tt>charT</tt> <ins>and <tt>traits</tt>, respectively</ins>,
++then the expression <tt>out &lt;&lt; quoted(s, delim, escape)</tt> behaves as specified for the <tt>const
++basic_string&lt;charT, traits, Allocator&gt;&amp;</tt> overload of the quoted function.
++</p></li>
++</ul>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2274"></a>2274. Does <tt>map::operator[]</tt> value-initialize or default-insert a missing element?</h3>
++<p><b>Section:</b> 23.4.4.3 [map.access], 23.5.4.3 [unord.map.elem] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Andrzej Krzemie&#324;ski <b>Opened:</b> 2013-07-16 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.access">issues</a> in [map.access].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Suppose that I provide a custom allocator for type <tt>int</tt>, that renders value 1 rather than 0 in default-insertion:
++</p>
++<blockquote>
++<pre>
++struct Allocator1 : std::allocator&lt;int&gt;
++{
++ using super = std::allocator&lt;int&gt;;
++
++ template&lt;typename Up, typename... Args&gt;
++ void construct(Up* p, Args&amp;&amp;... args)
++ { super::construct(p, std::forward&lt;Args&gt;(args)...); }
++
++ template&lt;typename Up&gt;
++ void construct(Up* p)
++ { ::new((void*)p) Up(1); }
++};
++</pre>
++</blockquote>
++
++<p>
++Now, if I use this allocator with <tt>std::map</tt>, and I use <tt>operator[]</tt> to access a not-yet-existent value,
++what value of the <tt>mapped_type</tt> should be created? 0 (value-initialization) or 1 (default-insertion):
++</p>
++
++<blockquote>
++<pre>
++map&lt;string, int, less&lt;string&gt;, Allocator1&gt; map;
++cout &lt;&lt; map["cat"];
++</pre>
++</blockquote>
++
++<p>
++N3960 is not very clear. 23.4.4.3 [map.access] in para 1 says:
++</p>
++<blockquote>
++<p>
++"If there is no key equivalent to <tt>x</tt> in the map, inserts <tt>value_type(x, T())</tt> into the map."
++</p>
++</blockquote>
++<p>
++So, it requires value-initialization.
++<p/>
++But para 2 says:
++</p>
++<blockquote>
++<p>
++"<tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>."
++</p>
++</blockquote>
++<p>
++This implies default-insertion, because if not, why the requirement. Also similar functions like
++<tt>vector::resize</tt> already require default-insertion wherever they put <tt>DefaultInsertable</tt> requirements.
++<p/>
++Not to mention that default-insertion is more useful, because it allows custom allocators to "override" the
++default value of <tt>mapped_type</tt>.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Alisdair: Matters only for POD or trivial types
++<p/>
++Marshall: issue might show up elsewhere other than <tt>map&lt;&gt;</tt>
++<p/>
++Alisdair: initialize elements in any containers &mdash; by calling construct on allocator traits
++<p/>
++Marshall: existing wording is clear
++<p/>
++Alisdair: main concern is difference in wording, discusses default initialization
++<p/>
++Nico: different requirement needed
++<p/>
++Alisdair: gut is issue is NAD, brings up <tt>DefaultInsertable</tt> definition &mdash; discusses definition
++<p/>
++Nico: why do we have the requirement?
++<p/>
++Alisdair: other containers have this requirement
++<p/>
++Marshall: this applies to many other containers
++<p/>
++Nico: <tt>deque&lt;&gt;</tt> in particular
++<p/>
++Alisdair: discusses allocator construct
++<p/>
++Alisdair: wording raises concerns that aren't said in existing standard
++<p/>
++Nico: sees no benefit to change
++<p/>
++Marshall: leery of change
++<p/>
++Alisdair: can be made clearer; might need to add note to <tt>DefaultInsertable</tt>; borderline editorial,
++comfortable without note, willing to wait until other issues arise. close issue as NAD
++</p>
++
++<p><i>[2015-01-20: Tomasz Kami&nacute;ski comments]</i></p>
++
++<p>
++With the addition of the <tt>try_emplace</tt> method the behavior of the <tt>operator[]</tt> for the maps,
++may be defined as follows:
++</p>
++<blockquote>
++<pre>
++T&amp; operator[](const key_type&amp; x);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: Equivalent to: <tt>try_emplace(x).first-&gt;second</tt>;
++</p>
++</blockquote>
++<pre>
++T&amp; operator[](key_type&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>: Equivalent to <tt>try_emplace(std::move(x)).first-&gt;second</tt>;
++</p>
++</blockquote>
++</blockquote>
++<p>
++This would simplify the wording and also after resolution of the issue <a href="lwg-defects.html#2464">2464</a>, this wording would
++also address this issue.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Wait until <a href="lwg-defects.html#2464">2464</a> and <a href="lwg-active.html#2469">2469</a> are in, which solve this.
++</p>
++
++<p><i>[2015-05-06 Lenexa: This is resolved by <a href="lwg-active.html#2469">2469</a>.]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 23.4.4.3 [map.access] p1+p5 as indicated:</p>
++
++<blockquote>
++<pre>
++T&amp; operator[](const key_type&amp; x);
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects:</i> If there is no key equivalent to <tt>x</tt> in the map, inserts <del><tt>value_type(x, T())</tt>
++into the map</del><ins>into the map a value with <tt>key_type</tt> initialized using expression <tt>x</tt> and <tt>mapped_type</tt>
++initialized by default-insertion</ins>.
++<p/>
++-2- <i>Requires:</i> <tt>key_type</tt> shall be <tt>CopyInsertable</tt> and <tt>mapped_type</tt> shall be
++<tt>DefaultInsertable</tt> into <tt>*this</tt>.
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++T&amp; operator[](key_type&amp;&amp; x);
++</pre>
++<blockquote>
++<p>
++-5- <i>Effects:</i> If there is no key equivalent to <tt>x</tt> in the map, inserts
++<del><tt>value_type(std::move(x), T())</tt> into the map</del><ins>into the map a value with <tt>key_type</tt>
++initialized using expression <tt>std::move(x)</tt> and <tt>mapped_type</tt> initialized by default-insertion</ins>.
++<p/>
++-6- <i>Requires:</i> <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.5.4.3 [unord.map.elem] p2 as indicated:</p>
++
++<blockquote>
++<pre>
++mapped_type&amp; operator[](const key_type&amp; k);
++mapped_type&amp; operator[](key_type&amp;&amp; k);
++</pre>
++<blockquote>
++<p>
++-1- <i>Requires:</i> <tt>mapped_type</tt> shall be <tt>DefaultInsertable</tt> into <tt>*this</tt>.
++For the first operator, <tt>key_type</tt> shall be <tt>CopyInsertable</tt> into <tt>*this</tt>. For the second
++operator, <tt>key_type</tt> shall be <tt>MoveConstructible</tt>.
++<p/>
++-2- <i>Effects:</i> If the <tt>unordered_map</tt> does not already contain an element whose key is equivalent to
++<tt>k</tt>, the first operator inserts <del>the value <tt>value_type(k, mapped_type())</tt></del><ins>a value with
++<tt>key_type</tt> initialized using expression <tt>x</tt> and <tt>mapped_type</tt> initialized by default-insertion</ins>
++and the second operator inserts <del>the value <tt>value_type(std::move(k), mapped_type())</tt></del><ins>a value
++with <tt>key_type</tt> initialized using expression <tt>std::move(x)</tt> and <tt>mapped_type</tt> initialized by
++default-insertion</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2275"></a>2275. [CD] Why is <tt>forward_as_tuple</tt> not <tt>constexpr</tt>?</h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2013-07-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses ES 11</b></p>
++
++<p>
++In <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">n3471</a>, a bunch of routines
++from header <tt>&lt;tuple&gt;</tt> were made <tt>constexpr</tt>.
++<p/>
++<tt>make_tuple/tuple_cat/get&lt;&gt;(tuple)/</tt>relational operators &mdash; all these were "constexpr-ified".
++<p/>
++But not <tt>forward_as_tuple</tt>.
++<p/>
++Why not?
++<p/>
++This was discussed in Portland, and STL opined that this was "an omission" (along with <tt>tuple_cat</tt>, which was added)
++<p/>
++In discussion on c++std-lib@accu.org list, Pablo agreed that <tt>forward_as_tuple</tt> should be <tt>constexpr</tt>.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Moved to Immediate, this directly addresses an NB comment and the wording is non-controversial.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change header <tt>&lt;tuple&gt;</tt> synopsis, 20.4.1 [tuple.general] as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class... Types&gt;
++ <ins>constexpr</ins> tuple&lt;Types&amp;&amp;...&gt; forward_as_tuple(Types&amp;&amp;...) noexcept;
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.4 [tuple.creation] before p5 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class... Types&gt;
++ <ins>constexpr</ins> tuple&lt;Types&amp;&amp;...&gt; forward_as_tuple(Types&amp;&amp;... t) noexcept;
++</pre>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2278"></a>2278. User-defined literals for Standard Library types</h3>
++<p><b>Section:</b> 20.12.2 [time.syn], 21.3 [string.classes] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-07-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3642.pdf">This paper</a> adds user-defined literals
++for <tt>string</tt>, <tt>complex</tt> and <tt>chrono</tt> types. It puts each new literal signature in an inline namespace
++inside of std. Section 3.1 of the paper gives the rationale for doing this:
++</p>
++
++<blockquote><p>
++As a common schema this paper proposes to put all suffixes for user defined literals in separate inline namespaces
++that are below the inline namespace <tt>std::literals</tt>. [<i>Note:</i> This allows a user either to do a
++<tt>using namespace std::literals;</tt> to import all literal operators from the standard available through header
++file inclusion, or to use <tt>using namespace std::string_literals;</tt> to just obtain the literals operators
++for a specific type. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>This isn't how inline namespaces work.</p>
++
++<p>
++7.3.1 [namespace.def]/p8 says in part:
++</p>
++
++<blockquote><p>
++Members of an inline namespace can be used in most respects as though they were members of the enclosing namespace.
++Specifically, the inline namespace and its enclosing namespace are both added to the set of associated namespaces
++used in argument-dependent lookup (3.4.2) whenever one of them is, and a using- directive (7.3.4) that names the
++inline namespace is implicitly inserted into the enclosing namespace as for an unnamed namespace (7.3.1.1). [&hellip;]
++</p></blockquote>
++
++<p>
++I.e. these literals will appear to the client to already be imported into namespace <tt>std</tt>. The rationale in
++the paper appears to indicate that this is not the intended behavior, and that instead the intended behavior is
++to require the user to say:
++</p>
++<blockquote><pre>
++using namespace std::literals;
++</pre></blockquote>
++<p>
++or:
++</p>
++<blockquote><pre>
++using namespace std::literals::string_literals;
++</pre></blockquote>
++<p>
++prior to use. To get this behavior non-inlined (normal) namespaces must be used.
++</p>
++
++<p>
++Originally proposed resolution:
++<p/>
++Strike the use of "inline" from each use associated with <tt>literals</tt>, <tt>string_literals</tt>,
++<tt>chrono_literals</tt>.
++<p/>
++My opinion is that this must be done prior to publishing C++14, otherwise we are stuck with this
++(apparently unwanted) decision forever.
++<p/>
++Marshall Clow:
++</p>
++<blockquote class="note">
++<p>
++The rationale that I recall was that:
++</p>
++<ol>
++<li><p>Users could write "<tt>using namespace std::literals;</tt>" to get all the literal suffixes, or</p></li>
++<li><p>Users could write "<tt>using namespace std::literals::string_literals;</tt>" or
++"<tt>using namespace std::literals::chrono_literals;</tt>" to get a subset of the suffixes.</p></li>
++</ol>
++<p>
++To accomplish that, I believe that:
++</p>
++<ol style="list-style-type:lower-alpha">
++<li><p>Namespace "<tt>std::literals</tt>" <em>should not</em> be <tt>inline</tt></p></li>
++<li><p>Namespaces "<tt>std::literals::string_literals</tt>" and "<tt>std::literals::chrono_literals</tt>" <em>should</em>
++be <tt>inline</tt></p></li>
++</ol>
++</blockquote>
++<p>
++Further details see also reflector message <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=34256">c++std-lib-34256</a>.
++</p>
++
++<p>
++Previous resolution from Marshall Clow:
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Modify header <tt>&lt;chrono&gt;</tt> synopsis, 20.12.2 [time.syn], as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++namespace chrono {
++[&hellip;]
++} // namespace chrono
++<del>inline</del> namespace literals {
++inline namespace chrono_literals {
++[&hellip;]
++} // namespace chrono_literals
++} // namespace literals
++} // namespace std
++</pre></blockquote>
++</li>
++
++<li><p>Modify header <tt>&lt;string&gt;</tt> synopsis, 21.3 [string.classes] p1, as indicated:</p>
++
++<blockquote><pre>
++#include &lt;initializer_list&gt;
++
++namespace std {
++[&hellip;]
++<del>inline</del> namespace literals {
++inline namespace string_literals {
++[&hellip;]
++}
++}
++}
++</pre></blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++
++<p>
++After a discussion about intent, the conclusion was that if you hoist a type with a "using" directive, then you should also
++get the associated literal suffixes with the type.
++<p/>
++This is accomplished by marking namespace <tt>std::literals</tt> as <tt>inline</tt>, but for types in their own namespace inside
++<tt>std</tt>, then they will need to do this as well. The only case in the current library is <tt>chrono</tt>.
++</p>
++
++<p>Marshall Clow provides alternative wording.</p>
++
++<p><i>[2013-09 Chicago (late night issues)]</i></p>
++
++<p>
++Moved to Ready, after confirming wording reflects the intent of the earlier discussion.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Modify header <tt>&lt;chrono&gt;</tt> synopsis, 20.12.2 [time.syn], as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++[&hellip;]
++inline namespace literals {
++inline namespace chrono_literals {
++[&hellip;]
++constexpr chrono::duration&lt;<i>unspecified</i> , nano&gt; operator "" ns(long double);
++
++} // namespace chrono_literals
++} // namespace literals
++
++<ins>
++namespace chrono {
++ using namespace literals::chrono_literals;
++} // namespace chrono
++</ins>
++} // namespace std
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2280"></a>2280. <tt>begin/end</tt> for arrays should be <tt>constexpr</tt> and <tt>noexcept</tt></h3>
++<p><b>Section:</b> 24.7 [iterator.range] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2013-08-22 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#iterator.range">active issues</a> in [iterator.range].</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.range">issues</a> in [iterator.range].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The array forms of <tt>std::begin</tt> and <tt>std::end</tt> should be <tt>constexpr</tt> and <tt>noexcept</tt>.
++</p>
++
++<p>
++<strong>Previous resolution from Andy Sawyer:</strong>
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Edit header <tt>&lt;iterator&gt;</tt> synopsis, 24.3 [iterator.synopsis] as indicated:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* begin(T (&amp;array)[N]) <ins>noexcept</ins>;
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* end(T (&amp;array)[N]) <ins>noexcept</ins>;
++template &lt;class C&gt; <ins>constexpr</ins> auto cbegin(const C&amp; c) -&gt; decltype(std::begin(c));
++template &lt;class C&gt; <ins>constexpr</ins> auto cend(const C&amp; c) -&gt; decltype(std::end(c));
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 24.7 [iterator.range] before p4+5 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* begin(T (&amp;array)[N]) <ins>noexcept</ins>;
++</pre>
++<blockquote>
++<p>
++-4- <i>Returns</i>: <tt>array</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* end(T (&amp;array)[N]) <ins>noexcept</ins>;
++</pre>
++<blockquote>
++<p>
++-5- <i>Returns</i>: <tt>array + N</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class C&gt; <ins>constexpr</ins> auto cbegin(const C&amp; c) -&gt; decltype(std::begin(c));
++</pre>
++<blockquote>
++<p>
++-6- <i>Returns</i>: <tt>std::begin(c)</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class C&gt; <ins>constexpr</ins> auto cend(const C&amp; c) -&gt; decltype(std::end(c));
++</pre>
++<blockquote>
++<p>
++-7- <i>Returns</i>: <tt>std::end(c)</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++</blockquote>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Add <tt>noexcept(noexcept(std::begin/end(c)))</tt> to <tt>cbegin</tt> and <tt>cend</tt>, move to ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Edit header <tt>&lt;iterator&gt;</tt> synopsis, 24.3 [iterator.synopsis] as indicated:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* begin(T (&amp;array)[N]) <ins>noexcept</ins>;
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* end(T (&amp;array)[N]) <ins>noexcept</ins>;
++template &lt;class C&gt; <ins>constexpr</ins> auto cbegin(const C&amp; c) <ins>noexcept(noexcept(std::begin(c)))</ins> -&gt; decltype(std::begin(c));
++template &lt;class C&gt; <ins>constexpr</ins> auto cend(const C&amp; c) <ins>noexcept(noexcept(std::end(c)))</ins> -&gt; decltype(std::end(c));
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 24.7 [iterator.range] before p4+5 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* begin(T (&amp;array)[N]) <ins>noexcept</ins>;
++</pre>
++<blockquote>
++<p>
++-4- <i>Returns</i>: <tt>array</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class T, size_t N&gt; <ins>constexpr</ins> T* end(T (&amp;array)[N]) <ins>noexcept</ins>;
++</pre>
++<blockquote>
++<p>
++-5- <i>Returns</i>: <tt>array + N</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class C&gt; <ins>constexpr</ins> auto cbegin(const C&amp; c) <ins>noexcept(noexcept(std::begin(c)))</ins> -&gt; decltype(std::begin(c));
++</pre>
++<blockquote>
++<p>
++-6- <i>Returns</i>: <tt>std::begin(c)</tt>.
++</p>
++</blockquote>
++<pre>
++template &lt;class C&gt; <ins>constexpr</ins> auto cend(const C&amp; c) <ins>noexcept(noexcept(std::end(c)))</ins> -&gt; decltype(std::end(c));
++</pre>
++<blockquote>
++<p>
++-7- <i>Returns</i>: <tt>std::end(c)</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2282"></a>2282. [fund.ts] Incorrect <tt>is_assignable</tt> constraint in <tt>optional::op=(U&amp;&amp;)</tt></h3>
++<p><b>Section:</b> X [optional.object.assign] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-08-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#optional.object.assign">issues</a> in [optional.object.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++Minor wording nit in X [optional.object.assign]/p15:
++</p>
++<blockquote><pre>
++template &lt;class U&gt; optional&lt;T&gt;&amp; operator=(U&amp;&amp; v);
++</pre>
++<blockquote>
++<p>
++-15- <i>Requires:</i> <tt>is_constructible&lt;T, U&gt;::value</tt> is true and <tt>is_assignable&lt;<span style="color:#C80000;font-weight:bold">U, T</span>&gt;::value</tt> is true.
++</p>
++</blockquote></blockquote>
++<p>
++Should be:
++</p>
++<blockquote><pre>
++template &lt;class U&gt; optional&lt;T&gt;&amp; operator=(U&amp;&amp; v);
++</pre>
++<blockquote>
++<p>
++-15- <i>Requires:</i> <tt>is_constructible&lt;T, U&gt;::value</tt> is true and <tt>is_assignable&lt;<span style="color:#C80000;font-weight:bold">T&amp;, U</span>&gt;::value</tt> is true.
++</p>
++</blockquote></blockquote>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as fundamentals-ts.
++</p>
++
++<p><i>[2014-06-07 Daniel comments]</i></p>
++
++<p>
++This issue should be set to <b>Resolved</b>, because the wording fix is already applied in the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html#optional.object.assign">last fundamentals working draft</a>.
++</p>
++
++<p><i>[2014-06-16 Rapperswill]</i></p>
++
++<p>
++Confirmed that this issue is resolved in the current Library Fundamentals working paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit X [optional.object.assign] p15 as indicated:</p>
++
++<blockquote><pre>
++template &lt;class U&gt; optional&lt;T&gt;&amp; operator=(U&amp;&amp; v);
++</pre>
++<blockquote>
++<p>
++-15- <i>Requires:</i> <tt>is_constructible&lt;T, U&gt;::value</tt> is true and
++<tt>is_assignable&lt;<del>U, T</del><ins>T&amp;, U</ins>&gt;::value</tt> is true.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2283"></a>2283. [fund.ts] <tt>optional</tt> declares and then does not define an <tt>operator&lt;()</tt></h3>
++<p><b>Section:</b> X [optional.comp_with_t] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-08-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++In [optional.syn] there is:
++</p>
++<blockquote><pre>
++template &lt;class T&gt; constexpr bool operator&lt;(const T&amp;, const optional&lt;T&gt;&amp;);
++</pre></blockquote>
++<p>
++But I can find no definition for this signature.
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as fundamentals-ts.
++</p>
++
++<p><i>[2014-06-07 Daniel comments]</i></p>
++
++<p>
++This issue should be set to <b>Resolved</b>, because the wording fix is already applied in the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html#optional.comp_with_t">last fundamentals working draft</a>.
++</p>
++
++<p><i>[2014-06-16 Rapperswill]</i></p>
++
++<p>
++Confirmed that this issue is resolved in the current Library Fundamentals working paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Add to X [optional.comp_with_t]:</p>
++
++<blockquote><pre>
++<ins>template &lt;class T&gt; constexpr bool operator&lt;(const T&amp; v, const optional&lt;T&gt;&amp; x);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns:</i> <tt>bool(x) ? less&lt;T&gt;{}(v, *x) : false</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2284"></a>2284. Inconsistency in <tt>allocator_traits::max_size</tt></h3>
++<p><b>Section:</b> 20.7.8 [allocator.traits] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2013-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Section 20.7.8 [allocator.traits] says:
++</p>
++<blockquote><pre>
++static size_type max_size(const Alloc&amp; a) noexcept;
++</pre></blockquote>
++<p>
++Section 20.7.8.2 [allocator.traits.members] says:
++</p>
++<blockquote><pre>
++static size_type max_size(Alloc&amp; a) noexcept;
++</pre></blockquote>
++
++<p>
++These should be the same.
++</p>
++
++<p>
++Discussion:
++</p>
++
++<p>
++Pablo (who I believe wrote the <tt>allocator_traits</tt> proposal) says "The function should take a <tt>const</tt> reference."
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++No objections, so moved to Immediate.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 20.7.8.2 [allocator.traits.members] as follows:</p>
++
++<blockquote><pre>
++static size_type max_size(<ins>const</ins> Alloc&amp; a) noexcept;
++</pre>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2285"></a>2285. <tt>make_reverse_iterator</tt></h3>
++<p><b>Section:</b> 24.5.1 [reverse.iterators] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2013-08-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iterators">issues</a> in [reverse.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++We have <tt>make_move_iterator</tt>, but not <tt>make_reverse_iterator</tt>, which
++is also useful when dealing with some types without an <tt>rbegin</tt>/<tt>rend</tt> support (like, C strings).
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Billy: reviewed it last night STL: has suggested prior, but denied for complexity
++<p/>
++Billy: Alisdair wanted to review for <tt>reverse(reverse())</tt>;
++<p/>
++STL: likes the issue, was like him
++<p/>
++Stefanus: likes definitions, places where things should be
++<p/>
++STL: for consistency with <tt>make_move_iterator</tt>
++<p/>
++Stefanus: minor editorial issue - subdivision in these 2 sections is different from [move.iter].
++See 24.5.3.3.14 [move.iter.nonmember]
++<p/>
++STL: motion to move to Ready
++<p/>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change header <tt>&lt;iterator&gt;</tt> synopsis, 24.3 [iterator.synopsis] as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ [&hellip;]
++ template &lt;class Iterator&gt;
++ reverse_iterator&lt;Iterator&gt; operator+(
++ typename reverse_iterator&lt;Iterator&gt;::difference_type n,
++ const reverse_iterator&lt;Iterator>&amp; x);
++<ins>
++ template &lt;class Iterator&gt;
++ reverse_iterator&lt;Iterator&gt; make_reverse_iterator(Iterator i);
++</ins>
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change class template <tt>reverse_iterator</tt> synopsis, 24.5.1.1 [reverse.iterator] as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ [&hellip;]
++ template &lt;class Iterator&gt;
++ reverse_iterator&lt;Iterator&gt; operator+(
++ typename reverse_iterator&lt;Iterator&gt;::difference_type n,
++ const reverse_iterator&lt;Iterator>&amp; x);
++<ins>
++ template &lt;class Iterator&gt;
++ reverse_iterator&lt;Iterator&gt; make_reverse_iterator(Iterator i);
++</ins>
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>After 24.5.1.3.20 [reverse.iter.opsum] add the following new sub-clause to 24.5.1.3 [reverse.iter.ops]:</p>
++
++<blockquote>
++<pre>
++<ins>
++template &lt;class Iterator&gt;
++ reverse_iterator&lt;Iterator&gt; make_reverse_iterator(Iterator i);
++</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Returns:</i> <tt>reverse_iterator&lt;Iterator&gt;(i)</tt>.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2287"></a>2287. [fund.ts] Incorrect exception safety for <tt>optional</tt> copy assignment operator</h3>
++<p><b>Section:</b> X [optional.object.assign] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2013-08-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#optional.object.assign">issues</a> in [optional.object.assign].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++The <i>Exception safety</i> paragraph of X [optional.object.assign] calls out <tt>T</tt>'s copy constructor when
++it should refer to <tt>T</tt>'s copy assignment operator.
++</p>
++
++<p><i>[2013-09 Chicago:]</i></p>
++
++<p>
++Move to Deferred. This feature will ship after C++14 and should be revisited then.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as fundamentals-ts.
++</p>
++
++<p><i>[2014-06-07 Daniel comments]</i></p>
++
++<p>
++This issue should be set to <b>Resolved</b>, because the wording fix is already applied in the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html#optional.object.assign">last fundamentals working draft</a>.
++</p>
++
++<p><i>[2014-06-16 Rapperswill]</i></p>
++
++<p>
++Confirmed that this issue is resolved in the current Library Fundamentals working paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change X [optional.object.assign] as indicated:</p>
++
++<blockquote><pre>
++optional&lt;T&gt;&amp; operator=(const optional&lt;T&gt;&amp; rhs);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-8- <i>Exception safety:</i> If any exception is thrown, the values of <tt>init</tt> and <tt>rhs.init</tt> remain unchanged. If
++an exception is thrown during the call to <tt>T</tt>'s copy constructor, no effect. If an exception is thrown
++during the call to <tt>T</tt>'s copy assignment, the state of its contained value is as defined by the exception
++safety guarantee of <tt>T</tt>'s copy <del>constructor</del><ins>assignment</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2288"></a>2288. Inconsistent requirements for shared mutexes</h3>
++<p><b>Section:</b> 30.4.1.4 [thread.sharedmutex.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-08-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Albeit shared mutex types refine timed mutex types, the requirements imposed on the corresponding required member function
++expressions are inconsistent in several aspects, most probably because failing synchronisation with wording changes for
++timed mutexes applied by some issues:
++</p>
++
++<ol>
++<li>
++<p>
++Due to acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3568.html">N3568</a> a wording phrase
++came in 30.4.1.4 [thread.sharedmutex.requirements] p26,
++</p>
++<blockquote><p>
++<i>Effects:</i> If the tick period of <tt>rel_time</tt> is not exactly convertible to the native tick period, the
++duration shall be rounded up to the nearest native tick period. [&hellip;]
++</p></blockquote>
++<p>
++while a very similar one had been removed for 30.4.1.3 [thread.timedmutex.requirements] by LWG <a href="lwg-defects.html#2091">2091</a>.
++<p/>
++Having this guaranteed effect for <tt>try_lock_shared_for</tt> but not for <tt>try_lock_for</tt> seems inconsistent
++and astonishing.
++<p/>
++If the actual intended restriction imposed onto the implementation is to forbid early wakeups here, we should ensure that
++to hold for timed mutex's <tt>try_lock_for</tt> as well. Note that the rationale provided for LWG <a href="lwg-defects.html#2091">2091</a> was
++a potential late wakeup situation, but it seems that there is no implementation restriction that prevents early wakeups.
++</p>
++</li>
++
++<li>
++<p>
++The shared-lock requirements for any <tt>*lock*()</tt> functions don't provide the guarantee that "If an exception is thrown then
++a lock shall not have been acquired for the current execution agent.". For other mutex types this guarantee can be derived from
++the corresponding <tt>TimedLockable</tt> requirements, but there are no <tt>SharedLockable</tt> requirements.
++</p>
++</li>
++
++<li>
++<p>
++The shared-lock requirements for <tt>*lock_for/_until()</tt> functions require "<i>Throws:</i> Nothing."
++instead of "<i>Throws:</i> Timeout-related exceptions (30.2.4)." which had been added by LWG <a href="lwg-defects.html#2093">2093</a>, because user-provided
++clocks, durations, or time points may throw exceptions.
++</p>
++</li>
++
++<li>
++<p>
++With the addition of <tt>std::shared_mutex</tt>, the explicit lists of 30.4.1.2 [thread.mutex.requirements.mutex] p7+15,
++</p>
++<blockquote><p>
++<i>Requires:</i> If <tt>m</tt> is of type <tt>std::mutex</tt> or <tt>std::timed_mutex</tt>, the calling thread does not own the mutex.
++</p></blockquote>
++<p>
++and of 30.4.1.3 [thread.timedmutex.requirements] p4+11,
++</p>
++<blockquote><p>
++<i>Requires:</i> If <tt>m</tt> is of type <tt>std::timed_mutex</tt>, the calling thread does not own the mutex.
++</p></blockquote>
++<p>
++are incomplete and should add the non-recursive <tt>std::shared_mutex</tt> as well.
++</p>
++</li>
++</ol>
++
++<p><i>[2014-02-16: Moved as Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 30.4.1.2 [thread.mutex.requirements.mutex] p7+15 as indicated:</p>
++
++<blockquote>
++<p>
++-6- The expression <tt>m.lock()</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-7- <i>Requires:</i> If <tt>m</tt> is of type <tt>std::mutex</tt><del> or</del><ins>,</ins> <tt>std::timed_mutex</tt><ins>, or
++<tt>std::shared_mutex</tt></ins>, the calling thread does not own the mutex.
++</p>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<p>
++-14- The expression <tt>m.try_lock()</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-15- <i>Requires:</i> If <tt>m</tt> is of type <tt>std::mutex</tt><del> or</del><ins>,</ins> <tt>std::timed_mutex</tt><ins>, or
++<tt>std::shared_mutex</tt></ins>, the calling thread does not own the mutex.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 30.4.1.3 [thread.timedmutex.requirements] p4+11 as indicated:</p>
++
++<blockquote>
++<p>
++-3- The expression <tt>m.try_lock_for(rel_time)</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-4- <i>Requires:</i> If <tt>m</tt> is of type <tt>std::timed_mutex</tt><ins> or <tt>std::shared_mutex</tt></ins>,
++the calling thread does not own the mutex.
++</p>
++</blockquote>
++<p>
++[&hellip;]
++</p>
++<p>
++-10- The expression <tt>m.try_lock_until(abs_time)</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-11- <i>Requires:</i> If <tt>m</tt> is of type <tt>std::timed_mutex</tt><ins> or <tt>std::shared_mutex</tt></ins>,
++the calling thread does not own the mutex.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 30.4.1.4 [thread.sharedmutex.requirements] as indicated:</p>
++
++<blockquote>
++<p>
++-3- The expression <tt>m.lock_shared()</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-4- <i>Requires:</i> The calling thread has no ownership of the mutex.
++<p/>
++-5- <i>Effects:</i> Blocks the calling thread until shared ownership of the mutex can be obtained for the calling
++thread. <ins>If an exception is thrown then a shared lock shall not have been acquired for the current thread.</ins>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<p>
++-24- The expression <tt>m.try_lock_shared_for(rel_time)</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-25- <i>Requires:</i> The calling thread has no ownership of the mutex.
++<p/>
++-26- <i>Effects:</i> <del>If the tick period of <tt>rel_time</tt> is not exactly convertible to the native tick period, the
++duration shall be rounded up to the nearest native tick period.</del> Attempts to obtain shared lock
++ownership for the calling thread within the relative timeout (30.2.4) specified by <tt>rel_time</tt>. If the
++time specified by <tt>rel_time</tt> is less than or equal to <tt>rel_time.zero()</tt>, the function attempts to obtain
++ownership without blocking (as if by calling <tt>try_lock_shared()</tt>). The function shall return within
++the timeout specified by <tt>rel_time</tt> only if it has obtained shared ownership of the mutex object. [<i>Note:</i>
++As with <tt>try_lock()</tt>, there is no guarantee that ownership will be obtained if the lock is available, but
++implementations are expected to make a strong effort to do so. &mdash; <i>end note</i>] <ins>If an exception is thrown then
++a shared lock shall not have been acquired for the current thread.</ins>
++<p/>
++[&hellip;]
++<p/>
++-30- <i>Throws:</i> <del>Nothing</del><ins>Timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++</p>
++</blockquote>
++<p>
++-31- The expression <tt>m.try_lock_shared_until(abs_time)</tt> shall be well-formed and have the following semantics:
++</p>
++<blockquote>
++<p>
++-32- <i>Requires:</i> The calling thread has no ownership of the mutex.
++<p/>
++-33- <i>Effects:</i> The function attempts to obtain shared ownership of the mutex. If <tt>abs_time</tt> has already
++passed, the function attempts to obtain shared ownership without blocking (as if by calling <tt>try_lock_shared()</tt>).
++The function shall return before the absolute timeout (30.2.4) specified by <tt>abs_time</tt>
++only if it has obtained shared ownership of the mutex object. [<i>Note:</i> As with <tt>try_lock()</tt>, there is no
++guarantee that ownership will be obtained if the lock is available, but implementations are expected
++to make a strong effort to do so. &mdash; <i>end note</i>] <ins>If an exception is thrown then
++a shared lock shall not have been acquired for the current thread.</ins>
++<p/>
++[&hellip;]
++<p/>
++-37- <i>Throws:</i> <del>Nothing</del><ins>Timeout-related exceptions (30.2.4 [thread.req.timing])</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2291"></a>2291. <tt>std::hash</tt> is vulnerable to collision DoS attack</h3>
++<p><b>Section:</b> 17.6.3.4 [hash.requirements] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2013-09-02 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#hash.requirements">issues</a> in [hash.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++For a non-cryptographic hash function, it's possible to pre-calculate massive inputs with
++the same hashed value to algorithmically slow down the unordered containers, and results
++in a denial-of-service attack. Many languages with built-in hash table support have fixed
++this issue. For example, Perl has universal hashing, Python 3 uses salted hashes.
++<p/>
++However, for C++, in 17.6.3.4 [hash.requirements] p2, Table 26:
++</p>
++
++<blockquote><p>
++The value returned shall depend only on the argument <tt>k</tt>.
++[<i>Note:</i> Thus all evaluations of the expression <tt>h(k)</tt> with the
++same value for <tt>k</tt> yield the same result. &mdash; <i>end note</i>]
++</p></blockquote>
++
++<p>
++The wording is not clear here: does that mean all the standard
++library implementations must use the same hash function for a same
++type? Or it is not allowed for an implementation to change its hash
++function?
++<p/>
++I suggest to explicitly allow the salted hash functions.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++Moved to Ready.
++</p>
++
++<p>
++There is some concern that the issue of better hashing, especially standardizing any kind of
++secure hashing, is a feature that deserves attention in LEWG
++</p>
++
++<p>
++The proposed resolution is much simpler than the larger issue though, merely clarifying a
++permission that many implementers believe they already have, without mandating a change to
++more straight forward implementations.
++</p>
++
++<p>
++Move to Ready, rather than Immediate, as even the permission has been contentious in reflector
++discussion, although the consensus in Chicago is to accept as written unless we hear a further
++strong objection.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 17.6.3.4 [hash.requirements] p2, Table 26, as indicated: <em>[Editorial note:
++We can consider adding some additional guideline here. Unlike
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3333.html">N3333</a>, this
++proposed change makes the hashing per-execution instead of per-process. The standard does not
++discuss OS processes. And, practically, a per-process hashing makes a program unable to
++share an unordered container to a child process. &mdash; end note ]</em></p>
++
++<blockquote>
++<table border="1">
++<caption>Table 26 &mdash; Hash requirements [hash]</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Requirement</th>
++</tr>
++
++<tr>
++<td>
++<tt>h(k)</tt>
++</td>
++<td>
++<tt>size_t</tt>
++</td>
++<td>
++The value returned shall depend only on the argument <tt>k</tt><br/>
++<ins>for the duration of the program</ins>.<br/>
++[<i>Note:</i> Thus all evaluations of the expression <tt>h(k)</tt> with the<br/>
++same value for <tt>k</tt> yield the same result <ins>for a given<br/>
++execution of the program</ins>. &mdash; <i>end note</i>]<br/>
++</td>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2293"></a>2293. Wrong facet used by <tt>num_put::do_put</tt></h3>
++<p><b>Section:</b> 22.4.2.2.2 [facet.num.put.virtuals] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Juan Soulie <b>Opened:</b> 2013-09-04 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#facet.num.put.virtuals">issues</a> in [facet.num.put.virtuals].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++At the end of 22.4.2.2.2 [facet.num.put.virtuals] (in p6), the return value is said to be obtained by calling
++<tt>truename</tt> or <tt>falsename</tt> on the wrong facet: <tt>ctype</tt> should be replaced by <tt>numpunct</tt>.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 22.4.2.2.2 [facet.num.put.virtuals] p6 as indicated:</p>
++
++<blockquote><p>
++-6- <i>Returns:</i> If <tt>(str.flags() &amp; ios_base::boolalpha) == 0</tt> returns <tt>do_put(out, str, fill, (int)val)</tt>,
++otherwise obtains a string <tt>s</tt> as if by
++</p>
++<blockquote><pre>
++string_type s =
++ val ? use_facet&lt;<del>ctype</del><ins>numpunct</ins>&lt;charT&gt; &gt;(loc).truename()
++ : use_facet&lt;<del>ctype</del><ins>numpunct</ins>&lt;charT&gt; &gt;(loc).falsename();
++</pre></blockquote>
++<p>
++and then inserts each character c of s into out via *out++ = c and returns out.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2298"></a>2298. [CD] <tt>is_nothrow_constructible</tt> is always false because of <tt>create&lt;&gt;</tt></h3>
++<p><b>Section:</b> 20.10.4.3 [meta.unary.prop] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.unary.prop">active issues</a> in [meta.unary.prop].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.unary.prop">issues</a> in [meta.unary.prop].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses US 18</b></p>
++
++<p>
++The trait <tt>is_constructible&lt;T, Args...&gt;</tt> is defined in terms of a helper template, <tt>create&lt;&gt;</tt>,
++that is identical to <tt>std::declval&lt;&gt;</tt> except for the latter's <tt>noexcept</tt> clause.
++<p/>
++If the absence of <tt>noexcept</tt> is critical to this definition, insert a Note of explanation; otherwise, excise
++<tt>create&lt;&gt;</tt> and reformulate in terms of <tt>declval&lt;&gt;</tt> the definition of <tt>is_constructible</tt>.
++</p>
++
++<p><i>[2013-09-24 Daniel comments and provides resolution suggestion]</i></p>
++
++
++<p>
++Replacing <tt>create&lt;&gt;</tt> by <tt>std::declval&lt;&gt;</tt> would make the situation worse, because the definition of
++<tt>is_constructible</tt> is based on a well-formed variable definition and there is no way to specify a variable definition
++without odr-using its initializer arguments. It should also be added, that there is another problem with the specification of
++all existing <tt>is_trivially_*</tt> traits, because neither <tt>create&lt;&gt;</tt> nor <tt>std::declval&lt;&gt;</tt>
++are considered as trivial functions, but this should be solved by a different issue.
++</p>
++
++<p><i>[2013-09-26 Nico improves wording]</i></p>
++
++
++<p>
++The additional change is just to keep both places were <tt>create()</tt> is defined consistent.
++</p>
++
++<p><i>[2013-09 Chicago]</i></p>
++
++<p>
++No objections, so moved to Immediate.
++</p>
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 20.10.4.3 [meta.unary.prop] around p6 as indicated:</p>
++
++<blockquote><p>
++-6- Given the following function prototype:
++</p>
++<blockquote><pre>
++template &lt;class T&gt;
++ typename add_rvalue_reference&lt;T&gt;::type create() <ins>noexcept</ins>;
++</pre></blockquote>
++<p>
++the predicate condition for a template specialization <tt>is_constructible&lt;T, Args...&gt;</tt> shall be satisfied
++if and only if the following variable definition would be well-formed for some invented variable <tt>t</tt>:
++</p>
++<blockquote><pre>
++T t(create&lt;Args&gt;()...);
++</pre></blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 20.10.4.3 [meta.unary.prop] around p4 as indicated:</p>
++
++<blockquote><p>
++-4- Given the following function prototype:
++</p>
++<blockquote><pre>template &lt;class T&gt;
++ typename add_rvalue_reference&lt;T&gt;::type create() <ins>noexcept</ins>;
++</pre></blockquote>
++<p>
++the predicate condition for a template specialization <tt>is_convertible&lt;From, To&gt;</tt> shall be satisfied if and
++only if the return expression in the following code would be well-formed, including any implicit conversions
++to the return type of the function:
++</p>
++<blockquote><pre>
++To test() {
++ return create&lt;From&gt;();
++}
++</pre></blockquote>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2299"></a>2299. [CD] Effects of inaccessible <tt>key_compare::is_transparent</tt> type are not clear</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-24 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses ES 16</b></p>
++
++<p>
++The condition "<tt>X::key_compare::is_transparent</tt> exists" does not specify that the type be publicly accessible.
++<p/>
++Consider the public accessibility of <tt>X::key_compare::is_transparent</tt> and whether its potential inaccessibility
++should be banned for a compliant <tt>key_compare</tt> type.
++</p>
++
++<p><i>[2013-09-24 Daniel provides resolution suggestion]</i></p>
++
++
++<p><i>[2013-09-25 Chicago]</i></p>
++
++<p>
++Daniel's wording is good, advance to Immediate to respond to NB comment.
++</p>
++
++<p><i>[2013-09-26 Chicago]</i></p>
++
++<p>
++Moved back to Review as Daniel would like another look at the words, and to confirm implementability.
++</p>
++
++<p>
++<strong>Previous resolution from Daniel [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<ol>
++
++<li><p>Change 23.2.4 [associative.reqmts] p8 as indicated:</p>
++
++<blockquote><p>
++-8- In Table 102, <tt>X</tt> denotes an associative container class, <tt>a</tt> denotes a value of <tt>X</tt>, <tt>a_uniq</tt>
++denotes a value of <tt>X</tt> when <tt>X</tt> supports unique keys, <tt>a_eq</tt> denotes a value of <tt>X</tt> when <tt>X</tt>
++supports multiple keys, <tt>a_tran</tt> denotes a value of <tt>X</tt> when <del>the</del><ins>a publicly accessible</ins> type
++<tt>X::key_compare::is_transparent</tt> exists <ins>whose name is unambiguous and not hidden</ins>,
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 23.2.4 [associative.reqmts] p13 as indicated:</p>
++
++<blockquote><p>
++The member function templates <tt>find</tt>, <tt>count</tt>, <tt>lower_bound</tt>, <tt>upper_bound</tt>, and <tt>equal_range</tt> shall not
++participate in overload resolution unless <del>the</del><ins>a publicly accessible</ins> type
++<tt>Compare::is_transparent</tt> exists <ins>whose name is unambiguous and not hidden</ins>.
++</p></blockquote>
++</li>
++</ol>
++
++</blockquote>
++
++<p><i>[2014-02-10 Daniel comments provides alternative wording]</i></p>
++
++
++<p>
++I could confirm that my previous concerns were unwarranted, because they turned out to be due to a compiler-bug.
++Nonetheless I would suggest to replace the previously suggested replication of core-wording situations (access, ambiguity, hidden)
++by a single more robust phrase based on "valid type".
++</p>
++
++
++<p><i>[2014-02-12 Issaquah: Move to Immediate]</i></p>
++
++<p>
++STL: This uses &quot;valid type&quot;, which is a Phrase Of Power in Core, and Daniel has a citation for the term.
++</p>
++<p>
++Jonathan: It's nice to rely on Core.
++</p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++
++<li><p>Change 23.2.4 [associative.reqmts] p8 as indicated:</p>
++
++<blockquote><p>
++-8- In Table 102, <tt>X</tt> denotes an associative container class, <tt>a</tt> denotes a value of <tt>X</tt>, <tt>a_uniq</tt>
++denotes a value of <tt>X</tt> when <tt>X</tt> supports unique keys, <tt>a_eq</tt> denotes a value of <tt>X</tt> when <tt>X</tt>
++supports multiple keys, <tt>a_tran</tt> denotes a value of <tt>X</tt> when the <del>type</del><ins>qualified-id</ins>
++<tt>X::key_compare::is_transparent</tt> <del>exists</del><ins>is valid and denotes a type (14.8.2 [temp.deduct])</ins>,
++[&hellip;]
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 23.2.4 [associative.reqmts] p13 as indicated:</p>
++
++<blockquote><p>
++The member function templates <tt>find</tt>, <tt>count</tt>, <tt>lower_bound</tt>, <tt>upper_bound</tt>, and <tt>equal_range</tt> shall not
++participate in overload resolution unless the <del>type</del><ins>qualified-id</ins>
++<tt>Compare::is_transparent</tt> <del>exists</del><ins>is valid and denotes a type (14.8.2 [temp.deduct])</ins>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2300"></a>2300. [CD] Redundant sections for <tt>map</tt> and <tt>multimap</tt> members should be removed</h3>
++<p><b>Section:</b> X [map.ops], X [multimap.ops] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2013-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses ES 17</b></p>
++
++<p>
++Sections are redundant with general associative container requirements at 23.2.4 [associative.reqmts], Table 102.
++<p/>
++Suggested action:
++<p/>
++Delete sections.
++</p>
++
++<p><i>[2013-09-25 Daniel provides resolution suggestion]</i></p>
++
++
++<p><i>[2013-09-25 Chicago]</i></p>
++
++<p>
++Daniel's wording is good, move to Immediate to resolve NB comment.
++</p>
++
++<p><i>[2013-09-29 Chicago]</i></p>
++
++<p>
++Accept for Working Paper
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change the header <tt>&lt;map&gt;</tt> synopsis, 23.4.4.1 [map.overview] p2 as indicated:</p>
++
++<blockquote><pre>
++// <del>23.4.4.5,</del> map operations:
++iterator find(const key_type&amp; x);
++const_iterator find(const key_type&amp; x) const;
++template &lt;class K&gt; iterator find(const K&amp; x);
++template &lt;class K&gt; const_iterator find(const K&amp; x) const;
++</pre>
++</blockquote>
++</li>
++
++<li><p>Delete the complete sub-clause X [map.ops]:</p>
++
++<p>
++<del>23.4.4.5 map operations [map.ops]</del>
++</p>
++<blockquote><pre>
++<del>iterator find(const key_type&amp; x);
++const_iterator find(const key_type&amp; x) const;
++iterator lower_bound(const key_type&amp; x);
++const_iterator lower_bound(const key_type&amp; x) const;
++iterator upper_bound(const key_type&amp; x);
++const_iterator upper_bound(const key_type &amp;x) const;
++pair&lt;iterator, iterator&gt;
++ equal_range(const key_type &amp;x);
++pair&lt;const_iterator, const_iterator&gt;
++ equal_range(const key_type&amp; x) const;</del>
++</pre><blockquote>
++<p>
++<del>-1- The <tt>find</tt>, <tt>lower_bound</tt>, <tt>upper_bound</tt> and <tt>equal_range</tt> member functions each have two versions,
++one const and the other non-const. In each case the behavior of the two functions is identical except
++that the const version returns a <tt>const_iterator</tt> and the non-const version an <tt>iterator</tt> (23.2.4).</del>
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Delete the complete sub-clause X [multimap.ops]:</p>
++
++<p>
++<del>23.4.5.4 multimap operations [multimap.ops]</del>
++</p>
++<blockquote><pre>
++<del>iterator find(const key_type &amp;x);
++const_iterator find(const key_type&amp; x) const;
++
++iterator lower_bound(const key_type&amp; x);
++const_iterator lower_bound(const key_type&amp; x) const;
++
++pair&lt;iterator, iterator&gt;
++ equal_range(const key_type &amp;x);
++pair&lt;const_iterator, const_iterator&gt;
++ equal_range(const key_type&amp; x) const;</del>
++</pre><blockquote>
++<p>
++<del>-1- The <tt>find</tt>, <tt>lower_bound</tt>, <tt>upper_bound</tt> and <tt>equal_range</tt> member functions each have two versions,
++one const and one non-const. In each case the behavior of the two versions is identical except
++that the const version returns a <tt>const_iterator</tt> and the non-const version an <tt>iterator</tt> (23.2.4).</del>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2301"></a>2301. Why is <tt>std::tie</tt> not <tt>constexpr</tt>?</h3>
++<p><b>Section:</b> 20.4.2.4 [tuple.creation] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Rein Halbersma <b>Opened:</b> 2013-09-11 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.creation">issues</a> in [tuple.creation].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">N3471</a>, a bunch of routines from header
++<tt>&lt;tuple&gt;</tt> were made <tt>constexpr</tt>.
++<p/>
++<tt>make_tuple/tuple_cat/get&lt;&gt;(tuple)/</tt>relational operators &mdash; all these were "<tt>constexpr</tt>-ified".
++<p/>
++But not <tt>tie</tt>. This is similar to Issue <a href="lwg-defects.html#2275">2275</a>, where the same observation was made about <tt>forward_as_tuple</tt>.
++</p>
++
++<p><i>[2014-02-13 Issaquah: Move as Immediate]</i></p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change the header <tt>&lt;tuple&gt;</tt> synopsis, 20.4.1 [tuple.general] p2 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class... Types&gt;
++ <ins>constexpr</ins> tuple&lt;Types&amp;...&gt; tie(Types&amp;...) noexcept;
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.4.2.4 [tuple.creation] around p7 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class... Types&gt;
++ <ins>constexpr</ins> tuple&lt;Types&amp;...&gt; tie(Types&amp;... t) noexcept;
++</pre>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2304"></a>2304. Complexity of <tt>count</tt> in unordered associative containers</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2013-09-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Table 103 in 23.2.5 [unord.req] states that the complexity of <tt>b.count(k)</tt> is average case &#x1d4aa;(<tt>1</tt>) rather
++than linear with the number of equivalent elements, which seems to be a typo as this requires holding an internal
++count of elements in each group of equivalent keys, something which hardly looks the intent of the standard and no
++(known by the submitter) stdlib implementation is currently doing.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change Table 103 as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 103 &mdash; Unordered associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>b.count(k)</tt>
++</td>
++<td>
++<tt>size_type</tt>
++</td>
++<td>
++Returns the number of elements with key equivalent to <tt>k</tt>.
++</td>
++<td>
++Average case &#x1d4aa;(<tt><del>1</del><ins>b.count(k)</ins></tt>), worst case &#x1d4aa;(<tt>b.size()</tt>).
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2306"></a>2306. <tt>match_results::reference</tt> should be <tt>value_type&amp;</tt>, not <tt>const value_type&amp;</tt></h3>
++<p><b>Section:</b> 28.10 [re.results] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Matt Austern <b>Opened:</b> 2013-09-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.results">issues</a> in [re.results].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The match_results class synopsis has
++</p>
++<blockquote><pre>
++typedef const value_type&amp; const_reference;
++typedef const_reference reference;
++</pre></blockquote>
++<p>
++We're getting too enthusiastic about types here by insisting that <tt>reference</tt> is a const reference, even
++though <tt>match_results</tt> is a read-only container. In the container requirements table (Table 96, in section
++23.2.1 [container.requirements.general] we say that <tt>Container::reference</tt> is "lvalue of <tt>T</tt>" and
++<tt>Container::const_reference</tt> is "const lvalue of <tt>T</tt>".
++</p>
++<p>
++That phrasing in the container requirements table is admittedly a little fuzzy and ought to be clarified (as discussed in
++lwg issue <a href="lwg-defects.html#2182">2182</a>), but in context it's clear that <tt>Container::reference</tt> ought to be a <tt>T&amp;</tt>
++even for constant containers. In the rest of Clause 23 we see that <tt>Container::reference</tt> is <tt>T&amp;</tt>, not
++<tt>const T&amp;</tt>, even for const-qualified containers and that it's <tt>T&amp;</tt>, not <tt>const T&amp;</tt>, even
++for containers like <tt>set</tt> and <tt>unordered_set</tt> that provide const iterators only.
++<p/>
++The way we handle const containers is just that in the case of a const-qualified container (including <tt>match_results</tt>)
++there are no operations that return <tt>Container::reference</tt>. That's already the case, so this issue is complaining
++about an unused typedef.
++</p>
++
++<p><i>[2013-10-17: Daniel comments]</i></p>
++
++<p>
++The <tt>std::initializer_list</tt> synopsis, 18.9 [support.initlist] shows a similar problem:
++</p>
++<blockquote><pre>
++template&lt;class E&gt; class initializer_list {
++public:
++ typedef E value_type;
++ typedef const E&amp; reference;
++ typedef const E&amp; const_reference;
++ [&hellip;]
++}
++</pre></blockquote>
++<p>
++Given the fact that <tt>std::initializer_list</tt> doesn't meet the container requirements anyway (and is such a core-language related
++type) I recommend to stick with the current state.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change the class template <tt>match_results</tt> header synopsis, 28.10 [re.results] p4 as indicated:</p>
++
++<blockquote><pre>
++typedef const value_type&amp; const_reference;
++typedef <del>const_reference</del><ins>value_type&amp;</ins> reference;
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2308"></a>2308. Clarify container destructor requirements w.r.t. <tt>std::array</tt></h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-09-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++It has been suggested that Table 96 &mdash; "Container requirements" makes
++confusing requirements for the destructor of <tt>std::array</tt>:
++<p/>
++"note: the destructor is applied to every element of <tt>a</tt>; all the memory is deallocated."
++<p/>
++Since <tt>std::array</tt> obtains no memory, there is none to deallocate,
++arguably making it unclear what the requirement means for <tt>std::array::~array()</tt>.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change in 23.2.1 [container.requirements.general], Table 96 &mdash; "Container requirements",
++the "Assertion/note/pre-/post-condition" for the expression "<tt>(&amp;a)-&gt;~X()</tt>" as indicated:</p>
++
++<blockquote><p>
++note: the destructor is applied to every element of <tt>a</tt>; <del>all the</del><ins>any</ins> memory
++<ins>obtained</ins> is deallocated.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2313"></a>2313. <tt>tuple_size</tt> should always derive from <tt>integral_constant&lt;size_t, N&gt;</tt></h3>
++<p><b>Section:</b> 20.4.2.5 [tuple.helper] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#tuple.helper">issues</a> in [tuple.helper].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 20.4.2.5 [tuple.helper], the "primary template" is depicted as:
++</p>
++<blockquote><pre>
++template &lt;class... Types&gt;
++class tuple_size&lt;tuple&lt;Types...&gt; &gt;
++ : public integral_constant&lt;size_t, sizeof...(Types)&gt; { };
++</pre></blockquote>
++<p>
++However, 20.3.4 [pair.astuple]/1-2 and 23.3.2.9 [array.tuple]/1-2 are underspecified, saying:
++</p>
++<blockquote><pre>
++tuple_size&lt;pair&lt;T1, T2&gt; &gt;::value
++</pre><blockquote>
++<p>
++<i>Returns:</i> Integral constant expression.
++<p/>
++<i>Value:</i> <tt>2</tt>.
++</p></blockquote>
++</blockquote>
++<blockquote><pre>
++tuple_size&lt;array&lt;T, N&gt; &gt;::value
++</pre><blockquote>
++<p>
++<i>Return type:</i> integral constant expression.
++<p/>
++<i>Value:</i> <tt>N</tt>
++</p></blockquote>
++</blockquote>
++<p>
++They should be required to behave like the "primary template". This is more than a stylistic decision &mdash; it allows
++<tt>tuple_size</tt> to be passed to a function taking <tt>integral_constant</tt>.
++<p/>
++LWG <a href="lwg-defects.html#1118">1118</a> noticed this underspecification, but instead of correcting it, the resolution changed
++20.4.2.5 [tuple.helper]/3 to require <tt>tuple_size&lt;<i>cv</i> T&gt;</tt> to derive from
++<tt>integral_constant&lt;remove_cv&lt;decltype(TS::value)&gt;::type, TS::value&gt;</tt>. This is unnecessarily overgeneralized.
++<tt>tuple_size</tt> is primarily for tuples, where it is required to be <tt>size_t</tt>, and it has been extended to handle
++pairs and arrays, which (as explained above) should also be guaranteed to be <tt>size_t</tt>. <tt>tuple_size&lt;<i>cv</i> T&gt;</tt>
++works with <i>cv</i>-qualified tuples, pairs, arrays, and user-defined types that also want to participate in the <tt>tuple_size</tt>
++system. It would be far simpler and perfectly reasonable to expect that user-defined types supporting the "tuple-like protocol"
++should have <tt>tuple_sizes</tt> of <tt>size_t</tt>.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 20.3.4 [pair.astuple]/1-2 as indicated:</p>
++
++<blockquote><pre>
++<del>tuple_size&lt;pair&lt;T1, T2&gt; &gt;::value</del>
++<ins>template &lt;class T1, class T2&gt;
++struct tuple_size&lt;pair&lt;T1, T2&gt;&gt;
++ : integral_constant&lt;size_t, 2&gt; { };</ins>
++</pre><blockquote>
++<p>
++<del>-1- <i>Returns:</i> Integral constant expression.</del>
++<p/>
++<del>-2- <i>Value:</i> <tt>2</tt>.</del>
++</p></blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 23.3.2.9 [array.tuple]/1-2 as indicated:</p>
++
++<blockquote><pre>
++<del>tuple_size&lt;array&lt;T, N&gt; &gt;::value</del>
++<ins>template &lt;class T, size_t N&gt;
++struct tuple_size&lt;array&lt;T, N&gt;&gt;
++ : integral_constant&lt;size_t, N&gt; { };</ins>
++</pre><blockquote>
++<p>
++<del>-1- <i>Returns:</i> Integral constant expression.</del>
++<p/>
++<del>-2- <i>Value:</i> <tt>N</tt>.</del>
++</p></blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 20.4.2.5 [tuple.helper]/p1-p3 as indicated:</p>
++
++<blockquote><pre>
++<ins>template &lt;class T&gt; struct tuple_size;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Remarks:</i> All specializations of <tt>tuple_size&lt;T&gt;</tt> shall meet the <tt>UnaryTypeTrait</tt>
++requirements (20.10.1 [meta.rqmts]) with a <tt>BaseCharacteristic</tt> of <tt>integral_constant&lt;size_t, N&gt;</tt>
++for some <tt>N</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++<blockquote><pre>
++template &lt;class... Types&gt;
++struct tuple_size&lt;tuple&lt;Types...&gt; &gt;
++ : integral_constant&lt;size_t, sizeof...(Types)&gt; { };
++
++template &lt;size_t I, class... Types&gt;
++class tuple_element&lt;I, tuple&lt;Types...&gt; &gt; {
++public:
++ typedef TI type;
++};
++</pre><blockquote>
++<p>
++-1- <i>Requires:</i> <tt>I &lt; sizeof...(Types)</tt>. The program is ill-formed if <tt>I</tt> is out of bounds.
++<p/>
++[&hellip;]
++</p></blockquote>
++</blockquote>
++<blockquote><pre>
++template &lt;class T&gt; class tuple_size&lt;const T&gt;;
++template &lt;class T&gt; class tuple_size&lt;volatile T&gt;;
++template &lt;class T&gt; class tuple_size&lt;const volatile T&gt;;
++</pre><blockquote>
++<p>
++-3- Let <i>TS</i> denote <tt>tuple_size&lt;T&gt;</tt> of the <i>cv</i>-unqualified type <tt>T</tt>. Then each of the
++three templates shall meet the <tt>UnaryTypeTrait</tt> requirements (20.10.1 [meta.rqmts]) with a <tt>BaseCharacteristic</tt> of
++</p>
++<blockquote><pre>
++integral_constant&lt;<del>remove_cv&lt;decltype(TS::value)&gt;::type</del><ins>size_t</ins>, TS::value&gt;
++</pre></blockquote>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2314"></a>2314. <tt>apply()</tt> should return <tt>decltype(auto)</tt> and use <tt>decay_t</tt> before <tt>tuple_size</tt></h3>
++<p><b>Section:</b> 20.5.1 [intseq.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The example in 20.5.1 [intseq.general]/2 depicts <tt>apply_impl()</tt> and <tt>apply()</tt> as returning <tt>auto</tt>.
++This is incorrect because it will trigger decay and will not preserve <tt>F</tt>'s return type. For example, if invoking the
++functor returns <tt>const int&amp;</tt>, <tt>apply_impl()</tt> and <tt>apply()</tt> will return <tt>int</tt>. <tt>decltype(auto)</tt>
++should be used for "perfect returning".
++</p>
++<p>
++Additionally, this depicts <tt>apply()</tt> as taking <tt>Tuple&amp;&amp;</tt>, then saying "<tt>std::tuple_size&lt;Tuple&gt;::value</tt>".
++This is incorrect because when <tt>apply()</tt> is called with lvalue tuples, perfect forwarding will deduce <tt>Tuple</tt> to be <i>cv</i>
++<tt>tuple&amp;</tt>, but 20.4.2.5 [tuple.helper] says that <tt>tuple_size</tt> handles only <i>cv</i> <tt>tuple</tt>, not
++references to tuples. Using <tt>remove_reference_t</tt> would avoid this problem, but so would <tt>decay_t</tt>, which has a
++significantly shorter name. (The additional transformations that <tt>decay_t</tt> does are neither beneficial nor harmful here.)
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit the example code in 20.5.1 [intseq.general]/2 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class F, class Tuple, std::size_t... I&gt;
++ <del>auto</del><ins>decltype(auto)</ins> apply_impl(F&amp;&amp; f, Tuple&amp;&amp; t, index_sequence&lt;I...&gt;) {
++ return std::forward&lt;F&gt;(f)(std::get&lt;I&gt;(std::forward&lt;Tuple&gt;(t))...);
++ }
++template&lt;class F, class Tuple&gt;
++ <del>auto</del><ins>decltype(auto)</ins> apply(F&amp;&amp; f, Tuple&amp;&amp; t) {
++ using Indices = make_index_sequence&lt;std::tuple_size&lt;<ins>std::decay_t&lt;</ins>Tuple<ins>&gt;</ins>&gt;::value&gt;;
++ return apply_impl(std::forward&lt;F&gt;(f), std::forward&lt;Tuple&gt;(t), Indices());
++ }
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2315"></a>2315. <tt>weak_ptr</tt> should be movable</h3>
++<p><b>Section:</b> 20.8.2.3 [util.smartptr.weak] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.weak">issues</a> in [util.smartptr.weak].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Like <tt>shared_ptr</tt>, <tt>weak_ptr</tt> should be movable to avoid unnecessary atomic increments/decrements of the weak refcount.
++</p>
++
++<p><i>[2014-02-13 Issaquah: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 20.8.2.3 [util.smartptr.weak]/1, class template <tt>weak_ptr</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class T&gt; class weak_ptr {
++ public:
++ typedef T element_type;
++
++ <i>// 20.9.2.3.1, constructors</i>
++ constexpr weak_ptr() noexcept;
++ template&lt;class Y&gt; weak_ptr(shared_ptr&lt;Y&gt; const&amp; r) noexcept;
++ weak_ptr(weak_ptr const&amp; r) noexcept;
++ template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt; const&amp; r) noexcept;
++ <ins>weak_ptr(weak_ptr&amp;&amp; r) noexcept;
++ template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;</ins>
++
++ [&hellip;]
++
++ <i>// 20.9.2.3.3, assignment</i>
++ weak_ptr&amp; operator=(weak_ptr const&amp; r) noexcept;
++ template&lt;class Y&gt; weak_ptr&amp; operator=(weak_ptr&lt;Y&gt; const&amp; r) noexcept;
++ template&lt;class Y&gt; weak_ptr&amp; operator=(shared_ptr&lt;Y&gt; const&amp; r) noexcept;
++ <ins>weak_ptr&amp; operator=(weak_ptr&amp;&amp; r) noexcept;
++ template&lt;class Y&gt; weak_ptr&amp; operator=(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;</ins>
++ };
++}
++</pre></blockquote>
++</li>
++
++<li><p>Add the following new paragraphs at the end of sub-clause 20.8.2.3.1 [util.smartptr.weak.const]:</p>
++
++<blockquote><pre>
++<ins>weak_ptr(weak_ptr&amp;&amp; r) noexcept;
++template&lt;class Y&gt; weak_ptr(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Remark:</i> The second constructor shall not participate in overload resolution unless <tt>Y*</tt> is implicitly
++convertible to <tt>T*</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects:</i> Move-constructs a <tt>weak_ptr</tt> instance from <tt>r</tt>.</ins>
++<p/>
++<ins>-?- <i>Postconditions:</i> <tt>*this</tt> shall contain the old value of <tt>r</tt>. <tt>r</tt> shall be <em>empty</em>.
++<tt>r.use_count() == 0</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 20.8.2.3.3 [util.smartptr.weak.assign] as indicated:</p>
++
++<blockquote><pre>
++weak_ptr&amp; operator=(const weak_ptr&amp; r) noexcept;
++template&lt;class Y&gt; weak_ptr&amp; operator=(const weak_ptr&lt;Y&gt;&amp; r) noexcept;
++template&lt;class Y&gt; weak_ptr&amp; operator=(const shared_ptr&lt;Y&gt;&amp; r) noexcept;
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> [&hellip;]
++<p/>
++-2- <i>Remarks:</i> [&hellip;]
++<p/>
++<ins>-?- <i>Returns:</i> <tt>*this</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++
++<blockquote><pre>
++<ins>weak_ptr&amp; operator=(weak_ptr&amp;&amp; r) noexcept;
++template&lt;class Y&gt; weak_ptr&amp; operator=(weak_ptr&lt;Y&gt;&amp;&amp; r) noexcept;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Effects:</i> Equivalent to <tt>weak_ptr(std::move(r)).swap(*this)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns:</i> <tt>*this</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2316"></a>2316. <tt>weak_ptr::lock()</tt> should be atomic</h3>
++<p><b>Section:</b> 20.8.2.3.5 [util.smartptr.weak.obs] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.weak.obs">issues</a> in [util.smartptr.weak.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.8.2.2 [util.smartptr.shared]/4 says: "For purposes of determining the presence of a data race, member functions shall
++access and modify only the <tt>shared_ptr</tt> and <tt>weak_ptr</tt> objects themselves and not objects they refer to. Changes
++in <tt>use_count()</tt> do not reflect modifications that can introduce data races." This requires <tt>shared_ptr/weak_ptr</tt>
++implementations to protect their strong and weak refcounts with atomic operations, without the Standardese having to say this
++elsewhere. However, 20.8.2.3.5 [util.smartptr.weak.obs]/5 describes <tt>weak_ptr::lock()</tt> with
++"<i>Returns:</i> <tt>expired() ? shared_ptr&lt;T&gt;() : shared_ptr&lt;T&gt;(*this)</tt>."
++Even after considering the blanket wording about
++data races, this specification is insufficient. If this conditional expression were literally implemented, the <tt>use_count()</tt>
++could change from nonzero to zero after testing <tt>expired()</tt>, causing <tt>shared_ptr&lt;T&gt;(*this)</tt> to throw
++<tt>bad_weak_ptr</tt> when the intention is for <tt>weak_ptr::lock()</tt> to return empty or nonempty without throwing &mdash; indeed,
++<tt>weak_ptr::lock()</tt> is marked as <tt>noexcept</tt>.</p>
++<p>
++We all know what <tt>weak_ptr::lock()</tt> should do, the Standardese just doesn't say it.
++<tt>shared_ptr(const weak_ptr&lt;Y&gt;&amp;)</tt>'s specification is not really affected because
++20.8.2.2.1 [util.smartptr.shared.const]/23-27 describes the behavior with English instead of code.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 20.8.2.3.5 [util.smartptr.weak.obs]/5 as indicated:</p>
++
++<blockquote><pre>
++shared_ptr&lt;T&gt; lock() const noexcept;
++</pre>
++<blockquote>
++<p>
++-5- <i>Returns:</i> <tt>expired() ? shared_ptr&lt;T&gt;() : shared_ptr&lt;T&gt;(*this)</tt><ins>, executed atomically</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2317"></a>2317. The type property queries should be <tt>UnaryTypeTraits</tt> returning <tt>size_t</tt></h3>
++<p><b>Section:</b> 20.10.5 [meta.unary.prop.query] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The sibling sections 20.10.4 [meta.unary], 20.10.6 [meta.rel], and 20.10.7 [meta.trans] respectively specify
++<tt>UnaryTypeTraits</tt>, <tt>BinaryTypeTraits</tt>, and <tt>TransformationTraits</tt>, as stated by each /2 paragraph. However,
++20.10.5 [meta.unary.prop.query] is underspecified. <tt>alignment_of</tt>, <tt>rank</tt>, and <tt>extent</tt> are said to produce
++"Values", but the type of that Value is not specified, and the struct templates are not required to derive from <tt>integral_constant</tt>.
++Such derivation is more than stylistic &mdash; it allows the structs to be passed to functions taking <tt>integral_constant</tt>.
++<p/>
++<tt>alignment_of</tt> returns <tt>alignof(T)</tt> which is <tt>size_t</tt> (5.3.6 [expr.alignof]/2). <tt>extent</tt> returns
++an array bound, which is clearly <tt>size_t</tt>. <tt>rank</tt> returns "the number of dimensions" of an array, so any type could
++be chosen, with <tt>size_t</tt> being a reasonable choice. (Another choice would be <tt>unsigned int</tt>, to match <tt>extent</tt>'s
++template parameter <tt>I</tt>.)
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Following 20.10.5 [meta.unary.prop.query]/1 add a new paragraph as indicated:</p>
++
++<blockquote><p>
++<ins>Each of these templates shall be a <tt>UnaryTypeTrait</tt> (20.10.1 [meta.rqmts]) with a <tt>BaseCharacteristic</tt> of
++<tt>integral_constant&lt;size_t, Value&gt;</tt>.</ins>
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2319"></a>2319. <tt>basic_string</tt>'s move constructor should not be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 21.4.2 [string.cons] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.cons">issues</a> in [string.cons].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In debugging implementations, containers (including <tt>basic_string</tt>) may need to own dynamically allocated helper objects at
++all times, including in their default-constructed and moved-from states. This means that their default constructors and move
++constructors may throw exceptions. Therefore, the Standard should not mark them as <tt>noexcept</tt>. (Other implementations will
++still be permitted to add <tt>noexcept</tt>.)
++</p>
++
++<p><i>[2014-02, Issaquah : move to Ready]</i></p>
++
++<p>
++The issue discussion was highly controversial: The arguments in favour was that implementations exist that always need to allocate
++memory even for the move operations (similar as for some other containers) and that this cleans up an inconsistency between <tt>std::string</tt>
++and other container types. Counter arguments were that potentially throwing move operations reduce much of the advantages of move-support,
++e.g. in <tt>vector&lt;string&gt;</tt>.
++</p>
++<p>
++straw poll: accept wording in the issue<br/>
++SF 4 WF 4 N 0 WA 1 SA 1
++</p>
++<p>
++straw poll: 14 or 17?<br/>
++C++14: 4 C++17: 4
++</p>
++<p>
++Move to Ready for C++17, as too close to 14 DIS without strong consensus.
++</p>
++<p>
++It was suggested to introduce a special library vocabulary that specifies a "normative encouragement to not throw exceptions" for
++functions like these.
++</p>
++<p>
++NJ: I offer to write a proposal to add encouragement for not throwing ... "<tt>noexcept</tt> in italics means should not throw"
++</p>
++
++
++<p><i>[2014/11 Urbana]</i></p>
++
++<p>
++Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4258">N4258</a>
++</p>
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 21.4 [basic.string]/5, class template <tt>basic_string</tt> synopsis, and 21.4.2 [string.cons]/2
++change as indicated:</p>
++
++<blockquote><pre>
++basic_string(basic_string&amp;&amp; str) <del>noexcept</del>;
++</pre></blockquote>
++</li>
++
++<li><p>Edit 21.4.2 [string.cons]/17 as indicated:</p>
++
++<blockquote><pre>
++basic_string(const basic_string&amp; str, const Allocator&amp; alloc);
++basic_string(basic_string&amp;&amp; str, const Allocator&amp; alloc);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-17- <i>Throws:</i> The second form throws nothing if <tt>alloc == str.get_allocator()</tt>.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2320"></a>2320. <tt>select_on_container_copy_construction()</tt> takes allocators, not containers</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++23.2.1 [container.requirements.general]/7 says "Copy constructors for these container types obtain an allocator by calling
++<tt>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</tt> on their first parameters." However,
++20.7.8.2 [allocator.traits.members]/8 says that this takes <tt>const Alloc&amp;</tt>, not a container.
++23.2.1 [container.requirements.general]/7 goes on to say "Move constructors obtain an allocator by move construction from
++the allocator belonging to the container being moved." so we can follow that wording.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>In 23.2.1 [container.requirements.general]/7 change as indicated:</p>
++
++<blockquote><p>
++-7- Unless otherwise specified, all containers defined in this clause obtain memory using an allocator (see 17.6.3.5).
++Copy constructors for these container types obtain an allocator by calling
++<tt>allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction</tt> on <del>their first
++parameters</del><ins>the allocator belonging to the container being copied</ins>.
++Move constructors obtain an allocator by move construction from the allocator belonging to the container being moved. [&hellip;]
++</p></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2322"></a>2322. Associative(<tt>initializer_list</tt>, stuff) constructors are underspecified</h3>
++<p><b>Section:</b> 23.2.4 [associative.reqmts], 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#associative.reqmts">active issues</a> in [associative.reqmts].</p>
++<p><b>View all other</b> <a href="lwg-index.html#associative.reqmts">issues</a> in [associative.reqmts].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++23.2.4 [associative.reqmts] specifies both <tt>X(i,j)</tt> and <tt>X(i,j,c)</tt>, but only <tt>X(il)</tt>.
++23.4.4.1 [map.overview] declares "<tt>map(initializer_list&lt;value_type&gt;, const Compare&amp; = Compare(),
++const Allocator&amp; = Allocator());</tt>" but 23.4.4.2 [map.cons] intentionally doesn't explain it, relying
++on the big table's requirements. As a result, <tt>map(il, c)</tt>'s behavior is not actually specified by the Standard.
++(All of the other ordered associative containers also provide such constructors.)
++<p/>
++The unordered associative containers are similarly affected, although they have more arguments. (Again, the actual
++containers are correctly depicted with the desired constructors, their behavior just isn't specified.)
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 23.2.4 [associative.reqmts], Table 102 &mdash; "Associative container requirements", as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 102 &mdash; Associative container requirements (in addition to container) (continued)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(il);</tt>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++Same as <tt>X(il.begin(), il.end())</tt>.
++</td>
++<td>
++<del>s</del><ins>S</ins>ame as <tt>X(il.begin(), il.end())</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X(il, c);</tt></ins>
++</td>
++<td>
++<tt>&nbsp;</tt>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), c)</tt>.</ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), c)</tt>.</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>Edit 23.2.5 [unord.req], Table 103 "Unordered associative container requirements", as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 103 &mdash; Unordered associative container requirements (in addition to container)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X(il)</tt>
++</td>
++<td>
++<tt>X</tt>
++</td>
++<td>
++Same as <tt>X(il.begin(), il.end())</tt>.
++</td>
++<td>
++Same as <tt>X(il.begin(), il.end())</tt>.
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X(il, n)</tt></ins>
++</td>
++<td>
++<ins><tt>X</tt></ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n)</tt>.</ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n)</tt>.</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X(il, n, hf)</tt></ins>
++</td>
++<td>
++<ins><tt>X</tt></ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n, hf)</tt>.</ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n, hf)</tt>.</ins>
++</td>
++</tr>
++
++<tr>
++<td>
++<ins><tt>X(il, n, hf, eq)</tt></ins>
++</td>
++<td>
++<ins><tt>X</tt></ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n, hf, eq)</tt>.</ins>
++</td>
++<td>
++<ins>Same as <tt>X(il.begin(), il.end(), n, hf, eq)</tt>.</ins>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2323"></a>2323. <tt>vector::resize(n, t)</tt>'s specification should be simplified</h3>
++<p><b>Section:</b> 23.3.6.3 [vector.capacity], 23.3.3.3 [deque.capacity] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#vector.capacity">active issues</a> in [vector.capacity].</p>
++<p><b>View all other</b> <a href="lwg-index.html#vector.capacity">issues</a> in [vector.capacity].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++First, 23.3.3.3 [deque.capacity]/4 and 23.3.6.3 [vector.capacity]/16 say that <tt>resize(size_type sz, const T&amp; c)</tt>
++"<i>Requires:</i> <tt>T</tt> shall be <tt>MoveInsertable</tt> into <tt>*this</tt> and <tt>CopyInsertable</tt> into <tt>*this</tt>."
++The <tt>CopyInsertable</tt> requirement is correct (because <tt>sz</tt> might be <tt>size() + 2</tt> or more), but the
++<tt>MoveInsertable</tt> requirement is redundant due to 23.2.1 [container.requirements.general]/13: "<tt>T</tt> is
++<tt>CopyInsertable</tt> into <tt>X</tt> means that, in addition to <tt>T</tt> being <tt>MoveInsertable</tt> into <tt>X</tt>, the [...]".
++(LWG <a href="lwg-defects.html#2033">2033</a>'s resolution said that this was "not redundant, because <tt>CopyInsertable</tt> is not necessarily a refinement
++of <tt>MoveInsertable</tt>" which was true at the time, but then LWG <a href="lwg-defects.html#2177">2177</a>'s resolution made it a refinement.)
++<p/>
++Second, 23.3.6.3 [vector.capacity]/17 says "<i>Remarks:</i> If an exception is thrown other than by the move constructor of a
++non-<tt>CopyInsertable</tt> <tt>T</tt> there are no effects." This is confusing because <tt>T</tt> is required to be
++<tt>CopyInsertable</tt>. (/14 says the same thing for <tt>resize(size_type sz)</tt>, where it is correct because that overload
++requires only <tt>MoveInsertable</tt> and <tt>DefaultInsertable</tt>.)
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 23.3.3.3 [deque.capacity]/4 as indicated:</p>
++
++<blockquote><pre>
++void resize(size_type sz, const T&amp; c);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-4- <i>Requires:</i> <tt>T</tt> shall be <del><tt>MoveInsertable</tt> into <tt>*this</tt> and</del> <tt>CopyInsertable</tt> into
++<tt>*this</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 23.3.6.3 [vector.capacity]/16+17 as indicated:</p>
++
++<blockquote><pre>
++void resize(size_type sz, const T&amp; c);
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-16- <i>Requires:</i> <tt>T</tt> shall be <del><tt>MoveInsertable</tt> into <tt>*this</tt> and</del> <tt>CopyInsertable</tt> into
++<tt>*this</tt>.
++<p/>
++-17- <i>Remarks:</i> If an exception is thrown <del>other than by the move constructor of a non-<tt>CopyInsertable</tt> <tt>T</tt></del>
++there are no effects.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2324"></a>2324. Insert iterator constructors should use <tt>addressof()</tt></h3>
++<p><b>Section:</b> 24.5.2.2.1 [back.insert.iter.cons], 24.5.2.4.1 [front.insert.iter.cons], 24.5.2.6.1 [insert.iter.cons] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++24.5.2.2.1 [back.insert.iter.cons]/1, 24.5.2.4.1 [front.insert.iter.cons]/1, and 24.5.2.6.1 [insert.iter.cons]/1
++say "Initializes container with <tt>&amp;x</tt>", which doesn't defend against containers overloading <tt>operator&amp;()</tt>.
++Containers are now required to have such defenses for their elements, so we may as well be consistent here.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 24.5.2.2.1 [back.insert.iter.cons]/1 as indicated:</p>
++
++<blockquote><pre>
++explicit back_insert_iterator(Container&amp; x);
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> Initializes <tt>container</tt> with <tt><del>&amp;x</del><ins>std::addressof(x)</ins></tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 24.5.2.4.1 [front.insert.iter.cons]/1 as indicated:</p>
++
++<blockquote><pre>
++explicit front_insert_iterator(Container&amp; x);
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> Initializes <tt>container</tt> with <tt><del>&amp;x</del><ins>std::addressof(x)</ins></tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++<li><p>Edit 24.5.2.6.1 [insert.iter.cons]/1 as indicated:</p>
++
++<blockquote><pre>
++insert_iterator(Container&amp; x, typename Container::iterator i);
++</pre><blockquote>
++<p>
++-1- <i>Effects:</i> Initializes <tt>container</tt> with <tt><del>&amp;x</del><ins>std::addressof(x)</ins></tt> and <tt>iter</tt> with <tt>i</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2325"></a>2325. <tt>minmax_element()</tt>'s behavior differing from <tt>max_element()</tt>'s should be noted</h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++25.4.7 [alg.min.max]/23 says that <tt>max_element()</tt> finds the <em>first</em> biggest element, while /25 says that
++<tt>minmax_element()</tt> finds the <em>last</em> biggest element. This significant difference is unusual &mdash; it means that
++<tt>minmax_element(args)</tt> is not equivalent to <tt>make_pair(min_element(args), max_element(args))</tt>, whereas the other
++major "two for one" algorithm <tt>equal_range(args)</tt> is equivalent to <tt>make_pair(lower_bound(args), upper_bound(args))</tt>.
++<tt>minmax_element()</tt>'s behavior is intentional &mdash; it is a fundamental consequence of the <tt>3N/2</tt> algorithm &mdash;
++but the Standardese does not draw attention to this in any way. This wording came from LWG <a href="lwg-defects.html#715">715</a>'s resolution (which
++changed the semantics but didn't mention it), citing CLRS for the algorithm &mdash; but CLRS doesn't mention the behavior for
++equivalent elements! The wording here deeply confused me (as an STL maintainer fixing an incorrect implementation) until I walked
++through the algorithm by hand and figured out the fundamental reason. It would be really nice for the Standard to provide a hint
++that something magical is happening here.
++</p>
++
++<p><i>[2014-06-06 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Add a footnote to 25.4.7 [alg.min.max]/25 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class ForwardIterator&gt;
++ pair&lt;ForwardIterator, ForwardIterator&gt;
++ minmax_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++ pair&lt;ForwardIterator, ForwardIterator&gt;
++ minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
++</pre><blockquote>
++<p>
++-25- <i>Returns:</i> <tt>make_pair(first, first)</tt> if <tt>[first,last)</tt> is empty, otherwise <tt>make_pair(m, M)</tt>, where
++<tt>m</tt> is the first iterator in <tt>[first,last)</tt> such that no iterator in the range refers to a smaller element,
++and where <tt>M</tt> is the last iterator <ins>[Footnote: This behavior intentionally differs from <tt>max_element()</tt>.]</ins>
++in <tt>[first,last)</tt> such that no iterator in the range refers to a larger element.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2329"></a>2329. <tt>regex_match()/regex_search()</tt> with <tt>match_results</tt> should forbid temporary strings</h3>
++<p><b>Section:</b> 28.4 [re.syn] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.syn">issues</a> in [re.syn].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider the following code:
++</p>
++<blockquote><pre>
++const regex r(R"(meow(\d+)\.txt)");
++smatch m;
++if (regex_match(dir_iter-&gt;path().filename().string(), m, r)) {
++ DoSomethingWith(m[1]);
++}
++</pre></blockquote>
++<p>
++This occasionally crashes. The problem is that <tt>dir_iter-&gt;path().filename().string()</tt> returns a temporary string,
++so the <tt>match_results</tt> contains invalidated iterators into a destroyed temporary string.
++<p/>
++It's fine for <tt>regex_match/regex_search(str, reg)</tt> to accept temporary strings, because they just return <tt>bool</tt>.
++However, the overloads taking <tt>match_results</tt> should forbid temporary strings.
++</p>
++
++<p><i>[2014-02-13 Issaquah: Move as Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 28.4 [re.syn], header <tt>&lt;regex&gt;</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++#include &lt;initializer_list&gt;
++
++namespace std {
++
++ [&hellip;]
++
++ <i>// 28.11.2, function template regex_match:</i>
++ [&hellip;]
++ <ins>template &lt;class ST, class SA, class Allocator, class charT, class traits&gt;
++ bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp;&amp;,
++ match_results&lt;
++ typename basic_string&lt;charT, ST, SA&gt;::const_iterator,
++ Allocator&gt;&amp;,
++ const basic_regex&lt;charT, traits&gt;&amp;,
++ regex_constants::match_flag_type =
++ regex_constants::match_default) = delete;</ins>
++
++ <i>// 28.11.3, function template regex_search:</i>
++ [&hellip;]
++ <ins>template &lt;class ST, class SA, class Allocator, class charT, class traits&gt;
++ bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp;&amp;,
++ match_results&lt;
++ typename basic_string&lt;charT, ST, SA&gt;::const_iterator,
++ Allocator&gt;&amp;,
++ const basic_regex&lt;charT, traits&gt;&amp;,
++ regex_constants::match_flag_type =
++ regex_constants::match_default) = delete;</ins>
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2330"></a>2330. <tt>regex("meow", regex::icase)</tt> is technically forbidden but should be permitted</h3>
++<p><b>Section:</b> 28.5.1 [re.synopt] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.synopt">active issues</a> in [re.synopt].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.synopt">issues</a> in [re.synopt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++28.5.1 [re.synopt]/1 says "A valid value of type <tt>syntax_option_type</tt> shall have exactly one of the elements
++<tt>ECMAScript</tt>, <tt>basic</tt>, <tt>extended</tt>, <tt>awk</tt>, <tt>grep</tt>, <tt>egrep</tt>, set."
++<p/>
++This "exactly one" wording technically forbids passing <tt>icase</tt> by itself! Users should not be required to pass
++<tt>regex::ECMAScript | regex::icase</tt>. (Note that the cost of an additional check for no grammar being explicitly requested
++is completely irrelevant, as regex construction is so much more expensive.)
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Edit 28.5.1 [re.synopt] as indicated:</p>
++
++<blockquote><p>
++-1- The type <tt>syntax_option_type</tt> is an implementation-defined bitmask type (17.5.2.1.3). Setting its elements
++has the effects listed in table 138. A valid value of type <tt>syntax_option_type</tt> shall have <del>exactly</del><ins>at most</ins>
++one of the <ins>grammar</ins> elements <tt>ECMAScript</tt>, <tt>basic</tt>, <tt>extended</tt>, <tt>awk</tt>, <tt>grep</tt>,
++<tt>egrep</tt>, set. <ins> If no grammar element is set, the default grammar is <tt>ECMAScript</tt>.</ins>
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2332"></a>2332. <tt>regex_iterator/regex_token_iterator</tt> should forbid temporary regexes</h3>
++<p><b>Section:</b> 28.12 [re.iter] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-09-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Users can write "<tt>for(sregex_iterator i(s.begin(), s.end(), regex("meow")), end; i != end; ++i)</tt>", binding a temporary
++<tt>regex</tt> to <tt>const regex&amp;</tt> and storing a pointer to it. This will compile silently, triggering undefined behavior
++at runtime. We now have the technology to prevent this from compiling, like how <tt>reference_wrapper</tt> refuses to bind to
++temporaries.
++</p>
++
++<p><i>[2014-02-14 Issaquah meeting: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Change 28.12.1 [re.regiter]/1, class template <tt>regex_iterator</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++regex_iterator();
++regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp; re,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default);
++<ins>regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp;&amp; re,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default) = delete;</ins>
++</pre></blockquote>
++</li>
++
++<li><p>Change 28.12.2 [re.tokiter]/6, class template <tt>regex_token_iterator</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++regex_token_iterator();
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp; re,
++ int submatch = 0,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default);
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp; re,
++ const std::vector&lt;int&gt;&amp; submatches,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default);
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp; re,
++ initializer_list&lt;int&gt; submatches,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default);
++template &lt;std::size_t N&gt;
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp; re,
++ const int (&amp;submatches)[N],
++ regex_constants::match_flag_type m =
++ regex_constants::match_default);
++<ins>regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp;&amp; re,
++ int submatch = 0,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default) = delete;
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp;&amp; re,
++ const std::vector&lt;int&gt;&amp; submatches,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default) = delete;
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp;&amp; re,
++ initializer_list&lt;int&gt; submatches,
++ regex_constants::match_flag_type m =
++ regex_constants::match_default) = delete;
++template &lt;std::size_t N&gt;
++regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
++ const regex_type&amp;&amp; re,
++ const int (&amp;submatches)[N],
++ regex_constants::match_flag_type m =
++ regex_constants::match_default) = delete;</ins>
++</pre></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2333"></a>2333. [fund.ts] Hashing disengaged <tt>optional&lt;T&gt;</tt> objects</h3>
++<p><b>Section:</b> X [optional.hash] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2013-10-03 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++The spec for <tt>hash&lt;optional&lt;T&gt;&gt;</tt> doesn't say anything about disengaged
++objects, so 1.3 [defns.undefined] would imply it's undefined behaviour,
++but that's very unhelpful to users.
++<p/>
++If hashing disengaged optional objects is undefined there should be a <i>Requires</i>, otherwise
++there should be some statement saying it's OK.
++<p/>
++It would be possible to specify the value, e.g. saying it returns the
++same value as something like <tt>std::hash&lt;void*&gt;()(nullptr)</tt>, but leaving
++it unspecified would permit users to specialize <tt>hash&lt;optional&lt;UserDefinedType&gt;&gt;</tt> so
++that the hash value for a disengaged object is distinct from any value returned by
++<tt>hash&lt;UserDefinedType&gt;</tt>.
++</p>
++
++<p><i>[2014-06-06 pre-Rapperswill]</i></p>
++
++<p>
++This issue has been reopened as fundamentals-ts.
++</p>
++
++<p><i>[2014-06-07 Daniel comments]</i></p>
++
++<p>
++This issue should be set to <b>Resolved</b>, because the wording fix is already applied in the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html#optional.hash">last fundamentals working draft</a>.
++</p>
++
++<p><i>[2014-06-16 Rapperswill]</i></p>
++
++<p>
++Confirmed that this issue is resolved in the current Library Fundamentals working paper.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3691.</p>
++
++<ol>
++<li><p>Add to X [optional.hash]/3</p>
++
++<blockquote><pre>
++template &lt;class T&gt; struct hash&lt;optional&lt;T&gt;&gt;;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- For an object <tt>o</tt> of type <tt>optional&lt;T&gt;</tt>, if <tt>bool(o) == true</tt>,
++<tt>hash&lt;optional&lt;T&gt;&gt;()(o)</tt> shall evaluate to the same value as
++<tt>hash&lt;T&gt;()(*o)</tt> <ins>otherwise it evaluates to an unspecified value</ins>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2339"></a>2339. Wording issue in <tt>nth_element</tt></h3>
++<p><b>Section:</b> 25.4.2 [alg.nth.element] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Christopher Jefferson <b>Opened:</b> 2013-10-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.nth.element">issues</a> in [alg.nth.element].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The wording of <tt>nth_element</tt> says:
++</p>
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++ void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last);
++</pre><blockquote>
++<p>
++After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would be in that
++position if the whole range were sorted. Also for every iterator <tt>i</tt> in the range <tt>[first,nth)</tt> and every
++iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt>!(*j &lt; *i)</tt> or <tt>comp(*j, *i) == false</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++That wording, to me, implies that there must be an element at '<tt>nth</tt>'.
++However, gcc at least accepts <tt>nth == last</tt>, and returns without effect
++(which seems like the sensible option).
++<p/>
++Is it intended to accept <tt>nth == last</tt>? If so, then I would suggest adding
++this to the wording explicitly, say:
++</p>
++<blockquote>
++<p>
++After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt><ins>, if any,</ins> is the element that
++would be in that position if the whole range were sorted. Also for every iterator <tt>i</tt> in the range <tt>[first,nth)</tt>
++and every iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt>!(*j &lt; *i)</tt> or <tt>comp(*j, *i) == false</tt>.
++</p>
++</blockquote>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 25.4.2 [alg.nth.element]/1 as indicated:</p>
++
++<blockquote><pre>
++template&lt;class RandomAccessIterator&gt;
++ void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last);
++template&lt;class RandomAccessIterator, class Compare&gt;
++ void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
++ RandomAccessIterator last, Compare comp);
++</pre><blockquote>
++<p>
++-1- After <tt>nth_element</tt> the element in the position pointed to by <tt>nth</tt> is the element that would be in that
++position if the whole range were sorted<ins>, unless <tt>nth == last</tt></ins>. Also for every iterator <tt>i</tt> in the
++range <tt>[first,nth)</tt> and every iterator <tt>j</tt> in the range <tt>[nth,last)</tt> it holds that: <tt>!(*j &lt; *i)</tt>
++or <tt>comp(*j, *i) == false</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2340"></a>2340. Replacement allocation functions declared as inline</h3>
++<p><b>Section:</b> 17.6.4.6 [replacement.functions] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> David Majnemer <b>Opened:</b> 2013-10-20 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#replacement.functions">issues</a> in [replacement.functions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++N3290 17.6.4.6 [replacement.functions]/p3 says:
++</p>
++<blockquote><p>
++The program's definitions shall not be specified as <tt>inline</tt>.
++</p></blockquote>
++<p>
++This seems to permit declarations of replacement allocation functions that are specified as <tt>inline</tt> so long
++as they aren't used. This behavior seems more like a bug than a feature, I propose that we do the following:
++</p>
++<blockquote><p>
++The program's <del>definitions</del><ins>declarations</ins> shall not be specified as <tt>inline</tt>.
++</p></blockquote>
++
++<p><i>[2014-02-15 Issaquah : Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 17.6.4.6 [replacement.functions]/3 as indicated:</p>
++
++<blockquote><p>
++-3- The program's definitions are used instead of the default versions supplied by the implementation (18.6).
++Such replacement occurs prior to program startup (3.2, 3.6). The program's <del>definitions</del><ins>declarations</ins>
++shall not be specified as <tt>inline</tt>. No diagnostic is required.</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2341"></a>2341. Inconsistency between <tt>basic_ostream::seekp(pos)</tt> and <tt>basic_ostream::seekp(off, dir)</tt></h3>
++<p><b>Section:</b> 27.7.3.5 [ostream.seeks] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2013-10-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++In 27.7.3.5 [ostream.seeks], we have:
++</p>
++<blockquote><pre>
++basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type pos);
++</pre><blockquote>
++<p>
++-3- <i>Effects:</i> If <tt>fail() != true</tt>, executes <tt>rdbuf()-&gt;pubseekpos(pos, ios_base::out)</tt>. In case of failure,
++the function calls <tt>setstate(failbit)</tt> (which may throw <tt>ios_base::failure</tt>).
++<p/>
++-4- <i>Returns:</i> <tt>*this</tt>.
++</p>
++</blockquote></blockquote>
++<blockquote><pre>
++basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type off, ios_base::seekdir dir);
++</pre><blockquote>
++<p>
++-5- <i>Effects:</i> If <tt>fail() != true</tt>, executes <tt>rdbuf()-&gt;pubseekoff(off, dir, ios_base::out)</tt>.
++<p/>
++-6- <i>Returns:</i> <tt>*this</tt>.
++</p>
++</blockquote></blockquote>
++<p>
++The first call is required to set the <tt>failbit</tt> on failure, but the second is not
++<p/>
++So (given two ostreams, <tt>os1</tt> and <tt>os2</tt>) the following code (confusingly) works:
++</p>
++<blockquote><pre>
++os1.seekp(-1);
++assert(os1.fail());
++
++os2.seekp(-1, std::ios_base::beg);
++assert(os2.good());
++</pre></blockquote>
++<p>
++Note that the description of <tt>basic_istream&lt;charT,traits&gt;&amp; seekg(off_type off, ios_base::seekdir dir)</tt> in
++27.7.2.3 [istream.unformatted] p43 <em>does</em> require setting <tt>failbit</tt>.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 27.7.3.5 [ostream.seeks]p5 as indicated:</p>
++
++<blockquote><pre>
++basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type off, ios_base::seekdir dir);
++</pre><blockquote>
++<p>
++-5- <i>Effects:</i> If <tt>fail() != true</tt>, executes <tt>rdbuf()-&gt;pubseekoff(off, dir, ios_base::out)</tt>.
++<ins>In case of failure, the function calls <tt>setstate(failbit)</tt> (which may throw <tt>ios_base::failure</tt>).</ins>
++<p/>
++-6- <i>Returns:</i> <tt>*this</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2344"></a>2344. <tt>quoted()</tt>'s interaction with padding is unclear</h3>
++<p><b>Section:</b> 27.7.6 [quoted.manip] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-11-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#quoted.manip">issues</a> in [quoted.manip].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Given this code:
++</p>
++<blockquote><pre>
++cout &lt;&lt; "[" &lt;&lt; left &lt;&lt; setfill('x') &lt;&lt; setw(20) &lt;&lt; R"("AB \"CD\" EF")" &lt;&lt; "]" &lt;&lt; endl;
++cout &lt;&lt; "[" &lt;&lt; left &lt;&lt; setfill('y') &lt;&lt; setw(20) &lt;&lt; quoted(R"(GH "IJ" KL)") &lt;&lt; "]" &lt;&lt; endl;
++</pre></blockquote>
++<p>
++The first line prints <tt>["AB \"CD\" EF"xxxxxx]</tt>. The second line should probably print <tt>["GH \"IJ\" KL"yyyyyy]</tt>, but
++27.7.6 [quoted.manip]/2 doesn't say whether or how <tt>quoted()</tt> should interact with padding. All it says is that
++</p>
++<blockquote><p>
++"<tt>out &lt;&lt; quoted(s, delim, escape)</tt> behaves as if it inserts the following characters into out using character
++inserter function templates (27.7.3.6.4)".
++</p></blockquote>
++<p>
++27.7.3.6.4 [ostream.inserters.character] specifies both single-character and null-terminated inserters, both referring to
++27.7.3.6.1 [ostream.formatted.reqmts]/3 for padding. Literally implementing <tt>quoted()</tt> with single-character inserters
++would result in padding being emitted after the first character, with undesirable effects for <tt>ios_base::left</tt>.
++<p/>
++It appears that 21.4.8.9 [string.io]/5 has the appropriate incantations to follow here. It says that <tt>os &lt;&lt; str</tt>
++</p>
++<blockquote><p>
++"Behaves as a formatted output function (27.7.3.6.1) of <tt>os</tt>. Forms a character sequence <tt>seq</tt>, initially consisting of the
++elements defined by the range <tt>[str.begin(), str.end())</tt>. Determines padding for <tt>seq</tt> as described in 27.7.3.6.1.
++Then inserts <tt>seq</tt> as if by calling <tt>os.rdbuf()-&gt;sputn(seq, n)</tt>, where <tt>n</tt> is the larger of <tt>os.width()</tt>
++and <tt>str.size();</tt> then calls <tt>os.width(0)</tt>."
++</p></blockquote>
++<p>
++Additionally, saying that it's a "formatted output function" activates 27.7.3.6.1 [ostream.formatted.reqmts]/1's wording for
++sentry objects.
++</p>
++
++<p><i>[2014-02-14 Issaquah meeting: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Edit 27.7.6 [quoted.manip] as follows:</p>
++
++<blockquote><pre>
++template &lt;class charT&gt;
++ unspecified quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\'));
++template &lt;class charT, class traits, class Allocator&gt;
++ unspecified quoted(const basic_string&lt;charT, traits, Allocator>&amp; s,
++ charT delim=charT('"'), charT escape=charT('\\'));
++</pre><blockquote>
++<p>
++-2- <i>Returns:</i> An object of unspecified type such that if <tt>out</tt> is an instance of <tt>basic_ostream</tt> with member
++type <tt>char_type</tt> the same as <tt>charT</tt>, then the expression <tt>out &lt;&lt; quoted(s, delim, escape)</tt> behaves
++as <del>if it inserts the following characters into <tt>out</tt> using character inserter function templates (27.7.3.6.4),
++which may throw <tt>ios_base::failure</tt> (27.5.3.1.1)</del><ins>a formatted output function (27.7.3.6.1 [ostream.formatted.reqmts])
++of <tt>out</tt>. This forms a character sequence <tt>seq</tt>, initially consisting of the following elements</ins>:
++</p>
++<ul>
++<li><p>
++<tt>delim</tt>.
++</p></li>
++<li><p>
++Each character in <tt>s</tt>. If the character to be output is equal to escape or <tt>delim</tt>, as determined by
++<tt>operator==</tt>, first output <tt>escape</tt>.
++</p></li>
++<li><p>
++<tt>delim</tt>.
++</p></li>
++</ul>
++<p>
++<ins>Let <tt>x</tt> be the number of elements initially in <tt>seq</tt>. Then padding is determined for <tt>seq</tt> as described
++in 27.7.3.6.1 [ostream.formatted.reqmts], <tt>seq</tt> is inserted as if by calling <tt>out.rdbuf()-&gt;sputn(seq, n)</tt>, where
++<tt>n</tt> is the larger of <tt>out.width()</tt> and <tt>x</tt>, and <tt>out.width(0)</tt> is called.</ins>
++The expression <tt>out &lt;&lt; quoted(s, delim, escape)</tt> shall have type <tt>basic_ostream&lt;charT, traits&gt;&amp;</tt>
++and value <tt>out</tt>.
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2346"></a>2346. <tt>integral_constant</tt>'s member functions should be marked <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.10.3 [meta.help] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2013-11-05 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.help">issues</a> in [meta.help].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Obvious.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Edit 20.10.3 [meta.help] as indicated:</p>
++
++<blockquote><pre>
++namespace std {
++ template&lt;class T, T v&gt;
++ struct integral_constant {
++ static constexpr T value = v;
++ typedef T value_type;
++ typedef integral_constant&lt;T,v&gt; type;
++ constexpr operator value_type() const <ins>noexcept</ins> { return value; }
++ constexpr value_type operator()() const <ins>noexcept</ins> { return value; }
++ };
++ [&hellip;]
++}
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2350"></a>2350. <tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt> should be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Ville Voutilainen <b>Opened:</b> 2013-12-15 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Having <tt>min</tt>, <tt>max</tt>, and <tt>minmax</tt> <tt>constexpr</tt>
++was a large part of the motivation to allow reference-to-const arguments for
++<tt>constexpr</tt> functions as per
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3039.pdf">N3039</a>.
++Furthermore, <tt>initializer_lists</tt> are immutable and not-movable-from
++for large part in order to allow using them in <tt>constexpr</tt> contexts
++and other hoisting-optimizations. In <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf">N3797</a>
++version of the draft none of these functions are <tt>constexpr</tt>, and they should be made
++<tt>constexpr</tt>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>In 25.1 [algorithms.general], header <tt>&lt;algorithm&gt;</tt> synopsis, and 25.4.7 [alg.min.max],
++change as indicated (add <tt>constexpr</tt> to every signature before <tt>min_element</tt>):</p>
++
++<blockquote><pre>
++template&lt;class T&gt; <ins>constexpr</ins> const T&amp; min(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++<ins>constexpr</ins> const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
++[&hellip;]
++template&lt;class T&gt;
++<ins>constexpr</ins> T min(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare>
++<ins>constexpr</ins> T min(initializer_list&lt;T&gt; t, Compare comp);
++[&hellip;]
++template&lt;class T&gt; <ins>constexpr</ins> const T&amp; max(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++<ins>constexpr</ins> const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);
++[&hellip;]
++template&lt;class T&gt;
++<ins>constexpr</ins> T max(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare>
++<ins>constexpr</ins> T max(initializer_list&lt;T&gt; t, Compare comp);
++[&hellip;]
++template&lt;class T&gt; <ins>constexpr</ins> pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b);
++template&lt;class T, class Compare&gt;
++<ins>constexpr</ins> pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b, Compare comp);
++[&hellip;]
++template&lt;class T&gt;
++<ins>constexpr</ins> pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t);
++template&lt;class T, class Compare>
++<ins>constexpr</ins> pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t, Compare comp);
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2354"></a>2354. Unnecessary copying when inserting into maps with braced-init syntax</h3>
++<p><b>Section:</b> 23.4.4.1 [map.overview], 23.4.5.1 [multimap.overview], 23.5.4.1 [unord.map.overview], 23.5.5.1 [unord.multimap.overview] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Geoffrey Romer <b>Opened:</b> 2014-01-08 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The rvalue-reference <tt>insert()</tt> members of <tt>map</tt>, <tt>multimap</tt>, <tt>unordered_map</tt>, and
++<tt>unordered_multimap</tt> are specified as function templates, where the rvalue-reference parameter type
++depends on the template parameter.
++As a consequence, these overloads cannot be invoked via braced-initializer syntax (e.g. <tt>my_map.insert({key, value})</tt>),
++because the template argument cannot be deduced from a braced-init-list. Such calls instead resolve to the
++const lvalue reference overload, which forces a non-elidable copy of the argument, despite the fact that the
++argument is an rvalue, and so should be eligible for moving and copy elision.
++<p/>
++This leads to sub-optimal performance for copyable values, and makes this syntax unusable with noncopyable
++values. This is particularly problematic because sources such as Josuttis's "C++ Standard Library" recommend
++this syntax as the preferred way to insert into a map in C++11.
++<p/>
++I think this can be fixed by adding an equivalent non-template <tt>value_type&amp;&amp;</tt> overload for each affected
++member template. Simply declaring these members in the class synopses should be sufficient; their semantics are
++already dictated by the container concepts (c.f. the corresponding lvalue-reference overloads, which have no
++additional discussion beyond being listed in the synopsis).
++</p>
++
++<p><i>[2012-02-13 Issaquah]</i></p>
++
++<p>
++AJM: Is this not better solved by <tt>emplace</tt>?
++</p>
++
++<p>
++Nico: <tt>emplace</tt> was a mistake, it breaks a uniform pattern designed into the STL.
++Hence, this fix is important, it should be the preferred way to do this.
++</p>
++
++<p>
++JonW: <tt>emplace</tt> is still more efficient, as this form must make a non-elidable copy.
++</p>
++
++<p>
++GeoffR: Also, cannot move from a <tt>const</tt> key, must always make a copy.
++</p>
++
++<p>
++Poll for adopting the proposed wording:
++<p/>
++SF: 1 WF: 4 N: 4 WA: 1 SA: 0
++</p>
++
++<p>
++Move to Ready, pending implementation experience.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Change 23.4.4.1 [map.overview], class template <tt>map</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++pair&lt;iterator, bool&gt; insert(const value_type&amp; x);
++<ins>pair&lt;iterator, bool&gt; insert(value_type&amp;&amp; x);</ins>
++template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
++iterator insert(const_iterator position, const value_type&amp; x);
++<ins>iterator insert(const_iterator position, value_type&amp;&amp; x);</ins>
++template &lt;class P&gt;
++ iterator insert(const_iterator position, P&amp;&amp;);
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.4.5.1 [multimap.overview], class template <tt>multimap</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++iterator insert(const value_type&amp; x);
++<ins>iterator insert(value_type&amp;&amp; x);</ins>
++template &lt;class P&gt; iterator insert(P&amp;&amp; x);
++iterator insert(const_iterator position, const value_type&amp; x);
++<ins>iterator insert(const_iterator position, value_type&amp;&amp; x);</ins>
++template &lt;class P&gt; iterator insert(const_iterator position, P&amp;&amp; x);
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.4.1 [unord.map.overview], class template <tt>unordered_map</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++pair&lt;iterator, bool&gt; insert(const value_type&amp; obj);
++<ins>pair&lt;iterator, bool&gt; insert(value_type&amp;&amp; obj);</ins>
++template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; obj);
++iterator insert(const_iterator hint, const value_type&amp; obj);
++<ins>iterator insert(const_iterator hint, value_type&amp;&amp; obj);</ins>
++template &lt;class P&gt; iterator insert(const_iterator hint, P&amp;&amp; obj);
++[&hellip;]
++</pre></blockquote>
++</li>
++
++<li><p>Change 23.5.5.1 [unord.multimap.overview], class template <tt>unordered_multimap</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++iterator insert(const value_type&amp; obj);
++<ins>iterator insert(value_type&amp;&amp; obj);</ins>
++template &lt;class P&gt; iterator insert(P&amp;&amp; obj);
++iterator insert(const_iterator hint, const value_type&amp; obj);
++<ins>iterator insert(const_iterator hint, value_type&amp;&amp; obj);</ins>
++template &lt;class P&gt; iterator insert(const_iterator hint, P&amp;&amp; obj);
++[&hellip;]
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2356"></a>2356. Stability of erasure in unordered associative containers</h3>
++<p><b>Section:</b> 23.2.5 [unord.req] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz <b>Opened:</b> 2014-01-21 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#unord.req">active issues</a> in [unord.req].</p>
++<p><b>View all other</b> <a href="lwg-index.html#unord.req">issues</a> in [unord.req].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Issue <a href="lwg-defects.html#518">518</a> resolution for unordered associative containers, modelled after that of issue <a href="lwg-defects.html#371">371</a>,
++which is related to associative containers, states that insertion, erasure and rehashing preserve the relative ordering
++of equivalent elements. Unfortunately, this is not sufficient to guarantee the validity of code such as this:
++</p>
++<blockquote><pre>
++std::unordered_multimap&lt;int, int&gt; m;
++auto i = m.begin();
++while (i != m.end()) {
++ if (pred(i))
++ m.erase(i++);
++ else
++ ++i;
++}
++</pre></blockquote>
++<p>
++(which is a direct translation from <tt>multimap</tt> to <tt>unordered_multimap</tt> of the motivating example in <a href="lwg-defects.html#371">371</a>),
++or even this:
++</p>
++<blockquote><pre>
++std::unordered_multimap&lt;int, int&gt; m;
++auto p = m.equal_range(k);
++while (p.first != p.second) {
++ if (pred(p.first))
++ m.erase((p.first)++);
++ else
++ ++(p.first);
++}
++</pre></blockquote>
++<p>
++because the relative ordering of <em>non-equivalent</em> elements elements could potentially change after erasure (not that any actual
++implementation does that, anyway). Such an underspecification does not happen for regular associative containers, where the
++relative ordering of non-equivalent elements is kept by design.
++</p>
++
++<p><i>[2014-02-13 Issaquah: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 23.2.5 [unord.req], p14 as indicated:</p>
++
++<blockquote><p>
++-14- The <tt>insert</tt> and <tt>emplace</tt> members shall not affect the validity of references to container elements, but may
++invalidate all iterators to the container. The <tt>erase</tt> members shall invalidate only iterators and references
++to the erased elements<ins>, and preserve the relative order of the elements that are not erased</ins>.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2357"></a>2357. Remaining "<tt>Assignable</tt>" requirement</h3>
++<p><b>Section:</b> 25.3.13 [alg.partitions] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.partitions">issues</a> in [alg.partitions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The <i>Requires</i> element of <tt>partition_copy</tt> says (emphasis mine):
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>InputIterator</tt>'s value type shall be <b><tt>Assignable</tt></b>, and &hellip;
++</p></blockquote>
++<p>
++The C++03 term <tt>Assignable</tt> was replaced by <tt>CopyAssignable</tt>, remaining cleanups happened via LWG issue
++<a href="lwg-closed.html#972">972</a>, but algorithm <tt>partition_copy</tt> was not affected at that time (during that time the requirements
++of <tt>partition_copy</tt> didn't mention writable nor assignable, but I cannot track down at the moment where these requirements
++had been added). Presumably this requirement should be corrected similarly to the approach used in <a href="lwg-closed.html#972">972</a>.
++<p/>
++Another question is whether a <tt>CopyAssignable</tt> is needed here, given the fact that we already require "writable to" an
++<tt>OutputIterator</tt> which is defined in 24.2.1 [iterator.requirements.general] and does already impose the necessary
++statement
++</p>
++<blockquote><pre>
++*out = *in;
++</pre></blockquote>
++<p>
++Given the fact that <tt>partition_copy</tt> never touches any input value twice, there is no reason why anything more than
++<i>writable to</i> should be necessary.
++<p/>
++The below suggested primary resolution does not respond to the second part of this question.
++</p>
++
++<p><i>[Issaquah 20014-10-11: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Modify 25.3.13 [alg.partitions], p12 as indicated:</p>
++
++<blockquote><p>
++-12- <i>Requires</i>: <tt>InputIterator</tt>'s value type shall be <tt><ins>Copy</ins>Assignable</tt>, and shall be writable
++to the <tt>out_true</tt> and <tt>out_false</tt> <tt>OutputIterator</tt>s, and shall be convertible to <tt>Predicate</tt>'s
++argument type. The input range shall not overlap with either of the output ranges.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2359"></a>2359. How does <tt>regex_constants::nosubs</tt> affect <tt>basic_regex::mark_count()</tt>?</h3>
++<p><b>Section:</b> 28.5.1 [re.synopt] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-02-01 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#re.synopt">active issues</a> in [re.synopt].</p>
++<p><b>View all other</b> <a href="lwg-index.html#re.synopt">issues</a> in [re.synopt].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As discussed in <a href="http://accu.org/cgi-bin/wg21/message?wg=lib&amp;msg=35399">c++std-lib-35399</a> and its replies,
++I can see two possible interpretations of the effects of <tt>regex_constants::nosubs</tt>:
++</p>
++<ol style="list-style-type:decimal">
++<li><p>
++The effect of <tt>nosubs</tt> only applies during matching. Parentheses are
++still recognized as marking a sub-expression by the <tt>basic_regex</tt>
++compiler, and <tt>basic_regex::mark_count()</tt> still returns the number of
++marked sub-expressions, but anything they match is not stored in the
++results. This means it is not always true that <tt>results.size() == r.mark_count() + 1</tt>
++for a successful match.
++</p></li>
++<li><p>
++<tt>nosubs</tt> affects how a regular expression is compiled, altering the
++state of the <tt>std::basic_regex</tt> object so that <tt>mark_count()</tt> returns
++zero. This also affects any subsequent matching.
++</p></li>
++</ol>
++<p>
++The definition of <tt>nosubs</tt> should make this clear.
++<p/>
++The wording in 28.5.1 [re.synopt]/1 seems to imply that <tt>nosubs</tt> only has
++effects during matching, which is (1), but all known implementations
++do (2). John Maddock confirmed that (2) was intended.
++</p>
++
++<p><i>[Issaquah 2014-02-12: Move to Immediate]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Apply the following edit to the table in 28.5.1 [re.synopt]/1</p>
++
++<blockquote><p>
++Specifies that <ins>no sub-expressions shall be considered to be
++marked, so that</ins> when a regular expression is matched against a character container
++sequence, no sub-expression matches shall be stored in the supplied
++<tt>match_results</tt> structure.
++</p></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2360"></a>2360. <tt>reverse_iterator::operator*()</tt> is unimplementable</h3>
++<p><b>Section:</b> 24.5.1.1 [reverse.iterator] <b>Status:</b> <a href="lwg-active.html#C++14">C++14</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-02-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#reverse.iterator">issues</a> in [reverse.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#C++14">C++14</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Previously, C++03 24.4.1.3.3 [lib.reverse.iter.op.star] required:
++</p>
++<blockquote>
++<pre>
++reference operator*() const;
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>:
++</p>
++<blockquote><pre>
++Iterator tmp = current;
++return *--tmp;
++</pre></blockquote>
++</blockquote></blockquote>
++<p>
++Now, N3797 24.5.1.1 [reverse.iterator] depicts:
++</p>
++<blockquote><pre>
++private:
++ Iterator deref_tmp; // exposition only
++};
++</pre></blockquote>
++<p>
++And 24.5.1.3.4 [reverse.iter.op.star] requires:
++</p>
++<blockquote>
++<pre>
++reference operator*() const;
++</pre>
++<blockquote>
++<p>
++<i>Effects</i>:
++</p>
++<blockquote><pre>
++deref_tmp = current;
++--deref_tmp;
++return *deref_tmp;
++</pre></blockquote>
++<p>
++[<i>Note</i>: This operation must use an auxiliary member variable rather than a temporary variable to avoid
++returning a reference that persists beyond the lifetime of its associated iterator. (See 24.2.) &mdash; <i>end note</i>]
++</p>
++</blockquote></blockquote>
++
++<p>
++As written, this won't compile, because <tt>operator*()</tt> is <tt>const</tt> yet it's modifying (via assignment and decrement)
++the <tt>deref_tmp</tt> data member. So what happens if you say "<tt>mutable Iterator deref_tmp;</tt>"?
++<p/>
++DANGER: WARP CORE BREACH IMMINENT.
++<p/>
++The Standard requires <tt>const</tt> member functions to be callable from multiple threads simultaneously. This is
++17.6.5.9 [res.on.data.races]/3: "A C++ standard library function shall not directly or indirectly modify objects (1.10)
++accessible by threads other than the current thread unless the objects are accessed directly or indirectly via the function's
++non-const arguments, including <tt>this</tt>."
++<p/>
++Multiple threads simultaneously modifying <tt>deref_tmp</tt> will trigger data races, so both <tt>mutable</tt> and some form of
++synchronization (e.g. <tt>mutex</tt> or <tt>atomic</tt>) are actually necessary!
++<p/>
++Here's what implementations currently do: Dinkumware/VC follows C++03 and doesn't use <tt>deref_tmp</tt> (attempting to
++implement it is what led me to file this issue). According to Jonathan Wakely, libstdc++ also follows C++03 (see
++<a href="http://gcc.gnu.org/PR51823">PR51823</a> which is suspended until LWG <a href="lwg-closed.html#2204">2204</a> is resolved). According to
++Marshall Clow, libc++ uses <tt>deref_tmp</tt> with <tt>mutable</tt> but without synchronization, so it can trigger data races.
++<p/>
++This <tt>deref_tmp</tt> Standardese was added by LWG <a href="lwg-defects.html#198">198</a> "Validity of pointers and references unspecified after
++iterator destruction" and is present in Working Papers going back to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1638.pdf">N1638</a>
++on April 11, 2004, long before C++ recognized the existence of multithreading and developed the "<tt>const</tt> means simultaneously
++readable" convention.
++<p/>
++A related issue is LWG <a href="lwg-active.html#1052">1052</a> "<tt>reverse_iterator::operator-&gt;</tt> should also support smart pointers" which
++mentioned the need to depict <tt>mutable</tt> in the Standardese, but it was resolved NAD Future and no change was made.
++<p/>
++Finally, LWG <a href="lwg-closed.html#2204">2204</a> "<tt>reverse_iterator</tt> should not require a second copy of the base iterator" talked about
++removing <tt>deref_tmp</tt>, but without considering multithreading.
++<p/>
++I argue that <tt>deref_tmp</tt> must be removed. Its existence has highly undesirable consequences: either no synchronization
++is used, violating the Standard's usual multithreading guarantees, or synchronization is used, adding further costs for all
++users that benefit almost no iterators.
++<p/>
++<tt>deref_tmp</tt> is attempting to handle iterators that return references to things "inside themselves", which I usually call
++"stashing iterators" (as they have a secret stash). Note that these are very unusual, and are different from proxy iterators like
++<tt>vector&lt;bool&gt;::iterator</tt>. While <tt>vector&lt;bool&gt;::iterator</tt>'s <tt>operator*()</tt> does not return a true
++reference, it refers to a bit that is unrelated to the iterator's lifetime.
++</p>
++
++<p><i>[2014-02-14 Issaquah meeting: Move to Immediate]</i></p>
++
++<p>
++Strike superfluous note to avoid potential confusion, and move to Immediate.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3797.</p>
++
++<ol>
++<li><p>Change class template <tt>reverse_iterator</tt> synopsis, 24.5.1.1 [reverse.iterator], as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++protected:
++ Iterator current;
++<del>private:
++ Iterator deref_tmp; // exposition only</del>
++};
++</pre></blockquote>
++</li>
++
++<li><p>Change 24.5.1.3.4 [reverse.iter.op.star] as indicated:</p>
++
++<blockquote><pre>
++reference operator*() const;
++</pre>
++<blockquote>
++<p>
++-1- <i>Effects</i>:
++</p>
++<blockquote><pre>
++<del>deref_tmp = current;
++--deref_tmp;
++return *deref_tmp;</del>
++<ins>Iterator tmp = current;
++return *--tmp;</ins>
++</pre></blockquote>
++<p>
++<del>-2- [<i>Note</i>: This operation must use an auxiliary member variable rather than a temporary variable to
++avoid returning a reference that persists beyond the lifetime of its associated iterator. (See 24.2.) &mdash; <i>end note</i>]</del>
++</p>
++</blockquote></blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2361"></a>2361. Apply 2299 resolution throughout library</h3>
++<p><b>Section:</b> 20.8.1.2 [unique.ptr.single], 20.7.3.1 [pointer.traits.types], 20.7.7.1 [allocator.uses.trait], 20.7.8.1 [allocator.traits.types], 23.2.3 [sequence.reqmts] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-02-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#unique.ptr.single">issues</a> in [unique.ptr.single].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++LWG <a href="lwg-defects.html#2299">2299</a> addressed a N.B. comment pointing out that recently added
++wording about a type existing was not clear what happens if the type
++exists but is inaccessible. There are 16 pre-existing uses of the same
++language in the library that should use the same wording used to
++resolve 2299.
++</p>
++
++<p>
++The relevant paragraphs are:
++</p>
++
++<p>
++20.8.1.2 [unique.ptr.single]
++<p/>
++20.7.3.1 [pointer.traits.types]
++<p/>
++20.7.7.1 [allocator.uses.trait]
++<p/>
++20.7.8.1 [allocator.traits.types]
++<p/>
++23.2.3 [sequence.reqmts]
++</p>
++
++<p><i>[2014-05-16, Daniel provides wording]</i></p>
++
++
++<p><i>[2014-05-18 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.7.3.1 [pointer.traits.types] as indicated:</p>
++
++<blockquote>
++<pre>
++typedef <i>see below</i> element_type;
++</pre>
++<blockquote>
++<p>
++-1- <i>Type</i>: <tt>Ptr::element_type</tt> if <del>such a type exists</del><ins>the qualified-id <tt>Ptr::element_type</tt> is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise, <tt>T</tt> if <tt>Ptr</tt> is a class template instantiation
++of the form <tt>SomePointer&lt;T, Args&gt;</tt>, where <tt>Args</tt> is zero or more type arguments; otherwise, the
++specialization is ill-formed.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> difference_type;
++</pre>
++<blockquote>
++<p>
++-2- <i>Type</i>: <tt>Ptr::difference_type</tt> if <del>such a type exists</del><ins>the qualified-id <tt>Ptr::difference_type</tt> is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise, <tt>std::ptrdiff_t</tt>.
++</p>
++</blockquote>
++
++<pre>
++template &lt;class U&gt; using rebind = <i>see below</i>;
++</pre>
++<blockquote>
++<p>
++-3- <i>Alias template</i>: <tt>Ptr::rebind&lt;U&gt;</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Ptr::rebind&lt;U&gt;</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>SomePointer&lt;U, Args&gt;</tt> if <tt>Ptr</tt> is a class template instantiation of the form <tt>SomePointer&lt;T, Args&gt;</tt>,
++where <tt>Args</tt> is zero or more type arguments; otherwise, the instantiation of <tt>rebind</tt> is ill-formed.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.7.1 [allocator.uses.trait] p1 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class T, class Alloc&gt; struct uses_allocator;
++</pre>
++<blockquote>
++<p>
++-1- <i>Remark<ins>s</ins></i>: automatically detects whether <tt>T</tt> has a nested <tt>allocator_type</tt> that is
++convertible from <tt>Alloc</tt>. Meets the <tt>BinaryTypeTrait</tt> requirements (20.10.1). The implementation shall provide a definition
++that is derived from <tt>true_type</tt> if <del>a type</del><ins>the qualified-id</ins> <tt>T::allocator_type</tt> <del>exists</del><ins>is
++valid and denotes a type (14.8.2 [temp.deduct])</ins> and <tt>is_convertible&lt;Alloc, T::allocator_type&gt;::value != false</tt>,
++otherwise it shall be derived from <tt>false_type</tt>. [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.8.1 [allocator.traits.types] as indicated:</p>
++
++<blockquote>
++<pre>
++typedef <i>see below</i> pointer;
++</pre>
++<blockquote>
++<p>
++-1- <i>Type</i>: <tt>Alloc::pointer</tt> if <del>such a type exists</del><ins>the qualified-id <tt>Alloc::pointer</tt> is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise, <tt>value_type*</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> const_pointer;
++</pre>
++<blockquote>
++<p>
++-2- <i>Type</i>: <tt>Alloc::const_pointer</tt> if <del>such a type exists</del><ins>the qualified-id <tt>Alloc::const_pointer</tt> is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>pointer_traits&lt;pointer&gt;::rebind&lt;const value_type&gt;</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> void_pointer;
++</pre>
++<blockquote>
++<p>
++-3- <i>Type</i>: <tt>Alloc::void_pointer</tt> if <del>such a type exists</del><ins>the qualified-id <tt>Alloc::void_pointer</tt> is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>pointer_traits&lt;pointer&gt;::rebind&lt;void&gt;</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> const_void_pointer;
++</pre>
++<blockquote>
++<p>
++-4- <i>Type</i>: <tt>Alloc::const_void_pointer</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::const_void_pointer</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>pointer_traits&lt;pointer&gt;::rebind&lt;const void&gt;</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> difference_type;
++</pre>
++<blockquote>
++<p>
++-5- <i>Type</i>: <tt>Alloc::difference_type</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::difference_type</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>pointer_traits&lt;pointer&gt;::difference_type</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> size_type;
++</pre>
++<blockquote>
++<p>
++-6- <i>Type</i>: <tt>Alloc::size_type</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::size_type</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>make_unsigned_t&lt;difference_type&gt;</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> propagate_on_container_copy_assignment;
++</pre>
++<blockquote>
++<p>
++-7- <i>Type</i>: <tt>Alloc::propagate_on_container_copy_assignment</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::propagate_on_container_copy_assignment</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>false_type</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> propagate_on_container_move_assignment;
++</pre>
++<blockquote>
++<p>
++-8- <i>Type</i>: <tt>Alloc::propagate_on_container_move_assignment</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::propagate_on_container_move_assignment</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>false_type</tt>.
++</p>
++</blockquote>
++
++<pre>
++typedef <i>see below</i> propagate_on_container_swap;
++</pre>
++<blockquote>
++<p>
++-9- <i>Type</i>: <tt>Alloc::propagate_on_container_swap</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::propagate_on_container_swap</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>false_type</tt>.
++</p>
++</blockquote>
++
++<pre>
++template &lt;class T&gt; using rebind_alloc = <i>see below</i>;
++</pre>
++<blockquote>
++<p>
++-10- <i>Alias template</i>: <tt>Alloc::rebind&lt;T&gt;::other</tt> if <del>such a type exists</del><ins>the qualified-id
++<tt>Alloc::rebind&lt;T&gt;::other</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins>; otherwise,
++<tt>Alloc&lt;T, Args&gt;</tt> if <tt>Alloc</tt> is a class template instantiation of the form <tt>Alloc&lt;U, Args&gt;</tt>,
++where <tt>Args</tt> is zero or more type arguments; otherwise, the instantiation of <tt>rebind_alloc</tt> is ill-formed.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.8.1.2 [unique.ptr.single] p3 as indicated:</p>
++
++<blockquote><p>
++-3- If the <del>type</del><ins>qualified-id</ins> <tt>remove_reference_t&lt;D&gt;::pointer</tt> <del>exists</del><ins>is
++valid and denotes a type (14.8.2 [temp.deduct])</ins>, then <tt>unique_ptr&lt;T, D&gt;::pointer</tt> shall be a synonym
++for <tt>remove_reference_t&lt;D&gt;::pointer</tt>. [&hellip;]
++</p></blockquote>
++</li>
++
++<li><p>Change 23.2.3 [sequence.reqmts] p3 as indicated:</p>
++
++<blockquote><p>
++-3- In Tables 100 and 101, <tt>X</tt> denotes a sequence container class, <tt>a</tt> denotes a value of <tt>X</tt> containing elements
++of type <tt>T</tt>, <tt>A</tt> denotes <tt>X::allocator_type</tt> if <del>it exists</del><ins>the qualified-id
++<tt>X::allocator_type</tt> is valid and denotes a type (14.8.2 [temp.deduct])</ins> and <tt>std::allocator&lt;T&gt;</tt>
++if it doesn't, [&hellip;]
++</p></blockquote>
++</li>
++
++
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2364"></a>2364. <tt>deque</tt> and <tt>vector</tt> <tt>pop_back</tt> don't specify iterator invalidation requirements</h3>
++<p><b>Section:</b> 23.3.3.4 [deque.modifiers], 23.3.6.5 [vector.modifiers] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Deskin Miller <b>Opened:</b> 2014-02-17 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#deque.modifiers">issues</a> in [deque.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I think it's obvious that <tt>vector::pop_back</tt> invalidates the path-the-end iterator, but I cannot find language that says so to
++my satisfaction in the Standard. N3797 23.2.3 [sequence.reqmts] Table 101 lists <tt>a.pop_back()</tt> semantics as "Destroys the
++last element", but nowhere do I see this required to invalidate the end iterator (or iterators previously referring to the last element).
++ [container.reqmts.general]/11 states "Unless otherwise specified (either explicitly or by defining a function in terms of
++other functions), invoking a container member function or passing a container as an argument to a library function shall not
++invalidate iterators to, or change the values of, objects within that container." 23.3.6.5 [vector.modifiers]/3 says that each
++flavor of <tt>vector::erase</tt> "Invalidates iterators and references at or after the point of the erase", but <tt>pop_back</tt> isn't
++discussed, and it wasn't specified in terms of <tt>erase</tt>.
++</p>
++<p>
++Similarly for <tt>std::deque</tt>, 23.2.3 [sequence.reqmts] Table 101 and [container.reqmts.general]/11 both apply.
++Yet 23.3.3.4 [deque.modifiers] likewise doesn't discuss <tt>pop_back</tt> nor <tt>pop_front</tt>. Furthermore paragraph 4 fails to
++specify the iterator-invalidation guarantees when erasing the first element but not the last.
++<p/>
++Both <tt>std::vector</tt> and <tt>std::deque</tt> are in contrast to <tt>std::list</tt>, which says in 23.3.5.4 [list.modifiers]/3
++regarding <tt>pop_back</tt> (as well as all forms of <tt>erase</tt>, <tt>pop_front</tt>, and <tt>clear</tt>) "Effects: Invalidates only
++the iterators and references to the erased elements."
++</p>
++
++<p><i>[2014-06-16 Jonathan comments and improves wording]</i></p>
++
++
++<p>
++I believe this reflects our preferred form discussed earlier,
++specifically putting the signatures with the <tt>erase</tt> signatures, so that
++the full specification of <tt>erase()</tt> applies to the <tt>pop_xxx()</tt> functions.
++This covers the case for <tt>deque</tt> where <tt>pop_front()</tt> erases the only
++element (which is both the first and last element).
++<p/>
++Open question: the "erase" wording talks about "An erase operation" &mdash;
++are <tt>pop_front</tt> and <tt>pop_back</tt> clearly covered by "erase operations"? I
++believe so, as 23.3.3.1 [deque.overview]/1 and other places talk about "insert
++and erase operations" which covers <tt>push</tt>/<tt>pop</tt> functions too. I've added
++a note which could be used to clarify that if desired.
++</p>
++
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 23.3.3.4 [deque.modifiers] as indicated:</p>
++
++<blockquote>
++<pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator first, const_iterator last);
++</pre>
++<blockquote><p>
++-4- <i>Effects</i>: An erase operation that erases the last element of a deque invalidates only the past-the-end
++iterator and all iterators and references to the erased elements. An erase operation that erases the first
++element of a deque but not the last element invalidates only <ins>iterators and references to</ins> the erased elements.
++An erase operation that erases neither the first element nor the last element of a deque invalidates the past-the-end iterator
++and all iterators and references to all the elements of the deque.
++<p/>
++-5- [&hellip;]
++<p/>
++-6- [&hellip;]
++</p>
++</blockquote>
++
++<pre>
++<ins>void pop_front();
++void pop_back();</ins>
++</pre>
++<blockquote><p>
++<ins>-?- <i>Effects</i>: <tt>pop_front</tt> invalidates iterators and references to the first element of the <tt>deque</tt>.
++<tt>pop_back</tt> invalidates the past-the-end iterator, and all iterators and references to the last element of the <tt>deque</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.5 [vector.modifiers] as indicated:</p>
++<blockquote>
++<blockquote>
++<p>
++-5- [&hellip;]
++</p>
++</blockquote>
++
++<pre>
++<ins>void pop_back();</ins>
++</pre>
++<blockquote><p>
++<ins>-?- <i>Effects</i>: Invalidates the past-the-end iterator, and iterators and references to the last element of the vector.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-06-21 Rapperswil]</i></p>
++
++<p>
++Tony van Eerd: Would be good to define "an erase operation is ..." somewhere.
++<p/>
++AM: The containers clause is known to be suboptimal in many ways.
++<p/>
++Looks good
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 23.3.3.4 [deque.modifiers] as indicated:</p>
++
++<blockquote>
++<pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator first, const_iterator last);
++<ins>void pop_front();
++void pop_back();</ins>
++</pre>
++<blockquote><p>
++-4- <i>Effects</i>: An erase operation that erases the last element of a deque invalidates only the past-the-end
++iterator and all iterators and references to the erased elements. An erase operation that erases the first
++element of a deque but not the last element invalidates only <ins>iterators and references to</ins> the erased elements.
++An erase operation that erases neither the first element nor the last element of a deque invalidates the past-the-end iterator
++and all iterators and references to all the elements of the deque. <ins>[<i>Note</i>: <tt>pop_front</tt> and <tt>pop_back</tt>
++are erase operations &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.5 [vector.modifiers] as indicated:</p>
++<blockquote>
++<pre>
++iterator erase(const_iterator position);
++iterator erase(const_iterator first, const_iterator last);
++<ins>void pop_back();</ins>
++</pre>
++<blockquote><p>
++-3- <i>Effects</i>: Invalidates iterators and references at or after the point of the erase.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2365"></a>2365. Missing <tt>noexcept</tt> in <tt>shared_ptr::shared_ptr(nullptr_t)</tt></h3>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Cassio Neri <b>Opened:</b> 2014-02-13 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The declaration and definition of <tt>shared_ptr::shared_ptr(nullptr_t)</tt>, given in 20.8.2.2 [util.smartptr.shared], is
++</p>
++<blockquote><pre>
++constexpr shared_ptr(nullptr_t) : shared_ptr() { }
++</pre></blockquote>
++<p>
++The intention seems clear: this constructor should have the same semantics of the default constructor. However, contrarily to the
++default constructor, this one is not <tt>noexcept</tt>. In contrast, <tt>unique_ptr::unique_ptr(nullptr_t)</tt> is <tt>noexcept</tt>,
++as per 20.8.1.2 [unique.ptr.single]:
++</p>
++<blockquote><pre>
++constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
++</pre></blockquote>
++<p>
++Both libstdc++ and libc++ have added <tt>noexcept</tt> to <tt>shared_ptr::shared_ptr(nullptr_t)</tt>. Microsoft's STL has not.
++</p>
++
++<p><i>[2014-03-26 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change class template <tt>shared_ptr</tt> synopsis, 20.8.2.2 [util.smartptr.shared], as indicated:</p>
++
++<blockquote>
++<pre>
++constexpr shared_ptr(nullptr_t) <ins>noexcept</ins> : shared_ptr() { }
++</pre>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2369"></a>2369. <tt>constexpr max(initializer_list)</tt> vs <tt>max_element</tt></h3>
++<p><b>Section:</b> 25.4.7 [alg.min.max] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Marc Glisse <b>Opened:</b> 2014-02-21 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.min.max">issues</a> in [alg.min.max].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++As part of the resolution for LWG issue <a href="lwg-defects.html#2350">2350</a>, <tt>max(initializer_list)</tt> was marked as <tt>constexpr</tt>. Looking
++at two implementations of this function (libstdc++ and libc++), both implement it in terms of <tt>max_element</tt>, which is <em>not</em>
++marked as <tt>constexpr</tt>. This is inconsistent and forces some small amount of code duplication in the implementation. Unless we
++remove <tt>constexpr</tt> from this overload of <tt>max</tt>, I believe we should add <tt>constexpr</tt> to <tt>max_element</tt>.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++AM: Can we implement this with the C++14 <tt>constexpr</tt> rules? JM: Yes. AM: Ready? [Yes]
++<p/>
++Accepted.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>In 25.1 [algorithms.general], header <tt>&lt;algorithm&gt;</tt> synopsis, and 25.4.7 [alg.min.max], change as
++indicated (add <tt>constexpr</tt> to every signature from the first <tt>min_element</tt> to the second <tt>minmax_element</tt>)::</p>
++
++<blockquote>
++<pre>
++template&lt;class ForwardIterator&gt;
++<ins>constexpr</ins> ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++<ins>constexpr</ins> ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
++ Compare comp);
++[&hellip;]
++template&lt;class ForwardIterator&gt;
++<ins>constexpr</ins> ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++<ins>constexpr</ins> ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
++ Compare comp);
++[&hellip;]
++template&lt;class ForwardIterator&gt;
++<ins>constexpr</ins> pair&lt;ForwardIterator, ForwardIterator&gt;
++minmax_element(ForwardIterator first, ForwardIterator last);
++template&lt;class ForwardIterator, class Compare&gt;
++<ins>constexpr</ins> pair&lt;ForwardIterator, ForwardIterator&gt;
++minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
++</pre>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2371"></a>2371. [fund.ts] No template aliases defined for new type traits</h3>
++<p><b>Section:</b> 20.10.2 [meta.type.synop] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2014-03-07 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++The library fundamentals specification defines two new type trait template classes: <tt>invocation_type</tt> and <tt>raw_invocation_type</tt>.
++But it does not define the corresponding template aliases. Note that both of these classes define a member typedef <tt>type</tt> and no
++other public members, so according to the argument in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3887.pdf">N3887</a>
++the template aliases should be defined.
++</p>
++
++<p><i>[2013-06-21 Rapperswil]</i></p>
++
++<p>
++Accept for Library Fundamentals TS Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html">N3908</a>.</p>
++
++<ol>
++<li><p>Add the following to section 3.3.1[meta.type.synop] of the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#meta">Library Fundamentals specification</a>
++as indicated:
++</p>
++
++<blockquote><pre>
++namespace std {
++namespace experimental {
++inline namespace fundamentals_v1 {
++ [&hellip;]
++ <i>// 3.3.2, Other type transformations</i>
++ template &lt;class&gt; class invocation_type; <i>// not defined</i>
++ template &lt;class F, class... ArgTypes&gt; class invocation_type&lt;F(ArgTypes...)&gt;;
++ template &lt;class&gt; class raw_invocation_type; <i>// not defined</i>
++ template &lt;class F, class... ArgTypes&gt; class raw_invocation_type&lt;F(ArgTypes...)&gt;;
++
++ <ins>template &lt;class T&gt;
++ using invocation_type_t = typename invocation_type&lt;T&gt;::type;
++ template &lt;class T&gt;
++ using raw_invocation_type_t = typename raw_invocation_type&lt;T&gt;::type;</ins>
++
++} <i>// namespace fundamentals_v1</i>
++} <i>// namespace experimental</i>
++} <i>// namespace std</i>
++</pre></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2374"></a>2374. [fund.ts] Remarks for <tt>optional::to_value</tt> are too restrictive</h3>
++<p><b>Section:</b> X [optional.object.observe] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-03-25 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++In Bristol I think I claimed that the remarks for <tt>optional::to_value()</tt>
++were unimplementable and the function could only be <tt>constexpr</tt> if both
++constructors that could be called were <tt>constexpr</tt>, but I was wrong.
++The remarks should be reverted to the original pre-n3793 form.
++</p>
++
++<p><i>[2013-06-21 Rapperswil]</i></p>
++
++<p>
++Accept for Library Fundamentals TS Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html">N3908</a>.</p>
++
++<ol>
++<li><p>Change [optional.object.observe] p23 of the
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#optional.object.observe">Library Fundamentals specification</a>
++as indicated:
++</p>
++
++<blockquote><pre>
++template &lt;class U&gt; constexpr T value_or(U&amp;&amp; v) const &amp;;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-23- <i>Remarks</i>: If <del>both constructors of <tt>T</tt> which could be selected are <tt>constexpr</tt> constructors</del><ins>the
++selected constructor of <tt>T</tt> is a <tt>constexpr</tt> constructor</ins>, this function
++shall be a <tt>constexpr</tt> function.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2376"></a>2376. <tt>bad_weak_ptr::what()</tt> overspecified</h3>
++<p><b>Section:</b> 20.8.2.1 [util.smartptr.weakptr] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-03-27 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++20.8.2.1 [util.smartptr.weakptr] p2 requires <tt>bad_weak_ptr</tt> to return precisely
++the string <tt>"bad_weak_ptr"</tt>.
++<p/>
++There was general agreement on the reflector and at the Issaquah
++meeting that this is over-constrained and implementation should be
++free to return something more descriptive if desired.
++<p/>
++The proposed resolution makes <tt>bad_weak_ptr</tt> consistent with other
++exception types such as <tt>bad_alloc</tt> and <tt>bad_cast</tt>.
++<p/>
++If accepted, the P/R for issue <a href="lwg-defects.html#2233">2233</a>, which currently uses similar
++wording to <tt>bad_weak_ptr</tt>, could be updated appropriately.
++</p>
++
++<p><i>[2014-03-27 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 20.8.2.1 [util.smartptr.weakptr]:</p>
++
++<blockquote>
++<pre>
++bad_weak_ptr() noexcept;
++</pre><blockquote>
++<p>
++-2- <i>Postconditions</i>: <tt>what()</tt> returns <del><tt>"bad_weak_ptr"</tt></del><ins>an implementation-defined NTBS</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2377"></a>2377. <tt>std::align</tt> requirements overly strict</h3>
++<p><b>Section:</b> 20.7.5 [ptr.align] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2014-03-30 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#ptr.align">issues</a> in [ptr.align].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>std::align</tt> requires that its <tt>alignment</tt> argument shall be "a fundamental alignment value or an
++extended alignment value supported by the implementation in this context".
++<p/>
++This requirement is overly strict. There are use cases that require a buffer aligned at values that are not tied
++to the C++ implementation, such as page size, cache line size, sector size. These come from the hardware or the
++OS and are generally not known until run time. The implementation of <tt>std::align</tt> does not depend on the
++requirement that <tt>alignment</tt> be a fundamental or an extended alignment value; any power of two would be handled
++the same way.
++<p/>
++In addition, it is not possible for the user to even determine whether a value is "a fundamental alignment value
++or an extended alignment value supported by the implementation in this context". One would expect values coming
++from <tt>alignof</tt> to be fine, but I'm not sure whether even that is guaranteed in the presence of <tt>alignas</tt>.
++<p/>
++Therefore, I propose that
++</p>
++<blockquote><p>
++<i>Requires</i>:
++</p>
++<ul>
++<li><p><tt>alignment</tt> shall be a fundamental alignment value or an extended alignment value supported by
++the implementation in this context</p></li>
++</ul>
++</blockquote>
++<p>
++be changed to
++</p>
++<blockquote><p>
++<i>Requires</i>:
++</p>
++<ul>
++<li><p><tt>alignment</tt> shall be a power of two</p></li>
++</ul>
++</blockquote>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 20.7.5 [ptr.align] p2 as indicated:</p>
++
++<blockquote>
++<pre>
++void* align(std::size_t alignment, std::size_t size,
++ void*&amp; ptr, std::size_t&amp; space);
++</pre><blockquote>
++<p>
++-1- [&hellip;]
++<p/>
++-2- <i>Requires</i>:
++</p>
++<ul>
++<li><p>
++<tt>alignment</tt> shall be a <del>fundamental alignment value or an extended alignment value supported by
++the implementation in this context</del><ins>power of two</ins>
++</p></li>
++</ul>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2378"></a>2378. Behaviour of standard exception types</h3>
++<p><b>Section:</b> 18.6.2.1 [bad.alloc], 18.6.2.2 [new.badlength], 18.7.2 [bad.cast], 18.7.3 [bad.typeid], 18.8.2 [bad.exception] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Andy Sawyer <b>Opened:</b> 2014-03-31 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++I think we have an issue with the specification of some of the standard exception types.
++In particular, several of them have default constructors with remarks to the effect that
++"The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined".
++(In some cases this is contradictory to a further specification of <tt>what()</tt>, which
++is specified to return an implementation-defined NTBS.)
++</p>
++
++<p>
++<strong>Previous resolution from Andy [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Edit 18.6.2.1 [bad.alloc] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_alloc() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- <i>Remarks</i>: <del>The result of calling <tt>what()</tt> on the newly constructed object is
++ implementation-defined</del><ins><tt>what()</tt> returns an implementation-defined NTBS</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.6.2.2 [new.badlength] p3 as indicated: [<i>Drafting note</i>: Added the Postcondition, since we don't
++say anything else about <tt>bad_array_new_length::what()</tt> &mdash; <i>end of note</i>]</p>
++
++<blockquote>
++<pre>
++bad_array_new_length() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- <i><del>Remarks</del><ins>Postcondition</ins></i>: <del>The result of calling <tt>what()</tt> on the newly constructed object is
++ implementation-defined</del><ins><tt>what()</tt> returns an implementation-defined NTBS</ins>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.7.2 [bad.cast] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_cast() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.7.3 [bad.typeid] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_typeid() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.8.2 [bad.exception] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_exception() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-06-17, Rapperswil]</i></p>
++
++<p>
++Jonathan provides alternative wording.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++NJ: I don't know why we need the explict statement about <tt>what()</tt> here, since <tt>bad_array_new_length</tt>
++already derives.<br/>
++AM: yes.<br/>
++NJ: Then "what()" is missing from the synopsis.<br/>
++AM: Yes, that's an error and it needs to be added.
++<p/>
++Conclusion: Update the wording to add the missing entry in the synopsis.
++<p/>
++AM: The issue needs another update; we need to add missing "Remarks". DK updates the paper.<br/>
++AM: Any objections to "tentatively ready"? No objections.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Edit 18.6.2.1 [bad.alloc] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_alloc() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is
++ implementation-defined.</del>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.6.2.1 [bad.alloc] p5 as indicated:</p>
++
++<blockquote>
++<pre>
++virtual const char* what() const noexcept;
++</pre>
++<blockquote>
++<p>
++-5- <i>Returns</i>: An implementation-defined NTBS.
++<p/>
++<ins>-?- <i>Remarks</i>: The message may be a null-terminated multibyte string (17.5.2.1.4.2), suitable for conversion
++and display as a <tt>wstring</tt> (21.3, 22.4.1.4).</ins>
++</p>
++</blockquote>
++</blockquote>
++
++</li>
++
++<li><p>Edit class <tt>bad_array_new_length</tt> synopsis 18.6.2.2 [new.badlength] as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ class bad_array_new_length : public bad_alloc {
++ public:
++ bad_array_new_length() noexcept;
++ <ins>virtual const char* what() const noexcept;</ins>
++ };
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Edit 18.6.2.2 [new.badlength] as indicated:</p>
++
++<blockquote>
++<pre>
++bad_array_new_length() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is
++ implementation-defined.</del>
++</p>
++</blockquote>
++<pre>
++<ins>virtual const char* what() const noexcept;</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Returns</i>: An implementation-defined NTBS.</ins>
++<p/>
++<ins>-?- <i>Remarks</i>: The message may be a null-terminated multibyte string (17.5.2.1.4.2), suitable for conversion
++and display as a <tt>wstring</tt> (21.3, 22.4.1.4).</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.7.2 [bad.cast] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_cast() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.7.3 [bad.typeid] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_typeid() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Edit 18.8.2 [bad.exception] p3 as indicated:</p>
++
++<blockquote>
++<pre>
++bad_exception() noexcept;
++</pre><blockquote>
++<p>
++[&hellip;]
++<p/>
++<del>-3- <i>Remarks</i>: The result of calling <tt>what()</tt> on the newly constructed object is implementation-defined.</del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2387"></a>2387. More nested types that must be accessible and unambiguous</h3>
++<p><b>Section:</b> 20.9.2 [func.require], 20.9.4 [refwrap] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.require">active issues</a> in [func.require].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.require">issues</a> in [func.require].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Further to <a href="lwg-defects.html#2299">2299</a> and <a href="lwg-defects.html#2361">2361</a>, 20.9.2 [func.require] p3 and 20.9.4 [refwrap] p3 and p4
++talk about member types without any mention of being accessible and unambiguous.
++</p>
++
++<p><i>[2014-06-05 Daniel provides wording]</i></p>
++
++
++<p><i>[2014-06-06 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.9.2 [func.require] p3 as indicated:</p>
++
++<blockquote><p>
++-3- If a call wrapper (20.9.1) has a <i>weak result type</i> the type of its member type <tt>result_type</tt> is based on the
++type <tt>T</tt> of the wrapper's target object (20.9.1):
++</p>
++<ul>
++<li><p>if <tt>T</tt> is a pointer to function type, <tt>result_type</tt> shall be a synonym for the return type of <tt>T</tt>;</p></li>
++<li><p>if <tt>T</tt> is a pointer to member function, <tt>result_type</tt> shall be a synonym for the return type of <tt>T</tt>;</p></li>
++<li><p>if <tt>T</tt> is a class type <ins>and the qualified-id <tt>T::result_type</tt> is valid and denotes a type
++(14.8.2 [temp.deduct])</ins><del>with a member type <tt>result_type</tt></del>, then <tt>result_type</tt> shall be a synonym for
++<tt>T::result_type</tt>;</p></li>
++<li><p>otherwise <tt>result_type</tt> shall not be defined.</p></li>
++</ul>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.4 [refwrap] p3+p4 as indicated:</p>
++
++<blockquote>
++<p>
++-3- The template instantiation <tt>reference_wrapper&lt;T&gt;</tt> shall define a nested type named <tt>argument_type</tt> as a
++synonym for <tt>T1</tt> only if the type <tt>T</tt> is any of the following:
++</p>
++<ul>
++<li><p>a function type or a pointer to function type taking one argument of type <tt>T1</tt></p></li>
++<li><p>a pointer to member function <tt>R T0::f</tt> <i>cv</i> (where <i>cv</i> represents the member function_s cv-qualifiers);
++the type <tt>T1</tt> is <i>cv</i> <tt>T0*</tt></p></li>
++<li><p>a class type <ins>where the qualified-id <tt>T::argument_type</tt> is valid and denotes a type
++(14.8.2 [temp.deduct])</ins><del>with a member type <tt>argument_type</tt></del>; the type <tt>T1</tt> is
++<tt>T::argument_type</tt>.</p></li>
++</ul>
++<p>
++-4- The template instantiation <tt>reference_wrapper&lt;T&gt;</tt> shall define two nested types named <tt>first_argument_type</tt>
++and <tt>second_argument_type</tt> as synonyms for <tt>T1</tt> and <tt>T2</tt>, respectively, only if the type <tt>T</tt> is any of the
++following:
++</p>
++<ul>
++<li><p>a function type or a pointer to function type taking two arguments of types <tt>T1</tt> and <tt>T2</tt></p></li>
++<li><p>a pointer to member function <tt>R T0::f(T2)</tt> <i>cv</i> (where <i>cv</i> represents the member function's cv-qualifiers);
++the type <tt>T1</tt> is <i>cv</i> <tt>T0*</tt></p></li>
++<li><p>a class type <ins>where the qualified-ids <tt>T::first_argument_type</tt> and <tt>T::second_argument_type</tt> are both valid
++and both denote types (14.8.2 [temp.deduct])</ins><del>with member types <tt>first_argument_type</tt> and
++<tt>second_argument_type</tt></del>; the type <tt>T1</tt> is <tt>T::first_argument_type</tt><del>.</del> and the type <tt>T2</tt> is
++<tt>T::second_argument_type</tt>.</p></li>
++</ul>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2389"></a>2389. [fund.ts] <tt>function::operator=</tt> is over-specified and handles allocators incorrectly</h3>
++<p><b>Section:</b> X [mods.func.wrap] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2014-05-23 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#mods.func.wrap">issues</a> in [mods.func.wrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++This issue against the TS is similar to LWG <a href="lwg-closed.html#2386">2386</a>, which is against the standard. The Effects clauses for the assignment
++operator for class template <tt>function</tt> are written as code that constructs a temporary <tt>function</tt> and then swaps it
++with <tt>*this</tt>.
++The intention appears to be that assignment should have the strong exception guarantee, i.e., <tt>*this</tt> is not modified if
++an exception is thrown. The description in the standard is incorrect when <tt>*this</tt> was originally constructed using an
++allocator. The TS attempts to correct the problem, but the correction is incomplete.
++<p/>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#mods.func.wrap">The wording in the TS</a> uses
++<tt>get_memory_resource()</tt> to construct a temporary <tt>function</tt> object with the same allocator as the left-hand size
++(lhs) of the assignment. The intended result of using this pattern was that the allocator for <tt>*this</tt> would be unchanged,
++but it doesn't quite work. The problem is that the allocator returned by <tt>get_memory_resource()</tt> is not the same type as
++the type-erased allocator used to construct the <tt>function</tt> object, but rather a type-erased distillation of that type that
++is insufficient for making a true copy of the allocator. The rules for type-erased allocators in the TS
++(<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#memory.type.erased.allocator">[memory.type.erased.allocator]</a>)
++specify that the lifetime of the object returned by <tt>get_memory_resource()</tt> is sometimes tied to the lifetime of <tt>*this</tt>,
++which might cause the (single copy of) the allocator to be destroyed if the <tt>swap</tt> operation destroys and reconstructs <tt>*this</tt>,
++as some implementations do (and are allowed to do).
++<p/>
++The desired behavior is that assignment would leave the allocator of the lhs unchanged. The way to achieve this behavior is to
++construct the temporary <tt>function</tt> using the original allocator. Unfortunately, we cannot describe the desired behavior in
++pure code, because <tt>get_memory_resource()</tt> does not really name the type-erased allocator, as mentioned above. The PR below,
++therefore, uses pseudo-code, inventing a fictitious <tt><i>ALLOCATOR_OF</i>(f)</tt> expression that evaluates to the actual allocator
++type, even if that allocator was type erased. I have implemented this PR successfully.
++</p>
++
++<p><i>[2014-06-21, Rapperswil]</i></p>
++
++<p>
++Apply to Library Fundamentals TS (after removing the previous "Throws: Nothing" element to prevent an editorial conflict with
++<a href="lwg-defects.html#2401">2401</a>).
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html">N3908</a>.</p>
++
++<ol>
++<li><p>Change in [mods.func.wrap] in the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#mods.func.wrap">Library TS</a>
++as indicated:
++</p>
++<blockquote>
++<p>
++<ins>In the following descriptions, let <tt><i>ALLOCATOR_OF</i>(f)</tt> be the allocator specified in the construction of <tt>function</tt>
++<tt>f</tt>, or <tt>allocator&lt;char&gt;()</tt> if no allocator was specified.</ins>
++</p>
++<pre>
++function&amp; operator=(const function&amp; f);
++</pre>
++<blockquote>
++<p>
++-5- <i>Effects</i>: <tt>function(allocator_arg, <del>get_memory_resource()</del><ins><i>ALLOCATOR_OF</i>(*this)</ins>, f).swap(*this);</tt>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++function&amp; operator=(function&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++-8- <i>Effects</i>: <tt>function(allocator_arg, <del>get_memory_resource()</del><ins><i>ALLOCATOR_OF</i>(*this)</ins>, std::move(f)).swap(*this);</tt>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++function&amp; operator=(nullptr_t);
++</pre>
++<blockquote>
++<p>
++-11- <i>Effects</i>: If <tt>*this != NULL</tt>, destroys the target of <tt>this</tt>.
++<p/>
++-12- <i>Postconditions</i>: <tt>!(*this)</tt>. <ins>The memory resource returned by <tt>get_memory_resource()</tt> after the assignment
++is equivalent to the memory resource before the assignment. [<i>Note</i>: the address returned by <tt>get_memory_resource()</tt>
++might change &mdash; <i>end note</i>]</ins>
++<p/>
++-13- <i>Returns</i>: <tt>*this</tt>
++</p>
++</blockquote>
++<pre>
++template&lt;class F&gt; function&amp; operator=(F&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++-15- <i>Effects</i>: <tt>function(allocator_arg, <del>get_memory_resource()</del><ins><i>ALLOCATOR_OF</i>(*this)</ins>,
++std::forward&lt;F&gt;(f)).swap(*this);</tt>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++<pre>
++template&lt;class F&gt; function&amp; operator=(reference_wrapper&lt;F&gt; f);
++</pre>
++<blockquote>
++<p>
++-18- <i>Effects</i>: <tt>function(allocator_arg, <del>get_memory_resource()</del><ins><i>ALLOCATOR_OF</i>(*this)</ins>, f).swap(*this);</tt>
++<p/>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2390"></a>2390. [fund.ts] Invocation types and rvalues</h3>
++<p><b>Section:</b> X [mods.func.wrap] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Michael Spertus <b>Opened:</b> 2014-05-26 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#mods.func.wrap">issues</a> in [mods.func.wrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++<tt>invocation_type</tt> falls short of its stated goals in the following case. Using the notation of
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3866.html">Invocation type traits</a>,
++consider
++</p>
++<blockquote>
++<pre>
++void f(int const&amp; i);
++more_perfect_forwarding_async(f, int(7)); // Oops. Dangling reference because rvalue gone when async runs
++</pre>
++</blockquote>
++<p>
++This was always the advertised intent of the proposal, but while the language reflects this for the first parameter in the
++case of a member pointer, it failed to include corresponding language for other parameters.
++</p>
++
++<p><i>[2014-06-18, Rapperswil]</i></p>
++
++<p>
++Mike Spertus, Richard Smith, Jonathan Wakely, and Jeffrey Yasskin suggest improved wording.
++</p>
++
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<p/>
++<blockquote class="note">
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html">N3908</a>.</p>
++
++<ol>
++<li><p>Change Table 3, [meta.trans.other] in the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3908.html#meta.trans.other">Library TS</a>
++as indicated:
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 3 &mdash; Other type transformations</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class Fn, class... ArgTypes&gt;<br/>
++struct invocation_type&lt;Fn(ArgTypes...)&gt;;</tt>
++</td>
++<td>
++<tt>Fn</tt> and all types in the parameter pack <tt>ArgTypes</tt><br/>
++shall be complete types, (possibly <i>cv</i>-qualified) <tt>void</tt>,<br/>
++or arrays of unknown bound.
++</td>
++<td>
++If <ins><tt>A1, A2,...</tt> denotes <tt>ArgTypes...</tt> and</ins><br/>
++<tt>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt><br/>
++is the function type <tt>R(T1, T2, ...)</tt> <ins>then let <tt>Ui</tt> be<br/>
++<tt>decay&lt;Ai&gt;::type</tt> if <tt>Ai</tt> is an rvalue otherwise <tt>Ti</tt>.<br/>
++If</ins> <del>and</del> <tt>Fn</tt> is a pointer to member type and <tt>T1</tt> is<br/>
++an rvalue reference, then <ins>let <tt>U1</tt> be</ins> <tt><del>R(</del>decay&lt;T1&gt;::type<del>,<br/>
++T2, ...)</del></tt>.<br/>
++<del>Otherwise, <tt>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt></del><br/>
++<ins>The member typedef <tt>type</tt> shall equal <tt>R(U1, U2, ...)</tt></ins>.
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2013-06-21 Rapperswil]</i></p>
++
++<p>
++Accept for Fundamentals TS Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html">N4023</a>.</p>
++
++<ol>
++<li><p>Change Table 3, [meta.trans.other] in the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html#meta.trans.other">Library TS</a>
++as indicated:
++</p>
++<blockquote>
++<table border="1">
++<caption>Table 3 &mdash; Other type transformations</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class Fn, class... ArgTypes&gt;<br/>
++struct invocation_type&lt;Fn(ArgTypes...)&gt;;</tt>
++</td>
++<td>
++<tt>Fn</tt> and all types in the parameter pack <tt>ArgTypes</tt><br/>
++shall be complete types, (possibly <i>cv</i>-qualified) <tt>void</tt>,<br/>
++or arrays of unknown bound.
++</td>
++<td>
++<ins>
++The nested typedef <tt>invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt><br/>
++shall be defined as follows. If<br/>
++<tt>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt><br/>
++does not exist, there shall be no member typedef <tt>type</tt>. Otherwise:<br/>
++<ul>
++<li><p><ins>Let <tt>A1, A2,</tt> &hellip; denote <tt>ArgTypes...</tt></ins></p></li>
++<li><p><ins>Let <tt>R(T1, T2, &hellip;)</tt> denote<br/>
++<tt>raw_invocation_type_t&lt;Fn(ArgTypes...)&gt;</tt></ins></p></li>
++<li><p><ins>Then the member typedef <tt>type</tt> shall name the function<br/>
++type <tt>R(U1, U2, &hellip;)</tt> where <tt>Ui</tt> is <tt>decay_t&lt;Ai&gt;</tt><br/>
++if <tt>declval&lt;Ai&gt;()</tt> is an rvalue otherwise <tt>Ti</tt>.</ins></p></li>
++</ul>
++</ins>
++<del>If <tt>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt><br/>
++is the function type <tt>R(T1, T2, &hellip;)</tt> <br/>
++and <tt>Fn</tt> is a pointer to member type and <tt>T1</tt> is<br/>
++an rvalue reference, then <tt>R(decay&lt;T1&gt;::type,<br/>
++T2, &hellip;)</tt>.<br/>
++Otherwise, <tt>raw_invocation_type&lt;Fn(ArgTypes...)&gt;::type</tt>.<br/></del>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2395"></a>2395. [fund.ts] <i>Preconditions:</i> is defined nowhere</h3>
++<p><b>Section:</b> X [mods.func.wrap], X [memory.resource.priv], X [memory.polymorphic.allocator.ctor], X [memory.polymorphic.allocator.mem], X [memory.resource.pool.ctor], X [memory.resource.monotonic.buffer.ctor] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2014-06-09 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#mods.func.wrap">issues</a> in [mods.func.wrap].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++
++<p>
++This element has been introduced by <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3916.pdf">N3916</a>,
++but the standard does not define it. The standard defines <i>Requires:</i> to indicate a precondition
++(17.5.1.4 [structure.specifications] p3).
++<p/>
++<em>Proposed wording</em>:
++<p/>
++Substitute all <i>Preconditions:</i> with <i>Requires:</i>.
++</p>
++
++<p><i>[2013-06-21 Rapperswil]</i></p>
++
++<p>
++Accept for Fundamentals TS Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html">N4023</a>.</p>
++
++<ol>
++<li><p>Substitute all <i>Preconditions:</i> with <i>Requires:</i>.</p></li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2396"></a>2396. <tt>underlying_type</tt> doesn't say what to do for an incomplete enumeration type</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-06-12 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider:
++</p>
++<blockquote><pre>
++enum E {
++ e = std::underlying_type&lt;E&gt;::type(1)
++};
++</pre></blockquote>
++<p>
++Clearly this should be ill-formed, but the library section doesn't appear to ban it. Suggestion:
++<p/>
++Change in 20.10.7.6 [meta.trans.other] Table 57:
++</p>
++<blockquote>
++<p>
++Template: <tt>template&lt;class T&gt; struct underlying_type;</tt>
++<p/>
++Condition: <tt>T</tt> shall be <ins>a complete</ins> <del>an</del> enumeration type (7.2)
++<p/>
++Comments: [&hellip;]
++</p>
++</blockquote>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change Table 57 &mdash; "Other transformations" as indicated:</p></li>
++
++<blockquote>
++<table border="1">
++<caption>Table 3 &mdash; Other type transformations</caption>
++<tr>
++<th align="center">Template</th>
++<th align="center">Condition</th>
++<th align="center">Comments</th>
++</tr>
++
++<tr>
++<td colspan="3" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>template &lt;class T&gt;<br/>
++struct underlying_type;</tt>
++</td>
++<td>
++T shall be <ins>a complete</ins> <del>an</del> enumeration type (7.2)
++</td>
++<td align="center">
++[&hellip;]
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2397"></a>2397. <tt>map&lt;K, V&gt;::emplace</tt> and explicit <tt>V</tt> constructors</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Peter Dimov <b>Opened:</b> 2014-06-12 <b>Last modified:</b> 2015-05-05</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Please consider the following example:
++</p>
++<blockquote><pre>
++#include &lt;map&gt;
++#include &lt;atomic&gt;
++
++int main()
++{
++ std::map&lt;int, std::atomic&lt;int&gt;&gt; map_;
++
++ map_.emplace(1, 0); // <span style="color:#C80000;font-weight:bold">fail</span>
++ map_.emplace(1); // <span style="color:#C80000;font-weight:bold">fail</span>
++ map_.emplace(1, {}); // <span style="color:#C80000;font-weight:bold">fail</span>
++
++ map_.emplace(std::piecewise_construct,
++ std::tuple&lt;int&gt;(1), std::tuple&lt;>()); // <span style="color:#006600;font-weight:bold">OK</span>
++}
++</pre></blockquote>
++<p>
++The first three calls represent attempts by an ordinary programmer (in which role I appear today) to construct
++a map element. Since <tt>std::atomic&lt;int&gt;</tt> is non-copyable and immovable, I was naturally drawn to
++<tt>emplace()</tt> because it constructs in-place and hence doesn't need to copy or move. The logic behind the
++attempts was that <tt>K=int</tt> would be constructed from '<tt>1</tt>', and <tt>V=std::atomic&lt;int&gt;</tt> would be
++(directly) constructed by '<tt>0</tt>', default constructed, or constructed by '<tt>{}</tt>'.
++<p/>
++Yet none of the obvious attempts worked.
++<p/>
++I submit that at least two of the three ought to have worked, and that we have therefore a defect in either
++<tt>map::emplace</tt> or <tt>pair</tt>.
++<p/>
++Ville:
++<p/>
++There exists a related <a href="http://cplusplus.github.io/EWG/ewg-toc.html#114">EWG issue</a> for this.
++<p/>
++Daniel:
++<p/>
++If the proposal N4387 would be accepted, it would solve the first problem mentioned above.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++AM: I think Peter's expectation is misguided that the second and third "//fail" cases should work.<br/>
++DK: Howard's paper [note: which hasn't been written yet] will make the second case work... AM: ...but
++the third one will never work without core changes.
++<p/>
++Case 1 is solved by DK's paper, cases 2 and 3 are not defects; at best they are extensions.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL: think this is covered with N4387<br/>
++MC: this was accepted in Cologne<br/>
++STL: only want to fix the first emplace<br/>
++MC: leave alone and mark as closed by N4387<br/>
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++Resolved by acceptance of <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387.html">N4387</a>.
++</p>
++
++
++
++
++
++<hr>
++<h3><a name="2399"></a>2399. <tt>shared_ptr</tt>'s constructor from <tt>unique_ptr</tt> should be constrained</h3>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Consider the following code:
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;memory&gt;
++#include &lt;string&gt;
++
++using namespace std;
++
++void meow(const shared_ptr&lt;int&gt;&amp; sp) {
++ cout &lt;&lt; "int: " &lt;&lt; *sp &lt;&lt; endl;
++}
++
++void meow(const shared_ptr&lt;string&gt;&amp; sp) {
++ cout &lt;&lt; "string: " &lt;&lt; *sp &lt;&lt; endl;
++}
++
++int main() {
++ meow(make_unique&lt;int&gt;(1729));
++ meow(make_unique&lt;string&gt;("kitty"));
++}
++</pre></blockquote>
++<p>
++This fails to compile due to ambiguous overload resolution, but we can easily make this work. (Note: <tt>shared_ptr</tt>'s
++constructor from <tt>auto_ptr</tt> is also affected, but I believe that it's time to remove <tt>auto_ptr</tt> completely.)
++</p>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.8.2.2.1 [util.smartptr.shared.const] around p33 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);
++</pre>
++<p>
++<ins>-?- <i>Remark</i>: This constructor shall not participate in overload resolution unless <tt>unique_ptr&lt;Y, D&gt;::pointer</tt>
++is convertible to <tt>T*</tt>.</ins>
++<p/>
++-33- <i>Effects</i>: Equivalent to <tt>shared_ptr(r.release(), r.get_deleter())</tt> when <tt>D</tt> is not a reference type,
++otherwise <tt>shared_ptr(r.release(), ref(r.get_deleter()))</tt>.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2400"></a>2400. <tt>shared_ptr</tt>'s <tt>get_deleter()</tt> should use <tt>addressof()</tt></h3>
++<p><b>Section:</b> 20.8.2.2.10 [util.smartptr.getdeleter] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.getdeleter">issues</a> in [util.smartptr.getdeleter].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++The Standard Library should consistently use <tt>addressof()</tt> to defend itself against overloaded <tt>operator&amp;()</tt>.
++<p/>
++While we're in the neighbourhood, we should editorially change <tt>0</tt> to <tt>nullptr</tt>.
++</p>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.8.2.2.10 [util.smartptr.getdeleter] as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class D, class T&gt; get_deleter(const shared_ptr&lt;T&gt;&amp; p) noexcept;
++</pre>
++<p>
++-1- <i>Returns</i>: If <tt>p</tt> owns a deleter <tt>d</tt> of type cv-unqualified <tt>D</tt>, returns
++<tt><del>&amp;</del><ins>std::addressof(</ins>d<ins>)</ins></tt>;
++otherwise returns <tt><del>0</del><ins>nullptr</ins></tt>. [&hellip;]
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2401"></a>2401. <tt>std::function</tt> needs more <tt>noexcept</tt></h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++There are two issues here:
++</p>
++<ol>
++<li><p><tt>std::function</tt>'s constructor from <tt>nullptr_t</tt> is marked as <tt>noexcept</tt>, but its assignment operator
++from <tt>nullptr_t</tt> isn't. This assignment can and should be marked as <tt>noexcept</tt>.</p></li>
++<li><p><tt>std::function</tt>'s comparisons with <tt>nullptr_t</tt> are marked as <tt>noexcept</tt> in two out of three places.</p></li>
++</ol>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.9 [function.objects] p2, header <tt>&lt;functional&gt;</tt> synopsis, as indicated:</p>
++
++<blockquote>
++<pre>
++namespace std {
++ [&hellip;]
++ <i>// 20.9.11 polymorphic function wrappers:</i>
++ [&hellip;]
++ template&lt;class R, class... ArgTypes&gt;
++ bool operator==(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) <ins>noexcept</ins>;
++ template&lt;class R, class... ArgTypes&gt;
++ bool operator==(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) <ins>noexcept</ins>;
++ template&lt;class R, class... ArgTypes&gt;
++ bool operator!=(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t) <ins>noexcept</ins>;
++ template&lt;class R, class... ArgTypes&gt;
++ bool operator!=(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;) <ins>noexcept</ins>;
++ [&hellip;]
++}
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2 [func.wrap.func], class template <tt>function</tt> synopsis, as indicated:</p>
++
++<blockquote>
++<pre>
++[&hellip;]
++<i>// 20.9.11.2.1, construct/copy/destroy:</i>
++[&hellip;]
++function&amp; operator=(nullptr_t) <ins>noexcept</ins>;
++[&hellip;]
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.1 [func.wrap.func.con] before p16 as indicated:</p>
++
++<blockquote>
++<pre>
++function&amp; operator=(nullptr_t) <ins>noexcept</ins>;
++</pre>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2403"></a>2403. <tt>stof()</tt> should call <tt>strtof()</tt> and <tt>wcstof()</tt></h3>
++<p><b>Section:</b> 21.5 [string.conversions] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#string.conversions">issues</a> in [string.conversions].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>stof()</tt> is currently specified to call <tt>strtod()</tt>/<tt>wcstod()</tt> (which converts the given string to
++<tt>double</tt>) and then it's specified to convert that <tt>double</tt> to <tt>float</tt>. This performs rounding twice,
++which introduces error. Here's an example written up by James McNellis:
++<p/>
++Consider the following number <tt>X</tt>:
++</p>
++<blockquote>
++<pre>
++1.999999821186065729339276231257827021181583404541015625 (X)
++</pre>
++</blockquote>
++<p>
++This number is exactly representable in binary as:
++</p>
++<blockquote>
++<pre>
++1.111111111111111111111101000000000000000000000000000001
++* ^1st ^23rd ^52nd
++</pre>
++</blockquote>
++<p>
++I've marked the 23rd and 52nd fractional bits. These are the least significant bits for <tt>float</tt> and <tt>double</tt>,
++respectively.
++<p/>
++If we convert this number directly to <tt>float</tt>, we take the 23 most significant bits:
++</p>
++<blockquote>
++<pre>
++1.11111111111111111111110
++</pre>
++</blockquote>
++<p>
++The next bit is a one and the tail is nonzero (the 54th fractional bit is a one), so we round up. This gives us the correctly
++rounded result:
++</p>
++<blockquote>
++<pre>
++1.11111111111111111111111
++</pre>
++</blockquote>
++<p>
++So far so good. But... If we convert <tt>X</tt> to <tt>double</tt>, we take the 52 most significant bits:
++</p>
++<blockquote>
++<pre>
++1.1111111111111111111111010000000000000000000000000000 (Y)
++</pre>
++</blockquote>
++<p>
++The next bit is a zero, so we round down (truncating the value). If we then convert <tt>Y</tt> to <tt>float</tt>, we take
++its 23 most significant bits:
++</p>
++<blockquote>
++<pre>
++1.11111111111111111111110
++</pre>
++</blockquote>
++<p>
++The next bit is a one and the tail is zero, so we round to even (leaving the value unchanged). This is off by 1ulp from the
++correctly rounded result.
++</p>
++
++<p><i>[2014-06 Rapperswil]</i></p>
++
++<p>
++Marshall Clow will look at this.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 21.5 [string.conversions] p4+p6 as indicated:</p>
++
++<blockquote>
++<pre>
++float stof(const string&amp; str, size_t* idx = 0);
++double stod(const string&amp; str, size_t* idx = 0);
++long double stold(const string&amp; str, size_t* idx = 0);
++</pre>
++<blockquote>
++<p>
++-4- <i>Effects</i>: <del>the first two</del><ins>These</ins> functions call <ins><tt>strtof(str.c_str(), ptr)</tt>,</ins>
++<tt>strtod(str.c_str(), ptr)</tt><ins>,</ins> and <del>the third function calls</del> <tt>strtold(str.c_str(), ptr)</tt><ins>,
++respectively</ins>. Each function returns the converted result, if any. [&hellip;]
++<p/>
++[&hellip;]
++<p/>
++-6- <i>Throws</i>: <tt>invalid_argument</tt> if <ins><tt>strtof</tt>,</ins> <tt>strtod</tt><ins>,</ins> or <tt>strtold</tt> reports
++that no conversion could be performed. Throws <tt>out_of_range</tt> if <ins><tt>strtof</tt>,</ins> <tt>strtod</tt><ins>,</ins> or
++<tt>strtold</tt> sets <tt>errno</tt> to <tt>ERANGE</tt> or if the converted value is outside the range of representable
++values for the return type.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 21.5 [string.conversions] p11+p13 as indicated:</p>
++
++<blockquote>
++<pre>
++float stof(const wstring&amp; str, size_t* idx = 0);
++double stod(const wstring&amp; str, size_t* idx = 0);
++long double stold(const wstring&amp; str, size_t* idx = 0);
++</pre>
++<blockquote>
++<p>
++-11- <i>Effects</i>: <del>the first two</del><ins>These</ins> functions call <ins><tt>wcstof(str.c_str(), ptr)</tt>,</ins>
++<tt>wcstod(str.c_str(), ptr)</tt><ins>,</ins> and <del>the third function calls</del> <tt>wcstold(str.c_str(), ptr)</tt><ins>,
++respectively</ins>. Each function returns the converted result, if any. [&hellip;]
++<p/>
++[&hellip;]
++<p/>
++-13- <i>Throws</i>: <tt>invalid_argument</tt> if <ins><tt>wcstof</tt>,</ins> <tt>wcstod</tt><ins>,</ins> or <tt>wcstold</tt>
++reports that no conversion could be performed. Throws <tt>out_of_range</tt> if <ins><tt>wcstof</tt>,</ins> <tt>wcstod</tt><ins>,</ins>
++or <tt>wcstold</tt> sets <tt>errno</tt> to <tt>ERANGE</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2404"></a>2404. <tt>mismatch()</tt>'s complexity needs to be updated</h3>
++<p><b>Section:</b> 25.2.10 [mismatch] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3671.html">N3671</a> updated the complexities of
++<tt>equal()</tt> and <tt>is_permutation()</tt>, but not <tt>mismatch()</tt>.
++</p>
++
++<p><i>[2014-06-16 Rapperswil]</i></p>
++
++<p>
++Move to Ready
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 25.2.10 [mismatch] p3 as indicated:</p>
++
++<blockquote>
++<p>
++-3- <i>Complexity</i>: At most <tt><ins>min(</ins>last1 - first1<ins>, last2 - first2)</ins></tt> applications of the
++corresponding predicate.
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2406"></a>2406. <tt>negative_binomial_distribution</tt> should reject <tt>p == 1</tt></h3>
++<p><b>Section:</b> 26.5.8.3.4 [rand.dist.bern.negbin] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++26.5.8.3.4 [rand.dist.bern.negbin] p2 requires "<tt>0 &lt; p &lt;= 1</tt>". Consider what happens when <tt>p == 1</tt>.
++The discrete probability function specified by p1 involves "<tt>* p^k * (1 - p)^i</tt>". For <tt>p == 1</tt>, this is
++"<tt>* 1^k * 0^i</tt>", so every integer <tt>i &gt;= 0</tt> is produced with zero probability. (Let's avoid thinking about
++<tt>0^0</tt>.)
++<p/>
++<a href="http://en.wikipedia.org/wiki/Negative_binomial_distribution">Wikipedia</a> states that <tt>p</tt> must be within
++<tt>(0, 1)</tt>, exclusive on both sides.
++</p>
++
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<blockquote class="note">
++<ol>
++<li><p>Change 26.5.8.3.4 [rand.dist.bern.negbin] p2 as indicated: [<i>Drafting note</i>: This should be read as: Replace the
++symbol "<tt>&le;</tt>" by "<tt>&lt;</tt>" &mdash; <i>end drafting note</i>]</p>
++
++<blockquote>
++<pre>
++explicit negative_binomial_distribution(IntType k = 1, double p = 0.5);
++</pre>
++<blockquote>
++<p>
++-2- <i>Requires</i>: <tt>0 &lt; p <del>&le;</del><ins>&lt;</ins> 1</tt> and <tt>0 &lt; k</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-11 Urbana]</i></p>
++
++<p>
++SG6 suggests better wording.
++</p>
++
++<p><i>[2014-11-08 Urbana]</i></p>
++
++<p>
++Moved to Ready with the node.
++</p>
++<p>
++There remains concern that the constructors are permitting
++values that may (or may not) be strictly outside the domain
++of the function, but that is a concern that affects the
++design of the random number facility as a whole, and should
++be addressed by a paper reviewing and addressing the whole
++clause, not picked up in the issues list one distribution
++at a time. It is still not clear that such a paper would be
++uncontroversial.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4140.</p>
++
++<ol>
++<li><p>Add a note after paragraph 1 before the synopsis in 26.5.8.3.4 [rand.dist.bern.negbin]:</p>
++
++<blockquote>
++<p>
++A <tt>negative_binomial_distribution</tt> random number distribution produces random integers
++<math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>i</mi><mo>&ge;</mo><mn>0</mn>
++</math>
++distributed according to the discrete probability function
++</p>
++<blockquote>
++<p>
++<math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>P</mi><mrow><mo>(</mo><mi>i</mi><mo>|</mo><mi>k</mi><mo>,</mo><mi>p</mi><mo>)</mo></mrow>
++<mo>=</mo>
++<mrow>
++<mfenced>
++<mfrac linethickness="0">
++<mrow><mi>k</mi> <mo>+</mo> <mi>i</mi> <mo>-</mo> <mn>1</mn></mrow>
++<mi>i</mi>
++</mfrac>
++</mfenced>
++<mo>&middot;</mo>
++<msup>
++<mi>p</mi>
++<mi>k</mi>
++</msup>
++<mo>&middot;</mo>
++<msup>
++<mrow><mo>(</mo><mn>1</mn><mo>-</mo><mi>p</mi><mo>)</mo></mrow>
++<mi>i</mi>
++</msup>
++</mrow>
++</math>
++.
++</p>
++</blockquote>
++<p>
++<ins>[<i>Note</i>: This implies that <math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>P</mi><mrow><mo>(</mo><mi>i</mi><mo>|</mo><mi>k</mi><mo>,</mo><mi>p</mi><mo>)</mo></mrow>
++</math> is undefined when <tt>p == 1</tt>. &mdash; <i>end note</i>]</ins>
++</p>
++</blockquote>
++<blockquote class="note">
++<p>
++<i>Drafting note</i>: <math xmlns="http://www.w3.org/1998/Math/MathML">
++<mi>P</mi><mrow><mo>(</mo><mi>i</mi><mo>|</mo><mi>k</mi><mo>,</mo><mi>p</mi><mo>)</mo></mrow>
++</math> should be in math font, and <tt>p == 1</tt> should be in code font.
++</p>
++</blockquote>
++
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2407"></a>2407. <tt>packaged_task(allocator_arg_t, const Allocator&amp;, F&amp;&amp;)</tt> should neither be constrained nor
++<tt>explicit</tt></h3>
++<p><b>Section:</b> 30.6.9.1 [futures.task.members] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-06-14 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#futures.task.members">issues</a> in [futures.task.members].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++LWG <a href="lwg-defects.html#2097">2097</a>'s resolution was slightly too aggressive. It constrained
++<tt>packaged_task(allocator_arg_t, const Allocator&amp;, F&amp;&amp;)</tt>, but that's unnecessary because
++<tt>packaged_task</tt> doesn't have any other three-argument constructors. Additionally, it's marked as
++<tt>explicit</tt> (going back to WP N2798 when <tt>packaged_task</tt> first appeared) which is unnecessary.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++Back to LWG; not an SG1 issue.
++</p>
++
++<p><i>[2015-05 Lenexa]</i></p>
++
++<p>
++STL improves proposed wording by restoring the constraint again.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 30.6.9 [futures.task] p2, class template <tt>packaged_task</tt> as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class F&gt;
++explicit packaged_task(F&amp;&amp; f);
++template &lt;class F, class Allocator&gt;
++<del>explicit</del> packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 30.6.9.1 [futures.task.members] as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class F&gt;
++packaged_task(F&amp;&amp; f);
++template &lt;class F, class Allocator&gt;
++<del>explicit</del> packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-3- <i>Remarks</i>: These constructors shall not participate in overload resolution if <tt>decay_t&lt;F&gt;</tt>
++is the same type as <tt>std::packaged_task&lt;R(ArgTypes...)&gt;</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2408"></a>2408. SFINAE-friendly <tt>common_type/iterator_traits</tt> is missing in C++14</h3>
++<p><b>Section:</b> 20.10.7.6 [meta.trans.other], 24.4.1 [iterator.traits] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-06-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View other</b> <a href="lwg-index-open.html#meta.trans.other">active issues</a> in [meta.trans.other].</p>
++<p><b>View all other</b> <a href="lwg-index.html#meta.trans.other">issues</a> in [meta.trans.other].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++During the Rapperswil meeting the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4041.html">N4041</a>
++had been discussed and there seemed to be strong consensus to apply the SFINAE-friendly definitions
++that currently exist within the fundamentals-ts to the C++ Standard working draft. This issue requests this change to happen.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.10.7.6 [meta.trans.other] p3 as indicated:</p>
++
++<blockquote>
++<p>
++-3- <ins>For the <tt>common_type</tt> trait applied to a parameter pack <tt>T</tt> of types,
++the member <tt>type</tt> shall be either defined or not present as follows:</ins>
++<ul>
++<li><p><ins>If <tt>sizeof...(T)</tt> is zero, there shall be no member <tt>type</tt>.</ins></p></li>
++<li><p><ins>If <tt>sizeof...(T)</tt> is one, let <tt>T0</tt> denote the sole type comprising <tt>T</tt>.
++The member typedef <tt>type</tt> shall denote the same type as <tt>decay_t&lt;T0&gt;</tt>.</ins></p></li>
++<li><p><ins>If <tt>sizeof...(T)</tt> is greater than one, let <tt>T1</tt>, <tt>T2</tt>, and <tt>R</tt>,
++respectively, denote the first, second, and (pack of) remaining types comprising <tt>T</tt>.
++[<i>Note</i>: <tt>sizeof...(R)</tt> may be zero. &mdash; <i>end note</i>] Finally, let <tt>C</tt> denote
++the type, if any, of an unevaluated conditional expression (5.16 [expr.cond]) whose first operand is an arbitrary value
++of type <tt>bool</tt>, whose second operand is an xvalue of type <tt>T1</tt>, and whose third operand is
++an xvalue of type <tt>T2</tt>. If there is such a type <tt>C</tt>, the member typedef <tt>type</tt> shall
++denote the same type, if any, as <tt>common_type_t&lt;C,R...&gt;</tt>. Otherwise, there shall be no member
++<tt>type</tt>.</ins></p></li>
++</ul>
++<del>The nested typedef <tt>common_type::type</tt> shall be defined as follows:</del>
++</p>
++<blockquote>
++<pre>
++<del>template &lt;class ...T&gt; struct common_type;
++
++template &lt;class T&gt;
++struct common_type&lt;T&gt; {
++ typedef decay_t&lt;T&gt; type;
++};
++
++template &lt;class T, class U&gt;
++struct common_type&lt;T, U&gt; {
++ typedef decay_t&lt;decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())&gt; type;
++};
++
++template &lt;class T, class U, class... V&gt;
++struct common_type&lt;T, U, V...&gt; {
++ typedef common_type_t&lt;common_type_t&lt;T, U&gt;, V...&gt; type;
++};</del>
++</pre>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 24.4.1 [iterator.traits] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- The template <tt>iterator_traits&lt;Iterator&gt;</tt> <del>is defined as</del><ins>shall have
++the following as publicly accessible members, and have no other members, if and only if
++<tt>Iterator</tt> has valid (14.8.2 [temp.deduct]) member types <tt>difference_type</tt>,
++<tt>value_type</tt>, <tt>pointer</tt>, <tt>reference</tt>, and <tt>iterator_category</tt>; otherwise,
++the template shall have no members:</ins>
++</p>
++<blockquote>
++<pre>
++<del>namespace std {
++ template&lt;class Iterator&gt; struct iterator_traits {</del>
++ typedef typename Iterator::difference_type difference_type;
++ typedef typename Iterator::value_type value_type;
++ typedef typename Iterator::pointer pointer;
++ typedef typename Iterator::reference reference;
++ typedef typename Iterator::iterator_category iterator_category;
++ <del>};
++}</del>
++</pre>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2409"></a>2409. [fund.ts] SFINAE-friendly <tt>common_type/iterator_traits</tt> should be removed from the fundamental-ts</h3>
++<p><b>Section:</b> X [mods.meta.trans.other], X [mods.iterator.traits] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-06-19 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++During the Rapperswil meeting the proposal <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4041.html">N4041</a>
++had been discussed and there seemed to be strong consensus to apply the SFINAE-friendly definitions
++that currently exist within the fundamentals-ts to the C++17 working draft. If this happens, the fundamentals-ts
++needs to remove its own specification regarding these templates. This issue requests this change to happen.
++</p>
++
++<p><i>[2013-06-21 Rapperswil]</i></p>
++
++<p>
++Accept for Fundamentals TS Working Paper
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4023 in regard to fundamental-ts changes.</p>
++
++<ol>
++<li><p>In fundamental-ts, change Table 2 &mdash; "Significant features in this technical specification" as
++indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 2 &mdash; Significant features in this technical specification</caption>
++<tr>
++<th align="center">Doc.<br/>No.</th>
++<th align="center">Title</th>
++<th align="center">Primary<br/>Section</th>
++<th align="center">Macro Name Suffix</th>
++<th align="center">Value</th>
++<th align="center">Header</th>
++</tr>
++
++<tr>
++<td colspan="6" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<del>N3843</del><br/>
++</td>
++<td>
++<del>A SFINAE-<br/>Friendly<br/><tt>common_type</tt></del>
++</td>
++<td>
++<del>2.4 [mods.meta.trans.other]</del><br/>
++</td>
++<td>
++<del><tt>common_type_sfinae</tt></del>
++</td>
++<td>
++<del><tt>201402</tt></del>
++</td>
++<td>
++<del><tt>&lt;type_traits&gt;</tt></del><br/>
++</td>
++</tr>
++
++<tr>
++<td>
++<del>N3843</del><br/>
++</td>
++<td>
++<del>A SFINAE-<br/>Friendly<br/><tt>iterator_traits</tt></del>
++</td>
++<td>
++<del>2.5 [mods.iterator.traits]</del><br/>
++</td>
++<td>
++<del><tt>iterator_traits_sfinae</tt></del>
++</td>
++<td>
++<del><tt>201402</tt></del>
++</td>
++<td>
++<del><tt>&lt;iterator&gt;</tt></del><br/>
++</td>
++</tr>
++
++<tr>
++<td colspan="6" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++
++<li><p>In fundamental-ts, remove the existing sub-clause 2.4 [mods.meta.trans.other] in its entirety:</p>
++
++<p>
++<del><b>2.4 Changes to <tt>std::common_type</tt> [mods.meta.trans.other]</b></del>
++</p>
++<blockquote>
++<p>
++<del>-1- [&hellip;]</del>
++</p>
++</blockquote>
++
++</li>
++
++<li><p>In fundamental-ts, remove the existing sub-clause 2.5 [mods.iterator.traits] in its entirety:</p>
++
++<p>
++<del><b>2.5 Changes to <tt>std::iterator_traits</tt> [mods.iterator.traits]</b></del>
++</p>
++<blockquote>
++<p>
++<del>-1- [&hellip;]</del>
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2410"></a>2410. [fund.ts] <tt>shared_ptr&lt;array&gt;</tt>'s constructor from <tt>unique_ptr</tt> should be constrained</h3>
++<p><b>Section:</b> X [mods.util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jeffrey Yasskin <b>Opened:</b> 2014-06-16 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++The proposed resolution for LWG <a href="lwg-defects.html#2399">2399</a> doesn't apply cleanly to the Fundamentals TS, but the issue is still present.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++Unanimous consent.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4023 in regard to fundamental-ts changes.</p>
++
++<ol>
++<li><p>In fundamental-ts, change [mods.util.smartptr.shared.const] p34 as indicated:</p>
++
++<blockquote>
++<pre>
++template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);
++</pre>
++<blockquote>
++<p>
++-34- <i><del>Requires</del><ins>Remarks</ins></i>: <ins>This constructor shall not participate in overload resolution
++unless</ins> <tt>Y*</tt> <del>shall be</del><ins>is</ins> <i>compatible with</i> <tt>T*</tt>.
++<p/>
++-35- <i>Effects</i>: Equivalent to <tt>shared_ptr(r.release(), r.get_deleter())</tt> when <tt>D</tt> is not a reference type,
++otherwise <tt>shared_ptr(r.release(), ref(r.get_deleter()))</tt>.
++<p/>
++-36- <i>Exception safety</i>: If an exception is thrown, the constructor has no effect.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2411"></a>2411. <tt>shared_ptr</tt> is only contextually convertible to <tt>bool</tt></h3>
++<p><b>Section:</b> 20.8.2.2 [util.smartptr.shared] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-06-21 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#util.smartptr.shared">active issues</a> in [util.smartptr.shared].</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared">issues</a> in [util.smartptr.shared].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++N3920 made this edit, which is correct but unrelated to the support for arrays:
++</p>
++<blockquote>
++<p>Change 20.7.2.2 [util.smartptr.shared] p2 as follows:</p>
++<blockquote>
++<p>
++Specializations of <tt>shared_ptr</tt> shall be <tt>CopyConstructible</tt>, <tt>CopyAssignable</tt>, and <tt>LessThanComparable</tt>,
++allowing their use in standard containers. Specializations of <tt>shared_ptr</tt> shall be <ins>contextually</ins> convertible to
++<tt>bool</tt>, allowing their use in boolean expressions and declarations in conditions. [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++<p>
++That change is actually fixing a defect in the current wording and should be applied directly to the working paper, not just to the
++Library Fundamentals TS. The declarations of the conversion operator in 20.8.2.2 [util.smartptr.shared] and
++20.8.2.2.5 [util.smartptr.shared.obs] are <tt>explicit</tt> which contradicts the "convertible to <tt>bool</tt>" statement. The
++intention is definitely for <tt>shared_ptr</tt> to only be contextually convertible to <tt>bool</tt>.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N3936.</p>
++
++<ol>
++<li><p>Change 20.8.2.2 [util.smartptr.shared] p2 as indicated:</p>
++
++<blockquote>
++<p>
++-2- Specializations of <tt>shared_ptr</tt> shall be <tt>CopyConstructible</tt>, <tt>CopyAssignable</tt>, and <tt>LessThanComparable</tt>,
++allowing their use in standard containers. Specializations of <tt>shared_ptr</tt> shall be <ins>contextually</ins> convertible to
++<tt>bool</tt>, allowing their use in boolean expressions and declarations in conditions. The template parameter <tt>T</tt> of
++<tt>shared_ptr</tt> may be an incomplete type.
++</p>
++</blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2415"></a>2415. Inconsistency between <tt>unique_ptr</tt> and <tt>shared_ptr</tt></h3>
++<p><b>Section:</b> 20.8.2.2.1 [util.smartptr.shared.const] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-07-03 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.const">issues</a> in [util.smartptr.shared.const].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>unique_ptr</tt> guarantees that it will not invoke its deleter if it stores
++a null pointer, which is useful for deleters that must not be called
++with a null pointer e.g.
++</p>
++<blockquote><pre>
++unique_ptr&lt;FILE, int(*)(FILE*)&gt; fptr(file, &amp;::fclose);
++</pre></blockquote>
++<p>
++However, <tt>shared_ptr</tt> does invoke the deleter if it owns a null pointer,
++which is a silent change in behaviour when transferring
++ownership from <tt>unique_ptr</tt> to <tt>shared_ptr</tt>. That means the following
++leads to undefined behaviour:
++</p>
++<blockquote><pre>
++std:shared_ptr&lt;FILE&gt; fp = std::move(fptr);
++</pre></blockquote>
++<p>
++Peter Dimov's suggested fix is to construct an empty <tt>shared_ptr</tt> from a
++<tt>unique_ptr</tt> that contains a null pointer.
++</p>
++
++<p><i>[2015-01-18 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on eight votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 20.8.2.2.1 [util.smartptr.shared.const] p29 as indicated:</p>
++<blockquote>
++<pre>
++template &lt;class Y, class D&gt; shared_ptr(unique_ptr&lt;Y, D&gt;&amp;&amp; r);
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-29- <i>Effects</i>: <ins>If <tt>r.get() == nullptr</tt>, equivalent to <tt>shared_ptr()</tt>. Otherwise, if <tt>D</tt> is
++not a reference type, equivalent to <tt>shared_ptr(r.release(), r.get_deleter())</tt>. Otherwise, equivalent to
++<tt>shared_ptr(r.release(), ref(r.get_deleter()))</tt></ins><del>Equivalent to <tt>shared_ptr(r.release(),
++r.get_deleter())</tt> when <tt>D</tt> is not a reference type, otherwise <tt>shared_ptr(r.release(),
++ref(r.get_deleter()))</tt></del>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2416"></a>2416. [fund.ts] <tt>std::experimental::any allocator</tt> support is unimplementable</h3>
++<p><b>Section:</b> X [any.class] <b>Status:</b> <a href="lwg-active.html#Resolved">Resolved</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-06-16 <b>Last modified:</b> 2015-04-08</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#Resolved">Resolved</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++The allocator-extended copy constructor for <tt>any</tt> requires an
++arbitrary template parameter to be available in a type-erased context
++where the dynamic type of the contained object is known. This is not
++believed to be possible in C++.
++<p/>
++If the allocator-extended copy constructor cannot be defined it
++questions the usefulness of the other allocator-extended constructors.
++</p>
++
++<p><i>[Urbana, 2014-11]</i></p>
++
++<p>
++Resolved by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4270">N4270</a>.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++
++
++
++
++<hr>
++<h3><a name="2418"></a>2418. [fund.ts] <tt>apply</tt> does not work with member pointers</h3>
++<p><b>Section:</b> X [tuple.apply] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Zhihao Yuan <b>Opened:</b> 2014-07-08 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++The definition of <tt>apply</tt> present in &sect;3.2.2 [tuple.apply] prevents this
++function template to be used with pointer to members type passed as the first argument.
++</p>
++<blockquote>
++<i>Effects:</i>
++<p/>
++[&hellip;]
++<p/>
++<tt>return std::forward&lt;F&gt;(f)(std::get&lt;I&gt;(std::forward&lt;Tuple&gt;(t))...);</tt>
++</blockquote>
++<p>
++This makes this utility inconsistent with other standard library components and limits its usability.
++<p/>
++We propose to define its functionally in terms of <tt><i>INVOKE</i></tt>.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++DK: We should use the new <tt>std::invoke</tt>.<br/>
++TK: Is this a defect?<br/>
++AM: <tt>std::invoke</tt> goes into C++17, and this is a defect against a TS based on C++14. We can change this later,
++but now leave it as INVOKE.<br/>
++GR: The TS lets you have Editor's Notes, so leave a note to make that change for C++17.
++<p/>
++[&hellip;]
++<p/>
++GR: I can't see how we can assume this is part of the design. I cannot believe it was ever intended for this
++design to exclude function pointers.<br/>
++AM: I can give you the exact evolution: We had "apply" as an example explaining the usefulness of <tt>index_sequence</tt>.
++Then someone looked at it and said, "why isn't this in the Standard". NJ to VV: Why are you against useful steps?
++We are trying to converge on a consistent standard across multiple documents. The alternative is to reopen this
++in a later discussion.<br/>
++VV: All I said is that this is not defect, whether or not people like it.<br/>
++AM: So you'd be fine with the issue, but not as a DR?<br/>
++Straw poll: Who's happy to make this tentatively ready as a DR against the Fundamentals TS?
++Lots of agreement, no opposition, 3 neutrals
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4081.html">N4081</a>
++in regard to fundamental-ts changes.</p>
++
++<ol>
++<li><p>Edit &sect;3.2.2 [tuple.apply] paragraph 2:</p>
++
++<blockquote>
++<pre>
++template &lt;class F, class Tuple&gt;
++constexpr decltype(auto) apply(F&amp;&amp; f, Tuple&amp;&amp; t);
++</pre>
++<blockquote>
++<p>
++-2- <i>Effects</i>: Given the exposition only function
++</p>
++<blockquote>
++<pre>
++template &lt;class F, class Tuple, size_t... I&gt;
++constexpr decltype(auto) apply_impl( // <i>exposition only</i>
++ F&amp;&amp; f, Tuple&amp;&amp; t, index_sequence&lt;I...&gt;) {
++ return <ins><i>INVOKE</i>(</ins>std::forward&lt;F&gt;(f)<del>(</del><ins>, </ins>std::get&lt;I&gt;(std::forward&lt;Tuple&gt;(t))...);
++}
++</pre>
++<p>
++[&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2420"></a>2420. <tt>function&lt;void(ArgTypes...)&gt;</tt> does not discard the return value of the target object</h3>
++<p><b>Section:</b> 20.9.12.2 [func.wrap.func] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Agust&iacute;n Berg&eacute; <b>Opened:</b> 2014-07-12 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#func.wrap.func">active issues</a> in [func.wrap.func].</p>
++<p><b>View all other</b> <a href="lwg-index.html#func.wrap.func">issues</a> in [func.wrap.func].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>function&lt;void(ArgTypes...)&gt;</tt> should discard the return value of the target object. This behavior was
++in the original proposal, and it was removed (accidentally?) by the resolution of LWG <a href="lwg-defects.html#870">870</a>.
++</p>
++
++<p>
++<strong>Previous resolution [SUPERSEDED]:</strong>
++</p>
++<blockquote class="note">
++<ol>
++<li><p>Edit 20.9.12.2 [func.wrap.func] paragraph 2:</p>
++
++<blockquote>
++<p>
++A callable object <tt>f</tt> of type <tt>F</tt> is <i>Callable</i> for argument types <tt>ArgTypes</tt> and return type
++<tt>R</tt> if the expression <tt><i>INVOKE</i>(f, declval&lt;ArgTypes&gt;()...<del>, R</del>)</tt>, considered as an unevaluated
++operand (Clause 5), is well formed (20.9.2 [func.require])<ins> and, if <tt>R</tt> is not <tt>void</tt>, implicitly
++convertible to <tt>R</tt></ins>.
++</p>
++</blockquote>
++</li>
++</ol>
++</blockquote>
++
++<p><i>[2014-10-05 Daniel comments]</i></p>
++
++<p>
++This side-effect was indeed not intended by <a href="lwg-defects.html#870">870</a>.
++</p>
++
++<p><i>[2015-05, Lenexa]</i></p>
++
++<p>
++STL provides improved wording. It replaces the current PR, and intentionally leaves 20.9.12.2 [func.wrap.func]
++unchanged.
++<p/>
++Due to 5 [expr]/6, <tt>static_cast&lt;void&gt;</tt> is correct even when <tt>R</tt> is <tt>const void</tt>.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4431.</p>
++
++<ol>
++<li><p>Edit 20.9.2 [func.require] as depicted:</p>
++
++<blockquote>
++<p>
++-2- Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN, R)</tt> as <ins><tt>static_cast&lt;void&gt;(<i>INVOKE</i>(f, t1, t2, ..., tN))</tt>
++if <tt>R</tt> is <i>cv</i> <tt>void</tt>, otherwise</ins> <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> implicitly converted
++to <tt>R</tt>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 20.9.12.2.4 [func.wrap.func.inv] as depicted:</p>
++
++<blockquote>
++<pre>
++R operator()(ArgTypes... args) const;
++</pre>
++<blockquote>
++<p>
++-1- <i><del>Effects</del><ins>Returns</ins></i>: <tt><i>INVOKE</i>(f, std::forward&lt;ArgTypes&gt;(args)..., R)</tt> (20.9.2),
++where <tt>f</tt> is the target object (20.9.1) of <tt>*this</tt>.
++<p/>
++<del>-2- <i>Returns</i>: Nothing if <tt>R</tt> is <tt>void</tt>, otherwise the return value of <tt><i>INVOKE</i>(f,
++std::forward&lt;ArgTypes&gt;(args)..., R)</tt>.</del>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2425"></a>2425. <tt>operator delete(void*, size_t)</tt> doesn't invalidate pointers sufficiently</h3>
++<p><b>Section:</b> 18.6.1 [new.delete] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-08-29 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#new.delete">issues</a> in [new.delete].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++18.6.1.1 [new.delete.single]/12 says:
++</p>
++<blockquote><p>
++<i>Requires</i>: <tt>ptr</tt> shall be a null pointer or its value shall be a value returned by an earlier call to the
++(possibly replaced) <tt>operator new(std::size_t)</tt> or <tt>operator new(std::size_t,const std::nothrow_t&amp;)</tt>
++which has not been invalidated by an intervening call to <tt>operator delete(void*)</tt>.
++</p></blockquote>
++<p>
++This should say:
++</p>
++<blockquote><p>
++[&hellip;] by an intervening call to <tt>operator delete(void*)</tt> <ins>or <tt>operator delete(void*, std::size_t)</tt></ins>.
++</p></blockquote>
++<p>
++Likewise at the end of 18.6.1.2 [new.delete.array]/11, <ins><tt>operator delete[](void*, std::size_t)</tt></ins>.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Change 18.6.1.1 [new.delete.single]p12 as indicated:</p>
++
++<blockquote>
++<p>
++-12- <i>Requires</i>: <tt>ptr</tt> shall be a null pointer or its value shall be a value returned by an earlier call to the
++(possibly replaced) <tt>operator new(std::size_t)</tt> or <tt>operator new(std::size_t,const std::nothrow_t&amp;)</tt> which
++has not been invalidated by an intervening call to <tt>operator delete(void*)</tt> <ins>or
++<tt>operator delete(void*, std::size_t)</tt></ins>.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 18.6.1.2 [new.delete.array]p11 as indicated:</p>
++
++<blockquote>
++<p>
++-11- <i>Requires</i>: <tt>ptr</tt> shall be a null pointer or its value shall be the value returned by an earlier call to
++<tt>operator new[](std::size_t)</tt> or <tt>operator new[](std::size_t,const std::nothrow_t&amp;)</tt> which
++has not been invalidated by an intervening call to <tt>operator delete[](void*)</tt> <ins>or
++<tt>operator delete[](void*, std::size_t)</tt></ins>.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2427"></a>2427. Container adaptors as sequence containers, redux</h3>
++<p><b>Section:</b> 23.3.1 [sequences.general] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Tim Song <b>Opened:</b> 2014-08-29 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++LWG <a href="lwg-defects.html#2194">2194</a> removed "These container adaptors meet the requirements for sequence containers." from
++23.6.1 [container.adaptors.general].
++<p/>
++However, N3936 23.3.1 [sequences.general]/p2 still says "The headers <tt>&lt;queue&gt;</tt> and <tt>&lt;stack&gt;</tt>
++define container adaptors (23.6) that also meet the requirements for sequence containers." I assume this is just an oversight.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<ol>
++<li><p>Delete paragraph 2 of 23.3.1 [sequences.general] as indicated:</p>
++
++<blockquote>
++<p>
++<del>-2- The headers <tt>&lt;queue&gt;</tt> and <tt>&lt;stack&gt;</tt> define container adaptors (23.6) that
++also meet the requirements for sequence containers.</del>
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2428"></a>2428. "External declaration" used without being defined</h3>
++<p><b>Section:</b> 17.6.2.2 [using.headers] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Tim Song <b>Opened:</b> 2014-09-03 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#using.headers">issues</a> in [using.headers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++17.6.2.2 [using.headers]/3 says
++</p>
++<blockquote><p>
++A translation unit shall include a header only outside of any external declaration or definition [&hellip;]
++</p></blockquote>
++<p>
++This wording appears to be borrowed from the C standard. However, the term "external declaration" is not defined
++in the C++ standard, and in fact is only used here as far as I can tell, so it is unclear what it means. The C
++standard does define external declarations as (WG14 N1570 6.9 External definitions/4-5):
++</p>
++<blockquote><p>
++As discussed in 5.1.1.1, the unit of program text after preprocessing is a translation unit, which consists of a
++sequence of external declarations. These are described as "external" because they appear outside any function
++(and hence have file scope). [...] An external definition is an external declaration that is also a definition of
++a function (other than an inline definition) or an object.
++</p></blockquote>
++<p>
++The corresponding description of a translation unit in C++ is "A translation unit consists of a sequence of declarations."
++(3.5 [basic.link]/3).
++<p/>
++So it appears that the C++ counterpart of "external declaration" in C is simply a "declaration" at file scope. There
++is no need to specifically limit the statement in 17.6.2.2 [using.headers]/3 to file-scope declarations, however,
++since every non-file-scope declaration is necessarily inside a file-scope declaration, so banning including a header
++inside file-scope declarations necessarily bans including one inside non-file-scope declarations as well.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++<ol>
++<li><p>Edit 17.6.2.2 [using.headers] as indicated:</p>
++
++<blockquote>
++<p>
++A translation unit shall include a header only outside of any <del>external</del> declaration or definition, and shall
++include the header lexically before the first reference in that translation unit to any of the entities declared
++in that header. No diagnostic is required.
++</p>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2433"></a>2433. <tt>uninitialized_copy()</tt>/etc. should tolerate overloaded <tt>operator&amp;</tt></h3>
++<p><b>Section:</b> 20.7.12 [specialized.algorithms] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#specialized.algorithms">issues</a> in [specialized.algorithms].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++This restriction isn't necessary anymore. In fact, this is the section that defines <tt>addressof()</tt>.
++</p>
++<p>
++(Editorial note: We can depict these algorithms as calling <tt>addressof()</tt> instead of <tt>std::addressof()</tt>
++thanks to 17.6.1.1 [contents]/3 "Whenever a name <tt>x</tt> defined in the standard library is mentioned, the name
++<tt>x</tt> is assumed to be fully qualified as <tt>::std::x</tt>, unless explicitly described otherwise.")
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 20.7.12 [specialized.algorithms] p1 as depicted:</p>
++
++<blockquote>
++<p>
++-1- <del>All the iterators that are used as formal template parameters in the following algorithms are required to
++have their <tt>operator*</tt> return an object for which <tt>operator&amp;</tt> is defined and returns a pointer to
++<tt>T</tt>.</del> In the algorithm <tt>uninitialized_copy</tt>, the formal template parameter <tt>InputIterator</tt>
++is required to satisfy the requirements of an input iterator (24.2.3). In all of the following algorithms, the formal
++template parameter <tt>ForwardIterator</tt> is required to satisfy the requirements of a forward iterator (24.2.5),
++and is required to have the property that no exceptions are thrown from increment, assignment, comparison, or indirection
++through valid iterators. In the following algorithms, if an exception is thrown there are no effects.
++</p>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.12.2 [uninitialized.copy] p1 as depicted:</p>
++<blockquote>
++<p>
++-1- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; first != last; ++result, ++first)
++ ::new (static_cast&lt;void*&gt;(<ins>addressof(</ins><del>&amp;</del>*result<ins>)</ins>))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++</pre>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.12.2 [uninitialized.copy] p3 as depicted:</p>
++<blockquote>
++<p>
++-3- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; n &gt; 0; ++result, ++first, --n) {
++ ::new (static_cast&lt;void*&gt;(<ins>addressof(</ins><del>&amp;</del>*result<ins>)</ins>))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(*first);
++}
++</pre>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.12.3 [uninitialized.fill] p1 as depicted:</p>
++<blockquote>
++<p>
++-1- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; first != last; ++first)
++ ::new (static_cast&lt;void*&gt;(<ins>addressof(</ins><del>&amp;</del>*first<ins>)</ins>))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(x);
++</pre>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.7.12.4 [uninitialized.fill.n] p1 as depicted:</p>
++<blockquote>
++<p>
++-1- <i>Effects</i>:
++</p>
++<blockquote>
++<pre>
++for (; n--; ++first)
++ ::new (static_cast&lt;void*&gt;(<ins>addressof(</ins><del>&amp;</del>*first<ins>)</ins>))
++ typename iterator_traits&lt;ForwardIterator&gt;::value_type(x);
++return first;
++</pre>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2434"></a>2434. <tt>shared_ptr::use_count()</tt> is efficient</h3>
++<p><b>Section:</b> 20.8.2.2.5 [util.smartptr.shared.obs] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#util.smartptr.shared.obs">issues</a> in [util.smartptr.shared.obs].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>shared_ptr</tt> and <tt>weak_ptr</tt> have Notes that their <tt>use_count()</tt> might be inefficient.
++This is an attempt to acknowledge reflinked implementations (which can be used by Loki smart pointers, for
++example). However, there aren't any <tt>shared_ptr</tt> implementations that use reflinking, especially
++after C++11 recognized the existence of multithreading. Everyone uses atomic refcounts, so <tt>use_count()</tt>
++is just an atomic load.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 20.8.2.2.5 [util.smartptr.shared.obs] p7-p10 as depicted:</p>
++
++<blockquote>
++<pre>
++long use_count() const noexcept;
++</pre>
++<blockquote>
++<p>
++-7- <i>Returns</i>: the number of <tt>shared_ptr</tt> objects, <tt>*this</tt> included, that <em>share ownership</em> with
++<tt>*this</tt>, or 0 when <tt>*this</tt> is <em>empty</em>.
++<p/>
++<del>-8- [<i>Note</i>: <tt>use_count()</tt> is not necessarily efficient. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote>
++<pre>
++bool unique() const noexcept;
++</pre>
++<blockquote>
++<p>
++-9- <i>Returns</i>: <tt>use_count() == 1</tt>.
++<p/>
++-10- [<i>Note</i>: <del><tt>unique()</tt> may be faster than <tt>use_count()</tt>.</del> If you are using <tt>unique()</tt>
++to implement copy on write, do not rely on a specific value when <tt>get() == 0</tt>. &mdash; <i>end note</i>]
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 20.8.2.3.5 [util.smartptr.weak.obs] p1-p4 as depicted:</p>
++
++<blockquote>
++<pre>
++long use_count() const noexcept;
++</pre>
++<blockquote>
++<p>
++-1- <i>Returns</i>: 0 if <tt>*this</tt> is <em>empty</em>; otherwise, the number of <tt>shared_ptr</tt> instances
++that <em>share ownership</em> with <tt>*this</tt>.
++<p/>
++<del>-2- [<i>Note</i>: <tt>use_count()</tt> is not necessarily efficient. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote>
++<pre>
++bool expired() const noexcept;
++</pre>
++<blockquote>
++<p>
++-3- <i>Returns</i>: <tt>use_count() == 0</tt>.
++<p/>
++<del>-4- [<i>Note</i>: <tt>expired()</tt> may be faster than <tt>use_count()</tt>. &mdash; <i>end note</i>]</del>
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2437"></a>2437. <tt>iterator_traits&lt;OutIt&gt;::reference</tt> can and can't be <tt>void</tt></h3>
++<p><b>Section:</b> 24.2.2 [iterator.iterators] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#iterator.iterators">issues</a> in [iterator.iterators].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++24.2.2 [iterator.iterators]/2 requires an <tt>Iterator</tt>'s <tt>*r</tt> to return <tt>reference</tt>,
++i.e. <tt>iterator_traits&lt;X&gt;::reference</tt> according to 24.2.1 [iterator.requirements.general]/11.
++<p/>
++24.2.4 [output.iterators]/1 requires an <tt>OutputIterator</tt>'s <tt>*r = o</tt> to do its job,
++so <tt>*r</tt> clearly can't return <tt>void</tt>.
++<p/>
++24.4.1 [iterator.traits]/1 says: "In the case of an output iterator, the types
++</p>
++<blockquote><pre>
++iterator_traits&lt;Iterator&gt;::difference_type
++iterator_traits&lt;Iterator&gt;::value_type
++iterator_traits&lt;Iterator&gt;::reference
++iterator_traits&lt;Iterator&gt;::pointer
++</pre></blockquote>
++<p>
++may be defined as <tt>void</tt>."
++<p/>
++This is contradictory. I suggest fixing this by moving the offending requirement down from <tt>Iterator</tt> to
++<tt>InputIterator</tt>, and making <tt>Iterator</tt> say that <tt>*r</tt> returns an unspecified type. This will
++have the following effects:
++</p>
++<ul>
++<li><p>Output-only iterators will inherit Iterator's "<tt>*r</tt> returns unspecified" requirement, while
++24.4.1 [iterator.traits]/1 clearly permits reference/etc. to be <tt>void</tt>.</p></li>
++<li><p>Input-or-stronger iterators (whether constant or mutable) are unaffected &mdash; they still have to satisfy
++"<tt>*r</tt> returns reference", they're just getting that requirement from <tt>InputIterator</tt> instead of
++<tt>Iterator</tt>.</p></li>
++</ul>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++EF: This is related to <a href="lwg-defects.html#2438">2438</a>. MC: I'd like to take up 2438 right after this.
++<p/>
++AM: Does anyone think this is wrong?
++<p/>
++GR: Why do we give output iterators to have reference type void? AM: we've mandated that certain output iterators
++define it as void since 1998. GR: Oh OK, I'm satisfied.
++<p/>
++Accepted. And <a href="lwg-defects.html#2438">2438</a> is already Ready.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>In 24.2.2 [iterator.iterators] Table 106 "Iterator requirements" change as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 106 &mdash; Iterator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational<br/>semantics</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td>
++<tt>*r</tt>
++</td>
++<td>
++<del><tt>reference</tt></del><ins>unspecified</ins>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++<i>pre</i>: <tt>r</tt> is dereferenceable.
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++</table>
++</blockquote></li>
++
++<li><p>In 24.2.3 [input.iterators] Table 107 "Input iterator requirements" change as indicated:</p>
++
++<blockquote>
++<table border="1">
++<caption>Table 107 &mdash; Input iterator requirements (in addition to Iterator)</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational<br/>semantics</th>
++<th>Assertion&#47;note pre-&#47;post-condition</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>*a</tt>
++</td>
++<td>
++<ins><tt>reference</tt>,</ins> convertible to <tt>T</tt>
++</td>
++<td>
++<tt></tt>
++</td>
++<td>
++[&hellip;]
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++</table>
++</blockquote></li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2438"></a>2438. <tt>std::iterator</tt> inheritance shouldn't be mandated</h3>
++<p><b>Section:</b> 24.4.2 [iterator.basic] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++For LWG convenience, nine STL iterators are depicted as deriving from <tt>std::iterator</tt> to get their
++<tt>iterator_category</tt>/etc. typedefs. Unfortunately (and unintentionally), this also mandates the
++inheritance, which is observable (not just through <tt>is_base_of</tt>, but also overload resolution).
++This is unfortunate because it confuses users, who can be misled into thinking that their own iterators
++must derive from <tt>std::iterator</tt>, or that overloading functions to take <tt>std::iterator</tt> is
++somehow meaningful. This is also unintentional because the STL's most important iterators, the container
++iterators, aren't required to derive from <tt>std::iterator</tt>. (Some are even allowed to be raw pointers.)
++Finally, this unnecessarily constrains implementers, who may not want to derive from <tt>std::iterator</tt>.
++(For example, to simplify debugger views.)
++<p/>
++We could add wording to 24.4.2 [iterator.basic] saying that any depicted inheritance is for exposition
++only, but that wouldn't really solve reader confusion. Replacing the depicted inheritance with direct typedefs
++will prevent confusion. Note that implementers won't be required to change their code &mdash; they are free to
++continue deriving from <tt>std::iterator</tt> if they want.
++<p/>
++(Editorial note: The order of the typedefs follows the order of <tt>std::iterator</tt>'s template parameters.)
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 20.7.10 [storage.iterator], class template <tt>raw_storage_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class OutputIterator, class T&gt;
++class raw_storage_iterator
++ <del>: public iterator&lt;output_iterator_tag,void,void,void,void&gt;</del> {
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++
++ explicit raw_storage_iterator(OutputIterator x);
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.5.1.1 [reverse.iterator], class template <tt>reverse_iterator</tt> synopsis, as depicted
++(editorial note: this reorders "<tt>reference</tt>, <tt>pointer</tt>" to "<tt>pointer</tt>, <tt>reference</tt>"
++and aligns whitespace):</p>
++
++<blockquote>
++<pre>
++template &lt;class Iterator&gt;
++class reverse_iterator <del>: public
++ iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
++ typename iterator_traits&lt;Iterator&gt;::value_type,
++ typename iterator_traits&lt;Iterator&gt;::difference_type,
++ typename iterator_traits&lt;Iterator&gt;::pointer,
++ typename iterator_traits&lt;Iterator&gt;::reference&gt;</del> {
++public:
++ <del>typedef Iterator iterator_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::reference reference;
++ typedef typename iterator_traits&lt;Iterator&gt;::pointer pointer;</del>
++ <ins>typedef Iterator iterator_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::iterator_category iterator_category;
++ typedef typename iterator_traits&lt;Iterator&gt;::value_type value_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
++ typedef typename iterator_traits&lt;Iterator&gt;::pointer pointer;
++ typedef typename iterator_traits&lt;Iterator&gt;::reference reference;</ins>
++
++ reverse_iterator();
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.5.2.1 [back.insert.iterator], class template <tt>back_insert_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class Container&gt;
++class back_insert_iterator <del>:
++ public iterator&lt;output_iterator_tag,void,void,void,void&gt;</del> {
++protected:
++ Container* container;
++
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++ typedef Container container_type;
++ explicit back_insert_iterator(Container&amp; x);
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.5.2.3 [front.insert.iterator], class template <tt>front_insert_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class Container&gt;
++class front_insert_iterator <del>:
++ public iterator&lt;output_iterator_tag,void,void,void,void&gt;</del> {
++protected:
++ Container* container;
++
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++ typedef Container container_type;
++ explicit front_insert_iterator(Container&amp; x);
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.5.2.5 [insert.iterator], class template <tt>insert_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class Container&gt;
++class insert_iterator <del>:
++ public iterator&lt;output_iterator_tag,void,void,void,void&gt;</del> {
++protected:
++ Container* container;
++ typename Container::iterator iter;
++
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++ typedef Container container_type;
++ insert_iterator(Container&amp; x, typename Container::iterator i);
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.6.1 [istream.iterator], class template <tt>istream_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,
++ class Distance = ptrdiff_t&gt;
++class istream_iterator <del>:
++ public iterator&lt;input_iterator_tag, T, Distance, const T*, const T&amp;&gt;</del> {
++public:
++ <ins>typedef input_iterator_tag iterator_category;
++ typedef T value_type;
++ typedef Distance difference_type;
++ typedef const T* pointer;
++ typedef const T&amp; reference;</ins>
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.6.2 [ostream.iterator], class template <tt>ostream_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;&gt;
++class ostream_iterator <del>:
++ public iterator&lt;output_iterator_tag, void, void, void, void&gt;</del> {
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.6.3 [istreambuf.iterator], class template <tt>istreambuf_iterator</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++template &lt;class charT = char, class traits = char_traits&lt;charT&gt; &gt;
++class istreambuf_iterator <del>:
++ public iterator&lt;input_iterator_tag, charT,
++ typename traits::off_type, <em>unspecified</em>, charT&gt;</del> {
++public:
++ <ins>typedef input_iterator_tag iterator_category;
++ typedef charT value_type;
++ typedef typename traits::off_type difference_type;
++ typedef <em>unspecified</em> pointer;
++ typedef charT reference;</ins>
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 24.6.4 [ostreambuf.iterator], class template <tt>ostreambuf_iterator</tt> synopsis, as depicted
++(editorial note: this removes a redundant "public:"):</p>
++
++<blockquote>
++<pre>
++template &lt;class charT = char, class traits = char_traits&lt;charT&gt;&gt;
++class ostreambuf_iterator <del>:
++ public iterator&lt;output_iterator_tag, void, void, void, void&gt;</del> {
++public:
++ <ins>typedef output_iterator_tag iterator_category;
++ typedef void value_type;
++ typedef void difference_type;
++ typedef void pointer;
++ typedef void reference;</ins>
++ [&hellip;]
++<del>public:</del>
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2439"></a>2439. <tt>unique_copy()</tt> sometimes can't fall back to reading its output</h3>
++<p><b>Section:</b> 25.3.9 [alg.unique] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#alg.unique">issues</a> in [alg.unique].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++<tt>unique_copy()</tt>'s wording says that if it's given input-only and output-only iterators, it needs
++the input's value type to be copyable. This is correct, because in this case the algorithm must have a
++local element copy in order to detect duplicates.
++<p/>
++The wording also says that if it's given an <tt>InputIterator</tt> that's forward or stronger, the input's
++value type doesn't have to be copyable. This is also correct, because in this case the algorithm can reread
++the input in order to detect duplicates.
++<p/>
++Finally, the wording says that if it's given an input-only iterator with an <tt>OutputIterator</tt> that's
++forward or stronger, the input's value type doesn't have to be copyable. This is telling the algorithm to
++compare its input to its output in order to detect duplicates, but that isn't always possible! If the input
++and output have the same value type, then they can be compared (as long as <tt>*result = *first</tt> behaves
++sanely; see below). If they have different value types, then we can't compare them.
++<p/>
++This could be resolved by requiring heterogeneous value types to be comparable in this situation, but that
++would be extremely tricky to wordsmith (as it would challenge the concept of "group of equal elements" used
++by the Effects). It will be vastly simpler and more effective to extend the "local element copy" requirement
++to this scenario.
++<p/>
++Note that the input-only, output forward-or-stronger, identical value types scenario needs a bit of work too.
++We always require *result = *first to be "valid", but in this case we need to additionally require that the
++assignment actually transfers the value. (Otherwise, we'd be allowing an <tt>op=()</tt> that ignores <tt>*first</tt>
++and always sets <tt>*result</tt> to zero, or other unacceptable behavior.) This is just <tt>CopyAssignable</tt>.
++<p/>
++(What happens when <tt>unique_copy()</tt> is given a <tt>move_iterator</tt> is a separate issue.)
++<p/>
++To summarize:
++</p>
++<blockquote><p>
++input forward+: no additional requirements
++<p/>
++input-only, output forward+, same value types: needs <tt>CopyAssignable</tt>
++<p/>
++input-only, output forward+, different value types: needs <tt>CopyConstructible</tt> and <tt>CopyAssignable</tt>
++<p/>
++input-only, output-only: needs <tt>CopyConstructible</tt> and <tt>CopyAssignable</tt>
++</p></blockquote>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 25.3.9 [alg.unique] p5, as depicted:</p>
++
++<blockquote>
++<pre>
++template&lt;class InputIterator, class OutputIterator>
++OutputIterator
++unique_copy(InputIterator first, InputIterator last,
++ OutputIterator result);
++template&lt;class InputIterator, class OutputIterator,
++ class BinaryPredicate>
++OutputIterator
++unique_copy(InputIterator first, InputIterator last,
++ OutputIterator result, BinaryPredicate pred);
++</pre>
++<blockquote>
++<p>
++-5- <i>Requires</i>: The comparison function shall be an equivalence relation. The ranges [<tt>first,last</tt>) and
++[<tt>result,result+(last-first)</tt>) shall not overlap. The expression <tt>*result = *first</tt> shall be valid.
++<del>If neither <tt>InputIterator</tt> nor <tt>OutputIterator</tt> meets the requirements of forward iterator then the
++value type of <tt>InputIterator</tt> shall be <tt>CopyConstructible</tt> (Table 21) and <tt>CopyAssignable</tt> (Table 23).
++Otherwise <tt>CopyConstructible</tt> is not required.</del><ins>Let <tt>T</tt> be the value type of <tt>InputIterator</tt>.
++If <tt>InputIterator</tt> meets the forward iterator requirements, then there are no additional requirements for <tt>T</tt>.
++Otherwise, if <tt>OutputIterator</tt> meets the forward iterator requirements and its value type is the same as <tt>T</tt>,
++then <tt>T</tt> shall be <tt>CopyAssignable</tt> (Table 23). Otherwise, <tt>T</tt> shall be both <tt>CopyConstructible</tt>
++(Table 21) and <tt>CopyAssignable</tt>.</ins>
++</p>
++</blockquote></blockquote></li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2440"></a>2440. <tt>seed_seq::size()</tt> should be <tt>noexcept</tt></h3>
++<p><b>Section:</b> 26.5.7.1 [rand.util.seedseq] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#rand.util.seedseq">issues</a> in [rand.util.seedseq].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Obvious.
++</p>
++
++<p><i>[Urbana 2014-11-07: Move to Ready]</i></p>
++
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 26.5.7.1 [rand.util.seedseq], class <tt>seed_seq</tt> synopsis, as depicted:</p>
++
++<blockquote>
++<pre>
++class seed_seq
++{
++public:
++ [&hellip;]
++ size_t size() const <ins>noexcept</ins>;
++ [&hellip;]
++};
++</pre>
++</blockquote></li>
++
++<li><p>Change 26.5.7.1 [rand.util.seedseq] around p10, as depicted:</p>
++
++<blockquote>
++<pre>
++size_t size() const <ins>noexcept</ins>;
++</pre>
++<blockquote>
++<p>
++-10- <i>Returns</i>: The number of 32-bit units that would be returned by a call to <tt>param()</tt>.
++<p/>
++<del>-11- <i>Throws</i>: Nothing.</del>
++<p/>
++-12- <i>Complexity</i>: Constant time.
++</p>
++</blockquote>
++</blockquote></li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2442"></a>2442. <tt>call_once()</tt> shouldn't <tt>DECAY_COPY()</tt></h3>
++<p><b>Section:</b> 30.4.4.2 [thread.once.callonce] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2014-10-01 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#thread.once.callonce">issues</a> in [thread.once.callonce].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++When LWG <a href="lwg-defects.html#891">891</a> overhauled <tt>call_once()</tt>'s specification, it used <tt>decay_copy()</tt>, following
++LWG <a href="lwg-defects.html#929">929</a>'s overhaul of <tt>thread</tt>'s constructor.
++<p/>
++In <tt>thread</tt>'s constructor, this is necessary and critically important. 30.3.1.2 [thread.thread.constr]/5
++"The new thread of execution executes <tt><i>INVOKE</i>(<i>DECAY_COPY</i>(std::forward&lt;F&gt;(f)),
++<i>DECAY_COPY</i>(std::forward&lt;Args&gt;(args))...)</tt>
++with the calls to <tt><i>DECAY_COPY</i></tt> being evaluated in the constructing thread." requires the parent thread
++to copy arguments for the child thread to access.
++<p/>
++In <tt>call_once()</tt>, this is unnecessary and harmful. It's unnecessary because <tt>call_once()</tt> doesn't transfer
++arguments between threads. It's harmful because:
++</p>
++<ul>
++<li><p><tt>decay_copy()</tt> returns a prvalue. Given <tt>meow(int&amp;)</tt>, <tt>meow(i)</tt> can be called directly,
++but <tt>call_once(flag, meow, i)</tt> won't compile.</p></li>
++<li><p><tt>decay_copy()</tt> moves from modifiable rvalues. Given <tt>purr(const unique_ptr&lt;int&gt;&amp;)</tt>,
++<tt>purr(move(up))</tt> won't modify <tt>up</tt>. (This is observable, because moved-from <tt>unique_ptr</tt>s are
++guaranteed empty.) However, <tt>call_once(flag, purr, move(up))</tt> will leave <tt>up</tt> empty after the first active
++execution. Observe the behavioral difference &mdash; if <tt>purr()</tt> is directly called like this repeatedly until it
++doesn't throw an exception, each call will observe <tt>up</tt> unchanged. With <tt>call_once()</tt>, the second active
++execution will observe <tt>up</tt> to be empty.</p></li>
++</ul>
++<p>
++<tt>call_once()</tt> should use perfect forwarding without <tt>decay_copy()</tt>, in order to avoid interfering with the call like this.
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++Handed over to SG1.
++</p>
++
++<p><i>[2015-05 Lenexa, SG1 response]</i></p>
++
++<p>
++Looks good to us, but this is really an LWG issue.
++</p>
++
++<p><i>[2015-05-07 Lenexa: Move Immediate]</i></p>
++
++<p>LWG 2442 call_once shouldn't decay_copy</p>
++<p>STL summarizes the SG1 minutes.</p>
++<p>Marshall: Jonathan updated all the issues with SG1 status last night. Except this one.</p>
++<p>STL summarizes the issue.</p>
++<p>Dietmar: Of course, call_once has become useless.</p>
++<p>STL: With magic statics.</p>
++<p>Jonathan: Magic statics can't be per object, which I use in future.</p>
++<p>Marshall: I see why you are removing the MoveConstructible on the arguments, but what about Callable?</p>
++<p>STL: That's a type named Callable, which we will no longer decay_copy. We're still requiring the INVOKE expression to be valid.</p>
++<p>Marshall: Okay. Basically, ripping the decay_copy out of here.</p>
++<p>STL: I recall searching the Standard for other occurrences and I believe this is the only inappropriate use of decay_copy.</p>
++<p>Marshall: We do the decay_copy.</p>
++<p>Jonathan: Us too.</p>
++<p>Marshall: What do people think?</p>
++<p>Jonathan: I think STL's right. In the use I was mentioning inside futures, I actually pass them by reference_wrapper and pointers, to avoid the decay causing problems. Inside the call_once, I then extract the args. So I've had to work around this and didn't realize it was a defect.</p>
++<p>Marshall: What do people think is the right resolution?</p>
++<p>STL: I would like to see Immediate.</p>
++<p>Hwrd: No objections to Immediate.</p>
++<p>Marshall: Bill is nodding.</p>
++<p>PJP: He said it. Everything STL says applies to our other customers.</p>
++<p>Marshall: Any objections to Immediate?</p>
++<p>Jonathan: I can't see any funky implementations where a decay_copy would be necessary?</p>
++<p>Marshall: 6 votes for Immediate, 0 opposed, 0 abstaining.</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N3936.
++</p>
++
++<ol>
++<li><p>Change 30.4.4.2 [thread.once.callonce] p1+p2 as depicted:</p>
++
++<blockquote>
++<pre>
++template&lt;class Callable, class ...Args&gt;
++ void call_once(once_flag&amp; flag, Callable&amp;&amp; func, Args&amp;&amp;... args);
++</pre>
++<blockquote>
++<p>
++-1- <i>Requires</i>: <del><tt>Callable</tt> and each <tt>Ti</tt> in <tt>Args</tt> shall satisfy the <tt>MoveConstructible</tt>
++requirements.</del> <tt><i>INVOKE</i>(<del><i>DECAY_COPY</i>(</del>std::forward&lt;Callable&gt;(func)<del>)</del>,
++<del><i>DECAY_COPY</i>(</del>std::forward&lt;Args&gt;(args)<del>)</del>...)</tt>
++(20.9.2) shall be a valid expression.
++<p/>
++-2- <i>Effects</i>; [&hellip;] An active execution shall call
++<tt><i>INVOKE</i>(<del><i>DECAY_COPY</i>(</del>std::forward&lt;Callable&gt;(func)<del>)</del>,
++<del><i>DECAY_COPY</i>(</del>std::forward&lt;Args&gt;(args)<del>)</del>...)</tt>. [&hellip;]
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++
++<hr>
++<h3><a name="2448"></a>2448. Non-normative Container destructor specification</h3>
++<p><b>Section:</b> 23.2.1 [container.requirements.general] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2014-10-18 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#container.requirements.general">active issues</a> in [container.requirements.general].</p>
++<p><b>View all other</b> <a href="lwg-index.html#container.requirements.general">issues</a> in [container.requirements.general].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++According to Table 96 &mdash; "Container requirements" the specification:
++</p>
++<blockquote><p>
++note: the destructor is applied to every element of <tt>a</tt>; any
++memory obtained is deallocated.
++</p></blockquote>
++<p>
++The initial "note:" can be read as if that part of the specification would not be normative (This note form
++differs from footnotes in tables, which have normative meaning).
++<p/>
++It seems that this initial part of the specification exists since C++98. But comparing with
++the similar <a href="https://www.sgi.com/tech/stl/Container.html">SGI Container specification</a> there is no evidence
++for that being intended to be non-normative.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++NJ: If we fix this, we should also fix it elsewhere. Oh, this is the only place?<br/>
++GR: If this is intended to be different from elsewhere, we should make sure.<br/>
++AM: <tt>valarray</tt> specifies this without the "note:".<br/>
++DK: <tt>valarray</tt> requires trivially destructible types!<br/>
++GR: That's good enough for me.<br/>
++NJ: First time <tt>valarray</tt> has been useful for something!
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N4140.
++</p>
++
++<ol>
++<li><p>Change 23.2.1 [container.requirements.general], Table 96 &mdash; "Container requirements", as indicated:</p>
++<blockquote>
++<table border="1">
++<caption>Table 96 &mdash; Container requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Operational<br/>semantics</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++<th>Complexity</th>
++</tr>
++
++<tr>
++<td colspan="5" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>(&amp;a)-&gt;~X()</tt>
++</td>
++<td>
++<tt>void</tt>
++</td>
++<td>
++</td>
++<td>
++<del>note:</del> the destructor<br/>
++is applied to every<br/>
++element of <tt>a</tt>; any<br/>
++memory obtained is
++deallocated.
++</td>
++<td>
++linear
++</td>
++</tr>
++
++<tr>
++<td colspan="5" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2454"></a>2454. Add <tt>raw_storage_iterator::base()</tt> member</h3>
++<p><b>Section:</b> 20.7.10 [storage.iterator] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Jonathan Wakely <b>Opened:</b> 2014-11-11 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#storage.iterator">issues</a> in [storage.iterator].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Eric Niebler pointed out that <tt>raw_storage_iterator</tt> should give access
++to the <tt>OutputIterator</tt> it wraps.
++<p/>
++This helps alleviate the exception-safety issue pointed out in the
++discussion of LWG <a href="lwg-active.html#2127">2127</a>, as an exception can be caught and then
++destructors can be run for the constructed elements in the range
++<tt>[begin, raw.base())</tt>
++</p>
++
++<p><i>[2015-02 Cologne]</i></p>
++
++<p>
++NJ: Is this "const" correct [in "base()"]? DK: Yes, we always do that. NJ: And the output iterator is not qualifying in any way?
++AM/DK: That wouldn't make sense. NJ: OK.
++<p/>
++VV: What did LEWG say about this feature request? In other words, why is this a library issue? AM: LEWG/JY thought this wouldn't
++be a contentious issue.
++<p/>
++NJ: I really hope the split of LEWG and LWG will be fixed soon, since it's only wasting time. VV: So you want to spend even
++more of your time on discussions that LEWG has?
++<p/>
++AM: I think this specified correctly. I'm not wild about it. But no longer bothered to stand in its way.
++<p/>
++GR: Why do we need to repeat the type in "Returns" even though it's part of the synopsis? AM: Good point, but not worth fixing.
++<p/>
++NJ: Why is "<tt>base()</tt>" for <tt>reverse_iterator</tt> commented with "// explicit"? AM: I guess in 1998 that was the
++only way to say this.
++<p/>
++AM: So, it's tentatively ready.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to <a href="http://www.open-std.org/jtc1/sc22/wg21/prot/14882fdis/n4140.pdf">N4140</a>.</p>
++
++<ol>
++<li><p>Add a new function to the synopsis in 20.7.10 [storage.iterator] p1:</p>
++
++<blockquote><pre>
++namespace std {
++ template &lt;class OutputIterator, class T&gt;
++ class raw_storage_iterator
++ : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
++ public:
++ explicit raw_storage_iterator(OutputIterator x);
++
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
++ raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();
++ raw_storage_iterator&lt;OutputIterator,T&gt; operator++(int);
++ <ins>OutputIterator base() const;</ins>
++};
++}
++</pre></blockquote>
++</li>
++
++<li><p>Insert the new function and a new paragraph series after p7:</p>
++
++<blockquote><pre>
++<ins>OutputIterator base() const;</ins>
++</pre><blockquote>
++<p>
++<ins>-?- <i>Returns</i>: An iterator of type <tt>OutputIterator</tt> that points to the
++same value as <tt>*this</tt> points to.</ins>
++</p>
++</blockquote></blockquote>
++</li>
++
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2455"></a>2455. Allocator default construction should be allowed to throw</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Pablo Halpern <b>Opened:</b> 2014-11-11 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++17.6.3.5 [allocator.requirements]/4 in the 2014-10 WP (N4140), says:
++</p>
++<blockquote><p>
++An allocator type <tt>X</tt> shall satisfy the requirements of <tt>CopyConstructible</tt> (17.6.3.1). The
++<tt>X::pointer</tt>, <tt>X::const_pointer</tt>, <tt>X::void_pointer</tt>, and <tt>X::const_void_pointer</tt>
++types shall satisfy the requirements of <tt>NullablePointer</tt> (17.6.3.3). No constructor, comparison operator,
++copy operation, move operation, or swap operation on these types shall exit via an exception. <tt>X::pointer</tt>
++and <tt>X::const_pointer</tt> shall also satisfy the requirements for a random access iterator (24.2).
++</p></blockquote>
++<p>
++The words "these types" would normally apply only to the previous sentence only, i.e., only to the pointer types.
++However, an alternative reading would be that the allocator constructors themselves cannot throw. The change to
++the <tt>vector</tt> and <tt>string</tt> default constructors, making them unconditionally <tt>noexcept</tt> depends
++on this alternative reading.
++<p/>
++I believe that the wording in the standard is not intended to forbid throwing default constructors for allocators.
++Indeed, I believe that allocators do not require default constructors and that if they provide a default constructor
++they should be allowed to throw.
++<p/>
++In addition, the <tt>noexcept</tt> specifications for the <tt>string</tt> and <tt>vector</tt> default constructors
++should be changed to make them conditional.
++</p>
++
++<p><i>[2015-01-18 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++
++<p><b>Proposed resolution:</b></p>
++
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements] p4 as indicated:</p>
++
++<blockquote><p>
++An allocator type <tt>X</tt> shall satisfy the requirements of <tt>CopyConstructible</tt> (17.6.3.1). The
++<tt>X::pointer</tt>, <tt>X::const_pointer</tt>, <tt>X::void_pointer</tt>, and <tt>X::const_void_pointer</tt>
++types shall satisfy the requirements of <tt>NullablePointer</tt> (17.6.3.3). No constructor, comparison operator,
++copy operation, move operation, or swap operation on these <ins>pointer</ins> types shall exit via an exception.
++<tt>X::pointer</tt> and <tt>X::const_pointer</tt> shall also satisfy the requirements for a random access iterator (24.2).
++</p></blockquote>
++</li>
++
++<li><p>Change 21.4 [basic.string] following p5, class template <tt>basic_string</tt> synopsis, as indicated:
++(This change assumes that N4258 has been applied, as voted on in Urbana on 2014-11-08)</p>
++
++<blockquote>
++<pre>
++<i>// 21.4.2, construct/copy/destroy:</i>
++basic_string() noexcept<ins>(noexcept(Allocator()))</ins> : basic_string(Allocator()) { }
++</pre>
++</blockquote>
++
++<blockquote class="note">
++<p>
++An alternative formulation of the above would be:
++</p>
++<pre>
++<i>// 21.4.2, construct/copy/destroy:</i>
++basic_string() noexcept<ins>(is_nothrow_default_constructible&lt;Allocator&gt;{})</ins> : basic_string(Allocator()) { }
++</pre>
++</blockquote>
++</li>
++
++<li><p>Change 23.3.6.1 [vector.overview] following p2, class template <tt>vector</tt> synopsis, as indicated:
++(This change assumes that N4258 has been applied, as voted on in Urbana on 2014-11-08)</p>
++
++<blockquote>
++<pre>
++<i>// 23.3.6.2, construct/copy/destroy:</i>
++vector() noexcept<ins>(noexcept(Allocator()))</ins> : vector(Allocator()) { }
++</pre>
++</blockquote>
++
++<blockquote class="note">
++<p>
++An alternative formulation of the above would be:
++</p>
++<pre>
++<i>// 23.3.6.2, construct/copy/destroy:</i>
++vector() noexcept<ins>(is_nothrow_default_constructible&lt;Allocator&gt;{})</ins> : vector(Allocator()) { }
++</pre>
++</blockquote>
+ </li>
+-</ol>
+
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1519"></a>1519. bucketsize() const only for unordered set</h3>
+-<p><b>Section:</b> 23.7.1 [unord.map], 23.7.2 [unord.multimap], 23.7.4 [unord.multiset] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Nicolai Josuttis <b>Opened:</b> 2010-10-09 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#unord.map">issues</a> in [unord.map].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="2458"></a>2458. N3778 and new library deallocation signatures</h3>
++<p><b>Section:</b> 18.6 [support.dynamic], 18.6.1.1 [new.delete.single], 18.6.1.2 [new.delete.array] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Richard Smith <b>Opened:</b> 2014-11-23 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-While <tt>bucket_size()</tt> is const for <tt>unordered_set</tt>, for all other unordered containers it is not defined as
+-constant member function.
++<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3778.html">N3778</a>
++added the following sized deallocation signatures to the library:
+ </p>
++<blockquote><pre>
++void operator delete(void* ptr, std::size_t size) noexcept;
++void operator delete[](void* ptr, std::size_t size) noexcept;
+
+-<p><i>[
+-Post-Rapperswil
+-]</i></p>
+-
++void operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;
++void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;
++</pre></blockquote>
++<p>
++The former two are an essential part of the proposal. The latter two seem
++spurious &mdash; they are not called when <tt>new (std::nothrow) X</tt> fails due to
++<tt>X::X()</tt> throwing, because the core language rules for selecting a placement
++deallocation function do not consider passing a <tt>size</tt> argument. Instead, the
++above would be the matching deallocation functions for:
++</p>
++<blockquote><pre>
++void *operator new(std::size_t size, std::size_t size_again, const std::nothrow_t&amp;) noexcept;
++void *operator new[](std::size_t size, std::size_t size_again, const std::nothrow_t&amp;) noexcept;
++</pre></blockquote>
++<p>
++... which don't exist.
++<p/>
++Since they're not implicitly called, the only other possible use for those
++functions would be to perform an explicitly non-throwing deallocation.
++But... the first two overloads are already explicitly non-throwing and are
++required to be semantically identical to the second two. So there's no
++point in making an explicit call to the second pair of functions either.
++<p/>
++It seems to me that we should remove the <tt>(void*, size_t, nothrow_t)</tt> overloads, because
++the core working group decided during the Urbana 2014 meeting, that no change to the core
++language was warranted.
++</p>
+
+-<blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+-</blockquote>
++<p><i>[2014-11-23, Daniel suggests concrete wording changes]</i></p>
+
+-<p><i>[
+-Adopted at 2010-11 Batavia
+-]</i></p>
+
++<p><i>[2015-02 Cologne]</i></p>
+
++<p>
++Nobody can call those overloads, since the nothrow allocation functions cannot throw. JY: Ship it. GR: Should we do due
++diligence and make sure we're deleting what we mean to be deleting? [Some checking, everything looks good.]
++<p/>
++Accepted.
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
+-
+-<p><i>The wording refers to N3126.</i></p>
++<p>This wording is relative to N4140.</p>
+
+ <ol>
+-<li>Change 23.7.1 Class template unordered_map [unord.map]/3, as indicated:
+-<blockquote><pre> namespace std {
+- template &lt;class Key,
+- class T,
+- class Hash = hash&lt;Key&gt;,
+- class Pred = std::equal_to&lt;Key&gt;,
+- class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
+- class unordered_map
+- {
+- public:
+- [..]
+- // bucket interface
+- size_type bucket_count() const;
+- size_type max_bucket_count() const;
+- size_type bucket_size(size_type n) <ins>const</ins>;
+- [..]
+-</pre></blockquote>
++<li><p>Change 18.6 [support.dynamic], header <tt>&lt;new&gt;</tt> synopsis, as indicated:</p>
++
++<blockquote><pre>
++[&hellip;]
++void operator delete(void* ptr, std::size_t size) noexcept;
++<del>void operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;</del>
++[&hellip;]
++void operator delete[](void* ptr, std::size_t size) noexcept;
++<del>void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;</del>
++[&hellip;]
++</pre></blockquote>
++
++</li>
++
++<li><p>Change 18.6.1.1 [new.delete.single], starting before p19, as indicated:</p>
++<blockquote><pre>
++void operator delete(void* ptr, const std::nothrow_t&amp;) noexcept;
++<del>void operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;</del>
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-20- <i>Replaceable</i>: a C++ program may define a function with signature <tt>void operator delete(void*
++ptr, const std::nothrow_t&amp;) noexcept</tt> that displaces the default version defined by the C++ standard
++library. <del>If this function (without <tt>size</tt> parameter) is defined, the program should also define
++<tt>void operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept</tt>. If
++this function with <tt>size</tt> parameter is defined, the program shall also define the version without the
++<tt>size</tt> parameter. [<i>Note</i>: The default behavior below may change in the future, which will require
++replacing both deallocation functions when replacing the allocation function. &mdash; <i>end note</i>]</del>
++<p/>
++[&hellip;]
++<p/>
++<del>-22- <i>Requires</i>: If present, the <tt>std::size_t size</tt> argument must equal the <tt>size</tt>
++argument passed to the allocation function that returned <tt>ptr</tt>.</del>
++<p/>
++<del>-23- <i>Required behavior</i>: Calls to <tt>operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;)</tt>
++may be changed to calls to <tt>operator delete(void* ptr, const std::nothrow_t&amp;)</tt> without affecting
++memory allocation. [<i>Note</i>: A conforming implementation is for <tt>operator delete(void* ptr, std::size_t size,
++const std::nothrow_t&amp;)</tt> to simply call <tt>operator delete(void* ptr, const std::nothrow_t&amp;)</tt>. &mdash;
++<i>end note</i>]</del>
++<p/>
++-24- <i>Default behavior</i>: <del><tt>operator delete(void* ptr, std::size_t size, const std::nothrow_t&amp;)</tt>
++calls <tt>operator delete(ptr, std::nothrow)</tt>, and</del> <tt>operator delete(void* ptr, const std::nothrow_t&amp;)</tt>
++calls <tt>operator delete(ptr)</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Change 18.6.1.2 [new.delete.array], starting before p16, as indicated:</p>
++<blockquote><pre>
++void operator delete[](void* ptr, const std::nothrow_t&amp;) noexcept;
++<del>void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept;</del>
++</pre>
++<blockquote>
++<p>
++[&hellip;]
++<p/>
++-17- <i>Replaceable</i>: a C++ program may define a function with signature <tt>void operator delete[](void*
++ptr, const std::nothrow_t&amp;) noexcept</tt> that displaces the default version defined by the C++ standard
++library. <del>If this function (without <tt>size</tt> parameter) is defined, the program should also define <tt>void
++operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;) noexcept</tt>. If this
++function with <tt>size</tt> parameter is defined, the program shall also define the version without the <tt>size</tt>
++parameter. [<i>Note</i>: The default behavior below may change in the future, which will require replacing
++both deallocation functions when replacing the allocation function. &mdash; <i>end note</i>]</del>
++<p/>
++[&hellip;]
++<p/>
++<del>-19- <i>Requires</i>: If present, the <tt>std::size_t size</tt> argument must equal the <tt>size</tt> argument
++passed to the allocation function that returned <tt>ptr</tt>.</del>
++<p/>
++<del>-20- <i>Required behavior</i>: Calls to <tt>operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;)</tt>
++may be changed to calls to <tt>operator delete[](void* ptr, const std::nothrow_t&amp;)</tt> without affecting memory allocation.
++[<i>Note</i>: A conforming implementation is for <tt>operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;)</tt>
++to simply call <tt>operator delete[](void* ptr, const std::nothrow_t&amp;)</tt>. &mdash; <i>end note</i>]</del>
++<p/>
++-21- <i>Default behavior</i>: <del><tt>operator delete[](void* ptr, std::size_t size, const std::nothrow_t&amp;)</tt>
++calls <tt>operator delete[](ptr, std::nothrow)</tt>, and</del> <tt>operator delete[](void* ptr, const std::nothrow_t&amp;)</tt>
++calls <tt>operator delete[](ptr)</tt>.
++</p>
++</blockquote>
++</blockquote>
+ </li>
+-<li>Change 23.7.2 Class template unordered_multimap [unord.multimap]/3, as indicated:
+-<blockquote><pre> namespace std {
+- template &lt;class Key,
+- class T,
+- class Hash = hash&lt;Key&gt;,
+- class Pred = std::equal_to&lt;Key&gt;,
+- class Alloc = std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
+- class unordered_multimap
+- {
+- public:
+- [..]
+- // bucket interface
+- size_type bucket_count() const;
+- size_type max_bucket_count() const;
+- size_type bucket_size(size_type n) <ins>const</ins>;
+- [..]
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2459"></a>2459. <tt>std::polar</tt> should require a non-negative rho</h3>
++<p><b>Section:</b> 26.4.7 [complex.value.ops] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Marshall Clow <b>Opened:</b> 2014-10-22 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#complex.value.ops">issues</a> in [complex.value.ops].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
++<p>
++Different implementations give different answers for the following code:
++</p>
++<blockquote><pre>
++#include &lt;iostream&gt;
++#include &lt;complex&gt;
++
++int main ()
++{
++ std::cout &lt;&lt; std::polar(-1.0, -1.0) &lt;&lt; '\n';
++ return 0;
++}
+ </pre></blockquote>
+-</li>
+-<li>Change 23.7.4 Class template unordered_multiset [unord.multiset]/3, as indicated:
+-<blockquote><pre> namespace std {
+- template &lt;class Key,
+- class Hash = hash&lt;Key&gt;,
+- class Pred = std::equal_to&lt;Key&gt;,
+- class Alloc = std::allocator&lt;Key&gt; &gt;
+- class unordered_multiset
+- {
+- public:
+- [..]
+- // bucket interface
+- size_type bucket_count() const;
+- size_type max_bucket_count() const;
+- size_type bucket_size(size_type n) <ins>const</ins>;
+- [..]
++<p>
++One implementation prints:
++</p>
++<blockquote><pre>
++(nan, nan)
+ </pre></blockquote>
++<p>
++Another:
++</p>
++<blockquote><pre>
++(-0.243068, 0.243068)
++</pre></blockquote>
++<p>
++Which is correct? Or neither?
++<p/>
++In <a href="http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-November/033591.html">this list</a>,
++Howard Hinnant wrote:
++</p>
++<blockquote class="note">
++<p>
++I've read this over several times. I've consulted C++11, C11, and IEC 10967-3. [snip]
++<p/>
++I'm finding:
++</p>
++<ol>
++<li><p>The magnitude of a complex number <tt>== abs(c) == hypot(c.real(), c.imag())</tt> and is always non-negative
++(by all three of the above standards).</p></li>
++<li><p>Therefore no complex number exists for which <tt>abs(c) &lt; 0</tt>.</p></li>
++<li><p>Therefore when the first argument to <tt>std::polar</tt> (which is called <tt>rho</tt>) is negative, no complex number
++can be formed which meets the post-conidtion that <tt>abs(c) == rho</tt>.</p>
+ </li>
+ </ol>
++<p>
++One could argue that this is already covered in 26.4 [complex.numbers]/3, but I think it's worth making explicit.
++</p>
++</blockquote>
+
++<p><i>[2015-02, Cologne]</i></p>
++
++<p>
++Discussion on whether theta should also be constrained.<br/>
++TK: infinite theta doesn't make sense, whereas infinite rho does (theta is on a compact domain, rho is on a non-compact domain).<br/>
++AM: We already have a narrow contract, so I don't mind adding further requirements. Any objections to requiring that theta be finite?<br/>
++Some more discussion, but general consensus. Agreement that if someone finds the restrictions problematic, they should write
++a proper paper to address how <tt>std::polar</tt> should behave. For now, we allow infinite rho (but not NaN and not negative),
++and require finite theta.
++<p/>
++No objections to tentatively ready.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 26.4.7 [complex.value.ops] around p9 as indicated</p>
++
++<blockquote><pre>
++template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp; rho, const T&amp; theta = 0);
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>rho</tt> shall be non-negative and non-NaN. <tt>theta</tt> shall be finite.</ins>
++<p/>
++-9- <i>Returns</i>: The complex value corresponding to a complex number whose magnitude is <tt>rho</tt> and whose
++phase angle is <tt>theta</tt>.
++</p>
++</blockquote>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1520"></a>1520. <tt>INVOKE</tt> on member data pointer with too many arguments</h3>
+-<p><b>Section:</b> 20.8.2 [func.require] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2010-10-10 <b>Last modified:</b> 2010-11-23</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#func.require">issues</a> in [func.require].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="2463"></a>2463. [fund.ts] Incorrect complexity for <tt>sample()</tt> algorithm</h3>
++<p><b>Section:</b> X [alg.random.sample] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Joe Gottman <b>Opened:</b> 2014-12-17 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
+ <p><b>Discussion:</b></p>
++<p><b>Addresses: fund.ts</b></p>
++<p>
++According to paragraph 10.1 of the Library Fundamentals 1 draft, the complexity of the new
++<tt>std::experimental::sample</tt> template function is O(<tt>n</tt>). Note that <tt>n</tt> is actually
++a parameter of this function, corresponding to the sample size. But both common algorithms for
++sampling, the selection algorithm and the reservoir algorithm, are linear with respect to the
++population size, which is often many orders of magnitude bigger than the sample size.
++</p>
++
++<p><i>[2015-02, Cologne]</i></p>
+
+ <p>
+-20.8.2 [func.require] p1 says:
++AM: I suggest we make this a DR against the Fundamentals TS.<br/>
++GR: Agreed, this is a no-brainer.
+ </p>
+
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4335 in regard to fundamental-ts changes.</p>
++
++<ol>
++<li><p>Change X [alg.random.sample] p5 to read:</p>
++
+ <blockquote>
+ <p>
+-1 Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++-5- <i>Complexity</i>: O(<tt><del>n</del><ins>last - first</ins></tt>).
+ </p>
+-
+-<ul>
+-<li>
+-<tt>(t1.*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member function
+-of a class <tt>T</tt> and <tt>t1</tt> is an object of type <tt>T</tt> or a
+-reference to an object of type <tt>T</tt> or a reference to an object of a type
+-derived from <tt>T</tt>;
+-</li>
+-<li>
+-<tt>((*t1).*f)(t2, ..., tN)</tt> when <tt>f</tt> is a pointer to a member
+-function of a class <tt>T</tt> and <tt>t1</tt> is not one of the types described
+-in the previous item;
+-</li>
+-<li>
+-<tt>t1.*f</tt> when <tt>f</tt> is a pointer to member data of a class <tt>T</tt>
+-and <tt>t1</tt> is an object of type <tt>T</tt> or a reference to an object of
+-type <tt>T</tt> or a reference to an object of a type derived from <tt>T</tt>;
+-</li>
+-<li>
+-<tt>(*t1).*f</tt> when <tt>f</tt> is a pointer to member data of a class
+-<tt>T</tt> and <tt>t1</tt> is not one of the types described in the previous
+-item;
+-</li>
+-<li>
+-<tt>f(t1, t2, ..., tN)</tt> in all other cases.
+-</li>
+-</ul>
+ </blockquote>
++</li>
++</ol>
++
++
++
+
++
++<hr>
++<h3><a name="2464"></a>2464. <tt>try_emplace</tt> and <tt>insert_or_assign</tt> misspecified</h3>
++<p><b>Section:</b> 23.4.4.4 [map.modifiers], 23.5.4.4 [unord.map.modifiers] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Thomas Koeppe <b>Opened:</b> 2014-12-17 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all other</b> <a href="lwg-index.html#map.modifiers">issues</a> in [map.modifiers].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-The question is: What happens in the 3<sup><i>rd</i></sup> and
+-4<sup><i>th</i></sup> bullets when <tt>N &gt; 1</tt>?
++The specification of the <tt>try_emplace</tt> and <tt>insert_or_assign</tt> member functions in N4279
++contains the following errors and omissions:
+ </p>
++<ol>
++<li><p>In <tt>insert_or_assign</tt>, each occurrence of <tt>std::forward&lt;Args&gt;(args)...</tt>
++should be <tt>std::forward&lt;M&gt;(obj)</tt>; this is was a mistake introduced in editing.</p></li>
++
++<li><p>In <tt>try_emplace</tt>, the construction of the <tt>value_type</tt> is misspecified, which
++is a mistake that was introduced during the evolution from a one-parameter to a variadic form.
++As written, <tt>value_type(k, std::forward&lt;Args&gt;(args)...)</tt> does not do the right thing;
++it can only be used with a single argument, which moreover must be convertible to a <tt>mapped_type</tt>.
++The intention is to allow direct-initialization from an argument pack, and the correct constructor
++should be <tt>value_type(piecewise_construct, forward_as_tuple(k),
++forward_as_tuple(std::forward&lt;Args&gt;(args)...)</tt>.</p></li>
++
++<li><p> Both <tt>try_emplace</tt> and <tt>insert_or_assign</tt> are missing requirements on the
++argument types. Since the semantics of these functions are specified independent of other functions,
++they need to include their requirements.</p></li>
++</ol>
++
++<p><i>[2015-02, Cologne]</i></p>
+
+ <p>
+-Does the presence of <tt>t2, ..., tN</tt> get ignored, or does it make the
+-<tt><i>INVOKE</i></tt> ill formed?
+-</p>
++This issue is related to <a href="lwg-active.html#2469">2469</a>.
++<p/>
++AM: The repeated references to "first and third forms" and "second and fourth forms" is a bit cumbersome.
++Maybe split the four functions?<br/>
++GR: We don't have precendent for "EmplaceConstructible from a, b, c". I don't like the ambiguity between code commas and
++text commas.<br/>
++TK: What's the danger?<br/>
++GR: It's difficult to follow standardese.<br/>
++AM: It seems fine with code commas. What's the problem?<br/>
++GR: It will lead to difficulties when we use a similar construction that's not at the end of a sentence.<br/>
++AM: That's premature generalization. DK: When that happens, let's look at this again.<br/>
++AM: Clean up "if the map does contain"<br/>
++TK: Can we call both containers "map"? DK/GR: yes.<br/>
++TK will send updated wording to DK.
++<p/>
++Conclusion: Update wording, then poll for tentatively ready
++</p>
++
++<p><i>[2015-03-26, Thomas provides improved wording]</i></p>
+
+ <p>
+-Here is sample code which presents the problem in a concrete example:
++The approach is to split the descriptions of the various blocks of four functions into two blocks each so as to make
++the wording easier to follow.
+ </p>
+
+-<blockquote><pre>#include &lt;functional&gt;
+-#include &lt;cassert&gt;
++<strong>Previous resolution [SUPERSEDED]:</strong>
++<blockquote class="note">
++<p>This wording is relative to N4296.</p>
+
+-struct S {
+- char data;
+-};
++<ol>
++<li><p>Apply the following changes to section 23.4.4.4 [map.modifiers] p3:</p>
+
+-typedef char S::*PMD;
++<blockquote>
++<pre>
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(const key_type&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: For the first and third forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into map
++from <tt>piecewise_construct</tt>, <tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.
++For the second and fourth forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into map
++from <tt>piecewise_construct</tt>, <tt>forward_as_tuple(move(k))</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++-3- <i>Effects</i>: <del>If the key <tt>k</tt> already exists in the map, there is no effect. Otherwise, inserts an element
++into the map. In the first and third forms, the element is constructed from the arguments as <tt>value_type(k,
++std::forward&lt;Args&gt;(args)...)</tt>. In the second and fourth forms, the element is
++constructed from the arguments as <tt>value_type(std::move(k), std::forward&lt;Args&gt;(args)...)</tt>.
++In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only if the
++insertion took place. The returned iterator points to the element of the map whose key is equivalent to <tt>k</tt></del>
++<ins>If the map does already contain an element whose key is equivalent to <tt>k</tt>, there is no effect.
++Otherwise for the first and third forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with
++<tt>piecewise_construct</tt>, <tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>,
++for the second and fourth forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with
++<tt>piecewise_construct</tt>, <tt>forward_as_tuple(move(k))</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt>
++if and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to
++<tt>k</tt>.</ins>
++</p>
++</blockquote>
++</blockquote>
++</li>
+
+-int main()
+-{
+- S s;
+- PMD pmd = &amp;S::data;
+- std::reference_wrapper&lt;PMD&gt; r(pmd);
+- r(s, 3.0) = 'a'; // well formed?
+- assert(s.data == 'a');
+-}
+-</pre></blockquote>
++<li><p>Apply the following changes to section 23.4.4.4 [map.modifiers] p5:</p>
+
++<blockquote>
++<pre>
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(const key_type&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);
++</pre>
++<blockquote>
+ <p>
+-Without the "<tt>3.0</tt>" the example is well formed.
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;>::value</tt> shall be true.
++For the first and third forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into map from <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt>. For the second and fourth forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt>
++into map from <tt>move(k), forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++-5- <i>Effects</i>: <del>If the key <tt>k</tt> does not exist in the map, inserts an element into the map. In the first
++and third forms, the element is constructed from the arguments as <tt>value_type(k, std::forward&lt;Args&gt;(args)...)</tt>.
++In the second and fourth forms, the element is constructed from the arguments as <tt>value_type(std::move(k),
++std::forward&lt;Args&gt;(args)...)</tt>. If the key already exists, <tt>std::forward&lt;M&gt;(obj)</tt> is assigned to the
++<tt>mapped_type</tt> corresponding to the key. In the first two overloads, the <tt>bool</tt> component of the returned
++value is true if and only if the insertion took place. The returned iterator points to the element that
++was inserted or updated</del>
++<ins>If the map does already contain an element whose key is equivalent to <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt> is assigned to the <tt>mapped_type</tt> corresponding to the key.
++Otherwise the first and third forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt>, the second and fourth forms inserts a <tt>value_type</tt> object <tt>t</tt>
++constructed with <tt>move(k), forward&lt;M&gt;(obj)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt>
++if and only if the insertion took place. The returned iterator points to the element of the map whose key is equivalent to
++<tt>k</tt>.</ins>
+ </p>
++</blockquote>
++</blockquote>
++</li>
++
++<li><p>Apply the following changes to section 23.5.4.4 [unord.map.modifiers] p5:</p>
++
++<blockquote>
++<pre>
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(const key_type&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);
++</pre>
++<blockquote>
+ <p>
+-[Note: Daniel provided wording to make it explicit that the above example is ill-formed. — end note ]
++<ins>-?- <i>Requires</i>: For the first and third forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into unordered_map
++from <tt>piecewise_construct</tt>, <tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.
++For the second and fourth forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into unordered_map
++from <tt>piecewise_construct</tt>, <tt>forward_as_tuple(move(k))</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++-5- <i>Effects</i>: <del>If the key <tt>k</tt> already exists in the map, there is no effect. Otherwise, inserts an element
++into the map. In the first and third forms, the element is constructed from the arguments as <tt>value_type(k,
++std::forward&lt;Args&gt;(args)...)</tt>. In the second and fourth forms, the element is
++constructed from the arguments as <tt>value_type(std::move(k), std::forward&lt;Args&gt;(args)...)</tt>.
++In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only if the
++insertion took place. The returned iterator points to the element of the map whose key is equivalent to <tt>k</tt></del>
++<ins>If the unordered_map does already contain an element whose key is equivalent to <tt>k</tt>, there is no effect.
++Otherwise for the first and third forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with
++<tt>piecewise_construct</tt>, <tt>forward_as_tuple(k)</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>,
++for the second and fourth forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with
++<tt>piecewise_construct</tt>, <tt>forward_as_tuple(move(k))</tt>, <tt>forward_as_tuple(forward&lt;Args&gt;(args)...)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt>
++if and only if the insertion took place. The returned iterator points to the element of the unordered_map whose key is equivalent to
++<tt>k</tt>.</ins>
+ </p>
++</blockquote>
++</blockquote>
++</li>
+
+-<p><i>[
+-Post-Rapperswil
+-]</i></p>
+-
++<li><p>Apply the following changes to section 23.5.4.4 [unord.map.modifiers] p7:</p>
+
+ <blockquote>
+-Moved to Tentatively Ready after 5 positive votes on c++std-lib.
++<pre>
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(const key_type&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;>::value</tt> shall be true.
++For the first and third forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into unordered_map from <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt>. For the second and fourth forms, <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt>
++into unordered_map from <tt>move(k), forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++-7- <i>Effects</i>: <del>If the key <tt>k</tt> does not exist in the map, inserts an element into the map.
++In the first and third forms, the element is constructed from the arguments as <tt>value_type(k, std::forward&lt;Args&gt;(args)...)</tt>.
++In the second and fourth forms, the element is constructed from the arguments as <tt>value_type(std::move(k),
++std::forward&lt;Args&gt;(args)...)</tt>. If the key already exists, <tt>std::forward&lt;M&gt;(obj)</tt> is assigned to the
++<tt>mapped_type</tt> corresponding to the key. In the first two overloads, the <tt>bool</tt> component of the returned
++value is true if and only if the insertion took place. The returned iterator points to the element that
++was inserted or updated</del>
++<ins>If the unordered_map does already contain an element whose key is equivalent to <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt> is assigned to the <tt>mapped_type</tt> corresponding to the key.
++Otherwise the first and third forms inserts a <tt>value_type</tt> object <tt>t</tt> constructed with <tt>k</tt>,
++<tt>forward&lt;M&gt;(obj)</tt>, the second and fourth forms inserts a <tt>value_type</tt> object <tt>t</tt>
++constructed with <tt>move(k), forward&lt;M&gt;(obj)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt>
++if and only if the insertion took place. The returned iterator points to the element of the unordered_map whose key is
++equivalent to <tt>k</tt>.</ins>
++</p>
++</blockquote>
+ </blockquote>
++</li>
+
+-<p><i>[
+-Adopted at 2010-11 Batavia
+-]</i></p>
++</ol>
++</blockquote>
+
++<p><i>[2015-05, Lenexa]</i></p>
+
++<p>
++STL: existing wording is horrible, this is Thomas' wording and his issue<br/>
++STL: already implemented the piecewise part<br/>
++MC: ok with changes<br/>
++STL: changes are mechanical<br/>
++STL: believe this is P1, it must be fixed, we have wording<br/>
++PJP: functions are sensible<br/>
++STL: has been implemented<br/>
++MC: consensus is to move to ready
++</p>
+
+
+ <p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
+
+-<p><i>The wording refers to N3126.</i></p>
++<ol>
++<li><p>Apply the following changes to 23.4.4.4 [map.modifiers] p3+p4:</p>
+
++<blockquote>
++<pre>
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(const key_type&amp; k, Args&amp;&amp;... args);
++<del>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);</del>
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&amp;&amp;... args);
++<del>template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);</del>
++</pre>
++<blockquote>
+ <p>
+-Change 20.8.2 [func.require]/1 as indicated:
++<ins>-?- <i>Requires</i>: <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from
++<tt>piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++-3- <i>Effects</i>: <del>If the key <tt>k</tt> already exists in the map, there is no effect. Otherwise, inserts an element
++into the map. In the first and third forms, the element is constructed from the arguments as <tt>value_type(k,
++std::forward&lt;Args&gt;(args)...)</tt>. In the second and fourth forms, the element is
++constructed from the arguments as <tt>value_type(std::move(k), std::forward&lt;Args&gt;(args)...)</tt>.
++In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only if the
++insertion took place. The returned iterator points to the element of the map whose key is equivalent to <tt>k</tt></del>
++<ins>If the map already contains an element whose key is equivalent to <tt>k</tt>, there is no effect. Otherwise inserts an
++object of type <tt>value_type</tt> constructed with <tt>piecewise_construct, forward_as_tuple(k),
++forward_as_tuple(forward&lt;Args&gt;(args)...)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only
++if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++-4- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.
+ </p>
++</blockquote>
++
++<pre>
++<ins>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);</ins>
++</pre>
+ <blockquote>
+ <p>
+-1 Define <tt><i>INVOKE</i>(f, t1, t2, ..., tN)</tt> as follows:
++<ins>-?- <i>Requires</i>: <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from
++<tt>piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects</i>: If the map already contains an element whose key is equivalent to <tt>k</tt>, there is no effect.
++Otherwise inserts an object of type <tt>value_type</tt> constructed with <tt>piecewise_construct, forward_as_tuple(move(k)),
++forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only
++if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.</ins>
+ </p>
+-
+-<ul>
+-<li>
+-...
+-</li>
+-<li>
+-...
+-</li>
+-<li>
+-<tt>t1.*f</tt> when <ins><tt>N == 1</tt> and</ins> <tt>f</tt> is a pointer to
+-member data of a class <tt>T</tt> and <tt>t1</tt> is an object of type
+-<tt>T</tt> or a reference to an object of type <tt>T</tt> or a reference to an
+-object of a type derived from <tt>T</tt>;
++</blockquote>
++</blockquote>
+ </li>
+-<li>
+-<tt>(*t1).*f</tt> when <ins><tt>N == 1</tt> and</ins> <tt>f</tt> is a pointer to
+-member data of a class <tt>T</tt> and <tt>t1</tt> is not one of the types
+-described in the previous item;
++
++<li><p>Apply the following changes to 23.4.4.4 [map.modifiers] p5+p6:</p>
++
++<blockquote>
++<pre>
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(const key_type&amp; k, M&amp;&amp; obj);
++<del>template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);</del>
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj);
++<del>template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);</del>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;&gt;::value</tt> shall be <tt>true</tt>.
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from <tt>k, forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++-5- <i>Effects</i>: <del>If the key <tt>k</tt> does not exist in the map, inserts an element into the map. In the first
++and third forms, the element is constructed from the arguments as <tt>value_type(k, std::forward&lt;Args&gt;(args)...)</tt>.
++In the second and fourth forms, the element is constructed from the arguments as <tt>value_type(std::move(k),
++std::forward&lt;Args&gt;(args)...)</tt>. If the key already exists, <tt>std::forward&lt;M&gt;(obj)</tt> is assigned to the
++<tt>mapped_type</tt> corresponding to the key. In the first two overloads, the <tt>bool</tt> component of the returned
++value is true if and only if the insertion took place. The returned iterator points to the element that
++was inserted or updated</del>
++<ins>If the map already contains an element <tt>e</tt> whose key is equivalent to <tt>k</tt>, assigns <tt>forward&lt;M&gt;(obj)</tt>
++to <tt>e.second</tt>. Otherwise inserts an object of type <tt>value_type</tt> constructed with <tt>k, forward&lt;M&gt;(obj)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and
++only if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++-6- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.
++</p>
++</blockquote>
++<pre>
++<ins>template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;&gt;::value</tt> shall be <tt>true</tt>.
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>map</tt> from <tt>move(k), forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects</i>: If the map already contains an element <tt>e</tt> whose key is equivalent to <tt>k</tt>,
++assigns <tt>forward&lt;M&gt;(obj)</tt> to <tt>e.second</tt>. Otherwise inserts an object of type <tt>value_type</tt>
++constructed with <tt>move(k), forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only
++if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.</ins>
++</p>
++</blockquote>
++</blockquote>
+ </li>
+-<li>
+-...
++
++<li><p>Apply the following changes to 23.5.4.4 [unord.map.modifiers] p5+p6:</p>
++
++<blockquote>
++<pre>
++template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(const key_type&amp; k, Args&amp;&amp;... args);
++<del>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);</del>
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, const key_type&amp; k, Args&amp;&amp;... args);
++<del>template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);</del>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>unordered_map</tt> from
++<tt>piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++-5- <i>Effects</i>: <del>If the key <tt>k</tt> already exists in the map, there is no effect. Otherwise, inserts an element
++into the map. In the first and third forms, the element is constructed from the arguments as <tt>value_type(k,
++std::forward&lt;Args&gt;(args)...)</tt>. In the second and fourth forms, the element is
++constructed from the arguments as <tt>value_type(std::move(k), std::forward&lt;Args&gt;(args)...)</tt>.
++In the first two overloads, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only if the
++insertion took place. The returned iterator points to the element of the map whose key is equivalent to <tt>k</tt></del>
++<ins>If the map already contains an element whose key is equivalent to <tt>k</tt>, there is no effect. Otherwise inserts
++an object of type <tt>value_type</tt> constructed with <tt>piecewise_construct, forward_as_tuple(k),
++forward_as_tuple(forward&lt;Args&gt;(args)...)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only
++if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++-6- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.
++</p>
++</blockquote>
++<pre>
++<ins>template &lt;class... Args&gt; pair&lt;iterator, bool&gt; try_emplace(key_type&amp;&amp; k, Args&amp;&amp;... args);
++template &lt;class... Args&gt; iterator try_emplace(const_iterator hint, key_type&amp;&amp; k, Args&amp;&amp;... args);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>unordered_map</tt> from
++<tt>piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects</i>: If the map already contains an element whose key is equivalent to <tt>k</tt>, there is no effect.
++Otherwise inserts an object of type <tt>value_type</tt> constructed with <tt>piecewise_construct, forward_as_tuple(move(k)),
++forward_as_tuple(forward&lt;Args&gt;(args)...)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if and only
++if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.</ins>
++</p>
++</blockquote>
++</blockquote>
+ </li>
+-</ul>
++
++<li><p>Apply the following changes to 23.5.4.4 [unord.map.modifiers] p7+p8:</p>
++
++<blockquote>
++<pre>
++template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(const key_type&amp; k, M&amp;&amp; obj);
++<del>template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);</del>
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, const key_type&amp; k, M&amp;&amp; obj);
++<del>template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);</del>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;&gt;::value</tt> shall be <tt>true</tt>.
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>unordered_map</tt> from <tt>k,
++forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++-7- <i>Effects</i>: <del>If the key <tt>k</tt> does not exist in the map, inserts an element into the map.
++In the first and third forms, the element is constructed from the arguments as <tt>value_type(k, std::forward&lt;Args&gt;(args)...)</tt>.
++In the second and fourth forms, the element is constructed from the arguments as <tt>value_type(std::move(k),
++std::forward&lt;Args&gt;(args)...)</tt>. If the key already exists, <tt>std::forward&lt;M&gt;(obj)</tt> is assigned to the
++<tt>mapped_type</tt> corresponding to the key. In the first two overloads, the <tt>bool</tt> component of the returned
++value is true if and only if the insertion took place. The returned iterator points to the element that
++was inserted or updated</del>
++<ins>If the map already contains an element <tt>e</tt> whose key is equivalent to <tt>k</tt>, assigns <tt>forward&lt;M&gt;(obj)</tt>
++to <tt>e.second</tt>. Otherwise inserts an object of type <tt>value_type</tt> constructed with <tt>k, forward&lt;M&gt;(obj)</tt></ins>.
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if
++and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to <tt>k</tt>.</ins>
++<p/>
++-8- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.
++</p>
++</blockquote>
++<pre>
++<ins>template &lt;class M&gt; pair&lt;iterator, bool&gt; insert_or_assign(key_type&amp;&amp; k, M&amp;&amp; obj);
++template &lt;class M&gt; iterator insert_or_assign(const_iterator hint, key_type&amp;&amp; k, M&amp;&amp; obj);</ins>
++</pre>
++<blockquote>
++<p>
++<ins>-?- <i>Requires</i>: <tt>is_assignable&lt;mapped_type&amp;, M&amp;&amp;&gt;::value</tt> shall be <tt>true</tt>.
++<tt>value_type</tt> shall be <tt>EmplaceConstructible</tt> into <tt>unordered_map</tt> from <tt>move(k),
++forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++<ins>-?- <i>Effects</i>: If the map already contains an element <tt>e</tt> whose key is equivalent to <tt>k</tt>,
++assigns <tt>forward&lt;M&gt;(obj)</tt> to <tt>e.second</tt>. Otherwise inserts an object of type <tt>value_type</tt>
++constructed with <tt>move(k), forward&lt;M&gt;(obj)</tt>.</ins>
++<p/>
++<ins>-?- <i>Returns</i>: In the first overload, the <tt>bool</tt> component of the returned pair is <tt>true</tt> if
++and only if the insertion took place. The returned iterator points to the map element whose key is equivalent to
++<tt>k</tt>.</ins>
++<p/>
++<ins>-?- <i>Complexity</i>: The same as <tt>emplace</tt> and <tt>emplace_hint</tt>, respectively.</ins>
++</p>
++</blockquote>
+ </blockquote>
++</li>
+
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="1522"></a>1522. <tt>conj</tt> specification is now nonsense</h3>
+-<p><b>Section:</b> 26.4.9 [cmplx.over] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#WP">WP</a>
+- <b>Submitter:</b> P.J. Plauger <b>Opened:</b> 2010-10-14 <b>Last modified:</b> 2010-11-24</p>
+-<p><b>View all other</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-index.html#cmplx.over">issues</a> in [cmplx.over].</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#WP">WP</a> status.</p>
++<h3><a name="2467"></a>2467. <tt>is_always_equal</tt> has slightly inconsistent default</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements], 20.7.8.1 [allocator.traits.types] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Howard Hinnant <b>Opened:</b> 2015-01-18 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-In Pittsburgh, we accepted the resolution of library issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1137">1137</a>, to add
+-a sentence 3 to [cmplx.over]:
++Table 28 &mdash; "Allocator requirements" says that <tt>X::is_always_equal</tt> has a default value
++of <tt>is_empty&lt;X&gt;</tt>, and this is consistent with the return type description:
+ </p>
+ <blockquote>
+-All the specified overloads shall have a return type which is the nested
+-<tt>value_type</tt> of the effectively cast arguments.
++<p>
++Identical to or derived from <tt>true_type</tt> or <tt>false_type</tt>
++</p>
+ </blockquote>
+ <p>
+-This was already true for four of the six functions except <tt>conj</tt> and
+-<tt>proj</tt>. It is not completely unreasonable to make <tt>proj</tt> return
+-the real value only, but the IEC specification does call for an imaginary part
+-of -0 in some circumstances. The people who care about these distinctions really
+-care, and it <em>is</em> required by an international standard.
++<tt>is_empty&lt;X&gt;</tt> is guaranteed to be derived from either <tt>true_type</tt> or <tt>false_type</tt>.
++So far so good.
++<p/>
++20.7.8.1 [allocator.traits.types]/p10 says:
+ </p>
++<blockquote>
++<pre>
++typedef <i>see below</i> is_always_equal;
++</pre>
++<blockquote>
+ <p>
+-Making <tt>conj</tt> return just the real part breaks it horribly, however. It is
+-well understood in mathematics that <tt>conj(re + i*im)</tt> is <tt>(re - i*im)</tt>,
+-and it is widely used. The accepted new definition makes <tt>conj</tt> useful only
+-for pure real operations. This botch <em>absolutely must</em> be fixed.
++<i>Type</i>: <tt>Alloc::is_always_equal</tt> if the qualified-id <tt>Alloc::is_always_equal</tt> is valid and denotes a
++type (14.8.2); otherwise <tt>is_empty&lt;Alloc&gt;::type</tt>.
++</p>
++</blockquote>
++</blockquote>
++<p>
++This is subtly different than what Table 28 says is the default: <tt>is_empty&lt;Alloc&gt;::type</tt> is
++not <tt>is_empty&lt;Alloc&gt;</tt>, but is rather one of <tt>true_type</tt> or <tt>false_type</tt>.
++<p/>
++There are two ways to fix this:
+ </p>
++<ol>
++<li>
++<p>
++Change Table 28 to say: <tt>is_empty&lt;X&gt;<ins>::type</ins></tt>.
++<p/>
++or
++</p></li>
+
+-<p><i>[
+-2010 Batavia: The working group concurred with the issue's Proposed Resolution
+-]</i></p>
++<li><p>Change 20.7.8.1 [allocator.traits.types]/p10:</p></li>
++<blockquote>
++<p>
++<i>Type</i>: <tt>Alloc::is_always_equal</tt> if the qualified-id <tt>Alloc::is_always_equal</tt> is valid and denotes a
++type (14.8.2); otherwise <tt>is_empty&lt;Alloc&gt;<del>::type</del></tt>.
++</p>
++</blockquote>
++</ol>
++<p>
++Both options are correct, and I see no reason to prefer one fix over the other. But Table 28 and
++20.7.8.1 [allocator.traits.types]/p10 should be consistent with one another.
++</p>
+
++<p><i>[2015-02 Cologne]</i></p>
+
+-<p><i>[
+-Adopted at 2010-11 Batavia
+-]</i></p>
++<p>
++DK: We should accept the first bullet. GR: Why does <tt>is_empty</tt> even have a type member? AM: All type traits
++have a type member. I agree with DK's preference for the first type.
++</p>
+
+
++<p><b>Proposed resolution:</b></p>
++<p>
++This wording is relative to N4296.
++</p>
+
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements], Table 28 &mdash; "Allocator requirements" as presented:</p>
+
+-<p><b>Proposed resolution:</b></p>
++<blockquote>
++<table border="1">
++<caption>Table 28 &mdash; Allocator requirements</caption>
++<tr>
++<th>Expression</th>
++<th>Return type</th>
++<th>Assertion&#47;note<br/>pre-&#47;post-condition</th>
++<th>Default</th>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>X::is_always_equal</tt>
++</td>
++<td>
++Identical to or derived<br/>
++from <tt>true_type</tt> or<br/>
++<tt>false_type</tt>
++</td>
++<td>
++[&hellip;]
++</td>
++<td>
++<tt>is_empty&lt;X&gt;<ins>::type</ins></tt>
++</td>
++</tr>
++
++<tr>
++<td colspan="4" align="center">
++<tt>&hellip;</tt>
++</td>
++</tr>
++
++</table>
++</blockquote>
++
++</li>
++</ol>
++
++
++
++
++
++<hr>
++<h3><a name="2470"></a>2470. Allocator's <tt>destroy</tt> function should be allowed to fail to instantiate</h3>
++<p><b>Section:</b> 17.6.3.5 [allocator.requirements] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Daniel Kr&uuml;gler <b>Opened:</b> 2015-03-22 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#allocator.requirements">active issues</a> in [allocator.requirements].</p>
++<p><b>View all other</b> <a href="lwg-index.html#allocator.requirements">issues</a> in [allocator.requirements].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-Remove the recently added paragraph 3 from [cmplx.over]:
++This issue is a spin-off of issue LWG <a href="lwg-active.html#2447">2447</a>: It focuses on the observation that
++17.6.3.5 [allocator.requirements] p9 (based on the numbering of working draft N4296) gives
++the template member <tt>construct</tt> more relaxations than the template member <tt>destroy</tt>:
+ </p>
+ <blockquote>
+-<del>3 All the specified overloads shall have a return type which is the nested
+-<tt>value_type</tt> of the effectively cast arguments.</del>
++<p>
++An allocator may constrain the types on which it can be instantiated and the arguments for which its
++<tt>construct</tt> member may be called. If a type cannot be used with a particular allocator, the allocator class
++or the call to <tt>construct</tt> may fail to instantiate.
++</p>
+ </blockquote>
++<p>
++Construction and destruction of a type <tt>T</tt> are usually intimately related to each other, so it
++seems similarly useful to allow the <tt>destroy</tt> member to fail to instantiate for a possible sub-set
++of instantiation types.
++</p>
++
++<p><i>[2015-04-01 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
++</p>
++
++
++<p><b>Proposed resolution:</b></p>
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 17.6.3.5 [allocator.requirements] p9 as indicated:</p>
++
++<blockquote><p>
++-8- An allocator may constrain the types on which it can be instantiated and the arguments for which its
++<tt>construct</tt> <ins>or <tt>destroy</tt></ins> member<ins>s</ins> may be called. If a type cannot be
++used with a particular allocator, the allocator class or the call to <tt>construct</tt> <ins>or <tt>destroy</tt></ins>
++may fail to instantiate.
++</p></blockquote>
++</li>
++</ol>
+
+
+
+
+
+ <hr>
+-<h3><a name="2002"></a>2002. Class template <tt>match_results</tt> does not specify the semantics of <tt>operator==</tt></h3>
+-<p><b>Section:</b> 28.10.8 [re.results.nonmember] <b>Status:</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#Resolved">Resolved</a>
+- <b>Submitter:</b> Daniel Krügler <b>Opened:</b> 2010-10-24 <b>Last modified:</b> 2010-11-26</p>
+-<p><b>View all issues with</b> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-status.html#Resolved">Resolved</a> status.</p>
++<h3><a name="2482"></a>2482. [c.strings] Table 73 mentions nonexistent functions</h3>
++<p><b>Section:</b> 21.8 [c.strings] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> S. B.Tam <b>Opened:</b> 2015-01-18 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View other</b> <a href="lwg-index-open.html#c.strings">active issues</a> in [c.strings].</p>
++<p><b>View all other</b> <a href="lwg-index.html#c.strings">issues</a> in [c.strings].</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
+ <p><b>Discussion:</b></p>
+ <p>
+-The <em>Returns</em> element of <tt>operator==</tt> says:
++N4296 Table 73 mentions the functions <tt>mbsrtowc</tt> and <tt>wcsrtomb</tt>, which are not defined in ISO C
++or ISO C++. Presumably they should be <tt>mbsrtowcs</tt> and <tt>wcsrtombs</tt> instead.
++</p>
++
++<p><i>[2015-04-02 Library reflector vote]</i></p>
++
++<p>
++The issue has been identified as Tentatively Ready based on six votes in favour.
+ </p>
+
++
++<p><b>Proposed resolution:</b></p>
++
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li>
+ <blockquote>
+-<tt>true</tt> only if the two objects refer to the same match
++<table border="1" cellpadding="4" rules="groups" style="table-layout:fixed">
++<caption>Table 33 &mdash; Potential <tt>mbstate_t</tt> data races</caption>
++<tr>
++<td>
++<tt>mbrlen</tt>
++</td>
++<td>
++<tt>mbrtowc</tt>
++</td>
++<td>
++<tt>mbsrtowc<ins>s</ins></tt>
++</td>
++<td>
++<tt>mbtowc</tt>
++</td>
++<td>
++<tt>wcrtomb</tt>
++</td>
++</tr>
++
++<tr>
++<td>
++<tt>wcsrtomb<ins>s</ins></tt>
++</td>
++<td>
++<tt>wctomb</tt>
++</td>
++</tr>
++
++</table>
+ </blockquote>
++</li>
++</ol>
++
++
++
+
++
++
++<hr>
++<h3><a name="2488"></a>2488. Placeholders should be allowed and encouraged to be <tt>constexpr</tt></h3>
++<p><b>Section:</b> 20.9.10.4 [func.bind.place] <b>Status:</b> <a href="lwg-active.html#WP">WP</a>
++ <b>Submitter:</b> Stephan T. Lavavej <b>Opened:</b> 2015-03-27 <b>Last modified:</b> 2015-05-22</p>
++<p><b>View all issues with</b> <a href="lwg-status.html#WP">WP</a> status.</p>
++<p><b>Discussion:</b></p>
+ <p>
+-It is not really clear what this means: The current specification would allow for an
+-implementation to return <tt>true</tt>, only if the address values of <tt>m1</tt> and
+-<tt>m2</tt> are the same. While this approach is unproblematic in terms of used operations
+-this is also a bit unsatisfactory. With identity equality alone there seems to be no convincing
+-reason to provide this operator at all. It could for example also refer to an comparison based
+-on iterator values. In this case a user should better know that this will be done, because
+-there is no guarantee at all that inter-container comparison of iterators
+-is a feasible operation. This was a clear outcome of the resolution provided in
+-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3066.html">N3066</a>
+-for LWG issue <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#446">446</a>.
+-It could also mean that a character-based comparison of the individual <tt>sub_match</tt>
+-elements should be done - this would be equivalent to applying <tt>operator==</tt> to
+-the subexpressions, prefix and suffix.
++<tt>piecewise_construct</tt> (20.3.5 [pair.piecewise]), <tt>allocator_arg</tt> (20.7.6 [allocator.tag]),
++and <tt>adopt_lock</tt>/<tt>defer_lock</tt>/<tt>try_to_lock</tt> (30.4.2 [thread.lock]) are all required to be
++<tt>constexpr</tt> with internal linkage. <tt>bind()</tt>'s placeholders should be allowed to follow this modern practice,
++for increased consistency and reduced implementer headaches (header-only is easier than separately-compiled).
+ </p>
+
++<p><i>[2015-05-07 Lenexa: Move to Immediate]</i></p>
++
++<p>STL: I'd like this one immediate.</p>
++<p>Jonathan: I want to think about forcing constexpr, but the current issue, I have no objections. I'd say ready, but I won't object to immediate if STL wants it.</p>
++<p>Marshall: You should report in Kona how it worked out.</p>
++<p>STL: We went around a bit on the reflector about how to phrase the encouragement.</p>
++<p>Jonathan: I think the shall may be not quite right.</p>
++<p>Marshall: I see, you can change your implementation, but you don't.</p>
++<p>Jonathan: There's precedent for the shall, but it's wrong, see editorial issue 493.</p>
++<p>STL: I would prefer not to ask Daniel to reword, and 493 can fix it later.</p>
++<p>Marshall: I remove my objection to immediate because it doesn't force implementations to change.</p>
++<p>Marshall: Any other discussion?</p>
++<p>Marshall: Immediate vote: 6. Opposed, 0. Abstain, 1.</p>
++
+
+
+ <p><b>Proposed resolution:</b></p>
+-Addressed by paper <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3158.html">n3158</a>.
++<p>This wording is relative to N4296.</p>
++
++<ol>
++<li><p>Change 20.9 [function.objects] p2 "Header <tt>&lt;functional&gt;</tt> synopsis" as depicted:</p>
++
++<blockquote>
++<pre>
++namespace placeholders {
++ <i>// M is the implementation-defined number of placeholders</i>
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _1;
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _2;
++ ...
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _M;
++}
++</pre>
++</blockquote>
++</li>
+
++<li><p>Change 20.9.10.4 [func.bind.place] p2 as depicted:</p>
++
++<blockquote>
++<pre>
++namespace std::placeholders {
++ <i>// M is the implementation-defined number of placeholders</i>
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _1;
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _2;
++ .
++ .
++ .
++ <ins><i>see below</i></ins><del>extern <i>unspecified</i></del> _M;
++}
++</pre>
++<p>
++-1- All placeholder types shall be <tt>DefaultConstructible</tt> and <tt>CopyConstructible</tt>, and
++their default constructors and copy/move constructors shall not throw exceptions. It is
++implementation-defined whether placeholder types are <tt>CopyAssignable</tt>. <tt>CopyAssignable</tt>
++placeholders' copy assignment operators shall not throw exceptions.
++<p/>
++<ins>-?- Placeholders should be defined as:</ins>
++</p>
++<blockquote>
++<pre>
++<ins>constexpr <i>unspecified</i> _1{};</ins>
++</pre>
++</blockquote>
++<p>
++<ins>If they are not, they shall be declared as:</ins>
++</p>
++<blockquote>
++<pre>
++<ins>extern <i>unspecified</i> _1;</ins>
++</pre>
++</blockquote>
++</blockquote>
++</li>
++</ol>
+
+
+
+
+
+
+-</body></html>
+\ No newline at end of file
++</body>
++</html>
+diff --git a/libstdc++-v3/doc/html/manual/bugs.html b/libstdc++-v3/doc/html/manual/bugs.html
+index 16dda6a..d1ef5ae 100644
+--- a/libstdc++-v3/doc/html/manual/bugs.html
++++ b/libstdc++-v3/doc/html/manual/bugs.html
+@@ -259,6 +259,9 @@
+ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#438" target="_top">438</a>:
+ <span class="emphasis"><em>Ambiguity in the "do the right thing" clause</em></span>
+ </span></dt><dd><p>Implement the resolution, basically cast less.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#445" target="_top">445</a>:
++ <span class="emphasis"><em>iterator_traits::reference unspecified for some iterator categories</em></span>
++ </span></dt><dd><p>Change <code class="code">istreambuf_iterator::reference</code> in C++11 mode.
+ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#453" target="_top">453</a>:
+ <span class="emphasis"><em>basic_stringbuf::seekoff need not always fail for an empty stream</em></span>
+ </span></dt><dd><p>Don't fail if the next pointer is null and newoff is zero.
+@@ -269,6 +272,9 @@
+ <span class="emphasis"><em>Suggestion for new member functions in standard containers</em></span>
+ </span></dt><dd><p>Add <code class="code">data()</code> to <code class="code">std::vector</code> and
+ <code class="code">at(const key_type&amp;)</code> to <code class="code">std::map</code>.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#467" target="_top">467</a>:
++ <span class="emphasis"><em>char_traits::lt(), compare(), and memcmp()</em></span>
++ </span></dt><dd><p>Change <code class="code">lt</code>.
+ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#508" target="_top">508</a>:
+ <span class="emphasis"><em>Bad parameters for ranlux64_base_01</em></span>
+ </span></dt><dd><p>Fix the parameters.
+@@ -348,4 +354,74 @@
+ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#1339" target="_top">1339</a>:
+ <span class="emphasis"><em>uninitialized_fill_n should return the end of its range</em></span>
+ </span></dt><dd><p>Return the end of the filled range.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2049" target="_top">2049</a>:
++ <span class="emphasis"><em><code class="code">is_destructible</code> underspecified</em></span>
++ </span></dt><dd><p>Handle non-object types.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2056" target="_top">2056</a>:
++ <span class="emphasis"><em>future_errc enums start with value 0 (invalid value for broken_promise)</em></span>
++ </span></dt><dd><p>Reorder enumerators.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2059" target="_top">2059</a>:
++ <span class="emphasis"><em>C++0x ambiguity problem with map::erase</em></span>
++ </span></dt><dd><p>Add additional overloads.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2062" target="_top">2062</a>:
++ <span class="emphasis"><em>2062. Effect contradictions w/o no-throw guarantee of <code class="code">std::function</code> swaps</em></span>
++ </span></dt><dd><p>Add <code class="code">noexcept</code> to swap functions.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2063" target="_top">2063</a>:
++ <span class="emphasis"><em>Contradictory requirements for string move assignment</em></span>
++ </span></dt><dd><p>Respect propagation trait for move assignment.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2064" target="_top">2064</a>:
++ <span class="emphasis"><em>More noexcept issues in basic_string</em></span>
++ </span></dt><dd><p>Add noexcept to the comparison operators.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2067" target="_top">2067</a>:
++ <span class="emphasis"><em>packaged_task should have deleted copy c'tor with const parameter</em></span>
++ </span></dt><dd><p>Fix signatures.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2101" target="_top">2101</a>:
++ <span class="emphasis"><em>Some transformation types can produce impossible types</em></span>
++ </span></dt><dd><p>Use the referenceable type concept.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2106" target="_top">2106</a>:
++ <span class="emphasis"><em>move_iterator wrapping iterators returning prvalues</em></span>
++ </span></dt><dd><p>Change the <code class="code">reference</code> type.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2132" target="_top">2132</a>:
++ <span class="emphasis"><em><code class="code">std::function</code> ambiguity</em></span>
++ </span></dt><dd><p>Constrain the constructor to only accept callable types.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2141" target="_top">2141</a>:
++ <span class="emphasis"><em><code class="code">common_type</code> trait produces reference types</em></span>
++ </span></dt><dd><p>Use <code class="code">decay</code> for the result type.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2144" target="_top">2144</a>:
++ <span class="emphasis"><em>Missing <code class="code">noexcept</code> specification in <code class="code">type_index</code></em></span>
++ </span></dt><dd><p>Add <code class="code">noexcept</code>
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2145" target="_top">2145</a>:
++ <span class="emphasis"><em><code class="code">error_category</code> default constructor</em></span>
++ </span></dt><dd><p>Declare a public constexpr constructor.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2162" target="_top">2162</a>:
++ <span class="emphasis"><em><code class="code">allocator_traits::max_size</code> missing <code class="code">noexcept</code></em></span>
++ </span></dt><dd><p>Add <code class="code">noexcept</code>.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2187" target="_top">2187</a>:
++ <span class="emphasis"><em><code class="code">vector&lt;bool&gt;</code> is missing <code class="code">emplace</code> and <code class="code">emplace_back</code> member functions</em></span>
++ </span></dt><dd><p>Add <code class="code">emplace</code> and <code class="code">emplace_back</code> member functions.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2196" target="_top">2196</a>:
++ <span class="emphasis"><em>Specification of <code class="code">is_*[copy/move]_[constructible/assignable]</code> unclear for non-referencable types</em></span>
++ </span></dt><dd><p>Use the referenceable type concept.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2313" target="_top">2313</a>:
++ <span class="emphasis"><em><code class="code">tuple_size</code> should always derive from <code class="code">integral_constant&lt;size_t, N&gt;</code></em></span>
++ </span></dt><dd><p>Update definitions of the partial specializations for const and volatile types.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2329" target="_top">2329</a>:
++ <span class="emphasis"><em><code class="code">regex_match()/regex_search()</code> with <code class="code">match_results</code> should forbid temporary strings</em></span>
++ </span></dt><dd><p>Add deleted overloads for rvalue strings.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2332" target="_top">2332</a>:
++ <span class="emphasis"><em><code class="code">regex_iterator/regex_token_iterator</code> should forbid temporary regexes</em></span>
++ </span></dt><dd><p>Add deleted constructors.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2399" target="_top">2399</a>:
++ <span class="emphasis"><em><code class="code">shared_ptr</code>'s constructor from <code class="code">unique_ptr</code> should be constrained</em></span>
++ </span></dt><dd><p>Constrain the constructor to require convertibility.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2400" target="_top">2400</a>:
++ <span class="emphasis"><em><code class="code">shared_ptr</code>'s <code class="code">get_deleter()</code> should use <code class="code">addressof()</code></em></span>
++ </span></dt><dd><p>Use <code class="code">addressof</code>.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2401" target="_top">2401</a>:
++ <span class="emphasis"><em><code class="code">std::function</code> needs more <code class="code">noexcept</code></em></span>
++ </span></dt><dd><p>Add <code class="code">noexcept</code> to the assignment and comparisons.
++ </p></dd><dt><span class="term"><a class="link" href="../ext/lwg-defects.html#2455" target="_top">2455</a>:
++ <span class="emphasis"><em>Allocator default construction should be allowed to throw
++ </em></span>
++ </span></dt><dd><p>Make <code class="code">noexcept</code> specifications conditional.
+ </p></dd></dl></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="license.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="status.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="setup.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">License </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Chapter 2. Setup</td></tr></table></div></body></html>
+\ No newline at end of file
+diff --git a/libstdc++-v3/doc/html/manual/source_organization.html b/libstdc++-v3/doc/html/manual/source_organization.html
+index 1ff2397..a5dc968 100644
+--- a/libstdc++-v3/doc/html/manual/source_organization.html
++++ b/libstdc++-v3/doc/html/manual/source_organization.html
+@@ -3,94 +3,95 @@
+ Contributing
+
+ </th><td width="20%" align="right"> <a accesskey="n" href="source_code_style.html">Next</a></td></tr></table><hr /></div><div class="section"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="contrib.organization"></a>Directory Layout and Source Conventions</h2></div></div></div><p>
+- The unpacked source directory of libstdc++ contains the files
+- needed to create the GNU C++ Library.
+- </p><div class="literallayout"><p><br />
+-It has subdirectories:<br />
+-<br />
+-  doc<br />
+-    Files in HTML and text format that document usage, quirks of the<br />
+-    implementation, and contributor checklists.<br />
+-<br />
+-  include<br />
+-    All header files for the C++ library are within this directory,<br />
+-    modulo specific runtime-related files that are in the libsupc++<br />
+-    directory.<br />
+-<br />
+-    include/std<br />
+-      Files meant to be found by #include &lt;name&gt; directives in<br />
+-      standard-conforming user programs.<br />
+-<br />
+-    include/c<br />
+-      Headers intended to directly include standard C headers.<br />
+-      [NB: this can be enabled via --enable-cheaders=c]<br />
+-<br />
+-    include/c_global<br />
+-      Headers intended to include standard C headers in<br />
+-      the global namespace, and put select names into the std::<br />
+-      namespace.  [NB: this is the default, and is the same as<br />
+-      --enable-cheaders=c_global]<br />
+-<br />
+-    include/c_std<br />
+-      Headers intended to include standard C headers<br />
+-      already in namespace std, and put select names into the std::<br />
+-      namespace.  [NB: this is the same as --enable-cheaders=c_std]<br />
+-<br />
+-    include/bits<br />
+-      Files included by standard headers and by other files in<br />
+-      the bits directory.<br />
+-<br />
+-    include/backward<br />
+-      Headers provided for backward compatibility, such as &lt;iostream.h&gt;.<br />
+-      They are not used in this library.<br />
+-<br />
+-    include/ext<br />
+-      Headers that define extensions to the standard library.  No<br />
+-      standard header refers to any of them.<br />
+-<br />
+-  scripts<br />
+-    Scripts that are used during the configure, build, make, or test<br />
+-    process.<br />
+-<br />
+-  src<br />
+-    Files that are used in constructing the library, but are not<br />
+-    installed.<br />
+-<br />
+-  testsuites/[backward, demangle, ext, performance, thread, 17_* to 30_*]<br />
+-    Test programs are here, and may be used to begin to exercise the<br />
+-    library.  Support for "make check" and "make check-install" is<br />
+-    complete, and runs through all the subdirectories here when this<br />
+-    command is issued from the build directory.  Please note that<br />
+-    "make check" requires DejaGNU 1.4 or later to be installed.  Please<br />
+-    note that "make check-script" calls the script mkcheck, which<br />
+-    requires bash, and which may need the paths to bash adjusted to<br />
+-    work properly, as /bin/bash is assumed.<br />
+-<br />
+-Other subdirectories contain variant versions of certain files<br />
+-that are meant to be copied or linked by the configure script.<br />
+-Currently these are:<br />
+-<br />
+-  config/abi<br />
+-  config/cpu<br />
+-  config/io<br />
+-  config/locale<br />
+-  config/os<br />
+-<br />
+-In addition, a subdirectory holds the convenience library libsupc++.<br />
+-<br />
+-  libsupc++<br />
+-    Contains the runtime library for C++, including exception<br />
+-    handling and memory allocation and deallocation, RTTI, terminate<br />
+-    handlers, etc.<br />
+-<br />
+-Note that glibc also has a bits/ subdirectory.  We will either<br />
+-need to be careful not to collide with names in its bits/<br />
+-directory; or rename bits to (e.g.) cppbits/.<br />
+-<br />
+-In files throughout the system, lines marked with an "XXX" indicate<br />
+-a bug or incompletely-implemented feature.  Lines marked "XXX MT"<br />
+-indicate a place that may require attention for multi-thread safety.<br />
+-  </p></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="appendix_contributing.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="source_code_style.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Appendix A. 
++ The <code class="filename">libstdc++-v3</code> directory in the
++ GCC sources contains the files needed to create the GNU C++ Library.
++ </p><p>
++It has subdirectories:
++</p><div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="filename">doc</code></span></dt><dd>
++ Files in HTML and text format that document usage, quirks of the
++ implementation, and contributor checklists.
++ </dd><dt><span class="term"><code class="filename">include</code></span></dt><dd>
++ All header files for the C++ library are within this directory,
++ modulo specific runtime-related files that are in the libsupc++
++ directory.
++
++ <div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="filename">include/std</code></span></dt><dd>
++ Files meant to be found by <code class="code">#include &lt;name&gt;</code> directives
++ in standard-conforming user programs.
++ </dd><dt><span class="term"><code class="filename">include/c</code></span></dt><dd>
++ Headers intended to directly include standard C headers.
++ [NB: this can be enabled via <code class="option">--enable-cheaders=c</code>]
++ </dd><dt><span class="term"><code class="filename">include/c_global</code></span></dt><dd>
++ Headers intended to include standard C headers in
++ the global namespace, and put select names into the <code class="code">std::</code>
++ namespace. [NB: this is the default, and is the same as
++ <code class="option">--enable-cheaders=c_global</code>]
++ </dd><dt><span class="term"><code class="filename">include/c_std</code></span></dt><dd>
++ Headers intended to include standard C headers
++ already in namespace std, and put select names into the <code class="code">std::</code>
++ namespace. [NB: this is the same as
++ <code class="option">--enable-cheaders=c_std</code>]
++ </dd><dt><span class="term"><code class="filename">include/bits</code></span></dt><dd>
++ Files included by standard headers and by other files in
++ the bits directory.
++ </dd><dt><span class="term"><code class="filename">include/backward</code></span></dt><dd>
++ Headers provided for backward compatibility, such as
++ <code class="filename">&lt;backward/hash_map&gt;</code>.
++ They are not used in this library.
++ </dd><dt><span class="term"><code class="filename">include/ext</code></span></dt><dd>
++ Headers that define extensions to the standard library. No
++ standard header refers to any of them, in theory (there are some
++ exceptions).
++ </dd></dl></div></dd><dt><span class="term"><code class="filename">scripts</code></span></dt><dd>
++ Scripts that are used during the configure, build, make, or test
++ process.
++ </dd><dt><span class="term"><code class="filename">src</code></span></dt><dd>
++ Files that are used in constructing the library, but are not
++ installed.
++
++ <div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="filename">src/c++98</code></span></dt><dd>
++ Source files compiled using <code class="option">-std=gnu++98</code>.
++ </dd><dt><span class="term"><code class="filename">src/c++11</code></span></dt><dd>
++ Source files compiled using <code class="option">-std=gnu++11</code>.
++ </dd><dt><span class="term"><code class="filename">src/filesystem</code></span></dt><dd>
++ Source files for the Filesystem TS.
++ </dd><dt><span class="term"><code class="filename">src/shared</code></span></dt><dd>
++ Source code included by other files under both
++ <code class="filename">src/c++98</code> and
++ <code class="filename">src/c++11</code></dd></dl></div></dd><dt><span class="term"><code class="filename">testsuites/[backward, demangle, ext, performance, thread, 17_* to 30_*]</code></span></dt><dd>
++ Test programs are here, and may be used to begin to exercise the
++ library. Support for "make check" and "make check-install" is
++ complete, and runs through all the subdirectories here when this
++ command is issued from the build directory. Please note that
++ "make check" requires DejaGNU 1.4 or later to be installed.
++ </dd></dl></div><p>
++Other subdirectories contain variant versions of certain files
++that are meant to be copied or linked by the configure script.
++Currently these are:
++</p><div class="literallayout"><p><code class="filename">config/abi</code><br />
++<code class="filename">config/allocator</code><br />
++<code class="filename">config/cpu</code><br />
++<code class="filename">config/io</code><br />
++<code class="filename">config/locale</code><br />
++<code class="filename">config/os</code><br />
++</p></div><p>
++</p><p>
++In addition, a subdirectory holds the convenience library libsupc++.
++</p><div class="variablelist"><dl class="variablelist"><dt><span class="term"><code class="filename">libsupc++</code></span></dt><dd>
++ Contains the runtime library for C++, including exception
++ handling and memory allocation and deallocation, RTTI, terminate
++ handlers, etc.
++ </dd></dl></div><p>
++Note that glibc also has a <code class="filename">bits/</code>
++subdirectory. We need to be careful not to collide with names in its
++<code class="filename">bits/</code> directory.
++Another solution would be to rename <code class="filename">bits</code>
++to (e.g.) <code class="filename">cppbits</code>.
++</p><p>
++In files throughout the system, lines marked with an "XXX" indicate
++a bug or incompletely-implemented feature. Lines marked "XXX MT"
++indicate a place that may require attention for multi-thread safety.
++</p></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="appendix_contributing.html">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="appendix_contributing.html">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="source_code_style.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Appendix A. 
+ Contributing
+
+  </td><td width="20%" align="center"><a accesskey="h" href="../index.html">Home</a></td><td width="40%" align="right" valign="top"> Coding Style</td></tr></table></div></body></html>
+\ No newline at end of file
+diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html
+index f9e240e..f82a3c5 100644
+--- a/libstdc++-v3/doc/html/manual/status.html
++++ b/libstdc++-v3/doc/html/manual/status.html
+@@ -156,8 +156,7 @@ options. The pre-defined symbol
+ <code class="constant">__cplusplus</code> is used to check for the
+ presence of the required flag.
+ </p><p>
+-This page describes the C++11 support in mainline GCC SVN, not in any
+-particular release.
++This page describes the C++11 support in the GCC 5 series.
+ </p><div class="table"><a id="table.cxx11_status"></a><p class="title"><strong>Table 1.2. C++ 2011 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 2011 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Section</th><th align="left">Description</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left">
+ <span class="emphasis"><em>18</em></span>
+ </td><td colspan="3" align="left">
+@@ -335,8 +334,7 @@ options. The pre-defined symbol
+ <code class="constant">__cplusplus</code> is used to check for the
+ presence of the required flag.
+ </p><p>
+-This page describes the C++14 and library TS support in mainline GCC SVN,
+-not in any particular release.
++This page describes the C++14 and library TS support in the GCC 5 series.
+ </p><div class="table"><a id="table.cxx14_status"></a><p class="title"><strong>Table 1.3. C++ 2014 Implementation Status</strong></p><div class="table-contents"><table summary="C++ 2014 Implementation Status" border="1"><colgroup><col align="left" class="c1" /><col align="left" class="c2" /><col align="left" class="c3" /><col align="left" class="c4" /></colgroup><thead><tr><th align="left">Paper</th><th align="left">Title</th><th align="left">Status</th><th align="left">Comments</th></tr></thead><tbody><tr><td align="left">
+ <a class="link" href="http://www.open-std.org/JTC1/sc22/WG21/docs/papers/2013/n3669.pdf" target="_top">
+ N3669
+diff --git a/libstdc++-v3/doc/xml/api.xml b/libstdc++-v3/doc/xml/api.xml
+index f9478c3..7ed0179 100644
+--- a/libstdc++-v3/doc/xml/api.xml
++++ b/libstdc++-v3/doc/xml/api.xml
+@@ -40,79 +40,15 @@
+ </para>
+
+ <para>
+- The API documentation, rendered into HTML, can be viewed online:
++ The API documentation, rendered into HTML, can be viewed online
++ <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/">for each GCC release</link>
++ and
++ <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/index.html">
++ for the main development tree
++ </link>
++ (see the date on the first page).
+ </para>
+
+-<itemizedlist>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-3.4/index.html">for the 3.4 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.1/index.html">for the 4.1 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.2/index.html">for the 4.2 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.3/index.html">for the 4.3 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.4/index.html">for the 4.4 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.5/index.html">for the 4.5 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.6/index.html">for the 4.6 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/gcc-4.7.4/libstdc++/api/">for the 4.7.4 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/">for the 4.8.3 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/">for the 4.9.0 release
+- </link>
+- </para>
+- </listitem>
+- <listitem>
+- <para>
+- <link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/index.html">"the latest collection"
+- </link>
+- (For the main development tree; see the date on the first page.)
+- </para>
+- </listitem>
+-</itemizedlist>
+-
+ <para>
+ The rendered HTML, as above, is also available for download on the
+ gcc.gnu.org site in a directory located at
+diff --git a/libstdc++-v3/doc/xml/manual/appendix_contributing.xml b/libstdc++-v3/doc/xml/manual/appendix_contributing.xml
+index 2c3b9fb..aca3d99 100644
+--- a/libstdc++-v3/doc/xml/manual/appendix_contributing.xml
++++ b/libstdc++-v3/doc/xml/manual/appendix_contributing.xml
+@@ -198,96 +198,197 @@
+
+
+ <para>
+- The unpacked source directory of libstdc++ contains the files
+- needed to create the GNU C++ Library.
++ The <filename class="directory">libstdc++-v3</filename> directory in the
++ GCC sources contains the files needed to create the GNU C++ Library.
+ </para>
+
+- <literallayout class="normal">
++<para>
+ It has subdirectories:
++</para>
+
+- doc
++<variablelist>
++ <varlistentry>
++ <term><filename class="directory">doc</filename></term>
++ <listitem>
+ Files in HTML and text format that document usage, quirks of the
+ implementation, and contributor checklists.
++ </listitem>
++ </varlistentry>
+
+- include
++ <varlistentry>
++ <term><filename class="directory">include</filename></term>
++ <listitem>
+ All header files for the C++ library are within this directory,
+ modulo specific runtime-related files that are in the libsupc++
+ directory.
+
+- include/std
+- Files meant to be found by #include &lt;name&gt; directives in
+- standard-conforming user programs.
++ <variablelist>
++ <varlistentry>
++ <term><filename class="directory">include/std</filename></term>
++ <listitem>
++ Files meant to be found by <code>#include &lt;name&gt;</code> directives
++ in standard-conforming user programs.
++ </listitem>
++ </varlistentry>
+
+- include/c
++ <varlistentry>
++ <term><filename class="directory">include/c</filename></term>
++ <listitem>
+ Headers intended to directly include standard C headers.
+- [NB: this can be enabled via --enable-cheaders=c]
++ [NB: this can be enabled via <option>--enable-cheaders=c</option>]
++ </listitem>
++ </varlistentry>
+
+- include/c_global
++ <varlistentry>
++ <term><filename class="directory">include/c_global</filename></term>
++ <listitem>
+ Headers intended to include standard C headers in
+- the global namespace, and put select names into the std::
++ the global namespace, and put select names into the <code>std::</code>
+ namespace. [NB: this is the default, and is the same as
+- --enable-cheaders=c_global]
++ <option>--enable-cheaders=c_global</option>]
++ </listitem>
++ </varlistentry>
+
+- include/c_std
++ <varlistentry>
++ <term><filename class="directory">include/c_std</filename></term>
++ <listitem>
+ Headers intended to include standard C headers
+- already in namespace std, and put select names into the std::
+- namespace. [NB: this is the same as --enable-cheaders=c_std]
++ already in namespace std, and put select names into the <code>std::</code>
++ namespace. [NB: this is the same as
++ <option>--enable-cheaders=c_std</option>]
++ </listitem>
++ </varlistentry>
+
+- include/bits
++ <varlistentry>
++ <term><filename class="directory">include/bits</filename></term>
++ <listitem>
+ Files included by standard headers and by other files in
+ the bits directory.
++ </listitem>
++ </varlistentry>
+
+- include/backward
+- Headers provided for backward compatibility, such as &lt;iostream.h&gt;.
++ <varlistentry>
++ <term><filename class="directory">include/backward</filename></term>
++ <listitem>
++ Headers provided for backward compatibility, such as
++ <filename class="headerfile">&lt;backward/hash_map&gt;</filename>.
+ They are not used in this library.
++ </listitem>
++ </varlistentry>
+
+- include/ext
++ <varlistentry>
++ <term><filename class="directory">include/ext</filename></term>
++ <listitem>
+ Headers that define extensions to the standard library. No
+- standard header refers to any of them.
+-
+- scripts
++ standard header refers to any of them, in theory (there are some
++ exceptions).
++ </listitem>
++ </varlistentry>
++ </variablelist>
++ </listitem>
++ </varlistentry>
++
++ <varlistentry>
++ <term><filename class="directory">scripts</filename></term>
++ <listitem>
+ Scripts that are used during the configure, build, make, or test
+ process.
++ </listitem>
++ </varlistentry>
+
+- src
++ <varlistentry>
++ <term><filename class="directory">src</filename></term>
++ <listitem>
+ Files that are used in constructing the library, but are not
+ installed.
+
+- testsuites/[backward, demangle, ext, performance, thread, 17_* to 30_*]
++ <variablelist>
++ <varlistentry>
++ <term><filename class="directory">src/c++98</filename></term>
++ <listitem>
++ Source files compiled using <option>-std=gnu++98</option>.
++ </listitem>
++ </varlistentry>
++
++ <varlistentry>
++ <term><filename class="directory">src/c++11</filename></term>
++ <listitem>
++ Source files compiled using <option>-std=gnu++11</option>.
++ </listitem>
++ </varlistentry>
++
++ <varlistentry>
++ <term><filename class="directory">src/filesystem</filename></term>
++ <listitem>
++ Source files for the Filesystem TS.
++ </listitem>
++ </varlistentry>
++
++ <varlistentry>
++ <term><filename class="directory">src/shared</filename></term>
++ <listitem>
++ Source code included by other files under both
++ <filename class="directory">src/c++98</filename> and
++ <filename class="directory">src/c++11</filename>
++ </listitem>
++ </varlistentry>
++ </variablelist>
++ </listitem>
++ </varlistentry>
++
++ <varlistentry>
++ <term><filename class="directory">testsuites/[backward, demangle, ext, performance, thread, 17_* to 30_*]</filename></term>
++ <listitem>
+ Test programs are here, and may be used to begin to exercise the
+ library. Support for "make check" and "make check-install" is
+ complete, and runs through all the subdirectories here when this
+ command is issued from the build directory. Please note that
+- "make check" requires DejaGNU 1.4 or later to be installed. Please
+- note that "make check-script" calls the script mkcheck, which
+- requires bash, and which may need the paths to bash adjusted to
+- work properly, as /bin/bash is assumed.
++ "make check" requires DejaGNU 1.4 or later to be installed.
++ </listitem>
++ </varlistentry>
++</variablelist>
+
++<para>
+ Other subdirectories contain variant versions of certain files
+ that are meant to be copied or linked by the configure script.
+ Currently these are:
++<literallayout><filename class="directory">config/abi</filename>
++<filename class="directory">config/allocator</filename>
++<filename class="directory">config/cpu</filename>
++<filename class="directory">config/io</filename>
++<filename class="directory">config/locale</filename>
++<filename class="directory">config/os</filename>
++</literallayout>
++</para>
+
+- config/abi
+- config/cpu
+- config/io
+- config/locale
+- config/os
+-
++<para>
+ In addition, a subdirectory holds the convenience library libsupc++.
++</para>
+
+- libsupc++
++<variablelist>
++<varlistentry>
++ <term><filename class="directory">libsupc++</filename></term>
++ <listitem>
+ Contains the runtime library for C++, including exception
+ handling and memory allocation and deallocation, RTTI, terminate
+ handlers, etc.
++ </listitem>
++</varlistentry>
++</variablelist>
+
+-Note that glibc also has a bits/ subdirectory. We will either
+-need to be careful not to collide with names in its bits/
+-directory; or rename bits to (e.g.) cppbits/.
++<para>
++Note that glibc also has a <filename class="directory">bits/</filename>
++subdirectory. We need to be careful not to collide with names in its
++<filename class="directory">bits/</filename> directory.
++Another solution would be to rename <filename class="directory">bits</filename>
++to (e.g.) <filename class="directory">cppbits</filename>.
++</para>
+
++<para>
+ In files throughout the system, lines marked with an "XXX" indicate
+ a bug or incompletely-implemented feature. Lines marked "XXX MT"
+ indicate a place that may require attention for multi-thread safety.
+- </literallayout>
++</para>
+
+ </section>
+
+diff --git a/libstdc++-v3/doc/xml/manual/intro.xml b/libstdc++-v3/doc/xml/manual/intro.xml
+index 2dd833d..8c951dc 100644
+--- a/libstdc++-v3/doc/xml/manual/intro.xml
++++ b/libstdc++-v3/doc/xml/manual/intro.xml
+@@ -640,6 +640,12 @@ requirements of the license of GCC.
+ <listitem><para>Implement the resolution, basically cast less.
+ </para></listitem></varlistentry>
+
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#445">445</link>:
++ <emphasis>iterator_traits::reference unspecified for some iterator categories</emphasis>
++ </term>
++ <listitem><para>Change <code>istreambuf_iterator::reference</code> in C++11 mode.
++ </para></listitem></varlistentry>
++
+ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#453">453</link>:
+ <emphasis>basic_stringbuf::seekoff need not always fail for an empty stream</emphasis>
+ </term>
+@@ -659,6 +665,12 @@ requirements of the license of GCC.
+ <code>at(const key_type&amp;)</code> to <code>std::map</code>.
+ </para></listitem></varlistentry>
+
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#467">467</link>:
++ <emphasis>char_traits::lt(), compare(), and memcmp()</emphasis>
++ </term>
++ <listitem><para>Change <code>lt</code>.
++ </para></listitem></varlistentry>
++
+ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#508">508</link>:
+ <emphasis>Bad parameters for ranlux64_base_01</emphasis>
+ </term>
+@@ -810,6 +822,146 @@ requirements of the license of GCC.
+ <listitem><para>Return the end of the filled range.
+ </para></listitem></varlistentry>
+
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2049">2049</link>:
++ <emphasis><code>is_destructible</code> underspecified</emphasis>
++ </term>
++ <listitem><para>Handle non-object types.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2056">2056</link>:
++ <emphasis>future_errc enums start with value 0 (invalid value for broken_promise)</emphasis>
++ </term>
++ <listitem><para>Reorder enumerators.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2059">2059</link>:
++ <emphasis>C++0x ambiguity problem with map::erase</emphasis>
++ </term>
++ <listitem><para>Add additional overloads.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2062">2062</link>:
++ <emphasis>2062. Effect contradictions w/o no-throw guarantee of <code>std::function</code> swaps</emphasis>
++ </term>
++ <listitem><para>Add <code>noexcept</code> to swap functions.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2063">2063</link>:
++ <emphasis>Contradictory requirements for string move assignment</emphasis>
++ </term>
++ <listitem><para>Respect propagation trait for move assignment.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2064">2064</link>:
++ <emphasis>More noexcept issues in basic_string</emphasis>
++ </term>
++ <listitem><para>Add noexcept to the comparison operators.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2067">2067</link>:
++ <emphasis>packaged_task should have deleted copy c'tor with const parameter</emphasis>
++ </term>
++ <listitem><para>Fix signatures.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2101">2101</link>:
++ <emphasis>Some transformation types can produce impossible types</emphasis>
++ </term>
++ <listitem><para>Use the referenceable type concept.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2106">2106</link>:
++ <emphasis>move_iterator wrapping iterators returning prvalues</emphasis>
++ </term>
++ <listitem><para>Change the <code>reference</code> type.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2132">2132</link>:
++ <emphasis><code>std::function</code> ambiguity</emphasis>
++ </term>
++ <listitem><para>Constrain the constructor to only accept callable types.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2141">2141</link>:
++ <emphasis><code>common_type</code> trait produces reference types</emphasis>
++ </term>
++ <listitem><para>Use <code>decay</code> for the result type.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2144">2144</link>:
++ <emphasis>Missing <code>noexcept</code> specification in <code>type_index</code></emphasis>
++ </term>
++ <listitem><para>Add <code>noexcept</code>
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2145">2145</link>:
++ <emphasis><code>error_category</code> default constructor</emphasis>
++ </term>
++ <listitem><para>Declare a public constexpr constructor.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2162">2162</link>:
++ <emphasis><code>allocator_traits::max_size</code> missing <code>noexcept</code></emphasis>
++ </term>
++ <listitem><para>Add <code>noexcept</code>.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2187">2187</link>:
++ <emphasis><code>vector&lt;bool&gt;</code> is missing <code>emplace</code> and <code>emplace_back</code> member functions</emphasis>
++ </term>
++ <listitem><para>Add <code>emplace</code> and <code>emplace_back</code> member functions.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2196">2196</link>:
++ <emphasis>Specification of <code>is_*[copy/move]_[constructible/assignable]</code> unclear for non-referencable types</emphasis>
++ </term>
++ <listitem><para>Use the referenceable type concept.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2313">2313</link>:
++ <emphasis><code>tuple_size</code> should always derive from <code>integral_constant&lt;size_t, N&gt;</code></emphasis>
++ </term>
++ <listitem><para>Update definitions of the partial specializations for const and volatile types.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2329">2329</link>:
++ <emphasis><code>regex_match()/regex_search()</code> with <code>match_results</code> should forbid temporary strings</emphasis>
++ </term>
++ <listitem><para>Add deleted overloads for rvalue strings.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2332">2332</link>:
++ <emphasis><code>regex_iterator/regex_token_iterator</code> should forbid temporary regexes</emphasis>
++ </term>
++ <listitem><para>Add deleted constructors.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2399">2399</link>:
++ <emphasis><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</emphasis>
++ </term>
++ <listitem><para>Constrain the constructor to require convertibility.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2400">2400</link>:
++ <emphasis><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></emphasis>
++ </term>
++ <listitem><para>Use <code>addressof</code>.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2401">2401</link>:
++ <emphasis><code>std::function</code> needs more <code>noexcept</code></emphasis>
++ </term>
++ <listitem><para>Add <code>noexcept</code> to the assignment and comparisons.
++ </para></listitem></varlistentry>
++
++ <varlistentry><term><link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="../ext/lwg-defects.html#2455">2455</link>:
++ <emphasis>Allocator default construction should be allowed to throw
++ </emphasis>
++ </term>
++ <listitem><para>Make <code>noexcept</code> specifications conditional.
++ </para></listitem></varlistentry>
++
++
+ </variablelist>
+
+ </section>
+diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
+index 16ea8c4..7769f52 100644
+--- a/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
++++ b/libstdc++-v3/doc/xml/manual/status_cxx2011.xml
+@@ -27,8 +27,7 @@ presence of the required flag.
+ </para>
+
+ <para>
+-This page describes the C++11 support in mainline GCC SVN, not in any
+-particular release.
++This page describes the C++11 support in the GCC 5 series.
+ </para>
+
+ <!-- Status is Yes or No, Broken/Partial-->
+diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2014.xml b/libstdc++-v3/doc/xml/manual/status_cxx2014.xml
+index 6f1fbe5..49c1600 100644
+--- a/libstdc++-v3/doc/xml/manual/status_cxx2014.xml
++++ b/libstdc++-v3/doc/xml/manual/status_cxx2014.xml
+@@ -20,8 +20,7 @@ presence of the required flag.
+ </para>
+
+ <para>
+-This page describes the C++14 and library TS support in mainline GCC SVN,
+-not in any particular release.
++This page describes the C++14 and library TS support in the GCC 5 series.
+ </para>
+
+ <table frame="all" xml:id="table.cxx14_status">
+diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
+index 5b6b4eb..5a3b189 100644
+--- a/libstdc++-v3/include/Makefile.am
++++ b/libstdc++-v3/include/Makefile.am
+@@ -649,6 +649,7 @@ experimental_headers = \
+ ${experimental_srcdir}/any \
+ ${experimental_srcdir}/chrono \
+ ${experimental_srcdir}/functional \
++ ${experimental_srcdir}/lfts_config.h \
+ ${experimental_srcdir}/optional \
+ ${experimental_srcdir}/ratio \
+ ${experimental_srcdir}/string_view \
+diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
+index 02b3ae8..591301a 100644
+--- a/libstdc++-v3/include/Makefile.in
++++ b/libstdc++-v3/include/Makefile.in
+@@ -938,6 +938,7 @@ experimental_headers = \
+ ${experimental_srcdir}/any \
+ ${experimental_srcdir}/chrono \
+ ${experimental_srcdir}/functional \
++ ${experimental_srcdir}/lfts_config.h \
+ ${experimental_srcdir}/optional \
+ ${experimental_srcdir}/ratio \
+ ${experimental_srcdir}/string_view \
+diff --git a/libstdc++-v3/include/bits/allocator.h b/libstdc++-v3/include/bits/allocator.h
+index 6057315..03953b4 100644
+--- a/libstdc++-v3/include/bits/allocator.h
++++ b/libstdc++-v3/include/bits/allocator.h
+@@ -77,6 +77,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2103. std::allocator propagate_on_container_move_assignment
+ typedef true_type propagate_on_container_move_assignment;
++
++ template<typename _Up, typename... _Args>
++ void
++ construct(_Up* __p, _Args&&... __args)
++ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
++
++ template<typename _Up>
++ void
++ destroy(_Up* __p) { __p->~_Up(); }
+ #endif
+ };
+
+diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
+index 9ef5be9..9e3aec0 100644
+--- a/libstdc++-v3/include/bits/basic_string.h
++++ b/libstdc++-v3/include/bits/basic_string.h
+@@ -387,7 +387,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ * @brief Construct an empty string using allocator @a a.
+ */
+ explicit
+- basic_string(const _Alloc& __a)
++ basic_string(const _Alloc& __a) _GLIBCXX_NOEXCEPT
+ : _M_dataplus(_M_local_data(), __a)
+ { _M_set_length(0); }
+
+@@ -396,7 +396,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ * @param __str Source string.
+ */
+ basic_string(const basic_string& __str)
+- : _M_dataplus(_M_local_data(), __str._M_get_allocator()) // TODO A traits
++ : _M_dataplus(_M_local_data(),
++ _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
+ { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+
+ /**
+@@ -509,10 +510,25 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ { _M_construct(__str.begin(), __str.end()); }
+
+ basic_string(basic_string&& __str, const _Alloc& __a)
++ noexcept(_Alloc_traits::_S_always_equal())
+ : _M_dataplus(_M_local_data(), __a)
+ {
+- if (__str.get_allocator() == __a)
+- *this = std::move(__str);
++ if (__str._M_is_local())
++ {
++ traits_type::copy(_M_local_buf, __str._M_local_buf,
++ _S_local_capacity + 1);
++ _M_length(__str.length());
++ __str._M_set_length(0);
++ }
++ else if (_Alloc_traits::_S_always_equal()
++ || __str.get_allocator() == __a)
++ {
++ _M_data(__str._M_data());
++ _M_length(__str.length());
++ _M_capacity(__str._M_allocated_capacity);
++ __str._M_data(__str._M_local_buf);
++ __str._M_set_length(0);
++ }
+ else
+ _M_construct(__str.begin(), __str.end());
+ }
+@@ -548,7 +564,23 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ */
+ basic_string&
+ operator=(const basic_string& __str)
+- { return this->assign(__str); }
++ {
++#if __cplusplus >= 201103L
++ if (_Alloc_traits::_S_propagate_on_copy_assign())
++ {
++ if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
++ && _M_get_allocator() != __str._M_get_allocator())
++ {
++ // replacement allocator cannot free existing storage
++ _M_destroy(_M_allocated_capacity);
++ _M_data(_M_local_data());
++ _M_set_length(0);
++ }
++ std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
++ }
++#endif
++ return this->assign(__str);
++ }
+
+ /**
+ * @brief Copy contents of @a s into this string.
+@@ -585,8 +617,51 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ // 2063. Contradictory requirements for string move assignment
+ basic_string&
+ operator=(basic_string&& __str)
++ noexcept(_Alloc_traits::_S_nothrow_move())
+ {
+- this->swap(__str);
++ if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
++ && !_Alloc_traits::_S_always_equal()
++ && _M_get_allocator() != __str._M_get_allocator())
++ {
++ // Destroy existing storage before replacing allocator.
++ _M_destroy(_M_allocated_capacity);
++ _M_data(_M_local_data());
++ _M_set_length(0);
++ }
++ // Replace allocator if POCMA is true.
++ std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
++
++ if (!__str._M_is_local()
++ && (_Alloc_traits::_S_propagate_on_move_assign()
++ || _Alloc_traits::_S_always_equal()))
++ {
++ pointer __data = nullptr;
++ size_type __capacity;
++ if (!_M_is_local())
++ {
++ if (_Alloc_traits::_S_always_equal())
++ {
++ __data = _M_data();
++ __capacity = _M_allocated_capacity;
++ }
++ else
++ _M_destroy(_M_allocated_capacity);
++ }
++
++ _M_data(__str._M_data());
++ _M_length(__str.length());
++ _M_capacity(__str._M_allocated_capacity);
++ if (__data)
++ {
++ __str._M_data(__data);
++ __str._M_capacity(__capacity);
++ }
++ else
++ __str._M_data(__str._M_local_buf);
++ }
++ else
++ assign(__str);
++ __str.clear();
+ return *this;
+ }
+
+@@ -1107,6 +1182,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ */
+ basic_string&
+ assign(basic_string&& __str)
++ noexcept(_Alloc_traits::_S_nothrow_move())
+ {
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2063. Contradictory requirements for string move assignment
+@@ -4903,13 +4979,14 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return __lhs.compare(__rhs) == 0; }
+
+ template<typename _CharT>
+ inline
+ typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+ operator==(const basic_string<_CharT>& __lhs,
+- const basic_string<_CharT>& __rhs)
++ const basic_string<_CharT>& __rhs) _GLIBCXX_NOEXCEPT
+ { return (__lhs.size() == __rhs.size()
+ && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+ __lhs.size())); }
+@@ -4949,6 +5026,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return !(__lhs == __rhs); }
+
+ /**
+@@ -4986,6 +5064,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return __lhs.compare(__rhs) < 0; }
+
+ /**
+@@ -5023,6 +5102,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return __lhs.compare(__rhs) > 0; }
+
+ /**
+@@ -5060,6 +5140,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return __lhs.compare(__rhs) <= 0; }
+
+ /**
+@@ -5097,6 +5178,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline bool
+ operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ const basic_string<_CharT, _Traits, _Alloc>& __rhs)
++ _GLIBCXX_NOEXCEPT
+ { return __lhs.compare(__rhs) >= 0; }
+
+ /**
+@@ -5134,6 +5216,9 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ inline void
+ swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+ basic_string<_CharT, _Traits, _Alloc>& __rhs)
++#if __cplusplus >= 201103L
++ noexcept(noexcept(__lhs.swap(__rhs)))
++#endif
+ { __lhs.swap(__rhs); }
+
+
+@@ -5541,6 +5626,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { };
+ #endif
+
++_GLIBCXX_END_NAMESPACE_VERSION
++
+ #if __cplusplus > 201103L
+
+ #define __cpp_lib_string_udls 201304
+@@ -5549,6 +5636,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ {
+ inline namespace string_literals
+ {
++_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ _GLIBCXX_DEFAULT_ABI_TAG
+ inline basic_string<char>
+@@ -5574,12 +5662,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return basic_string<char32_t>{__str, __len}; }
+ #endif
+
++_GLIBCXX_END_NAMESPACE_VERSION
+ } // inline namespace string_literals
+ } // inline namespace literals
+
+ #endif // __cplusplus > 201103L
+
+-_GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace std
+
+ #endif // C++11
+diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc
+index b9da93b..56af864 100644
+--- a/libstdc++-v3/include/bits/basic_string.tcc
++++ b/libstdc++-v3/include/bits/basic_string.tcc
+@@ -61,11 +61,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ if (this == &__s)
+ return;
+
+- // _GLIBCXX_RESOLVE_LIB_DEFECTS
+- // 431. Swapping containers with unequal allocators.
+- // TODO propagation traits
+- std::__alloc_swap<allocator_type>::_S_do_it(_M_get_allocator(),
+- __s._M_get_allocator());
++ _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
+
+ if (_M_is_local())
+ if (__s._M_is_local())
+@@ -404,7 +400,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ if (__new_size <= this->capacity())
+ {
+- _CharT* __p = this->_M_data() + __pos1;
++ pointer __p = this->_M_data() + __pos1;
+
+ const size_type __how_much = __old_size - __pos1 - __n1;
+ if (__how_much && __n1 != __n2)
+@@ -433,7 +429,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ if (__new_size <= this->capacity())
+ {
+- _CharT* __p = this->_M_data() + __pos;
++ pointer __p = this->_M_data() + __pos;
+
+ const size_type __how_much = __old_size - __pos - __len1;
+ if (_M_disjunct(__s))
+diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config
+index 79d1b36..662dbf8 100644
+--- a/libstdc++-v3/include/bits/c++config
++++ b/libstdc++-v3/include/bits/c++config
+@@ -177,8 +177,11 @@
+ namespace placeholders { }
+ namespace regex_constants { }
+ namespace this_thread { }
+-
+- namespace experimental { }
++ inline namespace literals {
++ inline namespace chrono_literals { }
++ inline namespace complex_literals { }
++ inline namespace string_literals { }
++ }
+ }
+
+ namespace abi { }
+@@ -263,7 +266,11 @@ namespace std
+ namespace regex_constants { inline namespace __7 { } }
+ namespace this_thread { inline namespace __7 { } }
+
+- namespace experimental { inline namespace __7 { } }
++ inline namespace literals {
++ inline namespace chrono_literals { inline namespace __7 { } }
++ inline namespace complex_literals { inline namespace __7 { } }
++ inline namespace string_literals { inline namespace __7 { } }
++ }
+
+ namespace __detail { inline namespace __7 { } }
+ }
+diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
+index a23c2c9..9b26c8f 100644
+--- a/libstdc++-v3/include/bits/regex.h
++++ b/libstdc++-v3/include/bits/regex.h
+@@ -769,10 +769,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+
+ template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+ __detail::_RegexExecutorPolicy, bool>
+- friend bool
+- __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+- const basic_regex<_Cp, _Rp>&,
+- regex_constants::match_flag_type);
++ friend bool __detail::
++#if _GLIBCXX_INLINE_VERSION
++ __7:: // Required due to PR c++/59256
++#endif
++ __regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
++ const basic_regex<_Cp, _Rp>&,
++ regex_constants::match_flag_type);
+
+ template<typename, typename, typename, bool>
+ friend class __detail::_Executor;
+@@ -1860,10 +1863,13 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+
+ template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
+ __detail::_RegexExecutorPolicy, bool>
+- friend bool
+- __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+- const basic_regex<_Cp, _Rp>&,
+- regex_constants::match_flag_type);
++ friend bool __detail::
++#if _GLIBCXX_INLINE_VERSION
++ __7:: // Required due to PR c++/59256
++#endif
++ __regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
++ const basic_regex<_Cp, _Rp>&,
++ regex_constants::match_flag_type);
+
+ void
+ _M_resize(unsigned int __size)
+diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h
+index 7b5872e..55e67a7 100644
+--- a/libstdc++-v3/include/bits/stl_iterator.h
++++ b/libstdc++-v3/include/bits/stl_iterator.h
+@@ -324,9 +324,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return !(__x < __y); }
+
+ template<typename _Iterator>
++#if __cplusplus < 201103L
+ inline typename reverse_iterator<_Iterator>::difference_type
+ operator-(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
++#else
++ inline auto
++ operator-(const reverse_iterator<_Iterator>& __x,
++ const reverse_iterator<_Iterator>& __y)
++ -> decltype(__x.base() - __y.base())
++#endif
+ { return __y.base() - __x.base(); }
+
+ template<typename _Iterator>
+diff --git a/libstdc++-v3/include/bits/stl_map.h b/libstdc++-v3/include/bits/stl_map.h
+index 179e3f2..04345c5 100644
+--- a/libstdc++-v3/include/bits/stl_map.h
++++ b/libstdc++-v3/include/bits/stl_map.h
+@@ -161,7 +161,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+ */
+ map()
+ #if __cplusplus >= 201103L
+- noexcept(is_nothrow_default_constructible<allocator_type>::value)
++ noexcept(is_nothrow_default_constructible<allocator_type>::value
++ && is_nothrow_default_constructible<key_compare>::value)
+ #endif
+ : _M_t() { }
+
+diff --git a/libstdc++-v3/include/bits/stl_multimap.h b/libstdc++-v3/include/bits/stl_multimap.h
+index 10ac0fa..20076a1 100644
+--- a/libstdc++-v3/include/bits/stl_multimap.h
++++ b/libstdc++-v3/include/bits/stl_multimap.h
+@@ -159,7 +159,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+ */
+ multimap()
+ #if __cplusplus >= 201103L
+- noexcept(is_nothrow_default_constructible<allocator_type>::value)
++ noexcept(is_nothrow_default_constructible<allocator_type>::value
++ && is_nothrow_default_constructible<key_compare>::value)
+ #endif
+ : _M_t() { }
+
+diff --git a/libstdc++-v3/include/bits/stl_multiset.h b/libstdc++-v3/include/bits/stl_multiset.h
+index ffe15ae..3a947d5 100644
+--- a/libstdc++-v3/include/bits/stl_multiset.h
++++ b/libstdc++-v3/include/bits/stl_multiset.h
+@@ -139,7 +139,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+ */
+ multiset()
+ #if __cplusplus >= 201103L
+- noexcept(is_nothrow_default_constructible<allocator_type>::value)
++ noexcept(is_nothrow_default_constructible<allocator_type>::value
++ && is_nothrow_default_constructible<key_compare>::value)
+ #endif
+ : _M_t() { }
+
+diff --git a/libstdc++-v3/include/bits/stl_set.h b/libstdc++-v3/include/bits/stl_set.h
+index 35cdf71..805fd07 100644
+--- a/libstdc++-v3/include/bits/stl_set.h
++++ b/libstdc++-v3/include/bits/stl_set.h
+@@ -141,7 +141,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+ */
+ set()
+ #if __cplusplus >= 201103L
+- noexcept(is_nothrow_default_constructible<allocator_type>::value)
++ noexcept(is_nothrow_default_constructible<allocator_type>::value
++ && is_nothrow_default_constructible<key_compare>::value)
+ #endif
+ : _M_t() { }
+
+diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h
+index d39042f..27bf6b3 100644
+--- a/libstdc++-v3/include/bits/stl_tree.h
++++ b/libstdc++-v3/include/bits/stl_tree.h
+@@ -841,7 +841,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ }
+
+ _Rb_tree(_Rb_tree&& __x)
+- : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
++ : _M_impl(__x._M_impl._M_key_compare,
++ std::move(__x._M_get_Node_allocator()))
+ {
+ if (__x._M_root() != 0)
+ _M_move_data(__x, std::true_type());
+@@ -1245,7 +1246,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ #if __cplusplus >= 201103L
+ _Rb_tree&
+- operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
++ operator=(_Rb_tree&&)
++ noexcept(_Alloc_traits::_S_nothrow_move()
++ && is_nothrow_move_assignable<_Compare>::value);
+
+ template<typename _Iterator>
+ void
+@@ -1264,6 +1267,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ // which might result in a copy not a move.
+ void
+ _M_move_data(_Rb_tree&, std::false_type);
++
++ // Move assignment from container with equal allocator.
++ void
++ _M_move_assign(_Rb_tree&, std::true_type);
++
++ // Move assignment from container with possibly non-equal allocator,
++ // which might result in a copy not a move.
++ void
++ _M_move_assign(_Rb_tree&, std::false_type);
+ #endif
+ };
+
+@@ -1379,23 +1391,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Key, typename _Val, typename _KeyOfValue,
+ typename _Compare, typename _Alloc>
+- _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
++ inline void
+ _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+- operator=(_Rb_tree&& __x)
+- noexcept(_Alloc_traits::_S_nothrow_move())
++ _M_move_assign(_Rb_tree& __x, true_type)
+ {
+- _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+- if (_Alloc_traits::_S_propagate_on_move_assign()
+- || _Alloc_traits::_S_always_equal()
+- || _M_get_Node_allocator() == __x._M_get_Node_allocator())
+- {
+- clear();
+- if (__x._M_root() != nullptr)
+- _M_move_data(__x, std::true_type());
+- std::__alloc_on_move(_M_get_Node_allocator(),
+- __x._M_get_Node_allocator());
+- return *this;
+- }
++ clear();
++ if (__x._M_root() != nullptr)
++ _M_move_data(__x, std::true_type());
++ std::__alloc_on_move(_M_get_Node_allocator(),
++ __x._M_get_Node_allocator());
++ }
++
++ template<typename _Key, typename _Val, typename _KeyOfValue,
++ typename _Compare, typename _Alloc>
++ void
++ _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
++ _M_move_assign(_Rb_tree& __x, false_type)
++ {
++ if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
++ return _M_move_assign(__x, true_type{});
+
+ // Try to move each node reusing existing nodes and copying __x nodes
+ // structure.
+@@ -1415,6 +1429,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ _M_impl._M_node_count = __x._M_impl._M_node_count;
+ __x.clear();
+ }
++ }
++
++ template<typename _Key, typename _Val, typename _KeyOfValue,
++ typename _Compare, typename _Alloc>
++ inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
++ _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
++ operator=(_Rb_tree&& __x)
++ noexcept(_Alloc_traits::_S_nothrow_move()
++ && is_nothrow_move_assignable<_Compare>::value)
++ {
++ _M_impl._M_key_compare = __x._M_impl._M_key_compare;
++ constexpr bool __move_storage =
++ _Alloc_traits::_S_propagate_on_move_assign()
++ || _Alloc_traits::_S_always_equal();
++ _M_move_assign(__x, __bool_constant<__move_storage>());
+ return *this;
+ }
+
+diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h
+index 670e379..123d4aa 100644
+--- a/libstdc++-v3/include/bits/uniform_int_dist.h
++++ b/libstdc++-v3/include/bits/uniform_int_dist.h
+@@ -36,10 +36,10 @@
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+-_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ namespace __detail
+ {
++_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ /* Determine whether number is a power of 2. */
+ template<typename _Tp>
+ inline bool
+@@ -47,8 +47,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ {
+ return ((__x - 1) & __x) == 0;
+ };
++_GLIBCXX_END_NAMESPACE_VERSION
+ }
+
++_GLIBCXX_BEGIN_NAMESPACE_VERSION
++
+ /**
+ * @brief Uniform discrete distribution for random numbers.
+ *
+diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h
+index 59078d7..cee8ca1 100644
+--- a/libstdc++-v3/include/bits/unique_ptr.h
++++ b/libstdc++-v3/include/bits/unique_ptr.h
+@@ -167,9 +167,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ */
+ explicit
+ unique_ptr(pointer __p) noexcept
+- : _M_t(__p, deleter_type())
+- { static_assert(!is_pointer<deleter_type>::value,
+- "constructed with null function pointer deleter"); }
++ : _M_t()
++ {
++ std::get<0>(_M_t) = __p;
++ static_assert(!is_pointer<deleter_type>::value,
++ "constructed with null function pointer deleter");
++ }
+
+ /** Takes ownership of a pointer.
+ *
+diff --git a/libstdc++-v3/include/c_global/cmath b/libstdc++-v3/include/c_global/cmath
+index d3fc8b7..723a9d2 100644
+--- a/libstdc++-v3/include/c_global/cmath
++++ b/libstdc++-v3/include/c_global/cmath
+@@ -558,7 +558,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ #if __cplusplus >= 201103L
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr int
+ fpclassify(float __x)
+ { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+@@ -575,13 +575,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ FP_SUBNORMAL, FP_ZERO, __x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ int>::__type
+ fpclassify(_Tp __x)
+ { return __x != 0 ? FP_NORMAL : FP_ZERO; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isfinite(float __x)
+ { return __builtin_isfinite(__x); }
+@@ -595,13 +597,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isfinite(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ bool>::__type
+ isfinite(_Tp __x)
+ { return true; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isinf(float __x)
+ { return __builtin_isinf(__x); }
+@@ -615,13 +619,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isinf(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ bool>::__type
+ isinf(_Tp __x)
+ { return false; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isnan(float __x)
+ { return __builtin_isnan(__x); }
+@@ -635,13 +641,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isnan(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ bool>::__type
+ isnan(_Tp __x)
+ { return false; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isnormal(float __x)
+ { return __builtin_isnormal(__x); }
+@@ -655,13 +663,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isnormal(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ bool>::__type
+ isnormal(_Tp __x)
+ { return __x != 0 ? true : false; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ // The front-end doesn't provide a type generic builtin (libstdc++/58625).
+ constexpr bool
+ signbit(float __x)
+@@ -676,13 +686,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_signbitl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ bool>::__type
+ signbit(_Tp __x)
+ { return __x < 0 ? true : false; }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isgreater(float __x, float __y)
+ { return __builtin_isgreater(__x, __y); }
+@@ -696,6 +708,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isgreater(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -705,8 +718,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_isgreater(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isgreaterequal(float __x, float __y)
+ { return __builtin_isgreaterequal(__x, __y); }
+@@ -720,6 +734,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isgreaterequal(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -729,8 +744,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_isgreaterequal(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isless(float __x, float __y)
+ { return __builtin_isless(__x, __y); }
+@@ -744,6 +760,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isless(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -753,8 +770,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_isless(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ islessequal(float __x, float __y)
+ { return __builtin_islessequal(__x, __y); }
+@@ -768,6 +786,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_islessequal(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -777,8 +796,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_islessequal(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ islessgreater(float __x, float __y)
+ { return __builtin_islessgreater(__x, __y); }
+@@ -792,6 +812,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_islessgreater(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -801,8 +822,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_islessgreater(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr bool
+ isunordered(float __x, float __y)
+ { return __builtin_isunordered(__x, __y); }
+@@ -816,6 +838,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_isunordered(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename
+ __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+@@ -825,6 +848,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return __builtin_isunordered(__type(__x), __type(__y));
+ }
++#endif
+
+ #else
+
+@@ -1209,7 +1233,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ using ::truncl;
+
+ /// Additional overloads.
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ acosh(float __x)
+ { return __builtin_acoshf(__x); }
+@@ -1219,13 +1243,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_acoshl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ acosh(_Tp __x)
+ { return __builtin_acosh(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ asinh(float __x)
+ { return __builtin_asinhf(__x); }
+@@ -1235,13 +1261,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_asinhl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ asinh(_Tp __x)
+ { return __builtin_asinh(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ atanh(float __x)
+ { return __builtin_atanhf(__x); }
+@@ -1251,13 +1279,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_atanhl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ atanh(_Tp __x)
+ { return __builtin_atanh(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ cbrt(float __x)
+ { return __builtin_cbrtf(__x); }
+@@ -1267,13 +1297,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_cbrtl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ cbrt(_Tp __x)
+ { return __builtin_cbrt(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ copysign(float __x, float __y)
+ { return __builtin_copysignf(__x, __y); }
+@@ -1283,6 +1315,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_copysignl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ copysign(_Tp __x, _Up __y)
+@@ -1290,8 +1323,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return copysign(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ erf(float __x)
+ { return __builtin_erff(__x); }
+@@ -1301,13 +1335,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_erfl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ erf(_Tp __x)
+ { return __builtin_erf(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ erfc(float __x)
+ { return __builtin_erfcf(__x); }
+@@ -1317,13 +1353,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_erfcl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ erfc(_Tp __x)
+ { return __builtin_erfc(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ exp2(float __x)
+ { return __builtin_exp2f(__x); }
+@@ -1333,13 +1371,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_exp2l(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ exp2(_Tp __x)
+ { return __builtin_exp2(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ expm1(float __x)
+ { return __builtin_expm1f(__x); }
+@@ -1349,13 +1389,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_expm1l(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ expm1(_Tp __x)
+ { return __builtin_expm1(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ fdim(float __x, float __y)
+ { return __builtin_fdimf(__x, __y); }
+@@ -1365,6 +1407,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_fdiml(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fdim(_Tp __x, _Up __y)
+@@ -1372,8 +1415,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fdim(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ fma(float __x, float __y, float __z)
+ { return __builtin_fmaf(__x, __y, __z); }
+@@ -1383,6 +1427,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_fmal(__x, __y, __z); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up, typename _Vp>
+ constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+ fma(_Tp __x, _Up __y, _Vp __z)
+@@ -1390,8 +1435,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+ return fma(__type(__x), __type(__y), __type(__z));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ fmax(float __x, float __y)
+ { return __builtin_fmaxf(__x, __y); }
+@@ -1401,6 +1447,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_fmaxl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fmax(_Tp __x, _Up __y)
+@@ -1408,8 +1455,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fmax(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ fmin(float __x, float __y)
+ { return __builtin_fminf(__x, __y); }
+@@ -1419,6 +1467,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_fminl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ fmin(_Tp __x, _Up __y)
+@@ -1426,8 +1475,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return fmin(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ hypot(float __x, float __y)
+ { return __builtin_hypotf(__x, __y); }
+@@ -1437,6 +1487,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_hypotl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ hypot(_Tp __x, _Up __y)
+@@ -1444,8 +1495,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return hypot(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr int
+ ilogb(float __x)
+ { return __builtin_ilogbf(__x); }
+@@ -1455,14 +1507,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_ilogbl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr
+ typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ int>::__type
+ ilogb(_Tp __x)
+ { return __builtin_ilogb(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ lgamma(float __x)
+ { return __builtin_lgammaf(__x); }
+@@ -1472,13 +1526,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_lgammal(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ lgamma(_Tp __x)
+ { return __builtin_lgamma(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr long long
+ llrint(float __x)
+ { return __builtin_llrintf(__x); }
+@@ -1488,13 +1544,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_llrintl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ long long>::__type
+ llrint(_Tp __x)
+ { return __builtin_llrint(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr long long
+ llround(float __x)
+ { return __builtin_llroundf(__x); }
+@@ -1504,13 +1562,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_llroundl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ long long>::__type
+ llround(_Tp __x)
+ { return __builtin_llround(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ log1p(float __x)
+ { return __builtin_log1pf(__x); }
+@@ -1520,13 +1580,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_log1pl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ log1p(_Tp __x)
+ { return __builtin_log1p(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ // DR 568.
+ constexpr float
+ log2(float __x)
+@@ -1537,13 +1599,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_log2l(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ log2(_Tp __x)
+ { return __builtin_log2(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ logb(float __x)
+ { return __builtin_logbf(__x); }
+@@ -1553,13 +1617,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_logbl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ logb(_Tp __x)
+ { return __builtin_logb(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr long
+ lrint(float __x)
+ { return __builtin_lrintf(__x); }
+@@ -1569,13 +1635,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_lrintl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ long>::__type
+ lrint(_Tp __x)
+ { return __builtin_lrint(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr long
+ lround(float __x)
+ { return __builtin_lroundf(__x); }
+@@ -1585,13 +1653,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_lroundl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ long>::__type
+ lround(_Tp __x)
+ { return __builtin_lround(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ nearbyint(float __x)
+ { return __builtin_nearbyintf(__x); }
+@@ -1601,13 +1671,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_nearbyintl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ nearbyint(_Tp __x)
+ { return __builtin_nearbyint(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ nextafter(float __x, float __y)
+ { return __builtin_nextafterf(__x, __y); }
+@@ -1617,6 +1689,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_nextafterl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ nextafter(_Tp __x, _Up __y)
+@@ -1624,8 +1697,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return nextafter(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ nexttoward(float __x, long double __y)
+ { return __builtin_nexttowardf(__x, __y); }
+@@ -1635,13 +1709,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_nexttowardl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ nexttoward(_Tp __x, long double __y)
+ { return __builtin_nexttoward(__x, __y); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ remainder(float __x, float __y)
+ { return __builtin_remainderf(__x, __y); }
+@@ -1651,6 +1727,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_remainderl(__x, __y); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ remainder(_Tp __x, _Up __y)
+@@ -1658,8 +1735,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return remainder(__type(__x), __type(__y));
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ remquo(float __x, float __y, int* __pquo)
+ { return __builtin_remquof(__x, __y, __pquo); }
+@@ -1669,6 +1747,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_remquol(__x, __y, __pquo); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp, typename _Up>
+ inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+ remquo(_Tp __x, _Up __y, int* __pquo)
+@@ -1676,8 +1755,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return remquo(__type(__x), __type(__y), __pquo);
+ }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ rint(float __x)
+ { return __builtin_rintf(__x); }
+@@ -1687,13 +1767,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_rintl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ rint(_Tp __x)
+ { return __builtin_rint(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ round(float __x)
+ { return __builtin_roundf(__x); }
+@@ -1703,13 +1785,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_roundl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ round(_Tp __x)
+ { return __builtin_round(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ scalbln(float __x, long __ex)
+ { return __builtin_scalblnf(__x, __ex); }
+@@ -1719,13 +1803,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_scalblnl(__x, __ex); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ scalbln(_Tp __x, long __ex)
+ { return __builtin_scalbln(__x, __ex); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ scalbn(float __x, int __ex)
+ { return __builtin_scalbnf(__x, __ex); }
+@@ -1735,13 +1821,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_scalbnl(__x, __ex); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ scalbn(_Tp __x, int __ex)
+ { return __builtin_scalbn(__x, __ex); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ tgamma(float __x)
+ { return __builtin_tgammaf(__x); }
+@@ -1751,13 +1839,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_tgammal(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ tgamma(_Tp __x)
+ { return __builtin_tgamma(__x); }
++#endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ constexpr float
+ trunc(float __x)
+ { return __builtin_truncf(__x); }
+@@ -1767,11 +1857,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_truncl(__x); }
+ #endif
+
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
+ template<typename _Tp>
+ constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+ double>::__type
+ trunc(_Tp __x)
+ { return __builtin_trunc(__x); }
++#endif
+
+ _GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace
+diff --git a/libstdc++-v3/include/debug/safe_iterator.h b/libstdc++-v3/include/debug/safe_iterator.h
+index 1eea238..6e3113a 100644
+--- a/libstdc++-v3/include/debug/safe_iterator.h
++++ b/libstdc++-v3/include/debug/safe_iterator.h
+@@ -329,7 +329,7 @@ namespace __gnu_debug
+ _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
+ _M_message(__msg_bad_inc)
+ ._M_iterator(*this, "this"));
+- __gnu_cxx::__scoped_lock(this->_M_get_mutex());
++ __gnu_cxx::__scoped_lock __l(this->_M_get_mutex());
+ ++base();
+ return *this;
+ }
+diff --git a/libstdc++-v3/include/debug/string b/libstdc++-v3/include/debug/string
+index 3793a35..6e07e9f 100644
+--- a/libstdc++-v3/include/debug/string
++++ b/libstdc++-v3/include/debug/string
+@@ -36,18 +36,19 @@
+
+ namespace __gnu_debug
+ {
+- /// Class std::basic_string with safety/checking/debug instrumentation.
+- template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
+- typename _Allocator = std::allocator<_CharT> >
+- class basic_string
+- : public __gnu_debug::_Safe_container<
+- basic_string<_CharT, _Traits, _Allocator>,
+- _Allocator, _Safe_sequence, false>,
+- public std::basic_string<_CharT, _Traits, _Allocator>
+- {
+- typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
+- typedef __gnu_debug::_Safe_container<
+- basic_string, _Allocator, _Safe_sequence, false> _Safe;
++/// Class std::basic_string with safety/checking/debug instrumentation.
++template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
++ typename _Allocator = std::allocator<_CharT> >
++ class basic_string
++ : public __gnu_debug::_Safe_container<
++ basic_string<_CharT, _Traits, _Allocator>,
++ _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>,
++ public std::basic_string<_CharT, _Traits, _Allocator>
++ {
++ typedef std::basic_string<_CharT, _Traits, _Allocator> _Base;
++ typedef __gnu_debug::_Safe_container<
++ basic_string, _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>
++ _Safe;
+
+ public:
+ // types:
+@@ -71,9 +72,15 @@ namespace __gnu_debug
+
+ using _Base::npos;
+
++ basic_string()
++#if __cplusplus >= 201103L
++ noexcept(std::is_nothrow_default_constructible<_Base>::value)
++#endif
++ : _Base() { }
++
+ // 21.3.1 construct/copy/destroy:
+- explicit basic_string(const _Allocator& __a = _Allocator())
+- // _GLIBCXX_NOEXCEPT
++ explicit
++ basic_string(const _Allocator& __a) _GLIBCXX_NOEXCEPT
+ : _Base(__a) { }
+
+ #if __cplusplus < 201103L
+@@ -90,7 +97,19 @@ namespace __gnu_debug
+ : _Base(__l, __a)
+ { }
+
++#if _GLIBCXX_USE_CXX11_ABI
++ basic_string(const basic_string& __s, const _Allocator& __a)
++ : _Base(__s, __a) { }
++
++ basic_string(basic_string&& __s, const _Allocator& __a)
++ : _Base(std::move(__s), __a) { }
++#endif
++
+ ~basic_string() = default;
++
++ // Provides conversion from a normal-mode string to a debug-mode string
++ basic_string(_Base&& __base) noexcept
++ : _Base(std::move(__base)) { }
+ #endif // C++11
+
+ // Provides conversion from a normal-mode string to a debug-mode string
+@@ -277,7 +296,7 @@ namespace __gnu_debug
+ reference
+ operator[](size_type __pos) // _GLIBCXX_NOEXCEPT
+ {
+-#ifdef _GLIBCXX_DEBUG_PEDANTIC
++#if __cplusplus < 201103L && defined(_GLIBCXX_DEBUG_PEDANTIC)
+ __glibcxx_check_subscript(__pos);
+ #else
+ // as an extension v3 allows s[s.size()] when s is non-const.
+@@ -406,6 +425,7 @@ namespace __gnu_debug
+ #if __cplusplus >= 201103L
+ basic_string&
+ assign(basic_string&& __x)
++ noexcept(noexcept(std::declval<_Base&>().assign(std::move(__x))))
+ {
+ _Base::assign(std::move(__x));
+ this->_M_invalidate_all();
+@@ -701,6 +721,9 @@ namespace __gnu_debug
+
+ void
+ swap(basic_string& __x)
++#if _GLIBCXX_USE_CXX11_ABI
++ _GLIBCXX_NOEXCEPT
++#endif
+ {
+ _Safe::_M_swap(__x);
+ _Base::swap(__x);
+diff --git a/libstdc++-v3/include/experimental/algorithm b/libstdc++-v3/include/experimental/algorithm
+index 4281b42..11498fa 100644
+--- a/libstdc++-v3/include/experimental/algorithm
++++ b/libstdc++-v3/include/experimental/algorithm
+@@ -37,6 +37,7 @@
+
+ #include <algorithm>
+ #include <random>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -67,9 +68,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ __distrib_type __d{};
+ _Size __sample_sz = 0;
+ while (__first != __last && __sample_sz != __n)
+- __out[__sample_sz++] = *__first++;
++ {
++ __out[__sample_sz++] = *__first;
++ ++__first;
++ }
+ for (auto __pop_sz = __sample_sz; __first != __last;
+- ++__first, ++__pop_sz)
++ ++__first, (void)++__pop_sz)
+ {
+ const auto __k = __d(__g, __param_type{0, __pop_sz});
+ if (__k < __n)
+@@ -122,9 +126,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ static_assert(is_integral<_Distance>::value,
+ "sample size must be an integer type");
+
++ typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
+ return std::experimental::__sample(
+ __first, __last, __pop_cat{}, __out, __samp_cat{},
+- __n, std::forward<_UniformRandomNumberGenerator>(__g));
++ __d, std::forward<_UniformRandomNumberGenerator>(__g));
+ }
+
+ _GLIBCXX_END_NAMESPACE_VERSION
+diff --git a/libstdc++-v3/include/experimental/any b/libstdc++-v3/include/experimental/any
+index 487ba01..30cdf54 100644
+--- a/libstdc++-v3/include/experimental/any
++++ b/libstdc++-v3/include/experimental/any
+@@ -39,6 +39,7 @@
+ #include <new>
+ #include <utility>
+ #include <type_traits>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+diff --git a/libstdc++-v3/include/experimental/chrono b/libstdc++-v3/include/experimental/chrono
+index 0631fa5..d4ac070 100644
+--- a/libstdc++-v3/include/experimental/chrono
++++ b/libstdc++-v3/include/experimental/chrono
+@@ -40,7 +40,7 @@
+ #else
+
+ #include <chrono>
+-
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+diff --git a/libstdc++-v3/include/experimental/fs_dir.h b/libstdc++-v3/include/experimental/fs_dir.h
+index 7c5f8e8..870b42b 100644
+--- a/libstdc++-v3/include/experimental/fs_dir.h
++++ b/libstdc++-v3/include/experimental/fs_dir.h
+@@ -312,6 +312,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ }
+
+ void pop();
++ void pop(error_code&);
+
+ void disable_recursion_pending() { _M_pending = false; }
+
+diff --git a/libstdc++-v3/include/experimental/fs_fwd.h b/libstdc++-v3/include/experimental/fs_fwd.h
+index 9cf903f..da13903 100644
+--- a/libstdc++-v3/include/experimental/fs_fwd.h
++++ b/libstdc++-v3/include/experimental/fs_fwd.h
+@@ -46,10 +46,13 @@ namespace filesystem
+ {
+ inline namespace v1
+ {
++#if _GLIBCXX_INLINE_VERSION
++inline namespace __7 { }
++#endif
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ #if _GLIBCXX_USE_CXX11_ABI
+- inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
++inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+ #endif
+
+ /**
+@@ -159,7 +162,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
+ unknown = 0xFFFF,
+ add_perms = 0x10000,
+ remove_perms = 0x20000,
+- resolve_symlinks = 0x40000
++ symlink_nofollow = 0x40000
+ };
+
+ constexpr perms
+diff --git a/libstdc++-v3/include/experimental/fs_ops.h b/libstdc++-v3/include/experimental/fs_ops.h
+index 91b8902..727c84f 100644
+--- a/libstdc++-v3/include/experimental/fs_ops.h
++++ b/libstdc++-v3/include/experimental/fs_ops.h
+@@ -112,6 +112,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ void current_path(const path& __p);
+ void current_path(const path& __p, error_code& __ec) noexcept;
+
++ bool
++ equivalent(const path& __p1, const path& __p2);
++
++ bool
++ equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
++
+ inline bool
+ exists(file_status __s) noexcept
+ { return status_known(__s) && __s.type() != file_type::not_found; }
+@@ -122,13 +128,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ inline bool
+ exists(const path& __p, error_code& __ec) noexcept
+- { return exists(status(__p, __ec)); }
+-
+- bool
+- equivalent(const path& __p1, const path& __p2);
+-
+- bool
+- equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;
++ {
++ auto __s = status(__p, __ec);
++ if (status_known(__s))
++ __ec.clear();
++ return exists(__s);
++ }
+
+ uintmax_t file_size(const path& __p);
+ uintmax_t file_size(const path& __p, error_code& __ec) noexcept;
+diff --git a/libstdc++-v3/include/experimental/fs_path.h b/libstdc++-v3/include/experimental/fs_path.h
+index 176918a..d430ab3 100644
+--- a/libstdc++-v3/include/experimental/fs_path.h
++++ b/libstdc++-v3/include/experimental/fs_path.h
+@@ -44,6 +44,9 @@
+ #include <bits/stl_algobase.h>
+ #include <bits/quoted_string.h>
+ #include <bits/locale_conv.h>
++#if __cplusplus >= 201402L
++# include <experimental/string_view>
++#endif
+
+ #if defined(_WIN32) && !defined(__CYGWIN__)
+ # define _GLIBCXX_FILESYSTEM_IS_WINDOWS 1
+@@ -61,6 +64,12 @@ inline namespace v1
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+
++#if __cplusplus >= 201402L
++ template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
++ using __basic_string_view
++ = std::experimental::basic_string_view<_CharT, _Traits>;
++#endif
++
+ /**
+ * @ingroup filesystem
+ * @{
+@@ -87,6 +96,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ static __is_encoded_char<_CharT>
+ __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int);
+
++#if __cplusplus >= 201402L
++ template<typename _CharT, typename _Traits>
++ static __is_encoded_char<_CharT>
++ __is_path_src(const __basic_string_view<_CharT, _Traits>&, int);
++#endif
++
+ template<typename _Unknown>
+ static std::false_type
+ __is_path_src(const _Unknown&, ...);
+@@ -130,6 +145,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str)
+ { return __str.data() + __str.size(); }
+
++#if __cplusplus >= 201402L
++ template<typename _CharT, typename _Traits>
++ static const _CharT*
++ _S_range_begin(const __basic_string_view<_CharT, _Traits>& __str)
++ { return __str.data(); }
++
++ template<typename _CharT, typename _Traits>
++ static const _CharT*
++ _S_range_end(const __basic_string_view<_CharT, _Traits>& __str)
++ { return __str.data() + __str.size(); }
++#endif
++
+ template<typename _Tp,
+ typename _Iter = decltype(_S_range_begin(std::declval<_Tp>())),
+ typename _Val = typename std::iterator_traits<_Iter>::value_type>
+@@ -159,6 +186,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ __p.clear();
+ }
+
++ path(string_type&& __source)
++ : _M_pathname(std::move(__source))
++ { _M_split_cmpts(); }
++
+ template<typename _Source,
+ typename _Require = _Path<_Source>>
+ path(_Source const& __source)
+@@ -193,6 +224,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+
+ path& operator=(const path& __p) = default;
+ path& operator=(path&& __p) noexcept;
++ path& operator=(string_type&& __source);
++ path& assign(string_type&& __source);
+
+ template<typename _Source>
+ _Path<_Source>&
+@@ -237,6 +270,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ path& operator+=(const string_type& __x);
+ path& operator+=(const value_type* __x);
+ path& operator+=(value_type __x);
++#if __cplusplus >= 201402L
++ path& operator+=(__basic_string_view<value_type> __x);
++#endif
+
+ template<typename _Source>
+ _Path<_Source>&
+@@ -305,6 +341,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ int compare(const path& __p) const noexcept;
+ int compare(const string_type& __s) const;
+ int compare(const value_type* __s) const;
++#if __cplusplus >= 201402L
++ int compare(const __basic_string_view<value_type> __s) const;
++#endif
+
+ // decomposition
+
+@@ -379,7 +418,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ _S_convert(_Iter __first, _Iter __last)
+ {
+ using __value_type = typename std::iterator_traits<_Iter>::value_type;
+- return _Cvt<__value_type>::_S_convert(__first, __last);
++ return _Cvt<typename remove_cv<__value_type>::type>::
++ _S_convert(__first, __last);
+ }
+
+ template<typename _InputIterator>
+@@ -387,10 +427,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ _S_convert(_InputIterator __src, __null_terminated)
+ {
+ using _Tp = typename std::iterator_traits<_InputIterator>::value_type;
+- std::basic_string<_Tp> __tmp;
+- while (*__src != _Tp{})
+- __tmp.push_back(*__src++);
+- return _S_convert(__tmp.data(), __tmp.data() + __tmp.size());
++ std::basic_string<typename remove_cv<_Tp>::type> __tmp;
++ for (; *__src != _Tp{}; ++__src)
++ __tmp.push_back(*__src);
++ return _S_convert(__tmp.c_str(), __tmp.c_str() + __tmp.size());
+ }
+
+ static string_type
+@@ -565,6 +605,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ struct path::__is_encoded_char<char32_t> : std::true_type
+ { using value_type = char32_t; };
+
++ template<typename _Tp>
++ struct path::__is_encoded_char<const _Tp> : __is_encoded_char<_Tp> { };
++
+ struct path::_Cmpt : path
+ {
+ _Cmpt(string_type __s, _Type __t, size_t __pos)
+@@ -722,6 +765,14 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ }
+
+ inline path&
++ path::operator=(string_type&& __source)
++ { return *this = path(std::move(__source)); }
++
++ inline path&
++ path::assign(string_type&& __source)
++ { return *this = path(std::move(__source)); }
++
++ inline path&
+ path::operator+=(const path& __p)
+ {
+ return operator+=(__p.native());
+@@ -751,6 +802,16 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ return *this;
+ }
+
++#if __cplusplus >= 201402L
++ inline path&
++ path::operator+=(__basic_string_view<value_type> __x)
++ {
++ _M_pathname.append(__x.data(), __x.size());
++ _M_split_cmpts();
++ return *this;
++ }
++#endif
++
+ template<typename _CharT>
+ inline path::_Path<_CharT*, _CharT*>&
+ path::operator+=(_CharT __x)
+@@ -892,6 +953,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
+ inline int
+ path::compare(const value_type* __s) const { return compare(path(__s)); }
+
++#if __cplusplus >= 201402L
++ inline int
++ path::compare(__basic_string_view<value_type> __s) const
++ { return compare(path(__s)); }
++#endif
++
+ inline path
+ path::filename() const { return empty() ? path() : *--end(); }
+
+diff --git a/libstdc++-v3/include/experimental/functional b/libstdc++-v3/include/experimental/functional
+index 40d3bd4..dbb9148 100644
+--- a/libstdc++-v3/include/experimental/functional
++++ b/libstdc++-v3/include/experimental/functional
+@@ -42,6 +42,7 @@
+ #include <vector>
+ #include <array>
+ #include <bits/stl_algo.h>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -115,7 +116,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ _Pred
+ _M_pred() const { return _M_bad_char.key_eq(); }
+
+- std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
++ _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
+ };
+
+ template<typename _Tp, size_t _Len, typename _Pred>
+@@ -124,7 +125,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _RAIter, typename _Unused>
+ __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
+ _Unused&&, _Pred&& __pred)
+- : _M_bad_char{ {}, std::move(__pred) }
++ : _M_bad_char{ _GLIBCXX_STD_C::array<_Tp, _Len>{}, std::move(__pred) }
+ {
+ std::get<0>(_M_bad_char).fill(__patlen);
+ if (__patlen > 0)
+@@ -152,7 +153,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ const _Pred&
+ _M_pred() const { return std::get<1>(_M_bad_char); }
+
+- std::tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char;
++ std::tuple<_GLIBCXX_STD_C::array<_Tp, _Len>, _Pred> _M_bad_char;
+ };
+
+ template<typename _Pred>
+@@ -225,7 +226,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ _RAIter _M_pat;
+ _RAIter _M_pat_end;
+- std::vector<__diff_type> _M_good_suffix;
++ _GLIBCXX_STD_C::vector<__diff_type> _M_good_suffix;
+ };
+
+ template<typename _RAIter, typename _Hash
+@@ -383,7 +384,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ public:
+ template<typename _Fn2>
+ explicit
+- _Not_fn(_Fn2&& __fn) : _M_fn(std::forward<_Fn2>(__fn)) { }
++ _Not_fn(_Fn2&& __fn, int) : _M_fn(std::forward<_Fn2>(__fn)) { }
+
+ _Not_fn(const _Not_fn& __fn) = default;
+ _Not_fn(_Not_fn&& __fn) = default;
+@@ -427,7 +428,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
+ {
+ using __maybe_type = _Maybe_wrap_member_pointer<std::decay_t<_Fn>>;
+- return _Not_fn<typename __maybe_type::type>{std::forward<_Fn>(__fn)};
++ return _Not_fn<typename __maybe_type::type>{std::forward<_Fn>(__fn), 0};
+ }
+
+ _GLIBCXX_END_NAMESPACE_VERSION
+diff --git a/libstdc++-v3/include/experimental/lfts_config.h b/libstdc++-v3/include/experimental/lfts_config.h
+new file mode 100644
+index 0000000..e93c9b7
+--- /dev/null
++++ b/libstdc++-v3/include/experimental/lfts_config.h
+@@ -0,0 +1,57 @@
++// Namespace declarations for Library Fundamentals TS -*- C++ -*-
++
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// Under Section 7 of GPL version 3, you are granted additional
++// permissions described in the GCC Runtime Library Exception, version
++// 3.1, as published by the Free Software Foundation.
++
++// You should have received a copy of the GNU General Public License and
++// a copy of the GCC Runtime Library Exception along with this program;
++// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
++// <http://www.gnu.org/licenses/>.
++
++/** @file experimental/lfts_config.h
++ * This is an internal header file, included by other library headers.
++ * Do not attempt to use it directly.
++ */
++
++#if __cplusplus <= 201103L
++# include <bits/c++14_warning.h>
++#else
++#include <bits/c++config.h>
++
++#if _GLIBCXX_INLINE_VERSION
++namespace std _GLIBCXX_VISIBILITY(default)
++{
++namespace chrono
++{
++namespace experimental
++{
++inline namespace fundamentals_v1 { inline namespace __7 { } }
++inline namespace fundamentals_v2 { inline namespace __7 { } }
++} // namespace experimental
++} // namespace chrono
++
++namespace experimental
++{
++inline namespace fundamentals_v1 { inline namespace __7 { } }
++inline namespace fundamentals_v2 { inline namespace __7 { } }
++inline namespace literals { inline namespace string_view_literals {
++ inline namespace __7 { }
++} } // namespace literals::string_view_literals
++} // namespace experimental
++} // namespace std
++#endif
++#endif
+diff --git a/libstdc++-v3/include/experimental/optional b/libstdc++-v3/include/experimental/optional
+index f6e3fa0..e9c5412 100644
+--- a/libstdc++-v3/include/experimental/optional
++++ b/libstdc++-v3/include/experimental/optional
+@@ -53,6 +53,7 @@
+ #include <bits/functexcept.h>
+ #include <bits/functional_hash.h>
+ #include <bits/enable_special_members.h>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -133,6 +134,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ __throw_bad_optional_access(const char* __s)
+ { _GLIBCXX_THROW_OR_ABORT(bad_optional_access(__s)); }
+
++#ifndef __cpp_lib_addressof_constexpr
+ template<typename _Tp, typename = void>
+ struct _Has_addressof_mem : std::false_type { };
+
+@@ -169,16 +171,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ * overloaded addressof operator (unary operator&), in which case the call
+ * will not be a constant expression.
+ */
+- template<typename _Tp, enable_if_t<!_Has_addressof<_Tp>::value, int>...>
+- constexpr _Tp* __constexpr_addressof(_Tp& __t)
++ template<typename _Tp>
++ constexpr
++ enable_if_t<!_Has_addressof<_Tp>::value, _Tp*>
++ __constexpr_addressof(_Tp& __t)
+ { return &__t; }
+
+ /**
+ * @brief Fallback overload that defers to __addressof.
+ */
+- template<typename _Tp, enable_if_t<_Has_addressof<_Tp>::value, int>...>
+- inline _Tp* __constexpr_addressof(_Tp& __t)
++ template<typename _Tp>
++ inline
++ enable_if_t<_Has_addressof<_Tp>::value, _Tp*>
++ __constexpr_addressof(_Tp& __t)
+ { return std::__addressof(__t); }
++#endif // __cpp_lib_addressof_constexpr
+
+ /**
+ * @brief Class template that holds the necessary state for @ref optional
+@@ -573,7 +580,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ // [X.Y.4.5] Observers.
+ constexpr const _Tp*
+ operator->() const
+- { return __constexpr_addressof(this->_M_get()); }
++ {
++#ifndef __cpp_lib_addressof_constexpr
++ return __constexpr_addressof(this->_M_get());
++#else
++ return std::__addressof(this->_M_get());
++#endif
++ }
+
+ _Tp*
+ operator->()
+diff --git a/libstdc++-v3/include/experimental/ratio b/libstdc++-v3/include/experimental/ratio
+index a009dea..6e784a2 100644
+--- a/libstdc++-v3/include/experimental/ratio
++++ b/libstdc++-v3/include/experimental/ratio
+@@ -40,7 +40,7 @@
+ #else
+
+ #include <ratio>
+-
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -49,6 +49,7 @@ namespace experimental
+ inline namespace fundamentals_v1
+ {
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
++
+ // See C++14 §20.11.5, ratio comparison
+ template <typename _R1, typename _R2>
+ constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
+diff --git a/libstdc++-v3/include/experimental/string_view b/libstdc++-v3/include/experimental/string_view
+index f11a187..9e7ca04 100644
+--- a/libstdc++-v3/include/experimental/string_view
++++ b/libstdc++-v3/include/experimental/string_view
+@@ -41,6 +41,7 @@
+
+ #include <string>
+ #include <limits>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -419,7 +420,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ private:
+
+- static constexpr const int
++ static constexpr int
+ _S_compare(size_type __n1, size_type __n2) noexcept
+ {
+ return difference_type{__n1 - __n2} > std::numeric_limits<int>::max()
+@@ -651,13 +652,12 @@ _GLIBCXX_END_NAMESPACE_VERSION
+
+ namespace experimental
+ {
+-_GLIBCXX_BEGIN_NAMESPACE_VERSION
+-
+ // I added these EMSR.
+ inline namespace literals
+ {
+ inline namespace string_view_literals
+ {
++ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ inline constexpr basic_string_view<char>
+ operator""sv(const char* __str, size_t __len)
+@@ -679,10 +679,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return basic_string_view<char32_t>{__str, __len}; }
+ #endif
+
+- }
+- }
+-
+-_GLIBCXX_END_NAMESPACE_VERSION
++ _GLIBCXX_END_NAMESPACE_VERSION
++ } // namespace string_literals
++ } // namespace literals
+ } // namespace experimental
+ } // namespace std
+
+diff --git a/libstdc++-v3/include/experimental/string_view.tcc b/libstdc++-v3/include/experimental/string_view.tcc
+index 9421842..7be3d53 100644
+--- a/libstdc++-v3/include/experimental/string_view.tcc
++++ b/libstdc++-v3/include/experimental/string_view.tcc
+@@ -44,6 +44,8 @@ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+ namespace experimental
+ {
++inline namespace fundamentals_v1
++{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _CharT, typename _Traits>
+@@ -222,6 +224,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ }
+
+ _GLIBCXX_END_NAMESPACE_VERSION
++} // namespace fundamentals_v1
+ } // namespace experimental
+ } // namespace std
+
+diff --git a/libstdc++-v3/include/experimental/system_error b/libstdc++-v3/include/experimental/system_error
+index ba3f8be..f034f9a 100644
+--- a/libstdc++-v3/include/experimental/system_error
++++ b/libstdc++-v3/include/experimental/system_error
+@@ -40,7 +40,7 @@
+ #else
+
+ #include <system_error>
+-
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+@@ -49,12 +49,14 @@ namespace experimental
+ inline namespace fundamentals_v1
+ {
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
++
+ // See C++14 §19.5, System error support
+ template <typename _Tp>
+ constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
+ template <typename _Tp>
+ constexpr bool is_error_condition_enum_v =
+ is_error_condition_enum<_Tp>::value;
++
+ _GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace fundamentals_v1
+ } // namespace experimental
+diff --git a/libstdc++-v3/include/experimental/tuple b/libstdc++-v3/include/experimental/tuple
+index 99935f1..fb15d2c 100644
+--- a/libstdc++-v3/include/experimental/tuple
++++ b/libstdc++-v3/include/experimental/tuple
+@@ -36,6 +36,7 @@
+ #else
+
+ #include <tuple>
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+diff --git a/libstdc++-v3/include/experimental/type_traits b/libstdc++-v3/include/experimental/type_traits
+index db78eec..a4257e2 100644
+--- a/libstdc++-v3/include/experimental/type_traits
++++ b/libstdc++-v3/include/experimental/type_traits
+@@ -40,7 +40,7 @@
+ #else
+
+ #include <type_traits>
+-
++#include <experimental/lfts_config.h>
+
+ namespace std _GLIBCXX_VISIBILITY(default)
+ {
+diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono
+index 50a2bbf..abe0ca1 100644
+--- a/libstdc++-v3/include/std/chrono
++++ b/libstdc++-v3/include/std/chrono
+@@ -788,6 +788,7 @@ _GLIBCXX_END_NAMESPACE_VERSION
+ {
+ inline namespace chrono_literals
+ {
++ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _Rep, unsigned long long _Val>
+ struct _Checked_integral_constant
+@@ -863,6 +864,7 @@ _GLIBCXX_END_NAMESPACE_VERSION
+ operator""ns()
+ { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
+
++ _GLIBCXX_END_NAMESPACE_VERSION
+ } // inline namespace chrono_literals
+ } // inline namespace literals
+
+diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex
+index 585683c..c06726c 100644
+--- a/libstdc++-v3/include/std/complex
++++ b/libstdc++-v3/include/std/complex
+@@ -1929,10 +1929,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ conj(_Tp __x)
+ { return __x; }
+
++_GLIBCXX_END_NAMESPACE_VERSION
++
+ #if __cplusplus > 201103L
+
+ inline namespace literals {
+ inline namespace complex_literals {
++_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ #define __cpp_lib_complex_udls 201309
+
+@@ -1960,12 +1963,12 @@ inline namespace complex_literals {
+ operator""il(unsigned long long __num)
+ { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
+
++_GLIBCXX_END_NAMESPACE_VERSION
+ } // inline namespace complex_literals
+ } // inline namespace literals
+
+ #endif // C++14
+
+-_GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace
+
+ #endif // C++11
+diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional
+index cc40e4d..a8d81d2 100644
+--- a/libstdc++-v3/include/std/functional
++++ b/libstdc++-v3/include/std/functional
+@@ -1593,7 +1593,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ void (_Undefined_class::*_M_member_pointer)();
+ };
+
+- union _Any_data
++ union [[gnu::may_alias]] _Any_data
+ {
+ void* _M_access() { return &_M_pod_data[0]; }
+ const void* _M_access() const { return &_M_pod_data[0]; }
+@@ -1699,7 +1699,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+- new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
++ ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+ // Clone a function object that is not location-invariant or
+@@ -1764,13 +1764,13 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+
+ template<typename _Tp>
+ static bool
+- _M_not_empty_function(_Tp* const& __fp)
+- { return __fp; }
++ _M_not_empty_function(_Tp* __fp)
++ { return __fp != nullptr; }
+
+ template<typename _Class, typename _Tp>
+ static bool
+- _M_not_empty_function(_Tp _Class::* const& __mp)
+- { return __mp; }
++ _M_not_empty_function(_Tp _Class::* __mp)
++ { return __mp != nullptr; }
+
+ template<typename _Tp>
+ static bool
+@@ -1780,7 +1780,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+- { new (__functor._M_access()) _Functor(std::move(__f)); }
++ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+@@ -1978,7 +1978,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ typedef _Res _Signature_type(_ArgTypes...);
+
+ template<typename _Func,
+- typename _Res2 = typename result_of<_Func(_ArgTypes...)>::type>
++ typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
+ struct _Callable : __check_func_return_type<_Res2, _Res> { };
+
+ // Used so the return type convertibility checks aren't done when
+@@ -2151,7 +2151,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ * Swap the targets of @c this function object and @a __f. This
+ * function will not throw an %exception.
+ */
+- void swap(function& __x)
++ void swap(function& __x) noexcept
+ {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+@@ -2364,9 +2364,11 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
+ *
+ * This function will not throw an %exception.
+ */
++ // _GLIBCXX_RESOLVE_LIB_DEFECTS
++ // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps
+ template<typename _Res, typename... _Args>
+ inline void
+- swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
++ swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+ { __x.swap(__y); }
+
+ _GLIBCXX_END_NAMESPACE_VERSION
+diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
+index e500a76..90a0d73 100644
+--- a/libstdc++-v3/include/std/tuple
++++ b/libstdc++-v3/include/std/tuple
+@@ -607,7 +607,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ template<typename _U1, typename _U2, typename = typename
+ enable_if<__and_<is_convertible<_U1, _T1>,
+- is_convertible<_U2, _T2>>::value>::type>
++ is_convertible<_U2, _T2>,
++ __not_<is_same<typename decay<_U1>::type,
++ allocator_arg_t>>>
++ ::value>::type>
+ explicit
+ constexpr tuple(_U1&& __a1, _U2&& __a2)
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+diff --git a/libstdc++-v3/include/tr1/cmath b/libstdc++-v3/include/tr1/cmath
+index 181cc24..f2edd17 100644
+--- a/libstdc++-v3/include/tr1/cmath
++++ b/libstdc++-v3/include/tr1/cmath
+@@ -490,7 +490,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ using std::ceil;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ copysign(float __x, float __y)
+ { return __builtin_copysignf(__x, __y); }
+@@ -511,7 +511,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ using std::cos;
+ using std::cosh;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ erf(float __x)
+ { return __builtin_erff(__x); }
+@@ -527,7 +527,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ erf(_Tp __x)
+ { return __builtin_erf(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ erfc(float __x)
+ { return __builtin_erfcf(__x); }
+@@ -545,7 +545,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ using std::exp;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ exp2(float __x)
+ { return __builtin_exp2f(__x); }
+@@ -561,7 +561,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ exp2(_Tp __x)
+ { return __builtin_exp2(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ expm1(float __x)
+ { return __builtin_expm1f(__x); }
+@@ -603,7 +603,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_fabs(__x); }
+ #endif
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ fdim(float __x, float __y)
+ { return __builtin_fdimf(__x, __y); }
+@@ -623,7 +623,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ using std::floor;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ fma(float __x, float __y, float __z)
+ { return __builtin_fmaf(__x, __y, __z); }
+@@ -641,7 +641,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return fma(__type(__x), __type(__y), __type(__z));
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ fmax(float __x, float __y)
+ { return __builtin_fmaxf(__x, __y); }
+@@ -659,7 +659,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return fmax(__type(__x), __type(__y));
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ fmin(float __x, float __y)
+ { return __builtin_fminf(__x, __y); }
+@@ -680,7 +680,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ using std::fmod;
+ using std::frexp;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ hypot(float __x, float __y)
+ { return __builtin_hypotf(__x, __y); }
+@@ -716,7 +716,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ using std::ldexp;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ lgamma(float __x)
+ { return __builtin_lgammaf(__x); }
+@@ -732,7 +732,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ lgamma(_Tp __x)
+ { return __builtin_lgamma(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline long long
+ llrint(float __x)
+ { return __builtin_llrintf(__x); }
+@@ -748,7 +748,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ llrint(_Tp __x)
+ { return __builtin_llrint(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline long long
+ llround(float __x)
+ { return __builtin_llroundf(__x); }
+@@ -767,7 +767,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ using std::log;
+ using std::log10;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ log1p(float __x)
+ { return __builtin_log1pf(__x); }
+@@ -784,7 +784,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ { return __builtin_log1p(__x); }
+
+ // DR 568.
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ log2(float __x)
+ { return __builtin_log2f(__x); }
+@@ -800,7 +800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ log2(_Tp __x)
+ { return __builtin_log2(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ logb(float __x)
+ { return __builtin_logbf(__x); }
+@@ -818,7 +818,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return __builtin_logb(__x);
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline long
+ lrint(float __x)
+ { return __builtin_lrintf(__x); }
+@@ -834,7 +834,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ lrint(_Tp __x)
+ { return __builtin_lrint(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline long
+ lround(float __x)
+ { return __builtin_lroundf(__x); }
+@@ -850,7 +850,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ lround(_Tp __x)
+ { return __builtin_lround(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP_FP
+ inline float
+ nearbyint(float __x)
+ { return __builtin_nearbyintf(__x); }
+@@ -866,7 +866,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ nearbyint(_Tp __x)
+ { return __builtin_nearbyint(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ nextafter(float __x, float __y)
+ { return __builtin_nextafterf(__x, __y); }
+@@ -884,7 +884,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return nextafter(__type(__x), __type(__y));
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP_FP
+ inline float
+ nexttoward(float __x, long double __y)
+ { return __builtin_nexttowardf(__x, __y); }
+@@ -900,7 +900,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ nexttoward(_Tp __x, long double __y)
+ { return __builtin_nexttoward(__x, __y); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ remainder(float __x, float __y)
+ { return __builtin_remainderf(__x, __y); }
+@@ -918,7 +918,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return remainder(__type(__x), __type(__y));
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ remquo(float __x, float __y, int* __pquo)
+ { return __builtin_remquof(__x, __y, __pquo); }
+@@ -936,7 +936,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ return remquo(__type(__x), __type(__y), __pquo);
+ }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ rint(float __x)
+ { return __builtin_rintf(__x); }
+@@ -952,7 +952,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ rint(_Tp __x)
+ { return __builtin_rint(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ round(float __x)
+ { return __builtin_roundf(__x); }
+@@ -968,7 +968,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ round(_Tp __x)
+ { return __builtin_round(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ scalbln(float __x, long __ex)
+ { return __builtin_scalblnf(__x, __ex); }
+@@ -984,7 +984,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ scalbln(_Tp __x, long __ex)
+ { return __builtin_scalbln(__x, __ex); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ scalbn(float __x, int __ex)
+ { return __builtin_scalbnf(__x, __ex); }
+@@ -1006,7 +1006,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ using std::tan;
+ using std::tanh;
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ tgamma(float __x)
+ { return __builtin_tgammaf(__x); }
+@@ -1022,7 +1022,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ tgamma(_Tp __x)
+ { return __builtin_tgamma(__x); }
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ trunc(float __x)
+ { return __builtin_truncf(__x); }
+@@ -1064,7 +1064,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ // the discussion about this issue here:
+ // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html
+
+-#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
++#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
+ inline float
+ pow(float __x, float __y)
+ { return std::pow(__x, __y); }
+diff --git a/libstdc++-v3/python/libstdcxx/v6/xmethods.py b/libstdc++-v3/python/libstdcxx/v6/xmethods.py
+index 6db0e16..4505f0f 100644
+--- a/libstdc++-v3/python/libstdcxx/v6/xmethods.py
++++ b/libstdc++-v3/python/libstdcxx/v6/xmethods.py
+@@ -165,7 +165,7 @@ class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher):
+ class DequeWorkerBase(gdb.xmethod.XMethodWorker):
+ def __init__(self, val_type):
+ self._val_type = val_type
+- self._bufsize = (512 / val_type.sizeof) or 1
++ self._bufsize = 512 // val_type.sizeof or 1
+
+ def size(self, obj):
+ first_node = obj['_M_impl']['_M_start']['_M_node']
+@@ -174,10 +174,10 @@ class DequeWorkerBase(gdb.xmethod.XMethodWorker):
+ first = obj['_M_impl']['_M_finish']['_M_first']
+ return (last_node - first_node) * self._bufsize + (cur - first)
+
+- def index(self, obj, index):
++ def index(self, obj, idx):
+ first_node = obj['_M_impl']['_M_start']['_M_node']
+- index_node = first_node + index / self._bufsize
+- return index_node[0][index % self._bufsize]
++ index_node = first_node + int(idx) // self._bufsize
++ return index_node[0][idx % self._bufsize]
+
+ class DequeEmptyWorker(DequeWorkerBase):
+ def get_arg_types(self):
+@@ -410,7 +410,7 @@ class VectorWorkerBase(gdb.xmethod.XMethodWorker):
+ if self._val_type.code == gdb.TYPE_CODE_BOOL:
+ start = obj['_M_impl']['_M_start']['_M_p']
+ bit_size = start.dereference().type.sizeof * 8
+- valp = start + index / bit_size
++ valp = start + index // bit_size
+ offset = index % bit_size
+ return (valp.dereference() & (1 << offset)) > 0
+ else:
+diff --git a/libstdc++-v3/src/c++11/shared_ptr.cc b/libstdc++-v3/src/c++11/shared_ptr.cc
+index 306492d..50d122b 100644
+--- a/libstdc++-v3/src/c++11/shared_ptr.cc
++++ b/libstdc++-v3/src/c++11/shared_ptr.cc
+@@ -54,7 +54,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ }
+ }
+
+- _Sp_locker::_Sp_locker(const void* p)
++ _Sp_locker::_Sp_locker(const void* p) noexcept
+ {
+ if (__gthread_active_p())
+ {
+@@ -65,7 +65,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ _M_key1 = _M_key2 = invalid;
+ }
+
+- _Sp_locker::_Sp_locker(const void* p1, const void* p2)
++ _Sp_locker::_Sp_locker(const void* p1, const void* p2) noexcept
+ {
+ if (__gthread_active_p())
+ {
+diff --git a/libstdc++-v3/src/filesystem/Makefile.in b/libstdc++-v3/src/filesystem/Makefile.in
+index bbc45a8..f8f0180 100644
+--- a/libstdc++-v3/src/filesystem/Makefile.in
++++ b/libstdc++-v3/src/filesystem/Makefile.in
+@@ -352,7 +352,7 @@ WARN_CXXFLAGS = \
+
+
+ # -I/-D flags to pass when compiling.
+-AM_CPPFLAGS = $(GLIBCXX_INCLUDES) $(CPPFLAGS)
++AM_CPPFLAGS = $(GLIBCXX_INCLUDES)
+ toolexeclib_LTLIBRARIES = libstdc++fs.la
+ headers =
+ @ENABLE_DUAL_ABI_FALSE@cxx11_abi_sources =
+diff --git a/libstdc++-v3/src/filesystem/dir.cc b/libstdc++-v3/src/filesystem/dir.cc
+index 63c10e7..503441a46 100644
+--- a/libstdc++-v3/src/filesystem/dir.cc
++++ b/libstdc++-v3/src/filesystem/dir.cc
+@@ -79,8 +79,7 @@ namespace
+ return (obj & bits) != Bitmask::none;
+ }
+
+- // Returns {dirp, p} on success, {nullptr, p} on error.
+- // If an ignored EACCES error occurs returns {}.
++ // Returns {dirp, p} on success, {} on error (whether ignored or not).
+ inline fs::_Dir
+ open_dir(const fs::path& p, fs::directory_options options,
+ std::error_code* ec)
+@@ -102,7 +101,7 @@ namespace
+ std::error_code(err, std::generic_category())));
+
+ ec->assign(err, std::generic_category());
+- return {nullptr, p};
++ return {};
+ }
+
+ inline fs::file_type
+@@ -169,7 +168,7 @@ fs::_Dir::advance(error_code* ec, directory_options options)
+ "directory iterator cannot advance",
+ std::error_code(err, std::generic_category())));
+ ec->assign(err, std::generic_category());
+- return true;
++ return false;
+ }
+ else
+ {
+@@ -191,12 +190,6 @@ directory_iterator(const path& p, directory_options options, error_code* ec)
+ if (sp->advance(ec, options))
+ _M_dir.swap(sp);
+ }
+- else if (!dir.path.empty())
+- {
+- // An error occurred, we need a non-empty shared_ptr so that *this will
+- // not compare equal to the end iterator.
+- _M_dir.reset(static_cast<fs::_Dir*>(nullptr));
+- }
+ }
+
+ const fs::directory_entry&
+@@ -270,10 +263,6 @@ recursive_directory_iterator(const path& p, directory_options options,
+ std::error_code(err, std::generic_category())));
+
+ ec->assign(err, std::generic_category());
+-
+- // An error occurred, we need a non-empty shared_ptr so that *this will
+- // not compare equal to the end iterator.
+- _M_dirs.reset(static_cast<_Dir_stack*>(nullptr));
+ }
+ }
+
+@@ -354,7 +343,10 @@ fs::recursive_directory_iterator::increment(error_code& ec) noexcept
+ {
+ _Dir dir = open_dir(top.entry.path(), _M_options, &ec);
+ if (ec)
+- return *this;
++ {
++ _M_dirs.reset();
++ return *this;
++ }
+ if (dir.dirp)
+ _M_dirs->push(std::move(dir));
+ }
+@@ -372,19 +364,33 @@ fs::recursive_directory_iterator::increment(error_code& ec) noexcept
+ }
+
+ void
+-fs::recursive_directory_iterator::pop()
++fs::recursive_directory_iterator::pop(error_code& ec)
+ {
+ if (!_M_dirs)
+- _GLIBCXX_THROW_OR_ABORT(filesystem_error(
+- "cannot pop non-dereferenceable recursive directory iterator",
+- std::make_error_code(errc::invalid_argument)));
++ {
++ ec = std::make_error_code(errc::invalid_argument);
++ return;
++ }
+
+ do {
+ _M_dirs->pop();
+ if (_M_dirs->empty())
+ {
+ _M_dirs.reset();
++ ec.clear();
+ return;
+ }
+- } while (!_M_dirs->top().advance(nullptr, _M_options));
++ } while (!_M_dirs->top().advance(&ec, _M_options));
++}
++
++void
++fs::recursive_directory_iterator::pop()
++{
++ error_code ec;
++ pop(ec);
++ if (ec)
++ _GLIBCXX_THROW_OR_ABORT(filesystem_error(_M_dirs
++ ? "recursive directory iterator cannot pop"
++ : "non-dereferenceable recursive directory iterator cannot pop",
++ ec));
+ }
+diff --git a/libstdc++-v3/src/filesystem/ops.cc b/libstdc++-v3/src/filesystem/ops.cc
+index 0f09ceb..fea744b 100644
+--- a/libstdc++-v3/src/filesystem/ops.cc
++++ b/libstdc++-v3/src/filesystem/ops.cc
+@@ -28,7 +28,9 @@
+
+ #include <experimental/filesystem>
+ #include <functional>
++#include <ostream>
+ #include <stack>
++#include <ext/stdio_filebuf.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <errno.h>
+@@ -48,9 +50,6 @@
+ #endif
+ #ifdef _GLIBCXX_USE_SENDFILE
+ # include <sys/sendfile.h>
+-#else
+-# include <ext/stdio_filebuf.h>
+-# include <ostream>
+ #endif
+ #if _GLIBCXX_HAVE_UTIME_H
+ # include <utime.h>
+@@ -143,7 +142,11 @@ fs::canonical(const path& p, const path& base, error_code& ec)
+ #endif
+
+ if (!exists(pa, ec))
+- return result;
++ {
++ if (!ec)
++ ec = make_error_code(std::errc::no_such_file_or_directory);
++ return result;
++ }
+ // else: we know there are (currently) no unresolvable symlink loops
+
+ result = pa.root_path();
+@@ -289,27 +292,24 @@ namespace
+ }
+
+ inline fs::file_time_type
+- file_time(const stat_type& st) noexcept
++ file_time(const stat_type& st, std::error_code& ec) noexcept
+ {
+ using namespace std::chrono;
+- return fs::file_time_type{
+ #ifdef _GLIBCXX_USE_ST_MTIM
+- seconds{st.st_mtim.tv_sec} + nanoseconds{st.st_mtim.tv_nsec}
++ time_t s = st.st_mtim.tv_sec;
++ nanoseconds ns{st.st_mtim.tv_nsec};
+ #else
+- seconds{st.st_mtime}
++ time_t s = st.st_mtime;
++ nanoseconds ns{};
+ #endif
+- };
+- }
+
+- // Returns true if the file descriptor was successfully closed,
+- // otherwise returns false and the reason will be in errno.
+- inline bool
+- close_fd(int fd)
+- {
+- while (::close(fd))
+- if (errno != EINTR)
+- return false;
+- return true;
++ if (s >= (nanoseconds::max().count() / 1e9))
++ {
++ ec = std::make_error_code(std::errc::value_too_large); // EOVERFLOW
++ return fs::file_time_type::min();
++ }
++ ec.clear();
++ return fs::file_time_type{seconds{s} + ns};
+ }
+
+ bool
+@@ -354,13 +354,25 @@ namespace
+ from_st = &st2;
+ }
+ f = make_file_status(*from_st);
++ // _GLIBCXX_RESOLVE_LIB_DEFECTS
++ // 2712. copy_file() has a number of unspecified error conditions
++ if (!is_regular_file(f))
++ {
++ ec = std::make_error_code(std::errc::not_supported);
++ return false;
++ }
+
+ using opts = fs::copy_options;
+
+ if (exists(t))
+ {
+- if (!is_other(t) && !is_other(f)
+- && to_st->st_dev == from_st->st_dev
++ if (!is_regular_file(t))
++ {
++ ec = std::make_error_code(std::errc::not_supported);
++ return false;
++ }
++
++ if (to_st->st_dev == from_st->st_dev
+ && to_st->st_ino == from_st->st_ino)
+ {
+ ec = std::make_error_code(std::errc::file_exists);
+@@ -374,22 +386,27 @@ namespace
+ }
+ else if (is_set(option, opts::update_existing))
+ {
+- if (file_time(*from_st) <= file_time(*to_st))
+- {
+- ec.clear();
+- return false;
+- }
++ const auto from_mtime = file_time(*from_st, ec);
++ if (ec)
++ return false;
++ if ((from_mtime <= file_time(*to_st, ec)) || ec)
++ return false;
+ }
+ else if (!is_set(option, opts::overwrite_existing))
+ {
+ ec = std::make_error_code(std::errc::file_exists);
+ return false;
+ }
++ else if (!is_regular_file(t))
++ {
++ ec = std::make_error_code(std::errc::not_supported);
++ return false;
++ }
+ }
+
+ struct CloseFD {
+- ~CloseFD() { if (fd != -1) close_fd(fd); }
+- bool close() { return close_fd(std::exchange(fd, -1)); }
++ ~CloseFD() { if (fd != -1) ::close(fd); }
++ bool close() { return ::close(std::exchange(fd, -1)) == 0; }
+ int fd;
+ };
+
+@@ -416,7 +433,7 @@ namespace
+
+ #ifdef _GLIBCXX_USE_FCHMOD
+ if (::fchmod(out.fd, from_st->st_mode))
+-#elif _GLIBCXX_USE_FCHMODAT
++#elif defined _GLIBCXX_USE_FCHMODAT
+ if (::fchmodat(AT_FDCWD, to.c_str(), from_st->st_mode, 0))
+ #else
+ if (::chmod(to.c_str(), from_st->st_mode))
+@@ -427,38 +444,47 @@ namespace
+ }
+
+ #ifdef _GLIBCXX_USE_SENDFILE
+- const auto n = ::sendfile(out.fd, in.fd, nullptr, from_st->st_size);
+- if (n != from_st->st_size)
++ off_t offset = 0;
++ const auto n = ::sendfile(out.fd, in.fd, &offset, from_st->st_size);
++ if (n < 0 && (errno == ENOSYS || errno == EINVAL))
+ {
+- ec.assign(errno, std::generic_category());
+- return false;
++#endif
++ __gnu_cxx::stdio_filebuf<char> sbin(in.fd, std::ios::in);
++ __gnu_cxx::stdio_filebuf<char> sbout(out.fd, std::ios::out);
++ if (sbin.is_open())
++ in.fd = -1;
++ if (sbout.is_open())
++ out.fd = -1;
++ if (from_st->st_size && !(std::ostream(&sbout) << &sbin))
++ {
++ ec = std::make_error_code(std::errc::io_error);
++ return false;
++ }
++ if (!sbout.close() || !sbin.close())
++ {
++ ec.assign(errno, std::generic_category());
++ return false;
++ }
++
++ ec.clear();
++ return true;
++
++#ifdef _GLIBCXX_USE_SENDFILE
+ }
+- if (!out.close() || !in.close())
++ if (n != from_st->st_size)
+ {
+ ec.assign(errno, std::generic_category());
+ return false;
+ }
+-#else
+- __gnu_cxx::stdio_filebuf<char> sbin(in.fd, std::ios::in);
+- __gnu_cxx::stdio_filebuf<char> sbout(out.fd, std::ios::out);
+- if (sbin.is_open())
+- in.fd = -1;
+- if (sbout.is_open())
+- out.fd = -1;
+- if (from_st->st_size && !(std::ostream(&sbout) << &sbin))
+- {
+- ec = std::make_error_code(std::errc::io_error);
+- return false;
+- }
+- if (!sbout.close() || !sbin.close())
++ if (!out.close() || !in.close())
+ {
+ ec.assign(errno, std::generic_category());
+ return false;
+ }
+-#endif
+
+ ec.clear();
+ return true;
++#endif
+ }
+ }
+ #endif
+@@ -474,7 +500,8 @@ fs::copy(const path& from, const path& to, copy_options options,
+
+ file_status f, t;
+ stat_type from_st, to_st;
+- // N4099 doesn't check copy_symlinks here, but I think that's a defect.
++ // _GLIBCXX_RESOLVE_LIB_DEFECTS
++ // 2681. filesystem::copy() cannot copy symlinks
+ if (use_lstat || copy_symlinks
+ ? ::lstat(from.c_str(), &from_st)
+ : ::stat(from.c_str(), &from_st))
+@@ -541,6 +568,10 @@ fs::copy(const path& from, const path& to, copy_options options,
+ do_copy_file(from, to, options, &from_st, ptr, ec);
+ }
+ }
++ // _GLIBCXX_RESOLVE_LIB_DEFECTS
++ // 2682. filesystem::copy() won't create a symlink to a directory
++ else if (is_directory(f) && create_symlinks)
++ ec = std::make_error_code(errc::is_a_directory);
+ else if (is_directory(f) && (is_set(options, copy_options::recursive)
+ || options == copy_options::none))
+ {
+@@ -553,7 +584,10 @@ fs::copy(const path& from, const path& to, copy_options options,
+ for (const directory_entry& x : directory_iterator(from))
+ copy(x.path(), to/x.path().filename(), options, ec);
+ }
+- // "Otherwise no effects." (should ec.clear() be called?)
++ // _GLIBCXX_RESOLVE_LIB_DEFECTS
++ // 2683. filesystem::copy() says "no effects"
++ else
++ ec.clear();
+ }
+
+ bool
+@@ -890,7 +924,7 @@ fs::equivalent(const path& p1, const path& p2)
+ {
+ error_code ec;
+ auto result = equivalent(p1, p2, ec);
+- if (ec.value())
++ if (ec)
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check file equivalence",
+ p1, p2, ec));
+ return result;
+@@ -900,25 +934,42 @@ bool
+ fs::equivalent(const path& p1, const path& p2, error_code& ec) noexcept
+ {
+ #ifdef _GLIBCXX_HAVE_SYS_STAT_H
++ int err = 0;
++ file_status s1, s2;
+ stat_type st1, st2;
+- if (::stat(p1.c_str(), &st1) == 0 && ::stat(p2.c_str(), &st2) == 0)
++ if (::stat(p1.c_str(), &st1) == 0)
++ s1 = make_file_status(st1);
++ else if (is_not_found_errno(errno))
++ s1.type(file_type::not_found);
++ else
++ err = errno;
++
++ if (::stat(p2.c_str(), &st2) == 0)
++ s2 = make_file_status(st2);
++ else if (is_not_found_errno(errno))
++ s2.type(file_type::not_found);
++ else
++ err = errno;
++
++ if (exists(s1) && exists(s2))
+ {
+- file_status s1 = make_file_status(st1);
+- file_status s2 = make_file_status(st2);
+ if (is_other(s1) && is_other(s2))
+ {
+ ec = std::make_error_code(std::errc::not_supported);
+ return false;
+ }
+ ec.clear();
++ if (is_other(s1) || is_other(s2))
++ return false;
+ return st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino;
+ }
+- else if (is_not_found_errno(errno))
+- {
+- ec = std::make_error_code(std::errc::no_such_file_or_directory);
+- return false;
+- }
+- ec.assign(errno, std::generic_category());
++ else if (!exists(s1) && !exists(s2))
++ ec = std::make_error_code(std::errc::no_such_file_or_directory);
++ else if (err)
++ ec.assign(err, std::generic_category());
++ else
++ ec.clear();
++ return false;
+ #else
+ ec = std::make_error_code(std::errc::not_supported);
+ #endif
+@@ -1000,20 +1051,24 @@ fs::hard_link_count(const path& p, error_code& ec) noexcept
+ bool
+ fs::is_empty(const path& p)
+ {
+- return fs::is_directory(status(p))
+- ? fs::directory_iterator(p) == fs::directory_iterator()
+- : fs::file_size(p) == 0;
++ error_code ec;
++ bool e = is_empty(p, ec);
++ if (ec)
++ _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot check if file is empty",
++ p, ec));
++ return e;
+ }
+
+ bool
+ fs::is_empty(const path& p, error_code& ec) noexcept
+ {
+ auto s = status(p, ec);
+- if (ec.value())
++ if (ec)
+ return false;
+- return fs::is_directory(s)
++ bool empty = fs::is_directory(s)
+ ? fs::directory_iterator(p, ec) == fs::directory_iterator()
+ : fs::file_size(p, ec) == 0;
++ return ec ? false : empty;
+ }
+
+ fs::file_time_type
+@@ -1029,7 +1084,7 @@ fs::last_write_time(const path& p)
+ fs::file_time_type
+ fs::last_write_time(const path& p, error_code& ec) noexcept
+ {
+- return do_stat(p, ec, [](const auto& st) { return file_time(st); },
++ return do_stat(p, ec, [&ec](const auto& st) { return file_time(st, ec); },
+ file_time_type::min());
+ }
+
+@@ -1050,6 +1105,11 @@ fs::last_write_time(const path& p __attribute__((__unused__)),
+ auto s = chrono::duration_cast<chrono::seconds>(d);
+ #if _GLIBCXX_USE_UTIMENSAT
+ auto ns = chrono::duration_cast<chrono::nanoseconds>(d - s);
++ if (ns < ns.zero()) // tv_nsec must be non-negative and less than 10e9.
++ {
++ --s;
++ ns += chrono::seconds(1);
++ }
+ struct ::timespec ts[2];
+ ts[0].tv_sec = 0;
+ ts[0].tv_nsec = UTIME_OMIT;
+@@ -1082,14 +1142,47 @@ fs::permissions(const path& p, perms prms)
+ _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot set permissions", p, ec));
+ }
+
+-void fs::permissions(const path& p, perms prms, error_code& ec) noexcept
++void
++fs::permissions(const path& p, perms prms, error_code& ec) noexcept
+ {
++ const bool add = is_set(prms, perms::add_perms);
++ const bool remove = is_set(prms, perms::remove_perms);
++ const bool nofollow = is_set(prms, perms::symlink_nofollow);
++ if (add && remove)
++ {
++ ec = std::make_error_code(std::errc::invalid_argument);
++ return;
++ }
++
++ prms &= perms::mask;
++
++ file_status st;
++ if (add || remove || nofollow)
++ {
++ st = nofollow ? symlink_status(p, ec) : status(p, ec);
++ if (ec)
++ return;
++ auto curr = st.permissions();
++ if (add)
++ prms |= curr;
++ else if (remove)
++ prms = curr & ~prms;
++ }
++
++ int err = 0;
+ #if _GLIBCXX_USE_FCHMODAT
+- if (::fchmodat(AT_FDCWD, p.c_str(), static_cast<mode_t>(prms), 0))
++ const int flag = (nofollow && is_symlink(st)) ? AT_SYMLINK_NOFOLLOW : 0;
++ if (::fchmodat(AT_FDCWD, p.c_str(), static_cast<mode_t>(prms), flag))
++ err = errno;
+ #else
+- if (::chmod(p.c_str(), static_cast<mode_t>(prms)))
++ if (nofollow && is_symlink(st))
++ ec = std::make_error_code(std::errc::operation_not_supported);
++ else if (::chmod(p.c_str(), static_cast<mode_t>(prms)))
++ err = errno;
+ #endif
+- ec.assign(errno, std::generic_category());
++
++ if (err)
++ ec.assign(err, std::generic_category());
+ else
+ ec.clear();
+ }
+@@ -1120,6 +1213,7 @@ fs::path fs::read_symlink(const path& p, error_code& ec)
+ ec.assign(errno, std::generic_category());
+ return {};
+ }
++ ec.clear();
+ return path{buf.data(), buf.data()+len};
+ #else
+ ec = std::make_error_code(std::errc::not_supported);
+@@ -1172,7 +1266,7 @@ fs::remove_all(const path& p, error_code& ec) noexcept
+ uintmax_t count = 0;
+ if (ec.value() == 0 && fs.type() == file_type::directory)
+ for (directory_iterator d(p, ec), end; ec.value() == 0 && d != end; ++d)
+- count += fs::remove(d->path(), ec);
++ count += fs::remove_all(d->path(), ec);
+ if (ec.value())
+ return -1;
+ return fs::remove(p, ec) ? ++count : -1; // fs:remove() calls ec.clear()
+@@ -1260,7 +1354,7 @@ fs::space(const path& p, error_code& ec) noexcept
+
+ #ifdef _GLIBCXX_HAVE_SYS_STAT_H
+ fs::file_status
+-fs::status(const fs::path& p, std::error_code& ec) noexcept
++fs::status(const fs::path& p, error_code& ec) noexcept
+ {
+ file_status status;
+ stat_type st;
+@@ -1270,6 +1364,10 @@ fs::status(const fs::path& p, std::error_code& ec) noexcept
+ ec.assign(err, std::generic_category());
+ if (is_not_found_errno(err))
+ status.type(file_type::not_found);
++#ifdef EOVERFLOW
++ else if (err == EOVERFLOW)
++ status.type(file_type::unknown);
++#endif
+ }
+ else
+ {
+@@ -1368,12 +1466,17 @@ fs::path fs::temp_directory_path(error_code& ec)
+ for (auto e = env; tmpdir == nullptr && *e != nullptr; ++e)
+ tmpdir = ::getenv(*e);
+ path p = tmpdir ? tmpdir : "/tmp";
+- if (exists(p) && is_directory(p))
++ auto st = status(p, ec);
++ if (!ec)
+ {
+- ec.clear();
+- return p;
++ if (is_directory(st))
++ {
++ ec.clear();
++ return p;
++ }
++ else
++ ec = std::make_error_code(std::errc::not_a_directory);
+ }
+- ec = std::make_error_code(std::errc::not_a_directory);
+ return {};
+ #endif
+ }
+diff --git a/libstdc++-v3/testsuite/17_intro/using_namespace_std_exp_neg.cc b/libstdc++-v3/testsuite/17_intro/using_namespace_std_exp_neg.cc
+new file mode 100644
+index 0000000..963edda
+--- /dev/null
++++ b/libstdc++-v3/testsuite/17_intro/using_namespace_std_exp_neg.cc
+@@ -0,0 +1,66 @@
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++#include <algorithm>
++#include <array>
++#include <bitset>
++#include <complex>
++#include <deque>
++#include <exception>
++#include <fstream>
++#include <functional>
++#include <iomanip>
++#include <ios>
++#include <iosfwd>
++#include <iostream>
++#include <istream>
++#include <iterator>
++#include <limits>
++#include <list>
++#include <locale>
++#include <map>
++#include <memory>
++#include <new>
++#include <numeric>
++#include <ostream>
++#include <queue>
++#include <random>
++#include <regex>
++#include <set>
++#include <sstream>
++#include <stack>
++#include <stdexcept>
++#include <streambuf>
++#include <string>
++#include <tuple>
++#include <typeinfo>
++#include <type_traits>
++#include <unordered_map>
++#include <unordered_set>
++#include <utility>
++#include <valarray>
++#include <vector>
++
++namespace gnu
++{
++ using namespace std::experimental; // { dg-error "is not a namespace-name" }
++}
++
++// { dg-error "expected namespace-name before" "" { target *-*-* } 63 }
+diff --git a/libstdc++-v3/testsuite/18_support/headers/new/synopsis.cc b/libstdc++-v3/testsuite/18_support/headers/new/synopsis.cc
+index c7a7163..cdf06eb 100644
+--- a/libstdc++-v3/testsuite/18_support/headers/new/synopsis.cc
++++ b/libstdc++-v3/testsuite/18_support/headers/new/synopsis.cc
+@@ -22,18 +22,19 @@
+
+ namespace std {
+ class bad_alloc;
++ class bad_array_new_length;
+ struct nothrow_t;
+ extern const nothrow_t nothrow;
+ typedef void (*new_handler)();
+- new_handler set_new_handler(new_handler new_p) throw();
+ new_handler get_new_handler() noexcept;
++ new_handler set_new_handler(new_handler new_p) noexcept;
+ }
+
+-void* operator new(std::size_t size) throw(std::bad_alloc);
+-void* operator new(std::size_t size, const std::nothrow_t&) throw();
++void* operator new(std::size_t size);
++void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+ void operator delete(void* ptr) throw();
+ void operator delete(void* ptr, const std::nothrow_t&) throw();
+-void* operator new[](std::size_t size) throw(std::bad_alloc);
++void* operator new[](std::size_t size);
+ void* operator new[](std::size_t size, const std::nothrow_t&) throw();
+ void operator delete[](void* ptr) throw();
+ void operator delete[](void* ptr, const std::nothrow_t&) throw();
+@@ -42,3 +43,13 @@ void* operator new (std::size_t size, void* ptr) throw();
+ void* operator new[](std::size_t size, void* ptr) throw();
+ void operator delete (void* ptr, void*) throw();
+ void operator delete[](void* ptr, void*) throw();
++
++#if __cplusplus >= 201402L
++// C++14 sized deallocation functions
++void operator delete(void* ptr, std::size_t size) noexcept;
++void operator delete(void* ptr, std::size_t size,
++ const std::nothrow_t&) noexcept;
++void operator delete[](void* ptr, std::size_t size) noexcept;
++void operator delete[](void* ptr, std::size_t size,
++ const std::nothrow_t&) noexcept;
++#endif
+diff --git a/libstdc++-v3/testsuite/18_support/headers/new/synopsis_cxx98.cc b/libstdc++-v3/testsuite/18_support/headers/new/synopsis_cxx98.cc
+new file mode 100644
+index 0000000..2b2abd2
+--- /dev/null
++++ b/libstdc++-v3/testsuite/18_support/headers/new/synopsis_cxx98.cc
+@@ -0,0 +1,43 @@
++// { dg-options "-std=gnu++98" }
++// { dg-do compile }
++
++// Copyright (C) 2007-2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++#include <new>
++
++namespace std {
++ class bad_alloc;
++ struct nothrow_t;
++ extern const nothrow_t nothrow;
++ typedef void (*new_handler)();
++ new_handler set_new_handler(new_handler new_p) throw();
++}
++
++void* operator new(std::size_t size) throw(std::bad_alloc);
++void* operator new(std::size_t size, const std::nothrow_t&) throw();
++void operator delete(void* ptr) throw();
++void operator delete(void* ptr, const std::nothrow_t&) throw();
++void* operator new[](std::size_t size) throw(std::bad_alloc);
++void* operator new[](std::size_t size, const std::nothrow_t&) throw();
++void operator delete[](void* ptr) throw();
++void operator delete[](void* ptr, const std::nothrow_t&) throw();
++
++void* operator new (std::size_t size, void* ptr) throw();
++void* operator new[](std::size_t size, void* ptr) throw();
++void operator delete (void* ptr, void*) throw();
++void operator delete[](void* ptr, void*) throw();
+diff --git a/libstdc++-v3/testsuite/20_util/allocator/void.cc b/libstdc++-v3/testsuite/20_util/allocator/void.cc
+new file mode 100644
+index 0000000..34f3beb
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/allocator/void.cc
+@@ -0,0 +1,40 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <memory>
++#include <testsuite_hooks.h>
++
++template class std::allocator<void>;
++
++void
++test01()
++{
++ int i;
++ using alloc_type = std::allocator<void>;
++ alloc_type a;
++ std::allocator_traits<alloc_type>::construct(a, &i, 42);
++ VERIFY( i == 42 );
++ std::allocator_traits<alloc_type>::destroy(a, &i);
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/20_util/duration/literals/range.cc b/libstdc++-v3/testsuite/20_util/duration/literals/range.cc
+index a56b238..9cd3215 100644
+--- a/libstdc++-v3/testsuite/20_util/duration/literals/range.cc
++++ b/libstdc++-v3/testsuite/20_util/duration/literals/range.cc
+@@ -27,5 +27,5 @@ test01()
+
+ // std::numeric_limits<int64_t>::max() == 9223372036854775807;
+ auto h = 9223372036854775808h;
+- // { dg-error "cannot be represented" "" { target *-*-* } 796 }
++ // { dg-error "cannot be represented" "" { target *-*-* } 797 }
+ }
+diff --git a/libstdc++-v3/testsuite/20_util/function/77322.cc b/libstdc++-v3/testsuite/20_util/function/77322.cc
+new file mode 100644
+index 0000000..52abdf6
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/function/77322.cc
+@@ -0,0 +1,26 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <functional>
++
++// PR libstdc++/77322
++std::function<void()> f, g;
++static_assert( noexcept(f.swap(g)), "member swap is noexcept" );
++static_assert( noexcept(swap(f, g)), "non-member swap is noexcept" );
+diff --git a/libstdc++-v3/testsuite/20_util/function/cons/57465.cc b/libstdc++-v3/testsuite/20_util/function/cons/57465.cc
+index ba04ed6..eb5556e 100644
+--- a/libstdc++-v3/testsuite/20_util/function/cons/57465.cc
++++ b/libstdc++-v3/testsuite/20_util/function/cons/57465.cc
+@@ -15,17 +15,33 @@
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+-// libstdc++/57465
+-
+ // { dg-options "-std=gnu++11" }
+
+ #include <functional>
+ #include <testsuite_hooks.h>
+
+-int main()
++void test01()
+ {
+ using F = void();
+ F* f = nullptr;
+ std::function<F> x(f);
+- VERIFY( !x );
++ VERIFY( !x ); // libstdc++/57465
++}
++
++void test02()
++{
++ struct X { };
++ int (X::*mf)() = nullptr;
++ std::function<int(X&)> f = mf;
++ VERIFY( !f ); // libstdc++/69243
++
++ int X::*mp = nullptr;
++ f = mp;
++ VERIFY( !f );
++}
++
++int main()
++{
++ test01();
++ test02();
+ }
+diff --git a/libstdc++-v3/testsuite/20_util/function/cons/72820.cc b/libstdc++-v3/testsuite/20_util/function/cons/72820.cc
+new file mode 100644
+index 0000000..1e4e0e8
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/function/cons/72820.cc
+@@ -0,0 +1,28 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <functional>
++
++struct foo {
++ void operator()() { }
++ static void* operator new(std::size_t, void* p);
++};
++
++std::function<void()> f = foo{};
+diff --git a/libstdc++-v3/testsuite/20_util/function/cons/refqual.cc b/libstdc++-v3/testsuite/20_util/function/cons/refqual.cc
+new file mode 100644
+index 0000000..d3744ee
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/function/cons/refqual.cc
+@@ -0,0 +1,31 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <functional>
++
++struct F {
++ void operator()() && { }
++ int operator()() & { return 0; }
++};
++
++int main() {
++ F f;
++ std::function<int()> ff{f};
++ return ff();
++}
+diff --git a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc
+index 46d1934..dcba138 100644
+--- a/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc
++++ b/libstdc++-v3/testsuite/20_util/reference_wrapper/invoke-2.cc
+@@ -1,5 +1,5 @@
+ // { dg-options "-std=gnu++11" }
+-// { dg-do compile}
++// { dg-do compile }
+ // Copyright (C) 2011-2015 Free Software Foundation, Inc.
+ //
+ // This file is part of the GNU ISO C++ Library. This library is free
+diff --git a/libstdc++-v3/testsuite/20_util/tuple/cons/allocator_with_any.cc b/libstdc++-v3/testsuite/20_util/tuple/cons/allocator_with_any.cc
+new file mode 100644
+index 0000000..dd9a066
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/tuple/cons/allocator_with_any.cc
+@@ -0,0 +1,42 @@
++// { dg-do run }
++// { dg-options "-std=gnu++14" }
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++
++// NOTE: This makes use of the fact that we know how moveable
++// is implemented on tuple. If the implementation changed
++// this test may begin to fail.
++
++#include <tuple>
++#include <experimental/any>
++#include <testsuite_hooks.h>
++
++using std::experimental::any;
++
++void test01()
++{
++ std::tuple<any, any> t(std::allocator_arg,
++ std::allocator<any>{});
++ VERIFY(std::get<0>(t).empty());
++ VERIFY(std::get<1>(t).empty());
++}
++
++int main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc
+index 185f39c..7c79282 100644
+--- a/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc
++++ b/libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc
+@@ -41,10 +41,10 @@ void f()
+ std::unique_ptr<int, B&> ub(nullptr, b);
+ std::unique_ptr<int, D&> ud(nullptr, d);
+ ub = std::move(ud);
+-// { dg-error "use of deleted function" "" { target *-*-* } 272 }
++// { dg-error "use of deleted function" "" { target *-*-* } 275 }
+
+ std::unique_ptr<int[], B&> uba(nullptr, b);
+ std::unique_ptr<int[], D&> uda(nullptr, d);
+ uba = std::move(uda);
+-// { dg-error "use of deleted function" "" { target *-*-* } 517 }
++// { dg-error "use of deleted function" "" { target *-*-* } 520 }
+ }
+diff --git a/libstdc++-v3/testsuite/20_util/unique_ptr/cons/77990.cc b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/77990.cc
+new file mode 100644
+index 0000000..1acc313
+--- /dev/null
++++ b/libstdc++-v3/testsuite/20_util/unique_ptr/cons/77990.cc
+@@ -0,0 +1,28 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <memory>
++
++struct D {
++ D() = default;
++ D(const D&) = delete;
++ void operator()(int*);
++};
++std::unique_ptr<int, D> p((int*)nullptr); // PR libstdc++/77990
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy.cc
+new file mode 100644
+index 0000000..d02e9b9
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy.cc
+@@ -0,0 +1,97 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(0 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(0 == v3.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v3.get_allocator().get_personality());
++}
++
++void test03()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1, alloc_type(2));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1, alloc_type(3));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(3 == v3.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ test03();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy_assign.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy_assign.cc
+new file mode 100644
+index 0000000..94e0796
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/copy_assign.cc
+@@ -0,0 +1,114 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ v1.assign(1, c);
++ test_type v3(alloc_type(3));
++ v3.assign(100, c);
++ v3 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(3 == v3.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v4(alloc_type(4));
++ v4.assign(1, c);
++ v4 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(4 == v4.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ v5 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(5 == v5.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ v1.assign(1, c);
++ test_type v3(alloc_type(3));
++ v3.assign(100, c);
++ v3 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v3.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v4(alloc_type(4));
++ v4.assign(1, c);
++ v4 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v4.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ v5 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v5.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/minimal.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/minimal.cc
+new file mode 100644
+index 0000000..d8dbb00
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/minimal.cc
+@@ -0,0 +1,51 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <memory>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::SimpleAllocator;
++
++template class std::basic_string<C, traits, SimpleAllocator<C>>;
++
++void test01()
++{
++ typedef SimpleAllocator<C> alloc_type;
++ typedef std::allocator_traits<alloc_type> traits_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v(alloc_type{});
++ v.assign(1, c);
++ v.assign(100, c);
++}
++#else
++void test01() { }
++#endif
++
++int main()
++{
++ test01();
++ return 0;
++}
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move.cc
+new file mode 100644
+index 0000000..113df8f
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move.cc
+@@ -0,0 +1,66 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::uneq_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef uneq_allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(std::move(v1));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef uneq_allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(std::move(v1), alloc_type(2));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move_assign.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move_assign.cc
+new file mode 100644
+index 0000000..153ffd2
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/move_assign.cc
+@@ -0,0 +1,160 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(4));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(3 == v3.get_allocator().get_personality());
++ VERIFY(4 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(6));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(5 == v5.get_allocator().get_personality());
++ VERIFY(6 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(8));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(7 == v7.get_allocator().get_personality());
++ VERIFY(8 == v8.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(0 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(4));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(0 == v3.get_allocator().get_personality());
++ VERIFY(3 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(6));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(0 == v5.get_allocator().get_personality());
++ VERIFY(5 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(8));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(0 == v7.get_allocator().get_personality());
++ VERIFY(7 == v8.get_allocator().get_personality());
++}
++
++void test03()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(1));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(3));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(3 == v3.get_allocator().get_personality());
++ VERIFY(3 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(5));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(5 == v5.get_allocator().get_personality());
++ VERIFY(5 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(7));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(7 == v7.get_allocator().get_personality());
++ VERIFY(7 == v8.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ test03();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/noexcept.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/noexcept.cc
+new file mode 100644
+index 0000000..8733ea1
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/noexcept.cc
+@@ -0,0 +1,61 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-do compile }
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ typedef std::allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1;
++ test_type v2;
++ // this is a GNU extension for std::allocator
++ static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++
++void test02()
++{
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ test_type v2(alloc_type(2));
++ static_assert( !noexcept( v1 = std::move(v2) ), "Move assign can throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++
++void test03()
++{
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ test_type v2(alloc_type(2));
++ static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/swap.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/swap.cc
+new file mode 100644
+index 0000000..21003eb
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/char/swap.cc
+@@ -0,0 +1,89 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = char;
++const C c = 'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++// It is undefined behaviour to swap() containers wth unequal allocators
++// if the allocator doesn't propagate, so ensure the allocators compare
++// equal, while still being able to test propagation via get_personality().
++bool
++operator==(const propagating_allocator<C, false>&,
++ const propagating_allocator<C, false>&)
++{
++ return true;
++}
++
++bool
++operator!=(const propagating_allocator<C, false>&,
++ const propagating_allocator<C, false>&)
++{
++ return false;
++}
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.push_back(C());
++ test_type v2(alloc_type(2));
++ v2.push_back(C());
++ std::swap(v1, v2);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++ // swap back so assertions in uneq_allocator::deallocate don't fail
++ std::swap(v1, v2);
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.push_back(C());
++ test_type v2(alloc_type(2));
++ v2.push_back(C());
++ std::swap(v1, v2);
++ VERIFY(2 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy.cc
+new file mode 100644
+index 0000000..8a51279
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy.cc
+@@ -0,0 +1,97 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(0 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(0 == v3.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v3.get_allocator().get_personality());
++}
++
++void test03()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(v1, alloc_type(2));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v3(v1, alloc_type(3));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(3 == v3.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ test03();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy_assign.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy_assign.cc
+new file mode 100644
+index 0000000..ed8feb7
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/copy_assign.cc
+@@ -0,0 +1,114 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ v1.assign(1, c);
++ test_type v3(alloc_type(3));
++ v3.assign(100, c);
++ v3 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(3 == v3.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v4(alloc_type(4));
++ v4.assign(1, c);
++ v4 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(4 == v4.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ v5 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(5 == v5.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ v1.assign(1, c);
++ test_type v3(alloc_type(3));
++ v3.assign(100, c);
++ v3 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v3.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v4(alloc_type(4));
++ v4.assign(1, c);
++ v4 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v4.get_allocator().get_personality());
++
++ v1.assign(100, c);
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ v5 = v1;
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v5.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc
+new file mode 100644
+index 0000000..8643785
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/minimal.cc
+@@ -0,0 +1,51 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <memory>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::SimpleAllocator;
++
++template class std::basic_string<C, traits, SimpleAllocator<C>>;
++
++void test01()
++{
++ typedef SimpleAllocator<C> alloc_type;
++ typedef std::allocator_traits<alloc_type> traits_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v(alloc_type{});
++ v.assign(1, c);
++ v.assign(100, c);
++}
++#else
++void test01() { }
++#endif
++
++int main()
++{
++ test01();
++ return 0;
++}
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move.cc
+new file mode 100644
+index 0000000..55d1878
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move.cc
+@@ -0,0 +1,66 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::uneq_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef uneq_allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(std::move(v1));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef uneq_allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(std::move(v1), alloc_type(2));
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move_assign.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move_assign.cc
+new file mode 100644
+index 0000000..7c28fa8
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/move_assign.cc
+@@ -0,0 +1,160 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(4));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(3 == v3.get_allocator().get_personality());
++ VERIFY(4 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(6));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(5 == v5.get_allocator().get_personality());
++ VERIFY(6 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(8));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(7 == v7.get_allocator().get_personality());
++ VERIFY(8 == v8.get_allocator().get_personality());
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(2));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(0 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(4));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(0 == v3.get_allocator().get_personality());
++ VERIFY(3 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(6));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(0 == v5.get_allocator().get_personality());
++ VERIFY(5 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(8));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(0 == v7.get_allocator().get_personality());
++ VERIFY(7 == v8.get_allocator().get_personality());
++}
++
++void test03()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++
++ test_type v1(alloc_type(1));
++ v1.assign(1, c);
++ test_type v2(alloc_type(1));
++ v2.assign(1, c);
++ v2 = std::move(v1);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++
++ test_type v3(alloc_type(3));
++ v3.assign(1, c);
++ test_type v4(alloc_type(3));
++ v4.assign(100, c);
++ v4 = std::move(v3);
++ VERIFY(3 == v3.get_allocator().get_personality());
++ VERIFY(3 == v4.get_allocator().get_personality());
++
++ test_type v5(alloc_type(5));
++ v5.assign(100, c);
++ test_type v6(alloc_type(5));
++ v6.assign(1, c);
++ v6 = std::move(v5);
++ VERIFY(5 == v5.get_allocator().get_personality());
++ VERIFY(5 == v6.get_allocator().get_personality());
++
++ test_type v7(alloc_type(7));
++ v7.assign(100, c);
++ test_type v8(alloc_type(7));
++ v8.assign(100, c);
++ v8 = std::move(v7);
++ VERIFY(7 == v7.get_allocator().get_personality());
++ VERIFY(7 == v8.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ test03();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/noexcept.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/noexcept.cc
+new file mode 100644
+index 0000000..77da966
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/noexcept.cc
+@@ -0,0 +1,61 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-do compile }
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++void test01()
++{
++ typedef std::allocator<C> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1;
++ test_type v2;
++ // this is a GNU extension for std::allocator
++ static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++
++void test02()
++{
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ test_type v2(alloc_type(2));
++ static_assert( !noexcept( v1 = std::move(v2) ), "Move assign can throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++
++void test03()
++{
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ test_type v2(alloc_type(2));
++ static_assert( noexcept( v1 = std::move(v2) ), "Move assign cannot throw" );
++ static_assert( noexcept( v1.swap(v2) ), "Swap cannot throw" );
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/swap.cc b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/swap.cc
+new file mode 100644
+index 0000000..23b8ac0
+--- /dev/null
++++ b/libstdc++-v3/testsuite/21_strings/basic_string/allocator/wchar_t/swap.cc
+@@ -0,0 +1,89 @@
++// Copyright (C) 2015 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <string>
++#include <testsuite_hooks.h>
++#include <testsuite_allocator.h>
++
++#if _GLIBCXX_USE_CXX11_ABI
++using C = wchar_t;
++const C c = L'a';
++using traits = std::char_traits<C>;
++
++using __gnu_test::propagating_allocator;
++
++// It is undefined behaviour to swap() containers wth unequal allocators
++// if the allocator doesn't propagate, so ensure the allocators compare
++// equal, while still being able to test propagation via get_personality().
++bool
++operator==(const propagating_allocator<C, false>&,
++ const propagating_allocator<C, false>&)
++{
++ return true;
++}
++
++bool
++operator!=(const propagating_allocator<C, false>&,
++ const propagating_allocator<C, false>&)
++{
++ return false;
++}
++
++void test01()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, false> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.push_back(C());
++ test_type v2(alloc_type(2));
++ v2.push_back(C());
++ std::swap(v1, v2);
++ VERIFY(1 == v1.get_allocator().get_personality());
++ VERIFY(2 == v2.get_allocator().get_personality());
++ // swap back so assertions in uneq_allocator::deallocate don't fail
++ std::swap(v1, v2);
++}
++
++void test02()
++{
++ bool test __attribute__((unused)) = true;
++ typedef propagating_allocator<C, true> alloc_type;
++ typedef std::basic_string<C, traits, alloc_type> test_type;
++ test_type v1(alloc_type(1));
++ v1.push_back(C());
++ test_type v2(alloc_type(2));
++ v2.push_back(C());
++ std::swap(v1, v2);
++ VERIFY(2 == v1.get_allocator().get_personality());
++ VERIFY(1 == v2.get_allocator().get_personality());
++}
++
++int main()
++{
++ test01();
++ test02();
++ return 0;
++}
++#else
++int main()
++{
++ // COW strings don't support C++11 allocators
++}
++#endif
+diff --git a/libstdc++-v3/testsuite/23_containers/map/77334.cc b/libstdc++-v3/testsuite/23_containers/map/77334.cc
+new file mode 100644
+index 0000000..14dfb2b
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/map/77334.cc
+@@ -0,0 +1,29 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <map>
++
++struct A { A(A&&) = delete; };
++
++void test01()
++{
++ std::map<int, A> m1, m2;
++ m2 = std::move(m1);
++}
+diff --git a/libstdc++-v3/testsuite/23_containers/map/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/map/cons/noexcept_default_construct.cc
+new file mode 100644
+index 0000000..1cb33c1
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/map/cons/noexcept_default_construct.cc
+@@ -0,0 +1,33 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <map>
++
++using mtype1 = std::map<int, int>;
++static_assert(std::is_nothrow_default_constructible<mtype1>::value, "Error");
++
++struct cmp
++{
++ cmp() { }
++ bool operator()(int, int) const;
++};
++
++using mtype2 = std::map<int, int, cmp>;
++static_assert( !std::is_nothrow_default_constructible<mtype2>::value, "Error");
+diff --git a/libstdc++-v3/testsuite/23_containers/multimap/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/multimap/cons/noexcept_default_construct.cc
+new file mode 100644
+index 0000000..69239dc
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/multimap/cons/noexcept_default_construct.cc
+@@ -0,0 +1,33 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <map>
++
++using mtype1 = std::multimap<int, int>;
++static_assert(std::is_nothrow_default_constructible<mtype1>::value, "Error");
++
++struct cmp
++{
++ cmp() { }
++ bool operator()(int, int) const;
++};
++
++using mtype2 = std::multimap<int, int, cmp>;
++static_assert( !std::is_nothrow_default_constructible<mtype2>::value, "Error");
+diff --git a/libstdc++-v3/testsuite/23_containers/multiset/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/multiset/cons/noexcept_default_construct.cc
+new file mode 100644
+index 0000000..6b003f0
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/multiset/cons/noexcept_default_construct.cc
+@@ -0,0 +1,33 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <set>
++
++using stype1 = std::multiset<int>;
++static_assert(std::is_nothrow_default_constructible<stype1>::value, "Error");
++
++struct cmp
++{
++ cmp() { }
++ bool operator()(int, int) const;
++};
++
++using stype2 = std::multiset<int, cmp>;
++static_assert( !std::is_nothrow_default_constructible<stype2>::value, "Error");
+diff --git a/libstdc++-v3/testsuite/23_containers/set/allocator/71964.cc b/libstdc++-v3/testsuite/23_containers/set/allocator/71964.cc
+new file mode 100644
+index 0000000..f13828f
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/set/allocator/71964.cc
+@@ -0,0 +1,71 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++
++#include <set>
++#include <testsuite_hooks.h>
++
++template<typename T>
++ struct mv_allocator
++ {
++ using value_type = T;
++ using size_type = unsigned;
++
++ mv_allocator()
++ : moved_to(false), moved_from(false) { }
++
++ template<typename U>
++ mv_allocator(const mv_allocator<U> & a)
++ : moved_to(a.moved_to), moved_from(a.moved_from) { }
++
++ mv_allocator(const mv_allocator &) = default;
++
++ mv_allocator(mv_allocator && a) noexcept : moved_to(true)
++ {
++ a.moved_from = true;
++ }
++
++ T* allocate(unsigned n) { return std::allocator<T>{}.allcoate(n); }
++ void deallocate(T* p, unsigned n) { std::allocator<T>{}.deallocate(p, n); }
++
++ bool moved_to;
++ bool moved_from;
++ };
++
++template<typename T, typename U>
++bool
++operator==(const mv_allocator<T>&, const mv_allocator<U>&) { return true; }
++
++template<typename T, typename U>
++bool
++operator!=(const mv_allocator<T>&, const mv_allocator<U>&) { return false; }
++
++void
++test01()
++{
++ std::set<int, std::less<int>, mv_allocator<int>> s;
++ auto t = std::move(s);
++ VERIFY( s.get_allocator().moved_from );
++ VERIFY( t.get_allocator().moved_to );
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/23_containers/set/cons/noexcept_default_construct.cc b/libstdc++-v3/testsuite/23_containers/set/cons/noexcept_default_construct.cc
+new file mode 100644
+index 0000000..5ba42b8
+--- /dev/null
++++ b/libstdc++-v3/testsuite/23_containers/set/cons/noexcept_default_construct.cc
+@@ -0,0 +1,33 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <set>
++
++using stype1 = std::set<int>;
++static_assert(std::is_nothrow_default_constructible<stype1>::value, "Error");
++
++struct cmp
++{
++ cmp() { }
++ bool operator()(int, int) const;
++};
++
++using stype2 = std::set<int, cmp>;
++static_assert( !std::is_nothrow_default_constructible<stype2>::value, "Error");
+diff --git a/libstdc++-v3/testsuite/24_iterators/reverse_iterator/71771.cc b/libstdc++-v3/testsuite/24_iterators/reverse_iterator/71771.cc
+new file mode 100644
+index 0000000..b7593dd
+--- /dev/null
++++ b/libstdc++-v3/testsuite/24_iterators/reverse_iterator/71771.cc
+@@ -0,0 +1,46 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11" }
++// { dg-do compile }
++
++#include <iterator>
++#include <testsuite_iterators.h>
++
++// PR libstdc++/71771
++
++template<typename Iter>
++auto
++diff2(std::reverse_iterator<Iter> it1, std::reverse_iterator<Iter> it2)
++-> decltype(it1 - it2)
++{ return it1 - it2; }
++
++template<typename Iter>
++void
++diff2(Iter, Iter)
++{ }
++
++void
++test01()
++{
++ int i[2];
++ __gnu_test::test_container<int, __gnu_test::bidirectional_iterator_wrapper>
++ c(i, i+2);
++ using reverse_iterator
++ = std::reverse_iterator<__gnu_test::bidirectional_iterator_wrapper<int>>;
++ diff2(reverse_iterator(c.end()), reverse_iterator(c.begin()));
++}
+diff --git a/libstdc++-v3/testsuite/26_numerics/random/default_random_engine.cc b/libstdc++-v3/testsuite/26_numerics/random/default_random_engine.cc
+index eb792ff..603d8ba 100644
+--- a/libstdc++-v3/testsuite/26_numerics/random/default_random_engine.cc
++++ b/libstdc++-v3/testsuite/26_numerics/random/default_random_engine.cc
+@@ -20,7 +20,7 @@
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+-// 26.4.5 Engines and egine adaptors with predefined parameters [rand.predef]
++// 26.4.5 Engines and engine adaptors with predefined parameters [rand.predef]
+ // 26.4.5 [10]
+
+ #include <random>
+@@ -38,7 +38,7 @@ test01()
+ std::minstd_rand0 b;
+ b.discard(9999);
+
+- assert( a() == b() );
++ VERIFY( a() == b() );
+ }
+
+ int main()
+diff --git a/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc b/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc
+index d26b467..b14dfa8 100644
+--- a/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc
++++ b/libstdc++-v3/testsuite/29_atomics/headers/atomic/macros.cc
+@@ -1,5 +1,5 @@
+ // { dg-options "-std=gnu++11" }
+-// { dg-do compile }
++// { dg-do preprocess }
+
+ // Copyright (C) 2008-2015 Free Software Foundation, Inc.
+ //
+@@ -22,42 +22,61 @@
+
+ #ifndef ATOMIC_BOOL_LOCK_FREE
+ # error "ATOMIC_BOOL_LOCK_FREE must be a macro"
++#elif ATOMIC_BOOL_LOCK_FREE != 1 && ATOMIC_BOOL_LOCK_FREE != 2
++# error "ATOMIC_BOOL_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_CHAR_LOCK_FREE
+ # error "ATOMIC_CHAR_LOCK_FREE must be a macro"
++#elif ATOMIC_CHAR_LOCK_FREE != 1 && ATOMIC_CHAR_LOCK_FREE != 2
++# error "ATOMIC_CHAR_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_CHAR16_T_LOCK_FREE
+ # error "ATOMIC_CHAR16_T_LOCK_FREE must be a macro"
++#elif ATOMIC_CHAR16_T_LOCK_FREE != 1 && ATOMIC_CHAR16_T_LOCK_FREE != 2
+ #endif
+
+ #ifndef ATOMIC_CHAR32_T_LOCK_FREE
+ # error "ATOMIC_CHAR32_T_LOCK_FREE must be a macro"
++#elif ATOMIC_CHAR32_T_LOCK_FREE != 1 && ATOMIC_CHAR32_T_LOCK_FREE != 2
++# error "ATOMIC_CHAR32_T_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_WCHAR_T_LOCK_FREE
+ # error "ATOMIC_WCHAR_T_LOCK_FREE must be a macro"
++#elif ATOMIC_WCHAR_T_LOCK_FREE != 1 && ATOMIC_WCHAR_T_LOCK_FREE != 2
++# error "ATOMIC_WCHAR_T_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_SHORT_LOCK_FREE
+ # error "ATOMIC_SHORT_LOCK_FREE must be a macro"
++#elif ATOMIC_SHORT_LOCK_FREE != 1 && ATOMIC_SHORT_LOCK_FREE != 2
++# error "ATOMIC_SHORT_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_INT_LOCK_FREE
+ # error "ATOMIC_INT_LOCK_FREE must be a macro"
++#elif ATOMIC_INT_LOCK_FREE != 1 && ATOMIC_INT_LOCK_FREE != 2
++# error "ATOMIC_INT_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_LONG_LOCK_FREE
+ # error "ATOMIC_LONG_LOCK_FREE must be a macro"
++#elif ATOMIC_LONG_LOCK_FREE != 1 && ATOMIC_LONG_LOCK_FREE != 2
++# error "ATOMIC_LONG_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_LLONG_LOCK_FREE
+ # error "ATOMIC_LLONG_LOCK_FREE must be a macro"
++#elif ATOMIC_LLONG_LOCK_FREE != 1 && ATOMIC_LLONG_LOCK_FREE != 2
++# error "ATOMIC_LLONG_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_POINTER_LOCK_FREE
+ # error "ATOMIC_POINTER_LOCK_FREE must be a macro"
++#elif ATOMIC_POINTER_LOCK_FREE != 1 && ATOMIC_POINTER_LOCK_FREE != 2
++# error "ATOMIC_POINTER_LOCK_FREE must be 1 or 2"
+ #endif
+
+ #ifndef ATOMIC_FLAG_INIT
+@@ -67,49 +86,3 @@
+ #ifndef ATOMIC_VAR_INIT
+ #error "ATOMIC_VAR_INIT_must_be_a_macro"
+ #endif
+-
+-
+-extern void abort(void);
+-
+-int main ()
+-{
+-#if (ATOMIC_BOOL_LOCK_FREE != 1 && ATOMIC_BOOL_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_CHAR_LOCK_FREE != 1 && ATOMIC_CHAR_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_CHAR16_T_LOCK_FREE != 1 && ATOMIC_CHAR16_T_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_CHAR32_T_LOCK_FREE != 1 && ATOMIC_CHAR32_T_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_WCHAR_T_LOCK_FREE != 1 && ATOMIC_WCHAR_T_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_SHORT_LOCK_FREE != 1 && ATOMIC_SHORT_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_INT_LOCK_FREE != 1 && ATOMIC_INT_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_LONG_LOCK_FREE != 1 && ATOMIC_LONG_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_LLONG_LOCK_FREE != 1 && ATOMIC_LLONG_LOCK_FREE != 2)
+- abort ();
+-#endif
+-
+-#if (ATOMIC_POINTER_LOCK_FREE != 1 && ATOMIC_POINTER_LOCK_FREE != 2)
+- abort ();
+-#endif
+-}
+diff --git a/libstdc++-v3/testsuite/Makefile.am b/libstdc++-v3/testsuite/Makefile.am
+index c54ad64..ea7c9a3 100644
+--- a/libstdc++-v3/testsuite/Makefile.am
++++ b/libstdc++-v3/testsuite/Makefile.am
+@@ -117,7 +117,7 @@ $(check_DEJAGNU_normal_targets): check-DEJAGNUnormal%: normal%/site.exp
+ check-DEJAGNU $(check_DEJAGNU_normal_targets): check-DEJAGNU%: site.exp
+ $(if $*,@)AR="$(AR)"; export AR; \
+ RANLIB="$(RANLIB)"; export RANLIB; \
+- if [ -z "$*" ] && [ "$(filter -j, $(MFLAGS))" = "-j" ]; then \
++ if [ -z "$*" ] && [ -n "$(filter -j%, $(MFLAGS))" ]; then \
+ rm -rf normal-parallel || true; \
+ mkdir normal-parallel; \
+ $(MAKE) $(AM_MAKEFLAGS) $(check_DEJAGNU_normal_targets); \
+diff --git a/libstdc++-v3/testsuite/Makefile.in b/libstdc++-v3/testsuite/Makefile.in
+index e0e7114..4f67a37 100644
+--- a/libstdc++-v3/testsuite/Makefile.in
++++ b/libstdc++-v3/testsuite/Makefile.in
+@@ -597,7 +597,7 @@ $(check_DEJAGNU_normal_targets): check-DEJAGNUnormal%: normal%/site.exp
+ check-DEJAGNU $(check_DEJAGNU_normal_targets): check-DEJAGNU%: site.exp
+ $(if $*,@)AR="$(AR)"; export AR; \
+ RANLIB="$(RANLIB)"; export RANLIB; \
+- if [ -z "$*" ] && [ "$(filter -j, $(MFLAGS))" = "-j" ]; then \
++ if [ -z "$*" ] && [ -n "$(filter -j%, $(MFLAGS))" ]; then \
+ rm -rf normal-parallel || true; \
+ mkdir normal-parallel; \
+ $(MAKE) $(AM_MAKEFLAGS) $(check_DEJAGNU_normal_targets); \
+diff --git a/libstdc++-v3/testsuite/experimental/algorithm/sample.cc b/libstdc++-v3/testsuite/experimental/algorithm/sample.cc
+index bfff937..8bdd5f0 100644
+--- a/libstdc++-v3/testsuite/experimental/algorithm/sample.cc
++++ b/libstdc++-v3/testsuite/experimental/algorithm/sample.cc
+@@ -22,6 +22,7 @@
+ #include <sstream>
+ #include <forward_list>
+ #include <vector>
++#include <random>
+ #include <testsuite_hooks.h>
+
+ std::mt19937 rng;
+diff --git a/libstdc++-v3/testsuite/experimental/any/misc/any_cast_neg.cc b/libstdc++-v3/testsuite/experimental/any/misc/any_cast_neg.cc
+index f1992d9..28388f6 100644
+--- a/libstdc++-v3/testsuite/experimental/any/misc/any_cast_neg.cc
++++ b/libstdc++-v3/testsuite/experimental/any/misc/any_cast_neg.cc
+@@ -26,5 +26,5 @@ void test01()
+ using std::experimental::any_cast;
+
+ const any y(1);
+- any_cast<int&>(y); // { dg-error "qualifiers" "" { target { *-*-* } } 310 }
++ any_cast<int&>(y); // { dg-error "qualifiers" "" { target { *-*-* } } 311 }
+ }
+diff --git a/libstdc++-v3/testsuite/experimental/any/typedefs.cc b/libstdc++-v3/testsuite/experimental/any/typedefs.cc
+index b10cfec..74099ae 100644
+--- a/libstdc++-v3/testsuite/experimental/any/typedefs.cc
++++ b/libstdc++-v3/testsuite/experimental/any/typedefs.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/chrono/value.cc b/libstdc++-v3/testsuite/experimental/chrono/value.cc
+index 32e757f..c375ad0 100644
+--- a/libstdc++-v3/testsuite/experimental/chrono/value.cc
++++ b/libstdc++-v3/testsuite/experimental/chrono/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc b/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
+index 60d91e2..5d1b62e 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
+@@ -34,14 +34,14 @@ test01()
+ const auto p = __gnu_test::nonexistent_path();
+ fs::directory_iterator iter(p, ec);
+ VERIFY( ec );
+- VERIFY( iter != fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test empty directory.
+ create_directory(p, fs::current_path(), ec);
+ VERIFY( !ec );
+ iter = fs::directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter == fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test non-empty directory.
+ create_directory_symlink(p, p / "l", ec);
+@@ -51,20 +51,20 @@ test01()
+ VERIFY( iter != fs::directory_iterator() );
+ VERIFY( iter->path() == p/"l" );
+ ++iter;
+- VERIFY( iter == fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible directory.
+ permissions(p, fs::perms::none, ec);
+ VERIFY( !ec );
+ iter = fs::directory_iterator(p, ec);
+ VERIFY( ec );
+- VERIFY( iter != fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible directory, skipping permission denied.
+ const auto opts = fs::directory_options::skip_permission_denied;
+ iter = fs::directory_iterator(p, opts, ec);
+ VERIFY( !ec );
+- VERIFY( iter == fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ permissions(p, fs::perms::owner_all, ec);
+ remove_all(p, ec);
+@@ -84,12 +84,12 @@ test02()
+ // Test post-increment (libstdc++/71005)
+ auto iter = fs::directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter != fs::directory_iterator() );
++ VERIFY( iter != end(iter) );
+ const auto entry1 = *iter;
+ const auto entry2 = *iter++;
+ VERIFY( entry1 == entry2 );
+ VERIFY( entry1.path() == p/"l" );
+- VERIFY( iter == fs::directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ remove_all(p, ec);
+ }
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/iterators/pop.cc b/libstdc++-v3/testsuite/experimental/filesystem/iterators/pop.cc
+new file mode 100644
+index 0000000..d0c50b7
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/iterators/pop.cc
+@@ -0,0 +1,107 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_hooks.h>
++#include <testsuite_fs.h>
++
++namespace fs = std::experimental::filesystem;
++
++void
++test01()
++{
++ std::error_code ec;
++ fs::recursive_directory_iterator dir;
++ dir.pop(ec); // This is undefined, but our implementation
++ VERIFY( ec ); // checks and returns an error.
++ VERIFY( dir == end(dir) );
++
++ std::error_code ec2;
++ try
++ {
++ dir.pop();
++ }
++ catch (const fs::filesystem_error& ex)
++ {
++ ec2 = ex.code();
++ }
++ VERIFY( ec2 == ec );
++}
++
++void
++test02()
++{
++ std::error_code ec = make_error_code(std::errc::interrupted);
++ const auto p = __gnu_test::nonexistent_path();
++ create_directories(p / "d1/d2/d3");
++ for (int i = 0; i < 3; ++i)
++ {
++ fs::recursive_directory_iterator dir(p);
++ std::advance(dir, i);
++ VERIFY( dir.depth() == i );
++ dir.pop(ec);
++ VERIFY( !ec );
++ VERIFY( dir == end(dir) );
++
++ dir = fs::recursive_directory_iterator(p);
++ std::advance(dir, i);
++ VERIFY( dir.depth() == i );
++ dir.pop();
++ VERIFY( dir == end(dir) );
++ }
++ remove_all(p, ec);
++}
++
++void
++test03()
++{
++ std::error_code ec = make_error_code(std::errc::interrupted);
++ const auto p = __gnu_test::nonexistent_path();
++ create_directories(p / "d1/d2/d3");
++ create_directories(p / "d1/d2/e3");
++ create_directories(p / "d1/e2/d3");
++ for (int i = 0; i < 3; ++i)
++ {
++ fs::recursive_directory_iterator dir(p);
++ std::advance(dir, i);
++ int expected_depth = i;
++ VERIFY( dir.depth() == expected_depth );
++ dir.pop(ec);
++ VERIFY( !ec );
++ if (dir != end(dir))
++ VERIFY( dir.depth() == (expected_depth - 1) );
++
++ dir = fs::recursive_directory_iterator(p);
++ std::advance(dir, i);
++ VERIFY( dir.depth() == i );
++ dir.pop();
++ if (dir != end(dir))
++ VERIFY( dir.depth() == (i -1) );
++ }
++ remove_all(p, ec);
++}
++
++int
++main()
++{
++ test01();
++ test02();
++ test03();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc b/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
+index ae98bee..fbfb9a6 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
+@@ -34,39 +34,39 @@ test01()
+ const auto p = __gnu_test::nonexistent_path();
+ fs::recursive_directory_iterator iter(p, ec);
+ VERIFY( ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test empty directory.
+ create_directory(p, fs::current_path(), ec);
+ VERIFY( !ec );
+ iter = fs::recursive_directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter == fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test non-empty directory.
+ create_directories(p / "d1/d2");
+ VERIFY( !ec );
+ iter = fs::recursive_directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter != end(iter) );
+ VERIFY( iter->path() == p/"d1" );
+ ++iter;
+ VERIFY( iter->path() == p/"d1/d2" );
+ ++iter;
+- VERIFY( iter == fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible directory.
+ permissions(p, fs::perms::none, ec);
+ VERIFY( !ec );
+ iter = fs::recursive_directory_iterator(p, ec);
+ VERIFY( ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible directory, skipping permission denied.
+ const auto opts = fs::directory_options::skip_permission_denied;
+ iter = fs::recursive_directory_iterator(p, opts, ec);
+ VERIFY( !ec );
+- VERIFY( iter == fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible sub-directory.
+ permissions(p, fs::perms::owner_all, ec);
+@@ -75,23 +75,24 @@ test01()
+ VERIFY( !ec );
+ iter = fs::recursive_directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter != end(iter) );
+ VERIFY( iter->path() == p/"d1" );
+ ++iter; // should recurse into d1
+ VERIFY( iter->path() == p/"d1/d2" );
+ iter.increment(ec); // should fail to recurse into p/d1/d2
+ VERIFY( ec );
++ VERIFY( iter == end(iter) );
+
+ // Test inaccessible sub-directory, skipping permission denied.
+ iter = fs::recursive_directory_iterator(p, opts, ec);
+ VERIFY( !ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter != end(iter) );
+ VERIFY( iter->path() == p/"d1" );
+ ++iter; // should recurse into d1
+ VERIFY( iter->path() == p/"d1/d2" );
+ iter.increment(ec); // should fail to recurse into p/d1/d2, so skip it
+ VERIFY( !ec );
+- VERIFY( iter == fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ permissions(p/"d1/d2", fs::perms::owner_all, ec);
+ remove_all(p, ec);
+@@ -110,7 +111,7 @@ test02()
+ // Test post-increment (libstdc++/71005)
+ auto iter = fs::recursive_directory_iterator(p, ec);
+ VERIFY( !ec );
+- VERIFY( iter != fs::recursive_directory_iterator() );
++ VERIFY( iter != end(iter) );
+ const auto entry1 = *iter;
+ const auto entry2 = *iter++;
+ VERIFY( entry1 == entry2 );
+@@ -119,7 +120,7 @@ test02()
+ const auto entry4 = *iter++;
+ VERIFY( entry3 == entry4 );
+ VERIFY( entry3.path() == p/"d1/d2" );
+- VERIFY( iter == fs::recursive_directory_iterator() );
++ VERIFY( iter == end(iter) );
+
+ remove_all(p, ec);
+ }
+@@ -150,7 +151,7 @@ test04()
+
+ // libstdc++/71004
+ const fs::recursive_directory_iterator it;
+- VERIFY( it == fs::recursive_directory_iterator() );
++ VERIFY( it == end(it) );
+ }
+
+ void
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc
+index ef28677..1b85695 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc
+@@ -21,7 +21,6 @@
+ // 15.3 Copy [fs.op.copy]
+
+ #include <experimental/filesystem>
+-#include <fstream>
+ #include <testsuite_fs.h>
+ #include <testsuite_hooks.h>
+
+@@ -44,14 +43,25 @@ test01()
+ fs::copy(".", ".", fs::copy_options::none, ec);
+ VERIFY( ec );
+
+- std::ofstream{p.native()};
++ __gnu_test::scoped_file f(p);
+ VERIFY( fs::is_directory(".") );
+ VERIFY( fs::is_regular_file(p) );
+ ec.clear();
+ fs::copy(".", p, fs::copy_options::none, ec);
+ VERIFY( ec );
+
+- remove(p, ec);
++ auto to = __gnu_test::nonexistent_path();
++ ec.clear();
++ auto opts = fs::copy_options::create_symlinks;
++ fs::copy("/", to, opts, ec);
++ VERIFY( ec == std::make_error_code(std::errc::is_a_directory) );
++ VERIFY( !exists(to) );
++
++ ec.clear();
++ opts != fs::copy_options::recursive;
++ fs::copy("/", to, opts, ec);
++ VERIFY( ec == std::make_error_code(std::errc::is_a_directory) );
++ VERIFY( !exists(to) );
+ }
+
+ // Test is_symlink(f) case.
+@@ -62,29 +72,35 @@ test02()
+
+ auto from = __gnu_test::nonexistent_path();
+ auto to = __gnu_test::nonexistent_path();
+- std::error_code ec;
++ std::error_code ec, bad = std::make_error_code(std::errc::invalid_argument);
+
++ ec = bad;
+ fs::create_symlink(".", from, ec);
+ VERIFY( !ec );
+ VERIFY( fs::exists(from) );
+
++ ec = bad;
+ fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
+ VERIFY( !ec );
+ VERIFY( !fs::exists(to) );
+
++ ec = bad;
+ fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
+ VERIFY( !ec );
+ VERIFY( !fs::exists(to) );
+
++ ec = bad;
+ fs::copy(from, to,
+ fs::copy_options::skip_symlinks|fs::copy_options::copy_symlinks,
+ ec);
+ VERIFY( !ec );
+ VERIFY( !fs::exists(to) );
+
++ ec = bad;
+ fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
+ VERIFY( !ec );
+ VERIFY( fs::exists(to) );
++ VERIFY( is_symlink(to) );
+
+ fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
+ VERIFY( ec );
+@@ -117,6 +133,9 @@ test03()
+ fs::copy(from, to);
+ VERIFY( fs::exists(to) );
+ VERIFY( fs::file_size(to) == fs::file_size(from) );
++
++ remove(from);
++ remove(to);
+ }
+
+ // Test is_directory(f) case.
+@@ -129,6 +148,37 @@ test04()
+ auto to = __gnu_test::nonexistent_path();
+ std::error_code ec;
+
++ create_directories(from/"a/b/c");
++
++ {
++ __gnu_test::scoped_file f(to);
++ copy(from, to, ec);
++ VERIFY( ec );
++ }
++
++ __gnu_test::scoped_file f1(from/"a/f1");
++ std::ofstream{f1.path} << "file one";
++ __gnu_test::scoped_file f2(from/"a/b/f2");
++ std::ofstream{f2.path} << "file two";
++
++ copy(from, to, ec);
++ VERIFY( !ec );
++ VERIFY( exists(to) && is_empty(to) );
++ remove(to);
++
++ copy(from, to, fs::copy_options::recursive, ec);
++ VERIFY( !ec );
++ VERIFY( exists(to) && !is_empty(to) );
++ VERIFY( is_regular_file(to/"a/f1") && !is_empty(to/"a/f1") );
++ VERIFY( file_size(from/"a/f1") == file_size(to/"a/f1") );
++ VERIFY( is_regular_file(to/"a/b/f2") && !is_empty(to/"a/b/f2") );
++ VERIFY( file_size(from/"a/b/f2") == file_size(to/"a/b/f2") );
++ VERIFY( is_directory(to/"a/b/c") && is_empty(to/"a/b/c") );
++
++ f1.path.clear();
++ f2.path.clear();
++ remove_all(from, ec);
++ remove_all(to, ec);
+ }
+
+ // Test no-op cases.
+@@ -138,10 +188,10 @@ test05()
+ bool test __attribute__((unused)) = false;
+
+ auto to = __gnu_test::nonexistent_path();
+- std::error_code ec;
++ std::error_code ec = std::make_error_code(std::errc::invalid_argument);
+
+- fs::copy("/", to, fs::copy_options::create_symlinks, ec);
+- VERIFY( !ec );
++ fs::copy("/", to, fs::copy_options::copy_symlinks, ec);
++ VERIFY( !ec ); // Previous value should be cleared (LWG 2683)
+ }
+
+ int
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc
+index cdb7911..bcbdd12 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc
+@@ -73,6 +73,9 @@ test01()
+ VERIFY( !ec );
+ VERIFY( exists(to) );
+ VERIFY( file_size(to) == file_size(from) );
++
++ remove(from);
++ remove(to);
+ }
+
+ int
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directories.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directories.cc
+index b84d966..8e4dea8 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directories.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directories.cc
+@@ -65,7 +65,8 @@ test01()
+ VERIFY( b );
+ VERIFY( is_directory(p/"./d4/../d5") );
+
+- remove_all(p, ec);
++ std::uintmax_t count = remove_all(p, ec);
++ VERIFY( count == 6 );
+ }
+
+ int
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/create_symlink.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_symlink.cc
+new file mode 100644
+index 0000000..2addee2
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_symlink.cc
+@@ -0,0 +1,92 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_hooks.h>
++#include <testsuite_fs.h>
++
++namespace fs = std::experimental::filesystem;
++
++void
++test01()
++{
++ std::error_code ec, ec2;
++ __gnu_test::scoped_file f;
++ auto tgt = f.path;
++
++ // Test empty path.
++ fs::path p;
++ create_symlink(tgt, p, ec );
++ VERIFY( ec );
++ try
++ {
++ create_symlink(tgt, p);
++ }
++ catch (const std::experimental::filesystem::filesystem_error& ex)
++ {
++ ec2 = ex.code();
++ VERIFY( ex.path1() == tgt );
++ VERIFY( ex.path2() == p );
++ }
++ VERIFY( ec2 == ec );
++}
++
++void
++test02()
++{
++ std::error_code ec, ec2;
++ __gnu_test::scoped_file f;
++ auto tgt = f.path;
++
++ // Test non-existent path
++ auto p = __gnu_test::nonexistent_path();
++ VERIFY( !exists(p) );
++
++ create_symlink(tgt, p, ec); // create the symlink once
++ VERIFY( !ec );
++ VERIFY( exists(p) );
++ VERIFY( is_symlink(p) );
++ remove(p);
++ create_symlink(tgt, p); // create the symlink again
++ VERIFY( exists(p) );
++ VERIFY( is_symlink(p) );
++
++ create_symlink(tgt, p, ec); // Try to create existing symlink
++ VERIFY( ec );
++ try
++ {
++ create_symlink(tgt, p);
++ }
++ catch (const std::experimental::filesystem::filesystem_error& ex)
++ {
++ ec2 = ex.code();
++ VERIFY( ex.path1() == tgt );
++ VERIFY( ex.path2() == p );
++ }
++ VERIFY( ec2 == ec );
++
++ remove(p);
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/equivalent.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/equivalent.cc
+new file mode 100644
+index 0000000..9195c2c
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/equivalent.cc
+@@ -0,0 +1,73 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_fs.h>
++#include <testsuite_hooks.h>
++
++namespace fs = std::experimental::filesystem;
++
++
++void
++test01()
++{
++ auto p1 = __gnu_test::nonexistent_path();
++ auto p2 = __gnu_test::nonexistent_path();
++ std::error_code ec;
++ bool result;
++
++ result = equivalent(p1, p2, ec);
++ VERIFY( ec );
++ VERIFY( !result );
++ const auto bad_ec = ec;
++
++ __gnu_test::scoped_file f1(p1);
++ result = equivalent(p1, p2, ec);
++ VERIFY( !ec );
++ VERIFY( !result );
++
++ __gnu_test::scoped_file f2(p2);
++ ec = bad_ec;
++ result = equivalent(p1, p2, ec);
++ VERIFY( !ec );
++ VERIFY( !result );
++
++ auto p3 = __gnu_test::nonexistent_path();
++ create_hard_link(p1, p3, ec);
++ if (ec)
++ return; // hard links not supported
++ __gnu_test::scoped_file f3(p3, __gnu_test::scoped_file::adopt_file);
++
++ ec = bad_ec;
++ result = equivalent(p1, p3, ec);
++ VERIFY( !ec );
++ VERIFY( result );
++
++ ec = bad_ec;
++ result = equivalent(p2, p3, ec);
++ VERIFY( !ec );
++ VERIFY( !result );
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
+index dba4a6f..5358fac 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/exists.cc
+@@ -34,6 +34,18 @@ test01()
+ VERIFY( exists(path{"."}) );
+ VERIFY( exists(path{".."}) );
+ VERIFY( exists(std::experimental::filesystem::current_path()) );
++
++ std::error_code ec = std::make_error_code(std::errc::invalid_argument);
++ VERIFY( exists(path{"/"}, ec) );
++ VERIFY( !ec );
++ VERIFY( exists(path{"/."}, ec) );
++ VERIFY( !ec );
++ VERIFY( exists(path{"."}, ec) );
++ VERIFY( !ec );
++ VERIFY( exists(path{".."}, ec) );
++ VERIFY( !ec );
++ VERIFY( exists(std::experimental::filesystem::current_path(), ec) );
++ VERIFY( !ec );
+ }
+
+ void
+@@ -43,6 +55,10 @@ test02()
+
+ path rel = __gnu_test::nonexistent_path();
+ VERIFY( !exists(rel) );
++
++ std::error_code ec = std::make_error_code(std::errc::invalid_argument);
++ VERIFY( !exists(rel, ec) );
++ VERIFY( !ec ); // DR 2725
+ }
+
+ void
+@@ -52,6 +68,38 @@ test03()
+
+ path abs = absolute(__gnu_test::nonexistent_path());
+ VERIFY( !exists(abs) );
++
++ std::error_code ec = std::make_error_code(std::errc::invalid_argument);
++ VERIFY( !exists(abs, ec) );
++ VERIFY( !ec ); // DR 2725
++}
++
++void
++test04()
++{
++ using perms = std::experimental::filesystem::perms;
++ path p = __gnu_test::nonexistent_path();
++ create_directory(p);
++ permissions(p, perms::all | perms::remove_perms);
++
++ auto unr = p / "unreachable";
++ std::error_code ec;
++ VERIFY( !exists(unr, ec) );
++ VERIFY( ec == std::errc::permission_denied );
++ ec.clear();
++ try
++ {
++ exists(unr);
++ }
++ catch(const std::experimental::filesystem::filesystem_error& ex)
++ {
++ ec = ex.code();
++ VERIFY( ex.path1() == unr );
++ }
++ VERIFY( ec == std::errc::permission_denied );
++
++ permissions(p, perms::owner_all);
++ remove(p);
+ }
+
+ int
+@@ -60,4 +108,5 @@ main()
+ test01();
+ test02();
+ test03();
++ test04();
+ }
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
+new file mode 100644
+index 0000000..8c84edd
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/is_empty.cc
+@@ -0,0 +1,108 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_hooks.h>
++#include <testsuite_fs.h>
++
++namespace fs = std::experimental::filesystem;
++
++void
++test01()
++{
++ auto p = __gnu_test::nonexistent_path();
++ create_directory(p);
++ permissions(p, fs::perms::none);
++ std::error_code ec, ec2;
++
++ bool result = fs::is_empty(p, ec);
++ VERIFY( ec == std::make_error_code(std::errc::permission_denied) );
++ VERIFY( !result );
++
++ try {
++ fs::is_empty(p);
++ } catch (const fs::filesystem_error& e) {
++ ec2 = e.code();
++ }
++ VERIFY( ec2 == ec );
++
++ result = fs::is_empty(p/"f", ec);
++ VERIFY( ec == std::make_error_code(std::errc::permission_denied) );
++ VERIFY( !result );
++
++ try {
++ fs::is_empty(p/"f");
++ } catch (const fs::filesystem_error& e) {
++ ec2 = e.code();
++ }
++ VERIFY( ec2 == ec );
++
++ permissions(p, fs::perms::owner_all, ec);
++ remove_all(p, ec);
++}
++
++void
++test02()
++{
++ auto p = __gnu_test::nonexistent_path();
++ create_directory(p);
++ std::error_code ec, bad_ec = make_error_code(std::errc::invalid_argument);
++ bool empty;
++
++ ec = bad_ec;
++ empty = is_empty(p, ec);
++ VERIFY( !ec );
++ VERIFY( empty );
++ empty = is_empty(p);
++ VERIFY( empty );
++
++ __gnu_test::scoped_file f(p/"f");
++ ec = bad_ec;
++ empty = is_empty(f.path, ec);
++ VERIFY( !ec );
++ VERIFY( empty );
++ empty = is_empty(f.path);
++ VERIFY( empty );
++
++ std::ofstream{f.path.native()} << "data";
++ ec = bad_ec;
++ empty = is_empty(p, ec);
++ VERIFY( !ec );
++ VERIFY( !empty );
++ empty = is_empty(p);
++ VERIFY( !empty );
++
++ ec = bad_ec;
++ empty = is_empty(p, ec);
++ VERIFY( !ec );
++ VERIFY( !empty );
++ empty = is_empty(p);
++ VERIFY( !empty );
++
++ f.path.clear();
++ remove_all(p, ec);
++}
++
++int
++main()
++{
++ test01();
++ test02();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/last_write_time.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/last_write_time.cc
+new file mode 100644
+index 0000000..2928299
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/last_write_time.cc
+@@ -0,0 +1,155 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++// 15.25 Permissions [fs.op.last_write_time]
++
++#include <experimental/filesystem>
++#include <testsuite_fs.h>
++#include <testsuite_hooks.h>
++
++#ifdef _GLIBCXX_HAVE_FCNTL_H
++# include <fcntl.h>
++#endif
++#if _GLIBCXX_HAVE_UTIME_H
++# include <utime.h>
++#endif
++
++using time_type = std::experimental::filesystem::file_time_type;
++
++void
++test01()
++{
++ // read times
++
++ auto p = __gnu_test::nonexistent_path();
++ std::error_code ec;
++ time_type mtime = last_write_time(p, ec);
++ VERIFY( ec );
++ VERIFY( ec == std::make_error_code(std::errc::no_such_file_or_directory) );
++#if __cpp_exceptions
++ bool caught = false;
++ try {
++ mtime = last_write_time(p);
++ } catch (std::system_error const& e) {
++ caught = true;
++ ec = e.code();
++ }
++ VERIFY( caught );
++ VERIFY( ec );
++ VERIFY( ec == std::make_error_code(std::errc::no_such_file_or_directory) );
++#endif
++
++ __gnu_test::scoped_file file(p);
++ VERIFY( exists(p) );
++ mtime = last_write_time(p, ec);
++ VERIFY( !ec );
++ VERIFY( mtime <= time_type::clock::now() );
++ VERIFY( mtime == last_write_time(p) );
++
++ auto end_of_time = time_type::duration::max();
++ auto last_second
++ = std::chrono::duration_cast<std::chrono::seconds>(end_of_time).count();
++ if (last_second > std::numeric_limits<std::time_t>::max())
++ return; // can't test overflow
++
++#if _GLIBCXX_USE_UTIMENSAT
++ struct ::timespec ts[2];
++ ts[0].tv_sec = 0;
++ ts[0].tv_nsec = UTIME_NOW;
++ ts[1].tv_sec = std::numeric_limits<std::time_t>::max() - 1;
++ ts[1].tv_nsec = 0;
++ VERIFY( !::utimensat(AT_FDCWD, p.c_str(), ts, 0) );
++#elif _GLIBCXX_HAVE_UTIME_H
++ ::utimbuf times;
++ times.modtime = std::numeric_limits<std::time_t>::max() - 1;
++ times.actime = std::numeric_limits<std::time_t>::max() - 1;
++ VERIFY( !::utime(p.c_str(), &times) );
++#else
++ return;
++#endif
++
++ mtime = last_write_time(p, ec);
++ VERIFY( ec );
++ VERIFY( ec == std::make_error_code(std::errc::value_too_large) );
++ VERIFY( mtime == time_type::min() );
++
++#if __cpp_exceptions
++ caught = false;
++ try {
++ mtime = last_write_time(p);
++ } catch (std::system_error const& e) {
++ caught = true;
++ ec = e.code();
++ }
++ VERIFY( caught );
++ VERIFY( ec );
++ VERIFY( ec == std::make_error_code(std::errc::value_too_large) );
++#endif
++}
++
++bool approx_equal(time_type file_time, time_type expected)
++{
++ auto delta = expected - file_time;
++ if (delta < delta.zero())
++ delta = -delta;
++ return delta < std::chrono::seconds(1);
++}
++
++void
++test02()
++{
++ // write times
++
++ __gnu_test::scoped_file f;
++ std::error_code ec;
++ time_type time;
++
++ time = last_write_time(f.path);
++ last_write_time(f.path, time, ec);
++ VERIFY( !ec );
++ VERIFY( approx_equal(last_write_time(f.path), time) );
++
++ time -= std::chrono::milliseconds(1000 * 60 * 10 + 15);
++ last_write_time(f.path, time, ec);
++ VERIFY( !ec );
++ VERIFY( approx_equal(last_write_time(f.path), time) );
++
++ time += std::chrono::milliseconds(1000 * 60 * 20 + 15);
++ last_write_time(f.path, time, ec);
++ VERIFY( !ec );
++ VERIFY( approx_equal(last_write_time(f.path), time) );
++
++ time = time_type();
++ last_write_time(f.path, time, ec);
++ VERIFY( !ec );
++ VERIFY( approx_equal(last_write_time(f.path), time) );
++
++ time -= std::chrono::milliseconds(1000 * 60 * 10 + 15);
++ last_write_time(f.path, time, ec);
++ VERIFY( !ec );
++ VERIFY( approx_equal(last_write_time(f.path), time) );
++}
++
++int
++main()
++{
++ test01();
++ test02();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/permissions.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/permissions.cc
+new file mode 100644
+index 0000000..45f1142
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/permissions.cc
+@@ -0,0 +1,152 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-std=gnu++11 -lstdc++fs" }
++// { dg-require-filesystem-ts "" }
++
++// 15.26 Permissions [fs.op.permissions]
++
++#include <experimental/filesystem>
++#include <testsuite_fs.h>
++#include <testsuite_hooks.h>
++
++void
++test01()
++{
++ bool test __attribute__((unused)) = true;
++ using perms = std::experimental::filesystem::perms;
++
++ auto p = __gnu_test::nonexistent_path();
++
++ __gnu_test::scoped_file f(p);
++ VERIFY( exists(p) );
++ permissions(p, perms::owner_all);
++ VERIFY( status(p).permissions() == perms::owner_all );
++ permissions(p, perms::group_read | perms::add_perms);
++ VERIFY( status(p).permissions() == (perms::owner_all | perms::group_read) );
++ permissions(p, perms::group_read | perms::remove_perms);
++ VERIFY( status(p).permissions() == perms::owner_all );
++}
++
++void
++test02()
++{
++ using perms = std::experimental::filesystem::perms;
++
++ auto p = __gnu_test::nonexistent_path();
++
++ std::error_code ec;
++ permissions(p, perms::owner_all, ec);
++ VERIFY( ec );
++
++ __gnu_test::scoped_file f(p);
++ VERIFY( exists(p) );
++
++ ec = std::make_error_code(std::errc::invalid_argument);
++ permissions(p, perms::owner_all, ec);
++ VERIFY( !ec );
++ VERIFY( status(p).permissions() == perms::owner_all );
++ permissions(p, perms::group_read | perms::add_perms, ec);
++ VERIFY( !ec );
++ VERIFY( status(p).permissions() == (perms::owner_all | perms::group_read) );
++ permissions(p, perms::group_read | perms::remove_perms, ec);
++ VERIFY( !ec );
++ VERIFY( status(p).permissions() == perms::owner_all );
++}
++
++void
++test03()
++{
++ using perms = std::experimental::filesystem::perms;
++
++ __gnu_test::scoped_file f;
++ VERIFY( exists(f.path) );
++
++ auto p = __gnu_test::nonexistent_path();
++ create_symlink(f.path, p);
++
++ std::error_code ec, ec2;
++ permissions(p, perms::owner_all | perms::symlink_nofollow, ec);
++ try
++ {
++ permissions(p, perms::owner_all | perms::symlink_nofollow);
++ }
++ catch (const std::experimental::filesystem::filesystem_error& ex)
++ {
++ ec2 = ex.code();
++ VERIFY( ex.path1() == p );
++ }
++ // Both calls should succeed, or both should fail with same error:
++ VERIFY( ec == ec2 );
++
++ remove(p);
++}
++
++void
++test04()
++{
++ using perms = std::experimental::filesystem::perms;
++
++ auto p = __gnu_test::nonexistent_path();
++ create_symlink(__gnu_test::nonexistent_path(), p);
++
++ std::error_code ec, ec2;
++ permissions(p, perms::owner_all, ec);
++ VERIFY( ec );
++ try
++ {
++ permissions(p, perms::owner_all);
++ }
++ catch (const std::experimental::filesystem::filesystem_error& ex)
++ {
++ ec2 = ex.code();
++ VERIFY( ex.path1() == p );
++ }
++ VERIFY( ec == ec2 );
++
++ remove(p);
++}
++
++void
++test05()
++{
++ using perms = std::experimental::filesystem::perms;
++ std::error_code ec;
++
++ __gnu_test::scoped_file f;
++ auto p = perms::owner_write;
++
++ // symlink_nofollow should not give an error for non-symlinks
++ permissions(f.path, p|perms::symlink_nofollow, ec);
++ VERIFY( !ec );
++ auto st = status(f.path);
++ VERIFY( st.permissions() == p );
++ p |= perms::owner_read;
++ permissions(f.path, p|perms::symlink_nofollow, ec);
++ st = status(f.path);
++ VERIFY( st.permissions() == p );
++}
++
++int
++main()
++{
++ test01();
++ test02();
++ test03();
++ test04();
++ test05();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc
+new file mode 100644
+index 0000000..c8cf7e7
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/read_symlink.cc
+@@ -0,0 +1,50 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_hooks.h>
++#include <testsuite_fs.h>
++
++namespace fs = std::experimental::filesystem;
++
++void
++test01()
++{
++ auto p = __gnu_test::nonexistent_path();
++ std::error_code ec;
++
++ read_symlink(p, ec);
++ VERIFY( ec );
++
++ fs::path tgt = ".";
++ create_symlink(tgt, p);
++
++ auto result = read_symlink(p, ec);
++ VERIFY( !ec );
++ VERIFY( result == tgt );
++
++ remove(p);
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/remove_all.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/remove_all.cc
+new file mode 100644
+index 0000000..f684206
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/remove_all.cc
+@@ -0,0 +1,91 @@
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// { dg-options "-lstdc++fs -std=gnu++11" }
++// { dg-require-filesystem-ts "" }
++
++#include <experimental/filesystem>
++#include <testsuite_hooks.h>
++#include <testsuite_fs.h>
++
++namespace fs = std::experimental::filesystem;
++
++void
++test01()
++{
++ std::error_code ec;
++ std::uintmax_t n;
++
++ n = fs::remove_all("", ec);
++ VERIFY( ec );
++ VERIFY( n == std::uintmax_t(-1) );
++
++ auto p = __gnu_test::nonexistent_path();
++ ec.clear();
++ n = remove_all(p, ec);
++ VERIFY( ec );
++ VERIFY( n == std::uintmax_t(-1) );
++
++ const auto bad_ec = ec;
++ auto link = __gnu_test::nonexistent_path();
++ create_symlink(p, link); // dangling symlink
++ ec = bad_ec;
++ n = remove_all(link, ec);
++ VERIFY( !ec );
++ VERIFY( n == 1 );
++ VERIFY( !exists(symlink_status(link)) ); // DR 2721
++
++ __gnu_test::scoped_file f(p);
++ create_symlink(p, link);
++ ec = bad_ec;
++ n = remove_all(link, ec);
++ VERIFY( !ec );
++ VERIFY( n == 1 );
++ VERIFY( !exists(symlink_status(link)) ); // The symlink is removed, but
++ VERIFY( exists(p) ); // its target is not.
++
++ auto dir = __gnu_test::nonexistent_path();
++ create_directories(dir/"a/b/c");
++ ec = bad_ec;
++ n = remove_all(dir/"a", ec);
++ VERIFY( !ec );
++ VERIFY( n == 3 );
++ VERIFY( exists(dir) );
++ VERIFY( !exists(dir/"a") );
++
++ create_directories(dir/"a/b/c");
++ __gnu_test::scoped_file a1(dir/"a/1");
++ __gnu_test::scoped_file a2(dir/"a/2");
++ __gnu_test::scoped_file b1(dir/"a/b/1");
++ __gnu_test::scoped_file b2(dir/"a/b/2");
++ ec = bad_ec;
++ n = remove_all(dir, ec);
++ VERIFY( !ec );
++ VERIFY( n == 8 );
++ VERIFY( !exists(dir) );
++
++ a1.path.clear();
++ a2.path.clear();
++ b1.path.clear();
++ b2.path.clear();
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
+index bd9b6ad..78e91a1 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/temp_directory_path.cc
+@@ -46,6 +46,7 @@ test01()
+
+ std::error_code ec;
+ fs::path p1 = fs::temp_directory_path(ec);
++ VERIFY( !ec );
+ VERIFY( exists(p1) );
+
+ fs::path p2 = fs::temp_directory_path();
+@@ -65,6 +66,7 @@ test02()
+ std::error_code ec;
+ fs::path p = fs::temp_directory_path(ec);
+ VERIFY( ec );
++ VERIFY( p == fs::path() );
+
+ std::error_code ec2;
+ try {
+@@ -75,10 +77,54 @@ test02()
+ VERIFY( ec2 == ec );
+ }
+
++void
++test03()
++{
++ auto p = __gnu_test::nonexistent_path();
++ create_directories(p/"tmp");
++ permissions(p, fs::perms::none);
++ setenv("TMPDIR", (p/"tmp").c_str(), 1);
++ std::error_code ec;
++ auto r = fs::temp_directory_path(ec); // libstdc++/PR71337
++ VERIFY( ec == std::make_error_code(std::errc::permission_denied) );
++ VERIFY( r == fs::path() );
++
++ std::error_code ec2;
++ try {
++ fs::temp_directory_path();
++ } catch (const fs::filesystem_error& e) {
++ ec2 = e.code();
++ }
++ VERIFY( ec2 == ec );
++
++ permissions(p, fs::perms::owner_all, ec);
++ remove_all(p, ec);
++}
++
++void
++test04()
++{
++ __gnu_test::scoped_file f;
++ setenv("TMPDIR", f.path.c_str(), 1);
++ std::error_code ec;
++ auto r = fs::temp_directory_path(ec);
++ VERIFY( ec == std::make_error_code(std::errc::not_a_directory) );
++ VERIFY( r == fs::path() );
++
++ std::error_code ec2;
++ try {
++ fs::temp_directory_path();
++ } catch (const fs::filesystem_error& e) {
++ ec2 = e.code();
++ }
++ VERIFY( ec2 == ec );
++}
+
+ int
+ main()
+ {
+ test01();
+ test02();
++ test03();
++ test04();
+ }
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/path/construct/range.cc b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/range.cc
+index 2e892291..659c4db 100644
+--- a/libstdc++-v3/testsuite/experimental/filesystem/path/construct/range.cc
++++ b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/range.cc
+@@ -1,4 +1,4 @@
+-// { dg-options "-std=gnu++11 -lstdc++fs" }
++// { dg-options "-lstdc++fs -std=gnu++11" }
+ // { dg-require-filesystem-ts "" }
+
+ // Copyright (C) 2014-2015 Free Software Foundation, Inc.
+@@ -23,6 +23,7 @@
+ #include <experimental/filesystem>
+ #include <string>
+ #include <testsuite_fs.h>
++#include <testsuite_iterators.h>
+
+ using std::experimental::filesystem::path;
+ using __gnu_test::compare_paths;
+@@ -53,6 +54,53 @@ test01()
+ compare_paths(p1, p7);
+ compare_paths(p1, p8);
+ #endif
++
++ using __gnu_test::test_container;
++ using __gnu_test::input_iterator_wrapper;
++ // Test with input iterators and const value_types
++
++ test_container<char, input_iterator_wrapper>
++ r1((char*)s.c_str(), (char*)s.c_str() + s.size());
++ path p9(r1.begin(), r1.end());
++ compare_paths(p1, p9);
++
++ test_container<char, input_iterator_wrapper>
++ r2((char*)s.c_str(), (char*)s.c_str() + s.size() + 1); // includes null-terminator
++ path p10(r2.begin());
++ compare_paths(p1, p10);
++
++ test_container<const char, input_iterator_wrapper>
++ r3(s.c_str(), s.c_str() + s.size());
++ path p11(r3.begin(), r3.end());
++ compare_paths(p1, p11);
++
++ test_container<const char, input_iterator_wrapper>
++ r4(s.c_str(), s.c_str() + s.size() + 1); // includes null-terminator
++ path p12(r4.begin());
++ compare_paths(p1, p12);
++
++#if _GLIBCXX_USE_WCHAR_T
++ // Test with input iterators and const value_types
++ test_container<wchar_t, input_iterator_wrapper>
++ r5((wchar_t*)ws.c_str(), (wchar_t*)ws.c_str() + ws.size());
++ path p13(r5.begin(), r5.end());
++ compare_paths(p1, p13);
++
++ test_container<wchar_t, input_iterator_wrapper>
++ r6((wchar_t*)ws.c_str(), (wchar_t*)ws.c_str() + ws.size() + 1); // includes null-terminator
++ path p14(r6.begin());
++ compare_paths(p1, p14);
++
++ test_container<const wchar_t, input_iterator_wrapper>
++ r7(ws.c_str(), ws.c_str() + ws.size());
++ path p15(r7.begin(), r7.end());
++ compare_paths(p1, p15);
++
++ test_container<const wchar_t, input_iterator_wrapper>
++ r8(ws.c_str(), ws.c_str() + ws.size() + 1); // includes null-terminator
++ path p16(r8.begin());
++ compare_paths(p1, p16);
++#endif
+ }
+ }
+
+diff --git a/libstdc++-v3/testsuite/experimental/filesystem/path/construct/string_view.cc b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/string_view.cc
+new file mode 100644
+index 0000000..c247813
+--- /dev/null
++++ b/libstdc++-v3/testsuite/experimental/filesystem/path/construct/string_view.cc
+@@ -0,0 +1,55 @@
++// { dg-options "-lstdc++fs -std=gnu++14" }
++// { dg-require-filesystem-ts "" }
++
++// Copyright (C) 2016 Free Software Foundation, Inc.
++//
++// This file is part of the GNU ISO C++ Library. This library is free
++// software; you can redistribute it and/or modify it under the
++// terms of the GNU General Public License as published by the
++// Free Software Foundation; either version 3, 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 General Public License for more details.
++
++// You should have received a copy of the GNU General Public License along
++// with this library; see the file COPYING3. If not see
++// <http://www.gnu.org/licenses/>.
++
++// 8.4.1 path constructors [path.construct]
++
++#include <experimental/filesystem>
++#include <experimental/string_view>
++#include <string>
++#include <testsuite_fs.h>
++
++using std::experimental::filesystem::path;
++using __gnu_test::compare_paths;
++
++void
++test01()
++{
++ for (std::string s : __gnu_test::test_paths)
++ {
++ path p1 = s;
++ std::experimental::string_view sv(s);
++ path p2 = sv;
++ compare_paths(p1, p2);
++
++#if _GLIBCXX_USE_WCHAR_T
++ std::wstring ws(s.begin(), s.end());
++ path p3 = ws;
++ std::experimental::wstring_view wsv(ws);
++ path p4 = wsv;
++ compare_paths(p1, p4);
++#endif
++ }
++}
++
++int
++main()
++{
++ test01();
++}
+diff --git a/libstdc++-v3/testsuite/experimental/functional/not_fn.cc b/libstdc++-v3/testsuite/experimental/functional/not_fn.cc
+index 4c137e8..18ea24e 100644
+--- a/libstdc++-v3/testsuite/experimental/functional/not_fn.cc
++++ b/libstdc++-v3/testsuite/experimental/functional/not_fn.cc
+@@ -76,10 +76,30 @@ test03()
+ VERIFY( not_fn(&X::b)(x) );
+ }
+
++void
++test04()
++{
++ struct abstract { virtual void f() = 0; };
++ struct derived : abstract { void f() { } };
++ struct F { bool operator()(abstract&) { return false; } };
++ F f;
++ derived d;
++ VERIFY( not_fn(f)(d) );
++}
++
++void
++test05()
++{
++ auto nf = std::experimental::not_fn([] { return false; });
++ auto copy(nf); // PR libstdc++/70564
++}
++
+ int
+ main()
+ {
+ test01();
+ test02();
+ test03();
++ test04();
++ test05();
+ }
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/1.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/1.cc
+index e9a866a..3f124c8 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/2.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/2.cc
+index ed160cb..615f5ca 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/2.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/2.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/3.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/3.cc
+index 55cc75a..4f210af 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/3.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/3.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/4.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/4.cc
+index e589dde..4b93e6d 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/4.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/4.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/5.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/5.cc
+index 2440339..2a836e1 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/5.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/5.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/assignment/6.cc b/libstdc++-v3/testsuite/experimental/optional/assignment/6.cc
+index f80e7d0..0a8af5b 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/assignment/6.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/assignment/6.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/cons/move.cc b/libstdc++-v3/testsuite/experimental/optional/cons/move.cc
+index fb123aea..53f2747 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/cons/move.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/cons/move.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/cons/value.cc b/libstdc++-v3/testsuite/experimental/optional/cons/value.cc
+index d7d2ad5..084195d 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/cons/value.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/cons/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/cons/value.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/cons/value.cc
+index bcc8919..eaafbab 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/cons/value.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/cons/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/make_optional.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/make_optional.cc
+index d57cf5c..f77a6f2 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/make_optional.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/make_optional.cc
+@@ -13,7 +13,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/1.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/1.cc
+index e0cce10..26d7f90 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/2.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/2.cc
+index 803927b..74896be 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/2.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/2.cc
+@@ -13,7 +13,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/3.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/3.cc
+index be170f5..6ccb06a 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/3.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/3.cc
+@@ -13,7 +13,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/4.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/4.cc
+index c8cd20a..c8b48dd 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/4.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/4.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/5.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/5.cc
+index bb66b8f..8915478 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/5.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/observers/5.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/1.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/1.cc
+index 66bbaee..92cb51b 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/2.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/2.cc
+index 35095cf..136b539 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/2.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/2.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/3.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/3.cc
+index 70cc525..ac6640c 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/3.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/3.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/4.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/4.cc
+index 7d859563..c4ab1ad 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/4.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/4.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/5.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/5.cc
+index 25f0eb4..e2883c2 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/5.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/5.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/6.cc b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/6.cc
+index 9df92b7..da66044 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/6.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/constexpr/relops/6.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/make_optional.cc b/libstdc++-v3/testsuite/experimental/optional/make_optional.cc
+index 3b3689f..65544ca 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/make_optional.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/make_optional.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/observers/1.cc b/libstdc++-v3/testsuite/experimental/optional/observers/1.cc
+index 1aeebf7..d8f43ae 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/observers/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/observers/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/observers/2.cc b/libstdc++-v3/testsuite/experimental/optional/observers/2.cc
+index 7cf5a58..04bee98 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/observers/2.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/observers/2.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/observers/3.cc b/libstdc++-v3/testsuite/experimental/optional/observers/3.cc
+index 68eacc4..003f482 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/observers/3.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/observers/3.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/observers/4.cc b/libstdc++-v3/testsuite/experimental/optional/observers/4.cc
+index 0de043a..0dcb4ac 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/observers/4.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/observers/4.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/observers/5.cc b/libstdc++-v3/testsuite/experimental/optional/observers/5.cc
+index 2bf4cc4..72febbc 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/observers/5.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/observers/5.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/1.cc b/libstdc++-v3/testsuite/experimental/optional/relops/1.cc
+index d82fae9..26a5ca5 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/2.cc b/libstdc++-v3/testsuite/experimental/optional/relops/2.cc
+index 3eed56f..48cf183 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/2.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/2.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/3.cc b/libstdc++-v3/testsuite/experimental/optional/relops/3.cc
+index de410d7..a1a37a8 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/3.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/3.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/4.cc b/libstdc++-v3/testsuite/experimental/optional/relops/4.cc
+index 0c25683..31964c0 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/4.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/4.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/5.cc b/libstdc++-v3/testsuite/experimental/optional/relops/5.cc
+index c3ed269..2362a96 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/5.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/5.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/relops/6.cc b/libstdc++-v3/testsuite/experimental/optional/relops/6.cc
+index 60a13a8..0587529 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/relops/6.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/relops/6.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/requirements.cc b/libstdc++-v3/testsuite/experimental/optional/requirements.cc
+index 531b6ca..b925e5b 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/requirements.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/requirements.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/swap/1.cc b/libstdc++-v3/testsuite/experimental/optional/swap/1.cc
+index 383791c..3a2d55e 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/swap/1.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/swap/1.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/optional/typedefs.cc b/libstdc++-v3/testsuite/experimental/optional/typedefs.cc
+index 503aa05..11150e6 100644
+--- a/libstdc++-v3/testsuite/experimental/optional/typedefs.cc
++++ b/libstdc++-v3/testsuite/experimental/optional/typedefs.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/ratio/value.cc b/libstdc++-v3/testsuite/experimental/ratio/value.cc
+index 7cc20b1..d48ee05 100644
+--- a/libstdc++-v3/testsuite/experimental/ratio/value.cc
++++ b/libstdc++-v3/testsuite/experimental/ratio/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/string_view/typedefs.cc b/libstdc++-v3/testsuite/experimental/string_view/typedefs.cc
+index c915270..a5acbb2 100644
+--- a/libstdc++-v3/testsuite/experimental/string_view/typedefs.cc
++++ b/libstdc++-v3/testsuite/experimental/string_view/typedefs.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/system_error/value.cc b/libstdc++-v3/testsuite/experimental/system_error/value.cc
+index c6e8f3b..2fb8f74 100644
+--- a/libstdc++-v3/testsuite/experimental/system_error/value.cc
++++ b/libstdc++-v3/testsuite/experimental/system_error/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/tuple/tuple_size.cc b/libstdc++-v3/testsuite/experimental/tuple/tuple_size.cc
+index 262bd57..70ef7a4 100644
+--- a/libstdc++-v3/testsuite/experimental/tuple/tuple_size.cc
++++ b/libstdc++-v3/testsuite/experimental/tuple/tuple_size.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/experimental/type_traits/value.cc b/libstdc++-v3/testsuite/experimental/type_traits/value.cc
+index fefe523..8f5bbec 100644
+--- a/libstdc++-v3/testsuite/experimental/type_traits/value.cc
++++ b/libstdc++-v3/testsuite/experimental/type_traits/value.cc
+@@ -14,7 +14,7 @@
+ // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ // GNU General Public License for more details.
+
+-// You should have received a moved_to of the GNU General Public License along
++// You should have received a copy of the GNU General Public License along
+ // with this library; see the file COPYING3. If not see
+ // <http://www.gnu.org/licenses/>.
+
+diff --git a/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc b/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
+index dd19f14..86065f7 100644
+--- a/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
++++ b/libstdc++-v3/testsuite/ext/profile/mutex_extensions_neg.cc
+@@ -25,4 +25,4 @@
+
+ #include <vector>
+
+-// { dg-error "multiple inlined namespaces" "" { target *-*-* } 322 }
++// { dg-error "multiple inlined namespaces" "" { target *-*-* } 329 }
+diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp
+index 8322fac..35487d1 100644
+--- a/libstdc++-v3/testsuite/lib/libstdc++.exp
++++ b/libstdc++-v3/testsuite/lib/libstdc++.exp
+@@ -628,8 +628,9 @@ proc v3-build_support { } {
+ set object_file [file tail $obj]
+ # Compile with "-w" so that warnings issued by the compiler
+ # do not prevent compilation.
++ # Disable LTO so that ar/ranlib don't need the LTO plugin.
+ if { [v3_target_compile $srcdir/util/$f $object_file "object" \
+- [list "incdir=$srcdir" "additional_flags=-w"]]
++ [list "incdir=$srcdir" "additional_flags=-w -fno-lto"]]
+ != "" } {
+ error "could not compile $f"
+ }
+@@ -1894,6 +1895,8 @@ proc check_v3_target_little_endian { } {
+ return $et_little_endian
+ }
+
++# Return 1 if the Filesystem TS is supported, 0 otherwise.
++# Cache the result.
+ proc check_v3_target_filesystem_ts { } {
+ global cxxflags
+ global DEFAULT_CXXFLAGS
+@@ -1921,7 +1924,7 @@ proc check_v3_target_filesystem_ts { } {
+ set et_filesystem_ts 0
+
+ # Set up and preprocess a C++ test program that depends
+- # on debug mode activated.
++ # on the Filesystem TS feature-test macro being defined.
+ set src filesystem_ts[pid].cc
+
+ set f [open $src "w"]
+diff --git a/libstdc++-v3/testsuite/util/testsuite_allocator.h b/libstdc++-v3/testsuite/util/testsuite_allocator.h
+index 642cef4..f94dd70 100644
+--- a/libstdc++-v3/testsuite/util/testsuite_allocator.h
++++ b/libstdc++-v3/testsuite/util/testsuite_allocator.h
+@@ -119,6 +119,8 @@ namespace __gnu_test
+ tracker_allocator() = default;
+ tracker_allocator(const tracker_allocator&) = default;
+ tracker_allocator(tracker_allocator&&) = default;
++ tracker_allocator& operator=(const tracker_allocator&) = default;
++ tracker_allocator& operator=(tracker_allocator&&) = default;
+
+ // Perfect forwarding constructor.
+ template<typename... _Args>
+diff --git a/libstdc++-v3/testsuite/util/testsuite_fs.h b/libstdc++-v3/testsuite/util/testsuite_fs.h
+index ddcb2b7..8dc2c08 100644
+--- a/libstdc++-v3/testsuite/util/testsuite_fs.h
++++ b/libstdc++-v3/testsuite/util/testsuite_fs.h
+@@ -23,7 +23,7 @@
+ #define _TESTSUITE_FS_H 1
+
+ #include <experimental/filesystem>
+-#include <iostream>
++#include <fstream>
+ #include <string>
+ #include <cstdio>
+ #include <stdlib.h>
+@@ -40,7 +40,6 @@ namespace __gnu_test
+ compare_paths(const std::experimental::filesystem::path& p1,
+ const std::experimental::filesystem::path& p2)
+ {
+- // std::cout << "Comparing " << p1 << " and " << p2 << std::endl;
+ PATH_CHK( p1, p2, string );
+ PATH_CHK( p1, p2, empty );
+ PATH_CHK( p1, p2, has_root_path );
+@@ -91,5 +90,23 @@ namespace __gnu_test
+ return p;
+ }
+
++ // RAII helper to remove a file on scope exit.
++ struct scoped_file
++ {
++ using path_type = std::experimental::filesystem::path;
++
++ enum adopt_file_t { adopt_file };
++
++ explicit
++ scoped_file(const path_type& p = nonexistent_path()) : path(p)
++ { std::ofstream{p.native()}; }
++
++ scoped_file(path_type p, adopt_file_t) : path(p) { }
++
++ ~scoped_file() { if (!path.empty()) remove(path); }
++
++ path_type path;
++ };
++
+ } // namespace __gnu_test
+ #endif
diff --git a/5.4.0/gentoo/README.history b/5.4.0/gentoo/README.history
index 5186f82..12c58de 100644
--- a/5.4.0/gentoo/README.history
+++ b/5.4.0/gentoo/README.history
@@ -1,3 +1,9 @@
+1.2 27 Dec 2016
+ + 95_all_gcc5-head-snapshot-diff-20161227.patch
+ - 95_all_gcc5-head-snapshot-diff-20161226.patch
+1.1 26 Dec 2016
+ - 71_all_gcc-5-march-native-pr67310.patch
+ + 95_all_gcc5-head-snapshot-diff-20161226.patch
1.0 12 Jun 2016
+ 05_all_gcc-spec-env.patch
+ 09_all_default-ssp.patch